From e85d6f69634791e7db19463acbed95eaa2f69ff1 Mon Sep 17 00:00:00 2001 From: SinuS Von SifriduS Date: Fri, 4 Sep 2026 21:53:36 +0200 Subject: [PATCH] v0.3.9-pre.005 --- Cargo.toml | 4 +- deltas/0.3.9/pre.005.md | 71 ++++++ .../011-RAW_TRANSACTION_ACQUISITION.md | 205 +++++++++++++++++- ...9_WORKER_API_RAW_TRANSACTION_AUDIT_PLAN.md | 6 +- ...V0_3_9_WORKER_API_RAW_TRANSACTION_AUDIT.md | 33 +-- 5 files changed, 299 insertions(+), 20 deletions(-) create mode 100644 deltas/0.3.9/pre.005.md diff --git a/Cargo.toml b/Cargo.toml index 52136ab..e3020e4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,12 +1,12 @@ # file: Cargo.toml -# version: 481 +# version: 482 [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-store-api", "crates/ksp-store-lib", "crates/ksp-store-postgres-lib", "crates/ksp-wallet-lib", "crates/ksp-worker-api"] [workspace.package] -version = "0.3.9-pre.4" +version = "0.3.9-pre.5" edition = "2024" license = "MIT" repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project" diff --git a/deltas/0.3.9/pre.005.md b/deltas/0.3.9/pre.005.md new file mode 100644 index 0000000..126cd7b --- /dev/null +++ b/deltas/0.3.9/pre.005.md @@ -0,0 +1,71 @@ + + + +# Delta `0.3.9-pre.005` + +## 1. Objet + +Poursuivre l'audit RAW post-freeze avec Helius, Yellowstone, providers alternatifs et la référence fonctionnelle historique kbot3. Cette tranche ferme les preuves provider/tier/replay nécessaires avant la synthèse multi-source `pre.006`. + +Aucun runtime, DTO, endpoint, secret, profil Config, Store model ou Worker API n'est modifié. + +## 2. Base et version + +Base : `0.3.9-pre.4`, dont les audits opérateur Rust/Markdown sont PASS. + +```text +workspace.package.version = 0.3.9-pre.5 +``` + +## 3. Décisions fermées + +```text +Helius Standard WSS -> admis ; provider-managed continuity, repair KSP conservé +Helius transactionSubscribe -> live_direct_full spécialisé déjà supporté par Transport +Helius LaserStream gRPC -> Yellowstone-compatible, replay from_slot 24 h prouvé +Yellowstone transactions -> live_direct_full générique prioritaire +Yellowstone status/meta -> signaux incomplets/continuité, jamais RAW seuls +PublicNode Yellowstone -> live prouvé, profondeur replay non prouvée +OrbitFlare Yellowstone -> live prouvé, profondeur replay non prouvée +OrbitFlare archive HTTP -> historique complet depuis genesis annoncé +kbot3 -> référence fonctionnelle uniquement, aucune source de code/config +``` + +## 4. Gaps ouverts + +- convergence RAW commune entre `transactionSubscribe`, Yellowstone transaction et autres sources full ; +- Config Yellowstone multi-provider par capabilities, sans SDK provider parallèle ; +- replay gRPC activé uniquement si support/rétention provider réellement observés ; +- repair externe conservé pour WSS lorsque la plage manquée n'est pas adressable ; +- réutilisation unique de `KSP_SECRET_HELIUS_API_KEY` dans la future composition Helius ; +- stratégies historiques provider-specific réservées à la synthèse `0.3.12`. + +## 5. Fichiers + +| Fichier | Action | Rôle | +|----------------------------------------------------------------|--------|------------------------------------------| +| Cargo.toml | MOD | workspace `0.3.9-pre.5` | +| docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md | MOD | audit providers/Yellowstone/kbot3 + gaps | +| docs/plans/030-V0_3_9_WORKER_API_RAW_TRANSACTION_AUDIT_PLAN.md | MOD | marque pre.005 réalisé | +| docs/validation/026-V0_3_9_WORKER_API_RAW_TRANSACTION_AUDIT.md | MOD | preuves/checklist pre.005 | +| deltas/0.3.9/pre.005.md | ADD | présent delta | + +## 6. Sources + +| Famille | Preuves consultées | +|----------------------|------------------------------------------------------------------------------------| +| Helius | LaserStream WSS/gRPC, pricing, rate limits, gTFA, Preconfirmations, Parsed Streams | +| Yellowstone upstream | proto, README, changelog | +| PublicNode | page Solana officielle | +| OrbitFlare | Yellowstone docs, pricing, archive, gRPC product | +| kbot3 fourni | référence fonctionnelle locale uniquement | + +Toutes les sources externes sont datées du 4 septembre 2026 dans l'owner architecture. Les URLs qui y figurent sont des liens documentaires ; aucune URL d'endpoint provider n'est transférée dans Config. + +## 7. kbot3 + +L'archive historique a uniquement servi à inventorier les comportements `BackfillSource`, discovery/hydration, reprise, session WS, fallback et provenance. Aucun code, type, DTO, URL d'endpoint, secret, configuration, dependency ou convention de version n'est repris. + +## 8. Gates + +Les audits Python sont exécutés après assemblage. Les gates Cargo de cette tranche restent opérateur-owned ; le changement Rust se limite au metadata de version workspace. diff --git a/docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md b/docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md index bcf7140..70b6c61 100644 --- a/docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md +++ b/docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md @@ -1,5 +1,5 @@ - + # Acquisition RAW Transaction @@ -267,3 +267,206 @@ mainnet-beta = identité réseau canonique à préserver ``` Restent ouverts pour `pre.005`/`pre.006` : Helius, Yellowstone, autres providers, replay provider-specific, quotas/tier, stratégie multi-source V1 exacte et décision finale d'ownership du canonicalizer RAW. + +## 9. Audit daté B — Helius, Yellowstone/providers et kbot3 historique + +Audit effectué le **4 septembre 2026**. Cette tranche réaudite les capacités providers et le protocole Yellowstone avec sources primaires courantes. L'archive kbot3 fournie par l'opérateur est utilisée exclusivement comme référence fonctionnelle historique ; aucun code, DTO, URL d'endpoint, Config, secret, dependency ou convention de version n'est transféré. + +### 9.1 Helius — surfaces et tiers courants + +Depuis le 31 mars 2026, Helius indique que ses WebSockets standard et enhanced sont servis par l'infrastructure LaserStream. Cela améliore l'ingestion multi-nœuds, le failover et l'ordering côté provider, mais ne change pas le contrat filaire consommé par KSP : les méthodes WSS standard/enhanced n'exposent toujours pas de `from_slot` adressable comme Yellowstone gRPC. + +| Surface | Réseau | Accès courant | Rôle RAW | Replay / continuité | Limites utiles auditées | Décision KSP | +|------------------------------|---------------------------------------|----------------------|---------------------------------------------|-------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------| +| RPC HTTP standard | Mainnet + Devnet | Free+ | history_discovery + hydration + gap_repair | aucun replay stream ; archive standard | RPC RPS 10 / 50 / 200 / 500 selon Free / Developer / Business / Professional | ADMIS ; réutilise les wrappers standard KSP | +| WSS standard LaserStream | Mainnet + Devnet | Free+ | rôles WS standard de pre.004 | failover/replay annoncés côté service ; pas de curseur replay KSP | 5 / 150 / 250 / 1 000 connexions ; 1 000 subscriptions/connexion | ADMIS ; gap repair explicite KSP conservé | +| WSS transactionSubscribe | Mainnet + Devnet | Developer+ | live_direct_full si transactionDetails=full | continuité provider-managed ; pas de from_slot WSS KSP | filtres include/exclude/required jusqu’à 50 000 adresses ; Developer annoncé jusqu’à 100 tx subscriptions/connexion | ADMIS spécialisé ; surface KSP déjà typée | +| LaserStream gRPC Yellowstone | Devnet Developer+ ; Mainnet Business+ | Developer+/Business+ | live_direct_full + gap_repair court | from_slot + replay explicite jusqu’à 24 h | 10 M pubkeys ; 10 connexions Business, 100 Professional | PRIORITAIRE pour V1 multi-source si Config l’active | +| getTransactionsForAddress | archive adressée | Developer+ | history_discovery + hydration combinées | pagination historique, pas stream | 100 crédits/appel ; 1 000 signatures ou 100 transactions full/page | SPÉCIALISÉ backfill 0.3.12 ; option 0.3.10 non nécessaire | +| Preconfirmations | signal leader partiel | Professional+ | signal ultra-précoce spécialisé | couverture partielle ; confirmation downstream obligatoire | 10 crédits/transaction ; filtres server-side | HORS RAW canonique V1 comme source autoritative | +| Parsed Streams | live confirmed décodé | plans payants, beta | flux sémantique provider-decoded | beta ; pas owner RAW | décodage provider de 3 600+ programmes annoncé | HORS RAW canonique V1 ; utile plus tard côté decode | + +Les tarifs généraux Helius consultés affichent actuellement Free / Developer / Business / Professional à **$0 / $49 / $499 / $999** par mois, avec **10 / 50 / 200 / 500 RPC RPS**. Le trafic WSS et LaserStream est unifié à 20 crédits/MB. Ces valeurs sont des données d'audit datées et ne deviennent jamais des constantes KSP. + +#### Replay WSS Helius : distinction provider/KSP + +Helius annonce un replay de 24 heures et des reconnexions automatiques pour l'infrastructure LaserStream qui sous-tend désormais les WSS. KSP ne doit toutefois pas transformer cette annonce en garantie de protocole native : + +```text +provider Helius WSS : continuité/failover/replay gérés par le service +protocole WSS KSP : aucun curseur from_slot ni fenêtre de replay explicitement demandable +conclusion KSP : conserver gap detection + repair explicite tant que le client ne peut pas adresser la plage manquée +``` + +Cette distinction empêche de déclarer une continuité vérifiable seulement parce qu'un provider annonce une infrastructure gapless. + +#### transactionSubscribe + +`transactionSubscribe` est une extension Helius et non une méthode Solana standard. Avec `transactionDetails=full`, la notification transporte un contenu transactionnel suffisamment riche pour être candidate `live_direct_full`, sans hydration HTTP obligatoire. Les filtres `accountInclude`, `accountExclude` et `accountRequired` acceptent jusqu'à 50 000 adresses selon la documentation Helius courante. + +La surface KSP correspondante existe déjà dans `ksp-onchain-transport-lib` avec types/filtres dédiés et `HeliusLaserStreamWsSession::transaction_subscribe`. Aucune nouvelle API Transport n'est requise pour la recevoir en `0.3.10`; restent à définir la conversion RAW commune, la provenance ingest et la composition Config. + +#### LaserStream gRPC + +LaserStream gRPC est Yellowstone-compatible et documente explicitement `fromSlot` avec une rétention de replay jusqu'à 24 heures. C'est la première voie auditée qui combine : + +```text +live transaction full +filters server-side +reconnect/replay adressable par slot +gap repair court sur le même protocole +provenance provider explicite +``` + +Le tier courant est Devnet à partir de Developer et Mainnet à partir de Business. KSP possède déjà le moteur Yellowstone générique ; `0.3.10` devra donc préférer une composition provider/capability plutôt qu'une deuxième implémentation Helius gRPC. Aucun endpoint Helius gRPC n'est ajouté en `0.3.9`. + +#### getTransactionsForAddress + +Helius propose aussi `getTransactionsForAddress`, qui combine discovery adressée et hydration avec tri ascendant/descendant, filtres temporels/slot/statut et pagination. La documentation annonce jusqu'à 1 000 signatures ou 100 transactions complètes par page, pour 100 crédits/appel, sur les plans payants. + +Cette voie est principalement un candidat **Backfill `0.3.12`**. Elle ne doit pas remplacer la primitive standard `getSignaturesForAddress + getTransaction` dans l'architecture générique, mais peut devenir une stratégie provider spécialisée lorsque son coût/capability est explicitement sélectionné. + +#### Signaux Helius non retenus comme RAW canonique V1 + +Deux surfaces actuelles sont enregistrées sans les promouvoir comme sources RAW autoritatives : + +- **Preconfirmations** : signal après exécution locale du leader mais avant propagation/finalité ; couverture partielle et confirmation downstream obligatoire. Le flux transporte la transaction et le statut mais ne prouve pas que le bloc deviendra canonique. Il est complémentaire aux sources on-chain normales, pas leur remplacement. +- **Parsed Streams** : flux confirmed déjà décodé côté provider, en beta. Il est utile pour des couches de decode/analytics futures mais ne doit pas devenir la vérité RAW canonique, précisément parce que la sémantique est transformée par le provider. + +### 9.2 Yellowstone upstream — sémantique du protocole + +Le protobuf upstream courant expose dans `SubscribeRequest` les maps `transactions`, `transactions_status`, `blocks`, `blocks_meta`, `accounts`, `slots`, `entry`, ainsi qu'un `commitment`, un `ping` et un `from_slot` optionnel. La présence de `from_slot` prouve une primitive de protocole ; elle ne prouve pas la profondeur réelle de rétention d'un provider. + +| Surface Yellowstone | Contenu | RAW complet | Filtres principaux | Rôle | Décision | +|---------------------|------------------------------------------------------|-----------------------------|-------------------------------------------------------------------------------------|----------------------------------|---------------------------------------------------------------------------------------| +| transactions | transaction + meta/execution | oui | vote/failed/signature/account include/exclude/required + extensions proto courantes | live_direct_full | source générique V1 privilégiée | +| transactions_status | signature + statut/erreur/index | non | mêmes familles de filtres transactionnels | live_discovery / targeted status | hydration requise si utilisée pour RAW | +| blocks | bloc assemblé + transactions optionnelles | oui si include_transactions | account_include + include_transactions/accounts/entries | live_direct_full par conteneur | utile pour couverture globale ; coût/volume supérieurs | +| blocks_meta | métadonnées de bloc | non | tous les blocs | gap_boundary / continuity | aucune persistence RawTransaction seule | +| from_slot | curseur de reprise | n/a | champ SubscribeRequest | gap_repair / catch-up court | capability à qualifier par provider et rétention réelle | +| SubscribeReplayInfo | first_available | n/a | unary | gap_boundary | permet de borner une rétention si le provider l’implémente | +| SubscribeDeshred | transaction pré-exécution sans TransactionStatusMeta | partiel | vote + accounts include/exclude/required | signal précoce spécialisé | proto/client exposés ; serveur OSS standard UNIMPLEMENTED, extension Triton seulement | + +Les limites de filtres Yellowstone ne sont **pas des constantes universelles du protocole** : le serveur upstream permet de configurer des limites différentes, voire de ne pas appliquer certaines contraintes lorsque la section correspondante est absente. KSP doit donc découvrir/documenter les limites provider et garder ses propres bornes défensives. + +Le changelog upstream du 22 juillet 2026 est également une alerte de conception : une régression avait accepté `from_slot` avec un filtre `blocks` tout en ne rejouant aucun bloc. La présence syntaxique du replay ne suffit donc jamais ; KSP doit caractériser la version/service provider et vérifier la reprise observée. + +### 9.3 Replay provider par provider + +| Provider / voie | Réseaux prouvés | Protocole | Replay explicite audité | Applicabilité | Conclusion | +|-------------------------|-------------------------------------------------|------------------------|-----------------------------------------------------------|-------------------------------|-------------------------------------------------------------------------------------| +| Helius LaserStream gRPC | Mainnet + Devnet selon tier | Yellowstone compatible | PROUVÉ : 24 h | live_direct_full + gap_repair | provider spécialisé du standard Yellowstone ; candidat V1 prioritaire | +| PublicNode Yellowstone | Mainnet + Testnet | Yellowstone gRPC | NON PROUVÉ par source officielle consultée | live_direct_full | alternative générique ; KSP possède déjà profils/smokes live, replay à caractériser | +| OrbitFlare Yellowstone | Devnet gratuit/Developer ; accès payant au-delà | Yellowstone gRPC | NON PROUVÉ explicitement dans docs Yellowstone consultées | live_direct_full | alternative générique ; archive HTTP complète comme complément repair/history | +| OrbitFlare archive HTTP | historique depuis genesis annoncé | Solana HTTP standard | n/a | history + gap_repair | complément historique fort, pas remplacement du live | + +Pour **PublicNode**, la page Solana officielle du provider expose Mainnet/Testnet avec RPC, WS RPC, Yellowstone gRPC et archive disponible. Aucune source officielle consultée pendant cette tranche ne donne une profondeur `from_slot`, des limites de filtres ou une fenêtre de replay contractualisable. Les smokes KSP historiques prouvent le streaming live, pas le replay. + +Pour **OrbitFlare**, la documentation Yellowstone expose transactions/slots/blocks/accounts/entries, filtres et keepalive. Le pricing courant donne gRPC Devnet sur Free/Developer, puis accès payant sur les tiers supérieurs. Les docs consultées ne matérialisent pas `fromSlot` dans le request de base et ne donnent pas de profondeur de replay ; cette capability reste donc **NON PROUVÉE** pour le provider. En revanche, OrbitFlare annonce une archive Solana complète depuis genesis via les méthodes HTTP standard, ce qui constitue un complément de repair/history indépendant du flux live. + +### 9.4 État KSP face aux providers + +L'inventaire `ksp-onchain-transport-lib` montre que les deux familles les plus importantes sont déjà présentes : + +```text +Helius LaserStream WSS + transactionSubscribe -> surface provider-specific déjà typée +Yellowstone gRPC standard -> transactions/status/blocks/meta + from_slot + replay info +``` + +Le runtime Yellowstone KSP sait conserver la dernière requête, avancer `from_slot` à partir du plus haut slot observé, consulter/clamp la reprise au `first_available` et compter gaps/duplicates/replay. Cette mécanique est générique ; elle ne doit pas être transformée en garantie de lossless/exactly-once. + +La conséquence architecturale pour `0.3.10` est de **réutiliser le moteur Yellowstone existant** pour Helius/PublicNode/OrbitFlare lorsque leur configuration le permet, avec des descriptors/capabilities provider-specific. Le Worker ingest ne doit pas brancher directement sur des SDK providers. + +### 9.5 Audit fonctionnel historique de kbot3 + +L'archive kbot3 fournie a été inspectée uniquement pour identifier des comportements déjà utiles historiquement. Les constats pertinents sont : + +| Domaine historique | Comportement observé | Propriété | Leçon KSP | +|--------------------|-----------------------------------------------------------------------|--------------------------------------|--------------------------------------------------------------------------------------------| +| Historique HTTP | `BackfillSource::ExplicitSignatures` ou `AddressHistory` before/after | discovery + hydration getTransaction | concept déjà refondé dans ksp-job-backfill-lib ; ne rien recopier | +| Pagination/reprise | page_size/max_pages + `resume_before_signature` + frontier contigu | reprise historique bornée | confirme l’intérêt d’un checkpoint de job, pas d’un Worker API commun | +| Hydration | client getTransaction sélectionné puis retries bornés | payload transaction canonique | faible failover dynamique : 0.3.10 doit préférer routing/capability multi-source explicite | +| Live WS | session persistante + standard subscriptions dont logsSubscribe | reconnect/resubscribe bornés | resubscribe sans replay explicite ; repair externe requis | +| Provenance | provider/endpoint/protocol/method/commitment/capture/filter | observation par acquisition | principe conservé par Store KSP ; aucun DTO historique repris | +| Fallback | pools HTTP/WS round-robin par rôle/capability | sélection initiale | utile comme référence fonctionnelle, insuffisant seul pour continuité multi-source V1 | + +L'audit ne trouve pas de voie Yellowstone ou `transactionSubscribe` servant de fondation générique dans le chemin fonctionnel historique principal de kbot3. Il ne doit donc pas limiter les capabilities plus récentes déjà présentes dans KSP. + +La leçon conservée est fonctionnelle seulement : séparer discovery/hydration, borner retries/concurrency, conserver une frontier de reprise contiguë pour les jobs historiques, maintenir une session live persistante, et enregistrer une provenance par acquisition. Les noms de types, structures, endpoints, secrets et implémentations de kbot3 ne sont pas réutilisés. + +### 9.6 Relations entre les voies auditées + +Les premières relations sont désormais suffisamment claires pour préparer la synthèse `pre.006` : + +```text +Yellowstone transactions <-> Helius LaserStream gRPC : même famille protocolaire ; provider specialization +PublicNode Yellowstone <-> OrbitFlare Yellowstone : alternatives provider pour live direct full +Helius transactionSubscribe <-> Yellowstone tx : alternatives de transport, JSON spécialisé vs gRPC générique +standard logsSubscribe + getTransaction : alternative live discovery+hydration, plus coûteuse mais très portable +Yellowstone blocks / blockSubscribe : alternatives par conteneur bloc pour couverture globale +Helius gTFA / OrbitFlare archive / standard HTTP : stratégies historiques complémentaires ou alternatives pour Backfill +preconfirmations / deshred / parsed streams : spécialisations précoces ou sémantiques, pas vérité RAW V1 +``` + +La sélection V1 exacte, les priorités/fallbacks et les règles de combinaison restent volontairement ouvertes jusqu'à `pre.006`. + +### 9.7 Gaps supplémentaires ouverts en pre.005 + +| ID | Owner futur | Gap / décision | Cible | Motif | +|--------|--------------------|-----------------------------------------------------------------------------------------------------------------|--------|--------------------------------------------------------------------------------------------| +| TR-C | Transport/ingest | caractériser une observation RAW commune pour transactionSubscribe et Yellowstone transaction | 0.3.10 | les DTOs live diffèrent mais doivent converger vers le même contenu canonique | +| GRPC-A | Config/composition | déclarer provider/network/capabilities Yellowstone sans SDK ni protocole provider parallèle | 0.3.10 | le moteur gRPC KSP est déjà générique ; seule la composition doit sélectionner le provider | +| GRPC-B | Ingest | ne considérer from_slot comme gap repair que si replay + first_available sont réellement supportés/observés | 0.3.10 | capability protocolaire != garantie de rétention provider | +| WS-A | Ingest | conserver un repair externe pour WSS même chez Helius tant que le replay n’est pas adressable par le client KSP | 0.3.10 | continuité provider-managed non équivalente à reprise déterministe KSP | +| CFG-B | Config | réutiliser exclusivement KSP_SECRET_HELIUS_API_KEY pour toutes les surfaces Helius sélectionnées | 0.3.10 | aucun second secret Helius ne doit être créé | +| BF-A | Backfill | évaluer gTFA/archives provider comme stratégies spécialisées derrière capabilities historiques | 0.3.12 | optimiser le backfill sans contaminer le Worker live | + +Aucun de ces gaps n'est implémenté en `pre.005`. + +### 9.8 Sources externes de l'audit providers + +Consultées le 4 septembre 2026 : + +| Source | URL | +|------------------------------------|---------------------------------------------------------------------------------------------------| +| Helius — LaserStream WebSockets | https://www.helius.dev/blog/laserstream-websockets | +| Helius — RPC quickstart | https://www.helius.dev/docs/quickstart | +| Helius — WebSocket quickstart | https://www.helius.dev/docs/rpc/websocket/quickstart | +| Helius — pricing | https://www.helius.dev/pricing | +| Helius — rate limits | https://www.helius.dev/docs/billing/rate-limits | +| Helius — LaserStream gRPC | https://www.helius.dev/blog/introducing-laserstream | +| Helius — getTransactionsForAddress | https://www.helius.dev/blog/introducing-gettransactionsforaddress | +| Helius — Enhanced WebSockets | https://www.helius.dev/blog/introducing-next-generation-enhanced-websockets | +| Helius — Preconfirmations | https://www.helius.dev/blog/solana-preconfirmations | +| Helius — Parsed Streams | https://www.helius.dev/blog/parsed-events-and-streams | +| Yellowstone — protobuf | https://github.com/rpcpool/yellowstone-grpc/blob/master/yellowstone-grpc-proto/proto/geyser.proto | +| Yellowstone — README | https://github.com/rpcpool/yellowstone-grpc/blob/master/README.md | +| Yellowstone — changelog | https://github.com/rpcpool/yellowstone-grpc/blob/master/CHANGELOG.md | +| PublicNode — Solana | https://solana.publicnode.com/ | +| OrbitFlare — Yellowstone docs | https://docs.orbitflare.com/data-streaming/yellowstone | +| OrbitFlare — pricing | https://orbitflare.com/pricing | +| OrbitFlare — archive | https://orbitflare.com/products/historical-data | +| OrbitFlare — gRPC | https://orbitflare.com/products/solana-grpc | + +Les URLs ci-dessus sont des **sources documentaires**. Aucun endpoint runtime provider n'est ajouté ou modifié dans KSP par cette tranche. + +## 10. État après pre.005 + +Décisions fermées par l'audit B : + +```text +Helius standard WSS = admis, continuité provider-managed mais repair KSP conservé +Helius transactionSubscribe = admis comme live_direct_full spécialisé +Helius LaserStream gRPC = admis comme Yellowstone provider + replay 24 h prouvé +Yellowstone transactions = source générique live_direct_full prioritaire +Yellowstone transaction_status = signal/status incomplet ; hydration requise pour RAW +Yellowstone blocks = direct full si transactions incluses +Yellowstone blocks_meta = continuité seulement +from_slot = capability à qualifier provider par provider +PublicNode replay = non prouvé par docs officielles consultées +OrbitFlare replay gRPC = non prouvé ; archive HTTP depuis genesis prouvée +kbot3 = référence fonctionnelle seulement, aucune source de code/Config +``` + +La synthèse `pre.006` doit maintenant convertir ces faits en matrice complète, stratégie multi-source V1, priorités/fallbacks et handoff exact `0.3.10` / `0.3.12`. + diff --git a/docs/plans/030-V0_3_9_WORKER_API_RAW_TRANSACTION_AUDIT_PLAN.md b/docs/plans/030-V0_3_9_WORKER_API_RAW_TRANSACTION_AUDIT_PLAN.md index dc84fad..9ab4410 100644 --- a/docs/plans/030-V0_3_9_WORKER_API_RAW_TRANSACTION_AUDIT_PLAN.md +++ b/docs/plans/030-V0_3_9_WORKER_API_RAW_TRANSACTION_AUDIT_PLAN.md @@ -1,5 +1,5 @@ - + # Plan v0.3.9 — Worker API générique + audit RAW Transaction @@ -587,9 +587,9 @@ Budget cible : **15-20 min**. Le document durable `docs/architecture/011-RAW_TRA ### `pre.005` — audit RAW B : Helius, Yellowstone/providers + kbot3 fonctionnel -**Statut : prévu.** +**Statut : réalisé ; audit documentaire/provider + référence fonctionnelle kbot3, aucun runtime modifié.** -Budget cible : **15-20 min**. Auditer Helius, Yellowstone et les autres providers retenus avec sources primaires courantes ; utiliser kbot3 uniquement comme référence fonctionnelle historique autorisée. Sortie : preuves de disponibilité, quotas, replay et contraintes provider. +Budget cible : **15-20 min**. `docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md` est enrichi avec Helius Standard/Enhanced WSS, LaserStream gRPC, `getTransactionsForAddress`, Preconfirmations/Parsed Streams, Yellowstone upstream, PublicNode, OrbitFlare et l'audit fonctionnel historique autorisé de kbot3. Helius LaserStream gRPC prouve un replay `from_slot` de 24 h ; PublicNode et OrbitFlare prouvent l'accès Yellowstone live mais pas une profondeur de replay contractualisable dans les sources officielles consultées. La tranche distingue explicitement continuité WSS provider-managed et gap repair adressable KSP, confirme la réutilisation du moteur Yellowstone générique existant et ouvre les gaps Config/ingest/Backfill à consolider en `pre.006`. Aucun code, DTO, endpoint, Config ou dependency de kbot3 n'est repris. ### `pre.006` — synthèse RAW multi-source + handoff `0.3.10` / `0.3.12` diff --git a/docs/validation/026-V0_3_9_WORKER_API_RAW_TRANSACTION_AUDIT.md b/docs/validation/026-V0_3_9_WORKER_API_RAW_TRANSACTION_AUDIT.md index eb3a2e2..9a02cc4 100644 --- a/docs/validation/026-V0_3_9_WORKER_API_RAW_TRANSACTION_AUDIT.md +++ b/docs/validation/026-V0_3_9_WORKER_API_RAW_TRANSACTION_AUDIT.md @@ -1,5 +1,5 @@ - + # Validation v0.3.9 — Worker API + audit RAW Transaction @@ -124,7 +124,7 @@ Les cases cochées de cette sous-section attestent la matérialisation de la sur - [X] Construction terminale confinée à `Self(u64::MAX)` dans l'impl propriétaire. - [X] Helper privé appelle `crate::WorkerSnapshotSequence::exhausted_for_test()`. - [X] Canarie dependency-boundary interdit le retour de `crate::WorkerSnapshotSequence(u64::MAX)`. -- [ ] Gate Cargo du fix exécuté par l'opérateur. +- [X] Gate Cargo du fix exécuté par l'opérateur : audits clean, check/clippy PASS, 13 unit + 4 dependency + 2 public API PASS, doc-tests PASS et arbres de dépendances Core-only. ### `pre.003` @@ -183,15 +183,20 @@ Aucun item ci-dessous n’est déclaré exécuté en `pre.001`. ### `pre.005` — providers + kbot3 historique -- [ ] Helius HTTP standard Mainnet/Devnet réaudité sur sources officielles courantes. -- [ ] Helius WS standard Mainnet/Devnet réaudité. -- [ ] Helius transactionSubscribe/extensions réaudités séparément avec tier courant. -- [ ] Yellowstone upstream transactions/transaction_status/blocks/block_meta réaudité. -- [ ] Replay/from_slot réellement supporté classifié provider par provider. -- [ ] Quotas/filter/subscription/reconnect limits sourcés. -- [ ] Providers supplémentaires pertinents réaudités uniquement sur docs officielles. -- [ ] kbot3 réaudité fonctionnellement : acquisition/live/history/recovery/fallback/provenance. -- [ ] Aucun code/DTO/URL/Config/dependency kbot3 repris. +- [X] Helius HTTP standard Mainnet/Devnet réaudité sur sources officielles courantes. +- [X] Helius WS standard Mainnet/Devnet réaudité ; limites de connexions/subscriptions et continuité LaserStream documentées. +- [X] Helius `transactionSubscribe` réaudité séparément : Developer+, filtres avancés, `transactionDetails=full`, surface KSP existante. +- [X] Helius LaserStream gRPC réaudité : Yellowstone-compatible, Devnet Developer+, Mainnet Business+, replay explicite jusqu'à 24 h. +- [X] Helius `getTransactionsForAddress`, Preconfirmations et Parsed Streams inventoriés séparément sans les confondre avec RAW canonique V1. +- [X] Yellowstone upstream `transactions` / `transaction_status` / `blocks` / `blocks_meta` / `from_slot` / replay info réaudité. +- [X] `SubscribeDeshred` enregistré comme extension pré-exécution spécialisée ; serveur OSS upstream standard actuellement non implémenté pour ce RPC. +- [X] Replay/from_slot classifié provider par provider : Helius 24 h prouvé ; PublicNode/OrbitFlare profondeur non prouvée par les sources officielles consultées. +- [X] Quotas/filter/subscription/reconnect limits sourcés lorsqu'ils sont publiés ; absence de limite provider explicite conservée comme UNKNOWN plutôt qu'inventée. +- [X] PublicNode et OrbitFlare réaudités uniquement sur leurs surfaces/docs officielles. +- [X] kbot3 réaudité fonctionnellement : acquisition/live/history/recovery/fallback/provenance. +- [X] Aucun code/DTO/URL d'endpoint/Config/dependency kbot3 repris. +- [X] Aucun endpoint ou secret provider ajouté/modifié en `pre.005`. +- [X] Audits opérateur post-`pre.004` : Rust clean, export completeness 0, KSP workspace clean, Markdown clean (327 tables / 738 fichiers). ### `pre.006` — synthèse et handoff @@ -248,10 +253,10 @@ Aucun item ci-dessous n’est déclaré exécuté en `pre.001`. La livraison initiale `pre.001` avait conservé `workspace.package.version = 0.3.8` en suivant l’exception du prompt 028. Cette exception est supplantée par la règle normative `VER-ID-009`. -Après l'audit standard `pre.004`, l'état courant est : +Après l'audit providers `pre.005`, l'état courant est : ```text -workspace.package.version = 0.3.9-pre.4 +workspace.package.version = 0.3.9-pre.5 ``` -`pre.002` reste la tranche non-fix `0.3.9-pre.2`. Les correctifs de conformité/compilation portent successivement `0.3.9-pre.2.fix.1` puis `0.3.9-pre.2.fix.2` conformément à `VER-ID-007` et `VER-ID-010`. `pre.003` reprend ensuite la séquence prerelease normale avec `0.3.9-pre.3`; son gate opérateur est PASS et freeze Worker API. `pre.004` poursuit avec `0.3.9-pre.4` sans changement runtime, uniquement l'audit standard Solana/KSP et la création de l'owner durable d'acquisition. L'état précédent `0.3.9-pre.1.fix.2` reste documenté dans `pre.001-fix.002`. +`pre.002` reste la tranche non-fix `0.3.9-pre.2`. Les correctifs de conformité/compilation portent successivement `0.3.9-pre.2.fix.1` puis `0.3.9-pre.2.fix.2` conformément à `VER-ID-007` et `VER-ID-010`. `pre.003` reprend ensuite la séquence prerelease normale avec `0.3.9-pre.3`; son gate opérateur est PASS et freeze Worker API. `pre.004` poursuit avec `0.3.9-pre.4` sans changement runtime, uniquement l'audit standard Solana/KSP et la création de l'owner durable d'acquisition. `pre.005` passe à `0.3.9-pre.5` et enrichit cet owner avec l'audit Helius/Yellowstone/providers/kbot3 sans modifier le runtime. L'état précédent `0.3.9-pre.1.fix.2` reste documenté dans `pre.001-fix.002`.