v0.3.10-rel.001

.env.example

@@ -1,5 +1,5 @@
 # file: .env.example
-# version: 13
+# version: 14
 
 # KSP Logging root directory. Used by config/std.logging.json for relative log output paths.
 # The current Config document fallback is "logs" when neither the process environment nor .env defines this variable.
@@ -28,16 +28,16 @@ KSP_WALLETS_DIRECTORY=wallets
 KSP_PUBLIC_SOLANA_DEVNET_HTTP_URL=https://api.devnet.solana.com
 
 # Optional public Solana Mainnet HTTP endpoint override used by config/std.transport.json and its example.
-# The committed Transport document falls back to https://api.mainnet-beta.solana.com when this variable is absent.
+# The committed Transport document falls back to https://api.mainnet.solana.com when this variable is absent.
-KSP_PUBLIC_SOLANA_MAINNET_HTTP_URL=https://api.mainnet-beta.solana.com
+KSP_PUBLIC_SOLANA_MAINNET_HTTP_URL=https://api.mainnet.solana.com
 
 # Optional public Solana Devnet WebSocket endpoint override used by config/std.transport.json.
 # The committed Transport document falls back to wss://api.devnet.solana.com when this variable is absent.
 KSP_PUBLIC_SOLANA_DEVNET_WS_URL=wss://api.devnet.solana.com
 
 # Optional public Solana Mainnet WebSocket endpoint override used by config/std.transport.json and its example.
-# The committed Transport document falls back to wss://api.mainnet-beta.solana.com when this variable is absent.
+# The committed Transport document falls back to wss://api.mainnet.solana.com when this variable is absent.
-KSP_PUBLIC_SOLANA_MAINNET_WS_URL=wss://api.mainnet-beta.solana.com
+KSP_PUBLIC_SOLANA_MAINNET_WS_URL=wss://api.mainnet.solana.com
 
 # Optional complete private-provider HTTP endpoint URL used only by the Transport example when explicitly selected.
 # Keep provider credentials in a KSP_SECRET_* variable; do not copy a real credential-bearing URL into committed JSON.

CHANGELOG.md

@@ -1,8 +1,36 @@
 <!-- file: CHANGELOG.md -->
-<!-- version: 28 -->
+<!-- version: 30 -->
 
 # Changelog KSP
 
+## 0.3.10 — Lower-layer RAW Transaction commune + qualification cross-source — 2026-09-08
+
+`0.3.10` introduit `ksp-raw-transaction-lib` comme lower-layer source-neutral commune aux producteurs `RawTransaction`. La canonicalisation RAW v1 auparavant locale à `ksp-job-backfill-lib` est extraite sans modifier les golden bytes/hash existants ; le Backfill consomme désormais cette common crate sans créer de dépendance vers un Worker. La bibliothèque construit les modèles `RawTransaction`/`RawTransactionObservation` de `ksp-store-api`, conserve l'identité canonique `(network, signature)`, borne et redacted les entrées hostiles, et reste volontairement sans Transport, Config, runtime async, Job, Worker ou backend Store physique.
+
+La common matérialise également un wire Solana source-neutral Legacy/V0/V1 avec sérialisation Base64 et extraction de signature depuis le matériau transactionnel complet. La représentation V1 couvre header, compiled instructions, configuration V1 et signatures terminales ; les gardes structurelles rejettent les états non supportés plutôt que d'inventer une compatibilité. `ksp-onchain-transport-lib` ajoute `get_block_observed`, qui conserve l'identité sûre de la route réellement gagnante tout en réutilisant la validation `getBlock` existante.
+
+Les preuves cross-source ferment explicitement ce qui est qualifié et ce qui exige encore hydration. Un `blockSubscribe` standard `full/base64` peut produire le même RAW v1 qu'un `getBlock` HTTP sur le sous-ensemble déterministe prouvé. Helius `transactionSubscribe` reste un signal nécessitant hydration HTTP lorsque `blockTime`/version manquent. Yellowstone qualifie le wire Transaction V1 et la conservation du `block_time` dans Block, mais `Transaction` nécessite hydration pour le temps de bloc et le chemin Block complet reste conservateur tant que l'identité byte-for-byte entre meta protobuf et meta JSON HTTP n'est pas prouvée. Aucun RAW-direct Yellowstone complet ni feed EARLY n'est revendiqué sans preuve.
+
+Le gate technique final `pre.007` passe les audits Rust/Markdown, `cargo check --workspace`, Clippy workspace/all-targets/all-features avec `-D warnings`, `cargo test --workspace --all-targets --all-features`, les suites ciblées common/Transport/Backfill et les graphes Cargo demandés ; les smokes live opt-in restent ignorés conformément à leur contrat. La réconciliation `pre.008` aligne ensuite la terminologie durable des couches Store sur `D1 RAW -> D2 STRUCTURAL -> D3 DECODED -> D4 DOMAIN`, réserve `N1–N4` aux niveaux architecturaux et complète `README.md`/`USAGE.md` de `ksp-raw-transaction-lib`. Son gate opérateur repasse format, audits, `cargo check --workspace` et Clippy strict sur `0.3.10-pre.8`.
+
+Le runtime concret a été volontairement retiré de `0.3.10` après recalibrage du sizing. La trajectoire devient `0.3.11` fondation runtime/persistence déterministe, `0.3.12` Yellowstone + hydration/continuité, `0.3.13` WS standard/Helius/HTTP live + convergence multi-source, `0.3.14` gap repair/hardening/smokes, `0.3.15` Desk d'ingestion et `0.3.16` extension Backfill multi-source. Le Job historique paramétré et le Worker continu restent des producteurs indépendants du même Store.
+
+`prompts/030-V0_3_11_START_PROMPT.md` ouvre `0.3.11` uniquement depuis le tag stable `v0.3.10`. Son `pre.001` doit auditer la base réelle, le graphe de dépendances, le runtime/supervision, les bornes de channels, la persistence/déduplication déterministe, les snapshots et le dimensionnement avant toute implémentation lourde ; aucune source live complexe n'est requise pour fermer cette release.
+
+## 0.3.9 — Worker API générique + audit exhaustif d'acquisition RawTransaction — 2026-09-05
+
+`0.3.9` introduit `ksp-worker-api` comme façade générique, courte et runtime-neutral pour services continus. La surface stable reste Core-only et expose `WorkerId`, `WorkerKindCode`, `WorkerState`, `WorkerHealth`, `WorkerActivity`, `WorkerLifecycle`, `WorkerStopToken`, `WorkerSnapshotSequence`, `WorkerSnapshot`, `WorkerSnapshotFuture` et `WorkerSnapshotSource`. Les identités sont bornées et redacted, le lifecycle possède des transitions explicites avec terminaux immuables, le stop token est partagé/idempotent, la séquence ne wrappe pas et le snapshot source latest-value reste object-safe, `Send + Sync` et implémentable depuis l'extérieur. L'API ne possède aucun runtime `start/stop` universel, aucune sémantique Job/checkpoint, aucun domaine Solana et aucune dépendance Transport/Store/Config/Tauri.
+
+Après freeze de cette API, la seconde moitié de la release réalise puis consolide l'audit exhaustif des voies d'acquisition `RawTransaction`. Le document durable `docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md` est réécrit comme une synthèse unique Store-centrique : `RawTransaction` est le cœur RAW durable, tandis que `RawTransactionObservation` conserve les provenances multiples. L'audit distingue systématiquement possibilité protocolaire/provider, support architectural KSP, support implémenté et preuve live ; il couvre HTTP, WebSocket standard, Helius `transactionSubscribe`, Yellowstone gRPC, acquisition par blocs/slots, discovery + hydration, replay/gap repair, archives et sources EARLY/pre-execution. Les matrices recensent aussi les principaux providers/réseaux/tier/coûts connus sans réduire l'architecture aux seuls comptes gratuits actuellement disponibles.
+
+La séparation des producteurs RAW est figée. `ksp-job-backfill-lib` reste un producteur historique **paramétré, borné et terminable** ; le futur `ksp-worker-raw-transaction-ingest-lib` sera un producteur live **continu start/stop sans requête métier historique**. Ils ne s'appellent pas, ne se supervisent pas et ne collaborent pas : chacun alimente indépendamment le même Store. HTTP, WS, gRPC, replay et archive sont des capabilities orthogonales à ces rôles ; un Worker peut utiliser HTTP pour hydration ou réparation de sa propre continuité live, tandis qu'un Job pourra utiliser gRPC/replay si une campagne historique bornée le justifie. Le handoff `0.3.10` retient `ksp-raw-transaction-lib` comme lower-layer source-neutral commune afin d'extraire la canonicalisation RAW v1 aujourd'hui locale au Backfill sans duplication ni edge Job ↔ Worker ; les golden bytes/hash RAW v1 doivent rester inchangés.
+
+La release normalise aussi l'identité réseau KSP : `mainnet` devient l'identité canonique dans Config/Store/Transport/tests et `mainnet-beta` reste seulement un alias legacy/externe lorsque la frontière provider l'exige. Les données Mainnet N1 encore utilisées comme données de test ne dictent aucune compatibilité durable et aucune migration SQL n'est introduite pour préserver l'ancien libellé. Pendant le gate final, les baselines workspace sont également relevées à `jsonschema ^0.53` et `yellowstone-grpc-proto ^12.7`; Yellowstone 12.7 ajoute le RPC serveur `SubscribeGossip`, ce qui nécessite uniquement l'adaptation des fixtures `Geyser` avec une réponse `UNIMPLEMENTED` et n'ouvre aucune capability Gossip de production.
+
+Le gate technique final passe les audits Rust/Markdown, `cargo check --workspace`, Clippy workspace/all-targets/all-features avec `-D warnings`, 385/385 tests unitaires `ksp-onchain-transport-lib`, 43/43 canaries `release_completeness`, `cargo test --workspace --all-targets --all-features`, le bundle complet `ksp-worker-api` et les graphes Cargo jusqu'à `cargo tree --duplicates`; seuls les smokes/probes explicitement opt-in restent ignorés. La réconciliation documentaire `pre.008` réaligne ensuite README/USAGE/indexes/architecture/plan/validation et son gate opérateur repasse audits Rust/Markdown plus `cargo check --workspace` en `0.3.9-pre.8`.
+
+`prompts/029-V0_3_10_START_PROMPT.md` ouvre `0.3.10` exclusivement depuis le tag stable `v0.3.9`. La prochaine release doit d'abord matérialiser `ksp-raw-transaction-lib`, migrer le Backfill vers cette canonicalisation commune sans changement fonctionnel, puis construire `ksp-worker-raw-transaction-ingest-lib` multi-source dès V1. Son `pre.001` est obligatoirement un gate d'audit/sizing : inventaire exact des gaps Transport/Config, runtime Worker, capabilities live, continuité, preuves provider et dépendances avant toute implémentation lourde.
+
 ## 0.3.8 — Store Desk V1 RAW, inspection backend-neutral et trajectoire Worker multi-source — 2026-09-04
 
 `0.3.8` introduit `ksp-app-store-desk`, application Tauri KSP read-only dédiée à l'inspection du Store. Le package reprend le gabarit Desk commun (splash/shell/assets/styles/tracing), compose `ksp-config-lib`, `ksp-logging-lib` et la seule façade `ksp-store-lib`, et interdit à l'application tout accès direct à `ksp-store-api`, `ksp-store-postgres-lib`, SQL, driver/pool PostgreSQL, Transport on-chain ou ressource physique. Le bootstrap ouvre un Store lié au profil/réseau composite, expose health/runtime backend-neutral et effectue un shutdown borné à la fermeture de la fenêtre principale.

Cargo.toml

@@ -1,12 +1,12 @@
 # file: Cargo.toml
-# version: 475
+# version: 505
 
 [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"]
+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"]
 
 [workspace.package]
-version = "0.3.8"
+version = "0.3.10"
 edition = "2024"
 license = "MIT"
 repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project"
@@ -25,7 +25,7 @@ fs2 = { version = "^0.4" }
 futures-util = { version = "^0.3", default-features = false }
 getrandom = { version = "^0.4", default-features = false }
 http = { version = "^1.5", default-features = false }
-jsonschema = { version = "^0.52", default-features = false }
+jsonschema = { version = "^0.53", default-features = false }
 reqwest = { version = "^0.13", default-features = false }
 rustls = { version = "^0.23", default-features = false }
 rustls-native-certs = { version = "^0.8", default-features = false }
@@ -49,7 +49,7 @@ tokio-tungstenite = { version = "^0.30", default-features = false }
 tonic = { version = "^0.14", default-features = false }
 tonic-prost = { version = "^0.14", default-features = false }
 ts-rs = { version = "^12.0" }
-yellowstone-grpc-proto = { version = "^12.6", default-features = false }
+yellowstone-grpc-proto = { version = "^12.7", default-features = false }
 zeroize = { version = "^1.9" }
 
 [workspace.lints.rust]

README.md

@@ -1,5 +1,5 @@
 <!-- file: README.md -->
-<!-- version: 10 -->
+<!-- version: 11 -->
 
 # Khadhroony Solana Project
 
@@ -55,7 +55,9 @@ La couche RAW dispose d'une façade Store backend-neutral et d'un premier job hi
 
 `ksp-app-store-desk` fournit l'inspection desktop read-only du Store RAW via `ksp-store-lib` : health/runtime backend-neutral, tables server-side `RawTransaction` et `RawAccountState`, observations associées, détails avec previews bornées et lecture des états de rétention/tombstones. DataTables possède l'unique pagination visible de l'inspection random-access ; la pagination cursor/keyset des consumers machine reste distincte et intacte.
 
-Ces contrats restent distincts des futurs workers continus : un job borné n'est ni un service worker ni un pipeline générique imposé aux autres couches.
+`ksp-worker-api` fournit désormais la fondation générique des services continus : identité Worker, lifecycle borné, health/activity, intention de stop coopératif et observation latest-value. Cette API reste Core-only, runtime-neutral et sans connaissance Solana, Transport, Store ou Job. Elle ne démarre ni n'arrête elle-même un runtime concret.
+
+Le futur `ksp-worker-raw-transaction-ingest-lib` sera un consumer concret distinct du Job Backfill : il fonctionnera en continu entre Start et Stop, sans scope historique métier, afin d'acquérir et persister des `RawTransaction` selon les sources/capabilities configurées. `ksp-job-backfill-lib` conserve de son côté son rôle historique paramétré et borné. Les deux producteurs restent indépendants et convergent uniquement vers les mêmes contrats RAW/Store.
 
 ## Points d'entrée
 

ROADMAP.md

@@ -1,5 +1,5 @@
 <!-- file: ROADMAP.md -->
-<!-- version: 103 -->
+<!-- version: 108 -->
 
 # Roadmap KSP
 
@@ -40,7 +40,7 @@ Le roadmap décrit les objectifs à atteindre et les grandes étapes prévues. U
 
 ### Cadrage
 
-- [X] `0.2.0` — Audit bot3, ordre fonctionnel de `0.2.x`, architecture durable, discipline de sizing et pipeline RAW/CORE/DECODE/SPECIALIZED stabilisés.
+- [X] `0.2.0` — Audit bot3, ordre fonctionnel de `0.2.x`, architecture durable, discipline de sizing et pipeline RAW/STRUCTURAL/DECODED/DOMAIN stabilisés.
 - [X] `0.2.1` — HTTP foundation stable : matrice 52+14, runtime/routing/résilience/exécution HTTP, 4 canaris typés, `std.transport`, adapter Config -> Transport, canaries de clôture, smoke Devnet opt-in et documentation durable validés ; les 48 wrappers typés restants sont reportés à `0.2.2`–`0.2.4`.
 
 ### Releases fonctionnelles décidées/pressenties
@@ -87,13 +87,13 @@ RAW -> STRUCTURAL -> DECODED -> DOMAIN
 ```
 
 - **RAW** et **STRUCTURAL** ne nécessitent aucun décodage Program.
-- La progression n'est pas une chaîne obligatoire pour chaque famille : une donnée event-only peut s'arrêter en N1, et un état de compte pourra aller directement vers un futur decoder si aucune décomposition STRUCTURAL utile n'existe.
+- La progression n'est pas une chaîne obligatoire pour chaque famille : une donnée event-only peut s'arrêter en D1, et un état de compte pourra aller directement vers un futur decoder si aucune décomposition STRUCTURAL utile n'existe.
 - À la fin des couches horizontales RAW/STRUCTURAL réellement persistées, ajouter les jobs/workers/apps nécessaires avant d'ouvrir la couche suivante.
 - À partir de **DECODED**, avancer verticalement groupe par groupe ; **DOMAIN** désigne les projections métier et la matérialisation est le processus qui les produit.
 
 ## 0.3.x — RAW / acquisition persistée
 
-- [X] `0.3.1` — `ksp-store-api` stable : modèles N1 RAW backend-agnostic `RawTransaction` et `RawAccountState` avec observations, provenance, payload/hash/timestamps bornés, 10 capabilities object-safe, queries cursorisées sans plafond métier arbitraire, outcomes idempotence/conflit et lifecycle logique rétention/tombstone/force-rehydrate ; aucun backend physique, Config, runtime Store, notification dédiée ni surface STRUCTURAL/DECODED/DOMAIN.
+- [X] `0.3.1` — `ksp-store-api` stable : modèles D1 RAW backend-agnostic `RawTransaction` et `RawAccountState` avec observations, provenance, payload/hash/timestamps bornés, 10 capabilities object-safe, queries cursorisées sans plafond métier arbitraire, outcomes idempotence/conflit et lifecycle logique rétention/tombstone/force-rehydrate ; aucun backend physique, Config, runtime Store, notification dédiée ni surface STRUCTURAL/DECODED/DOMAIN.
 - [X] `0.3.2` — `ksp-store-lib` + `ksp-store-postgres-lib` stables comme fondation runtime/backend PostgreSQL : feature `postgres` par défaut, `Store` lié à un unique `RawNetworkId`, Config `std.store` avec targets/bases `devnet`/`mainnet`/`testnet`, pool Deadpool borné, `tokio-postgres`, TLS Rustls `Disabled`/`VerifyFull`, moteur de migrations privé `V000` + SHA-256/advisory lock, health/readiness portable et close borné. Gate complet + PostgreSQL réel major 17 verts ; aucune table/capability `RawTransaction`/`RawAccountState` métier n'est encore ajoutée.
 - [X] `0.3.3` — Vertical slice PostgreSQL `RawTransaction` complète sur `ksp-store-lib` + `ksp-store-postgres-lib` : six capabilities transaction/observation/rétention, V001 physique liée à un réseau, acquisition canonical+observation atomique, idempotence/conflit, get/list keyset cursorisé, archive/purge/tombstone/ForceRehydrate, hardening des erreurs et du schéma, concurrence et rollback validés sur PostgreSQL 17.
 - [X] `0.3.4` — Vertical slice PostgreSQL `RawAccountState` complète sur `ksp-store-lib` + `ksp-store-postgres-lib` : quatre capabilities account ajoutées aux six transaction pour une conformance RAW 10/10, V002 additive de 32 ressources au-dessus de V000/V001 immuables, state+observation atomiques, idempotence/conflit exacts, metadata Yellowstone observation-only, get/list keyset `(slot,pubkey,state_hash)` avec cursor KSPA anti-replay, hardening cross-family et live validé sur PostgreSQL 17 sans rétention destructive account.
@@ -101,22 +101,26 @@ RAW -> STRUCTURAL -> DECODED -> DOMAIN
 - [X] `0.3.6` — `ksp-job-api` + `ksp-job-backfill-lib` stables pour la première verticale historique `RawTransaction` : lifecycle/cancellation/latest-value runtime-neutral, scopes `Latest`/`Before`/`After`/signatures explicites, découverte/hydratation Transport observée, RAW v1 canonique, persistance Store atomique/idempotente, concurrence bornée, frontier contiguë, checkpoint/reprise caller-owned, snapshots sûrs et hardening externe sans dépendance backend/provider directe.
 - [X] `0.3.7` — `ksp-app-backfill-desk` livrée comme Desk Tauri KSP spécialisée : composition Config Mainnet/Devnet/Testnet, quatre scopes HTTP, validation/start single-run, monitoring latest-value `ksp-backfill-status`, Cancel ciblé/idempotent, Resume in-session par checkpoint Rust-only réémis pour un nouveau JobId, autocomplete libre depuis `ksp-core-lib`, hardening IPC/dependency boundaries et build Linux `.deb`/`.rpm`/`.AppImage`. Aucun SQL/backend/provider physique ni checkpoint durable n’est exposé.
 - [X] `0.3.8` — `ksp-app-store-desk` V1 RAW livrée sur le gabarit KSP courant comme application Tauri read-only backend-neutral. La Desk compose Config + Logging + `ksp-store-lib`, expose health/runtime sûrs, DataTables `serverSide` pour `RawTransaction`, `RawAccountState` et leurs observations, détails bornés, provenance sûre et états de rétention/tombstone, sans SQL/backend physique/Transport dans l'application. La nouvelle inspection random-access `offset + limit + counts exacts` reste distincte de la pagination machine cursor/keyset conservée pour workers/backfills/replays. Le gate final et les builds Linux `.deb`/`.rpm` sont verts.
-- [ ] `0.3.9` — Introduire `ksp-worker-api` comme API **générique et volontairement courte** de lifecycle/health/progression/snapshot pour services continus, distincte de `ksp-job-api` et sans dépendance Solana/Transport/Store/Tauri. Une fois l'API Worker fonctionnellement fermée, terminer la release par un audit fonctionnel exhaustif des sources/méthodes d'acquisition `RawTransaction` : HTTP, WS standard, extensions provider, Yellowstone gRPC, blocks/slots, discovery + hydration, replay/gap-repair et combinaisons multi-provider. Cet audit prépare `0.3.10` sans ajouter d'endpoint ni de Config provider dans `0.3.9`.
+- [X] `0.3.9` — `ksp-worker-api` stable comme API générique et volontairement courte pour services continus : identité/kind bornés, lifecycle explicite, health/activity sûrs, stop token partagé, séquence/snapshot latest-value et `WorkerSnapshotSource` object-safe, avec dépendance Core-only et sans runtime/start-stop universel, Solana, Transport, Store, Config ou Tauri. Après freeze Worker API, l'audit `RawTransaction` a été consolidé dans une synthèse Store-centrique exhaustive séparant possibilités/support/preuve et classant HTTP, WS standard/provider, Yellowstone gRPC, blocs/slots, discovery + hydration, replay de continuité, archives et sources EARLY. Le Job Backfill historique paramétré et le Worker Ingest live start/stop sont deux producteurs indépendants du même Store ; `mainnet` est désormais l'identité KSP canonique et `mainnet-beta` un alias legacy/externe. Le handoff retient `ksp-raw-transaction-lib` comme lower-layer commune de canonicalisation RAW v1 pour `0.3.10`, sans edge Job ↔ Worker.
-- [ ] `0.3.10` — Introduire `ksp-worker-raw-transaction-ingest-lib` **multi-source dès V1**. Le worker compose les stratégies retenues par l'audit `0.3.9` comme sources alternatives, complémentaires, redondantes ou spécialisées live/catch-up/gap-repair, converge vers `RawTransaction + RawTransactionObservation`, persiste par `ksp-store-lib` et utilise `ksp-worker-api` pour supervision/cancellation. Cette release porte aussi, et seulement si l'audit les justifie, les adaptations nécessaires de `ksp-onchain-transport-lib`/`ksp-config-lib` : futures sources Helius HTTP/WS Mainnet/Devnet avec réutilisation de `KSP_SECRET_HELIUS_API_KEY`, capabilities/tier réaudités au moment du travail, et éventuelle canonicalisation `mainnet`/`mainnet-beta` uniquement avec stratégie de compatibilité sûre. Aucun decode Program ni dépendance backend/provider directe dans le worker.
+- [X] `0.3.10` — Lower-layer RAW Transaction commune stabilisée : `ksp-raw-transaction-lib` possède la canonicalisation RAW v1 source-neutral partagée, le Backfill est migré sans changement des golden bytes/hash, Transport expose `get_block_observed`, le wire Solana Legacy/V0/V1 est matérialisé et les canaris HTTP/WS standard/Helius/Yellowstone qualifient précisément les voies directes ou nécessitant hydration. La release se ferme sans runtime Worker concret ; celui-ci commence en `0.3.11` selon le redécoupage `0.3.11`–`0.3.14`.
-- [ ] `0.3.11` — Introduire `ksp-app-raw-transaction-ingest-desk`, Desk Tauri KSP spécialisée qui choisit et supervise **une ou plusieurs sources/méthodes** réellement admises par `0.3.10` : lifecycle, health, rates, backpressure, reconnect/recovery, gap state et compteurs sûrs. La Desk ne réimplémente ni discovery, hydration, déduplication, reprise ni persistence ; l'inspection détaillée des RAW persistés reste la responsabilité de `ksp-app-store-desk`.
+- [ ] `0.3.11` — Introduire la **fondation runtime** de `ksp-worker-raw-transaction-ingest-lib` sans source live complexe : crate/dependency firewall, settings source-neutral, handle/start-stop, lifecycle, snapshots, supervisor, bounded channels et pipeline de persistence/déduplication déterministe. Aucun protocole live n'est encore requis pour fermer cette release.
-- [ ] `0.3.12` — Étendre `ksp-job-backfill-lib` et `ksp-app-backfill-desk` au **backfill multi-source/multi-stratégie** à partir de la même matrice d'acquisition auditée en `0.3.9`. Conserver la stratégie actuelle `getSignaturesForAddress + getTransaction` comme première voie HTTP valide, puis ajouter seulement les voies historiques/catch-up/gap-repair réellement pertinentes et sûres (par exemple block/slot, replay provider lorsqu'il existe), sans supposer qu'une source live WS constitue un historique universel.
+- [ ] `0.3.12` — Ajouter au Worker la voie **Yellowstone + hydration HTTP** : transactions/blocks/status, projection vers la common RAW, provenance sûre, `from_slot`, replay info, frontier de run et continuité propre au run, avec fixtures déterministes et smokes accessibles sans prétendre à un RAW-direct lorsque les métadonnées restent incomplètes.
+- [ ] `0.3.13` — Ajouter les voies **WS standard / Helius / HTTP live** et leur convergence multi-source : `logsSubscribe + getTransaction`, `blockSubscribe`, `transactionSubscribe + hydration`, polling blocs HTTP, observations multiples, content conflict explicite, coalescence et backpressure sans second actor Transport.
+- [ ] `0.3.14` — Fermer le Worker par le **gap repair/hardening multi-source** : replay natif, source redondante, scan HTTP blocs, hydration de réparation, unresolved gaps visibles, politiques degraded/unhealthy/faulted, shutdown pendant repair, smokes provider accessibles et adapter EARLY seulement si réellement prouvé.
+- [ ] `0.3.15` — Introduire `ksp-app-raw-transaction-ingest-desk`, Desk Tauri KSP spécialisée qui choisit et supervise une ou plusieurs sources/méthodes réellement admises par le Worker finalisé : lifecycle, health, rates, backpressure, reconnect/recovery, gap state et compteurs sûrs. La Desk ne réimplémente ni discovery, hydration, déduplication, reprise ni persistence.
+- [ ] `0.3.16` — Étendre `ksp-job-backfill-lib` et `ksp-app-backfill-desk` au **backfill multi-source/multi-stratégie** à partir de la même matrice d'acquisition auditée en `0.3.9`. Conserver la stratégie actuelle `getSignaturesForAddress + getTransaction` comme première voie HTTP valide, puis ajouter seulement les voies historiques/catch-up/gap-repair réellement pertinentes et sûres, sans supposer qu'une source live WS constitue un historique universel.
 
 ### TODO/IDEAS — applications spécialisées et control plane
 
 - [ ] **TODO** — faire évoluer `ksp-app-store-desk` avec chaque nouvelle couche réellement persistée : RAW d'abord, puis STRUCTURAL, DECODED, journal de processing/materialization et projections DOMAIN selon les contrats effectivement disponibles. Les vues avancées restent backend-agnostiques et passent uniquement par `ksp-store-lib`.
-- [ ] **TODO** — différer une future `ksp-app-control-desk` jusqu'à ce que KSP dispose au minimum d'un niveau N3/D3 de processing/materialization exploitable et de plusieurs decoders réels. Cette application sera une surface **end-user simplifiée** : démarrer/arrêter les flux autorisés, lancer une recherche courante, voir l'état global et les erreurs importantes. Elle ne recopiera pas le diagnostic détaillé, les réglages avancés, les tables complètes ni toutes les fonctions des `ksp-app-*-desk` spécialisées, qui resteront les outils d'administration, développement et investigation approfondie.
+- [ ] **TODO** — différer une future `ksp-app-control-desk` jusqu'à ce que KSP dispose au minimum d'une couche D3 DECODED de processing/materialization exploitable et de plusieurs decoders réels. Cette application sera une surface **end-user simplifiée** : démarrer/arrêter les flux autorisés, lancer une recherche courante, voir l'état global et les erreurs importantes. Elle ne recopiera pas le diagnostic détaillé, les réglages avancés, les tables complètes ni toutes les fonctions des `ksp-app-*-desk` spécialisées, qui resteront les outils d'administration, développement et investigation approfondie.
 
-### TODO/IDEAS — taxonomie N1, processing et rétention
+### TODO/IDEAS — taxonomie D1, processing et rétention
 
-- [ ] **TODO** — maintenir la matrice d’admission HTTP/WS/gRPC/provider lors de toute nouvelle famille N1 : plusieurs sources ne convergent vers un même struct que si elles satisfont la même sémantique sans perte.
+- [ ] **TODO** — maintenir la matrice d’admission HTTP/WS/gRPC/provider lors de toute nouvelle famille D1 : plusieurs sources ne convergent vers un même struct que si elles satisfont la même sémantique sans perte.
-- [ ] **TODO `0.3.9`** — produire après fermeture de `ksp-worker-api` une matrice RAW Transaction unique et réutilisable par `0.3.10` puis `0.3.12`, couvrant discovery, hydration/direct payload, filtres, ordering/duplicates, reconnect/replay, gap repair, backpressure, commitment, provenance, quotas, gaps Transport/Config et applicability continuous-ingest/catch-up/backfill.
+- [X] **TODO `0.3.9`** — matrice RAW Transaction unique produite et consolidée dans `docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md`, avec séparation possibilités/support/preuve, capabilities orthogonales aux producteurs, provenance/déduplication/continuité et handoffs désormais scindés `0.3.11`–`0.3.14` Worker live / `0.3.16` Backfill historique.
-- [ ] **TODO Helius futur** — ne pas ajouter d'URL/endpoints Helius en `0.3.8` ni pendant la construction générique de Worker API. L'audit `0.3.9` réévalue les capabilities/tier courants ; `0.3.10` peut ensuite ajouter les profils HTTP/WS réellement nécessaires en réutilisant exclusivement `KSP_SECRET_HELIUS_API_KEY` via Config.
+- [ ] **TODO Helius `0.3.13`** — ajouter uniquement les profils/capabilities Helius réellement nécessaires au Worker live après revalidation des surfaces/tier courants ; réutiliser exclusivement `KSP_SECRET_HELIUS_API_KEY` via Config et la surface `transactionSubscribe` déjà Transport-owned, sans SDK provider ni second client parallèle.
-- [ ] **TODO réseau** — auditer `mainnet` vs `mainnet-beta` avant tout renommage : Store persisté, Config, Transport, checkpoints/fingerprints et aliases externes doivent converger vers une identité KSP unique pour le même cluster ; aucune migration/canonicalisation n'est supposée avant cette preuve.
+- [X] **TODO réseau** — identité KSP canonique fixée à `mainnet` dans Config/Store/Transport/tests ; `mainnet-beta` reste uniquement un alias legacy/externe lorsque la frontière provider l'exige. Les données D1 RAW antérieures restent non autoritaires pendant cette phase et aucune compatibilité de base de test n'impose l'ancien libellé.
 - [X] `RawAccountState` + observation — contrat commun stabilisé en `0.3.1` avec bytes complets + slot, provenance séparée et enrichissements source-specific optionnels ; la persistence PostgreSQL physique est complétée en `0.3.4` avec les quatre capabilities account et la conformance RAW 10/10.
 - [ ] **TODO** — statut/commitment transactionnel restant : `0.3.5` couvre uniquement le fait passif d’exécution `slot + signature + outcome`; réauditer séparément `signatureSubscribe` et `getSignatureStatuses` lorsqu’un consumer de commitment/snapshot réel apparaît, sans fusionner snapshot, transition et execution update dans un modèle Option-soup.
 - [ ] **IDEA** — logs realtime enrichis : `logsSubscribe` alimente déjà la projection minimale `TransactionExecutionEvent`, mais un éventuel `TransactionLogEvent` portant les lignes de log reste différé dans `docs/IDEAS.md` jusqu’à démonstration d’un consumer et de bornes explicites. `logMessages` reste dans `RawTransaction` jusqu’à STRUCTURAL ; le wake-up post-commit reste distinct et Store API-owned conformément à `KSP-NOTIFY-*`.
@@ -129,13 +133,13 @@ RAW -> STRUCTURAL -> DECODED -> DOMAIN
 - [X] rétention physique `RawTransaction` PostgreSQL — `0.3.3` matérialise `Full -> Archived -> Purged`, tombstone et ForceRehydrate atomiques ; `Compacted` reste explicitement unsupported tant qu’aucune représentation compactée réelle n’existe.
 - [ ] **TODO** — policy de rétention/compaction : définir les critères d’éligibilité fondés sur les preuves de processing et la maintenance worker/job ; Store applique une transition demandée mais ne décide pas seul qu’un RAW peut être archivé/purgé, et la compaction physique ne sera ajoutée qu’avec un besoin réel.
 - [X] frontière `ksp-interface-lib` / `ksp-store-api` — ownership documenté et canaris de non-duplication stabilisés en `0.3.1`; les events passifs non persistés restent Interface, les modèles persistants/replayables restent Store API.
-- [ ] **IDEA** — réauditer la structure de processing/decode/materialization historique kbot2/kbot3 lors de l’ouverture de N2/N3 ; conserver l’isolation instruction/CPI et les statuts terminal/versionnés, sans reprendre automatiquement le schéma SQL historique.
+- [ ] **IDEA** — réauditer la structure de processing/decode/materialization historique kbot2/kbot3 lors de l’ouverture de D2/D3 ; conserver l’isolation instruction/CPI et les statuts terminal/versionnés, sans reprendre automatiquement le schéma SQL historique.
 
 ## Série STRUCTURAL suivante
 
 - [ ] Définir la persistence STRUCTURAL canonique Solana générique pour les familles réellement décomposables.
 - [ ] Implémenter en priorité `RawTransaction -> STRUCTURAL` sans decoder Program : transaction/message, comptes/références, instructions top-level, CPI/inner instructions, logs/meta/balances/return data et relations structurelles.
-- [ ] Vérifier avant extension si d'autres familles N1 possèdent une vraie décomposition STRUCTURAL utile ; ne pas créer de niveau vide par convention.
+- [ ] Vérifier avant extension si d'autres familles D1 possèdent une vraie décomposition STRUCTURAL utile ; ne pas créer de niveau vide par convention.
 - [ ] Ajouter replay/backfill RAW -> STRUCTURAL avec processing versionné.
 - [ ] Ajouter le worker/service STRUCTURAL utile sans le coupler à un worker RAW concret.
 - [ ] Faire évoluer `ksp-app-store-desk` avec des vues/requêtes STRUCTURAL lorsque cette couche est réellement persistée ; ne pas créer une seconde application de browsing des mêmes données.

config/examples/std.store.example.json

@@ -29,7 +29,7 @@
         },
         {
             "profile_id": "mainnet",
-            "network": "mainnet-beta",
+            "network": "mainnet",
             "backend": "postgres",
             "postgres": {
                 "connection_uri": "${KSP_SECRET_STORE_MAINNET_POSTGRES_URI:-postgresql://localhost/ksp_mainnet}",

config/examples/std.transport.example.json

@@ -31,8 +31,8 @@
                     "name": "mainnet_public",
                     "enabled": true,
                     "provider": "solana-public",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
-                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_HTTP_URL:-https://api.mainnet-beta.solana.com}",
+                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_HTTP_URL:-https://api.mainnet.solana.com}",
                     "connect_timeout_ms": 5000,
                     "request_timeout_ms": 15000,
                     "max_idle_connections_per_host": 8,
@@ -57,7 +57,7 @@
                     "name": "mainnet_private",
                     "enabled": true,
                     "provider": "private-provider",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "url": "${KSP_SECRET_SOLANA_HTTP_URL:-https://example.invalid}",
                     "connect_timeout_ms": 5000,
                     "request_timeout_ms": 10000,
@@ -85,15 +85,15 @@
                     "name": "mainnet_public_ws",
                     "enabled": true,
                     "provider": "solana-public",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "kind": "solana_standard",
-                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_WS_URL:-wss://api.mainnet-beta.solana.com}"
+                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_WS_URL:-wss://api.mainnet.solana.com}"
                 },
                 {
                     "name": "mainnet_helius_ws",
                     "enabled": true,
                     "provider": "helius",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "kind": "helius_laserstream",
                     "url": "wss://mainnet.helius-rpc.com/?api-key=${KSP_SECRET_HELIUS_API_KEY:-replace-me}",
                     "session": {

config/std.store.json

@@ -29,7 +29,7 @@
         },
         {
             "profile_id": "mainnet",
-            "network": "mainnet-beta",
+            "network": "mainnet",
             "backend": "postgres",
             "postgres": {
                 "connection_uri": "${KSP_SECRET_STORE_MAINNET_POSTGRES_URI:-postgresql://localhost/ksp_mainnet}",

config/std.transport.json

@@ -144,8 +144,8 @@
                     "name": "solana_mainnet_public",
                     "enabled": true,
                     "provider": "solana-public",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
-                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_HTTP_URL:-https://api.mainnet-beta.solana.com}",
+                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_HTTP_URL:-https://api.mainnet.solana.com}",
                     "connect_timeout_ms": 5000,
                     "request_timeout_ms": 15000,
                     "max_idle_connections_per_host": 8,
@@ -172,9 +172,9 @@
                     "name": "solana_mainnet_public_ws",
                     "enabled": true,
                     "provider": "solana-public",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "kind": "solana_standard",
-                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_WS_URL:-wss://api.mainnet-beta.solana.com}"
+                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_WS_URL:-wss://api.mainnet.solana.com}"
                 }
             ]
         },
@@ -185,8 +185,8 @@
                     "name": "solana_mainnet_public",
                     "enabled": true,
                     "provider": "solana-public",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
-                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_HTTP_URL:-https://api.mainnet-beta.solana.com}",
+                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_HTTP_URL:-https://api.mainnet.solana.com}",
                     "connect_timeout_ms": 5000,
                     "request_timeout_ms": 15000,
                     "max_idle_connections_per_host": 8,
@@ -225,7 +225,7 @@
                     "name": "publicnode_solana_mainnet_http",
                     "enabled": true,
                     "provider": "publicnode",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "url": "https://solana-rpc.publicnode.com",
                     "connect_timeout_ms": 5000,
                     "request_timeout_ms": 15000,
@@ -267,9 +267,9 @@
                     "name": "solana_mainnet_public_ws",
                     "enabled": true,
                     "provider": "solana-public",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "kind": "solana_standard",
-                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_WS_URL:-wss://api.mainnet-beta.solana.com}"
+                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_WS_URL:-wss://api.mainnet.solana.com}"
                 }
             ]
         },
@@ -280,8 +280,8 @@
                     "name": "solana_mainnet_public",
                     "enabled": true,
                     "provider": "solana-public",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
-                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_HTTP_URL:-https://api.mainnet-beta.solana.com}",
+                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_HTTP_URL:-https://api.mainnet.solana.com}",
                     "connect_timeout_ms": 5000,
                     "request_timeout_ms": 15000,
                     "max_idle_connections_per_host": 8,
@@ -308,9 +308,9 @@
                     "name": "solana_mainnet_public_ws",
                     "enabled": true,
                     "provider": "solana-public",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "kind": "solana_standard",
-                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_WS_URL:-wss://api.mainnet-beta.solana.com}"
+                    "url": "${KSP_PUBLIC_SOLANA_MAINNET_WS_URL:-wss://api.mainnet.solana.com}"
                 }
             ],
             "grpc_endpoints": [
@@ -318,7 +318,7 @@
                     "name": "publicnode_solana_mainnet_yellowstone",
                     "enabled": true,
                     "provider": "publicnode",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "protocol": "solana_yellowstone",
                     "url": "https://solana-yellowstone-grpc.publicnode.com:443",
                     "secret_metadata": [

crates/ksp-app-backfill-desk/unit_tests/backfill_request.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-backfill-desk/unit_tests/backfill_request.rs
-// version: 3
+// version: 4
 
 fn ready_options() -> crate::BackfillDeskOptionsDto {
     let limits = crate::backfill_request_limits();
@@ -22,7 +22,7 @@ fn ready_options() -> crate::BackfillDeskOptionsDto {
     return crate::BackfillDeskOptionsDto {
         commitments: crate::backfill_commitment_codes(),
         composition_ready: true,
-        configured_networks: vec!["mainnet-beta".to_owned()],
+        configured_networks: vec!["mainnet".to_owned()],
         http_routes: vec![
             crate::BackfillHttpRouteOptionDto {
                 pooled: true,
@@ -36,7 +36,7 @@ fn ready_options() -> crate::BackfillDeskOptionsDto {
         program_id_options: crate::program_id_autocomplete_options(),
         scope_kinds: crate::backfill_scope_kind_codes(),
         store_diagnostic: std::option::Option::None,
-        store_network: std::option::Option::Some("mainnet-beta".to_owned()),
+        store_network: std::option::Option::Some("mainnet".to_owned()),
         store_ready: true,
         transport_diagnostic: std::option::Option::None,
         transport_ready: true,
@@ -81,7 +81,7 @@ fn latest_address_maps_to_backend_network_role_commitment_and_bounds() {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return,
     };
-    assert_eq!(mapped.network().as_str(), "mainnet-beta");
+    assert_eq!(mapped.network().as_str(), "mainnet");
     assert_eq!(mapped.role().as_str(), "backfill_pool");
     assert_eq!(mapped.commitment(), ksp_job_backfill_lib::BackfillCommitment::Finalized);
     assert_eq!(mapped.scope().kind(), ksp_job_backfill_lib::BackfillScopeKind::LatestAddress);
@@ -193,7 +193,7 @@ fn request_preview_never_contains_address_or_signature_values() {
     if let std::result::Result::Ok(serialized) = serialized {
         assert!(!serialized.contains("11111111111111111111111111111111"));
         assert!(!serialized.contains(&"1".repeat(64)));
-        assert!(serialized.contains("mainnet-beta"));
+        assert!(serialized.contains("mainnet"));
         assert!(serialized.contains("backfill_pool"));
     }
 }

crates/ksp-app-backfill-desk/unit_tests/backfill_run.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-backfill-desk/unit_tests/backfill_run.rs
-// version: 3
+// version: 4
 
 #[test]
 fn generated_run_ids_are_backend_owned_bounded_and_unique_in_session() {
@@ -30,7 +30,7 @@ fn cancellable_runtime(
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return std::option::Option::None,
     };
-    let network = match ksp_store_lib::RawNetworkId::new("mainnet-beta") {
+    let network = match ksp_store_lib::RawNetworkId::new("mainnet") {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return std::option::Option::None,
     };

crates/ksp-app-backfill-desk/unit_tests/backfill_status.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-backfill-desk/unit_tests/backfill_status.rs
-// version: 1
+// version: 2
 
 fn initial_notification() -> std::option::Option<ksp_job_api::JobNotification<ksp_job_backfill_lib::BackfillJobSnapshot>> {
     let signature = match ksp_job_backfill_lib::BackfillSignature::new("1".repeat(ksp_job_backfill_lib::MIN_BACKFILL_SIGNATURE_TEXT_BYTES)) {
@@ -14,7 +14,7 @@ fn initial_notification() -> std::option::Option<ksp_job_api::JobNotification<ks
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return std::option::Option::None,
     };
-    let network = match ksp_store_lib::RawNetworkId::new("mainnet-beta") {
+    let network = match ksp_store_lib::RawNetworkId::new("mainnet") {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return std::option::Option::None,
     };

crates/ksp-app-backfill-desk/unit_tests/store_runtime.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-backfill-desk/unit_tests/store_runtime.rs
-// version: 1
+// version: 2
 
 #[test]
 fn store_health_mapping_is_explicit_and_conservative() {
@@ -10,7 +10,7 @@ fn store_health_mapping_is_explicit_and_conservative() {
 #[test]
 fn store_transport_network_coherence_requires_exact_logical_identity() {
     assert!(super::validate_network_coherence("devnet", "devnet").is_ok());
-    let mismatch = super::validate_network_coherence("mainnet-beta", "devnet");
+    let mismatch = super::validate_network_coherence("mainnet", "devnet");
     assert!(mismatch.is_err());
     if let std::result::Result::Err(error) = mismatch {
         assert_eq!(error.code(), crate::ERROR_CODE_STORE_NETWORK_MISMATCH);

crates/ksp-app-store-desk/unit_tests/dto_common.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-store-desk/unit_tests/dto_common.rs
-// version: 2
+// version: 3
 
 #[test]
 fn command_error_projection_keeps_only_stable_public_fields() {
@@ -19,7 +19,7 @@ fn store_runtime_status_dto_contains_only_safe_portable_fields() {
         diagnostic: std::option::Option::None,
         health_state: "ready".to_owned(),
         migration_version_decimal: std::option::Option::Some("2".to_owned()),
-        network: std::option::Option::Some("mainnet-beta".to_owned()),
+        network: std::option::Option::Some("mainnet".to_owned()),
         pending_migration_count: 0,
         pool_available: 1,
         pool_capacity: 8,

crates/ksp-app-wallet-desk/capabilities/default.json

@@ -8,7 +8,6 @@
     ],
     "permissions": [
         "core:default",
-        "tracing:default",
+        "tracing:default"
-        "dialog:default"
     ]
 }

crates/ksp-app-wallet-desk/package.json

@@ -11,7 +11,6 @@
         "@fltsci/tauri-plugin-tracing": "^0.3",
         "@fortawesome/fontawesome-free": "^7.3",
         "@tauri-apps/api": "^2.11",
-        "@tauri-apps/plugin-dialog": "^2.7",
         "bootstrap": "^5.3",
         "datatables.net-bs5": "^3.0",
         "datatables.net-select-bs5": "^4.0",

crates/ksp-config-lib/USAGE.md

@@ -1,5 +1,5 @@
 <!-- file: crates/ksp-config-lib/USAGE.md -->
-<!-- version: 14 -->
+<!-- version: 15 -->
 
 # Utilisation de ksp-config-lib
 
@@ -250,7 +250,7 @@ Targets committed :
 
 ```text
 devnet   -> network devnet       -> KSP_SECRET_STORE_DEVNET_POSTGRES_URI
-mainnet  -> network mainnet-beta -> KSP_SECRET_STORE_MAINNET_POSTGRES_URI
+mainnet  -> network mainnet -> KSP_SECRET_STORE_MAINNET_POSTGRES_URI
 testnet  -> network testnet      -> KSP_SECRET_STORE_TESTNET_POSTGRES_URI
 ```
 

crates/ksp-config-lib/unit_tests/fixtures/std.store.json

@@ -29,7 +29,7 @@
         },
         {
             "profile_id": "mainnet",
-            "network": "mainnet-beta",
+            "network": "mainnet",
             "backend": "postgres",
             "postgres": {
                 "connection_uri": "${KSP_SECRET_STORE_MAINNET_POSTGRES_URI:-postgresql://localhost/ksp_mainnet}",

crates/ksp-config-lib/unit_tests/fixtures/std.transport.json

@@ -76,7 +76,7 @@
                     "name": "fixture_helius_ws",
                     "enabled": true,
                     "provider": "helius",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "kind": "helius_laserstream",
                     "url": "wss://mainnet.helius-rpc.com/?api-key=${KSP_SECRET_HELIUS_API_KEY:-fixture-helius-key}"
                 }

crates/ksp-config-lib/unit_tests/fixtures_v3/std.transport.json

@@ -45,7 +45,7 @@
                     "name": "fixture_http",
                     "enabled": true,
                     "provider": "fixture-provider",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "url": "https://fallback.invalid",
                     "connect_timeout_ms": 1000,
                     "request_timeout_ms": 3000,
@@ -73,7 +73,7 @@
                     "name": "fixture_ws",
                     "enabled": true,
                     "provider": "fixture-provider",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "kind": "solana_standard",
                     "url": "wss://fallback.invalid"
                 }
@@ -83,7 +83,7 @@
                     "name": "fixture_grpc",
                     "enabled": true,
                     "provider": "fixture-provider",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "protocol": "solana_yellowstone",
                     "url": "https://grpc.invalid",
                     "metadata": [
@@ -115,7 +115,7 @@
                     "name": "fixture_http",
                     "enabled": true,
                     "provider": "fixture-provider",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "url": "https://fallback.invalid",
                     "connect_timeout_ms": 1000,
                     "request_timeout_ms": 3000,
@@ -143,7 +143,7 @@
                     "name": "fixture_ws",
                     "enabled": true,
                     "provider": "fixture-provider",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "kind": "solana_standard",
                     "url": "wss://fallback.invalid"
                 }
@@ -153,7 +153,7 @@
                     "name": "fixture_grpc",
                     "enabled": true,
                     "provider": "fixture-provider",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "protocol": "solana_yellowstone",
                     "url": "https://grpc.invalid",
                     "metadata": [
@@ -180,7 +180,7 @@
                     "name": "fixture_http",
                     "enabled": true,
                     "provider": "fixture-provider",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "url": "https://fallback.invalid",
                     "connect_timeout_ms": 1000,
                     "request_timeout_ms": 3000,
@@ -208,7 +208,7 @@
                     "name": "fixture_ws",
                     "enabled": true,
                     "provider": "fixture-provider",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "kind": "solana_standard",
                     "url": "wss://fallback.invalid"
                 }
@@ -218,7 +218,7 @@
                     "name": "fixture_grpc",
                     "enabled": true,
                     "provider": "fixture-provider",
-                    "cluster": "mainnet-beta",
+                    "cluster": "mainnet",
                     "protocol": "solana_yellowstone",
                     "url": "https://grpc.invalid",
                     "metadata": [],

crates/ksp-config-lib/unit_tests/store.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-config-lib/unit_tests/store.rs
-// version: 4
+// version: 5
 
 #[test]
 fn committed_store_profile_maps_exact_runtime_settings_and_secret_fallback() {
@@ -122,7 +122,7 @@ fn named_store_targets_select_one_network_and_database_without_runtime_multiplex
     let environment = crate::ConfigEnvironment::from_maps(process, std::collections::BTreeMap::new());
     for (target_id, network, expected_uri) in [
         ("devnet", "devnet", "postgresql://devnet.invalid/ksp_devnet"),
-        ("mainnet", "mainnet-beta", "postgresql://mainnet.invalid/ksp_mainnet"),
+        ("mainnet", "mainnet", "postgresql://mainnet.invalid/ksp_mainnet"),
         ("testnet", "testnet", "postgresql://testnet.invalid/ksp_testnet"),
     ] {
         let resolved = engine.load_resolved_store_config(std::option::Option::Some(target_id), &environment);

crates/ksp-config-lib/unit_tests/transport.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-config-lib/unit_tests/transport.rs
-// version: 12
+// version: 13
 
 #[test]
 fn fixture_transport_profile_maps_complete_runtime_contract() {
@@ -68,7 +68,7 @@ fn fixture_transport_profile_maps_complete_runtime_contract() {
         let helius = &ws.endpoints()[1];
         assert_eq!(helius.name(), "fixture_helius_ws");
         assert_eq!(helius.provider().as_str(), "helius");
-        assert_eq!(helius.cluster().as_str(), "mainnet-beta");
+        assert_eq!(helius.cluster().as_str(), "mainnet");
         assert_eq!(helius.protocol(), ksp_onchain_transport_lib::WsProtocolKind::HeliusLaserStream);
         assert_eq!(helius.url().as_str(), "wss://mainnet.helius-rpc.com/?api-key=fixture-helius-key");
         let _connect_future = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::connect(helius.clone());
@@ -122,13 +122,13 @@ fn committed_transport_document_maps_default_and_explicit_profiles() {
     if let std::result::Result::Ok(mainnet) = mainnet {
         assert_eq!(mainnet.profile_id(), "mainnet_public");
         assert_eq!(mainnet.selection_source(), crate::ConfigProfileSelectionSource::Explicit);
-        assert_eq!(mainnet.settings().endpoints()[0].cluster().as_str(), "mainnet-beta");
+        assert_eq!(mainnet.settings().endpoints()[0].cluster().as_str(), "mainnet");
-        assert_eq!(mainnet.settings().endpoints()[0].url().as_str(), "https://api.mainnet-beta.solana.com");
+        assert_eq!(mainnet.settings().endpoints()[0].url().as_str(), "https://api.mainnet.solana.com");
         assert!(mainnet.grpc_settings().is_none(), "generic Mainnet profile must stay distinct from the PublicNode gRPC profile");
         let ws = mainnet.ws_settings();
         assert!(ws.is_some(), "committed V3 Mainnet profile should expose WebSocket settings");
         if let std::option::Option::Some(ws) = ws {
-            assert_eq!(ws.endpoints()[0].url().as_str(), "wss://api.mainnet-beta.solana.com");
+            assert_eq!(ws.endpoints()[0].url().as_str(), "wss://api.mainnet.solana.com");
         }
     }
 }
@@ -190,7 +190,7 @@ fn committed_v3_publicnode_profiles_map_provider_neutral_yellowstone_grpc_with_n
         (
             "publicnode_mainnet",
             "publicnode_solana_mainnet_yellowstone",
-            "mainnet-beta",
+            "mainnet",
             "https://solana-yellowstone-grpc.publicnode.com:443",
             "KSP_SECRET_PUBLICNODE_MAINNET_GRPC_X_TOKEN",
             "PUBLICNODE-MAINNET-GRPC-X-TOKEN-CANARY",
@@ -480,7 +480,7 @@ fn helius_laserstream_mainnet_and_devnet_api_key_map_to_protocol_and_safe_redact
         assert_eq!(ws.endpoints().len(), 2);
         let endpoint = &ws.endpoints()[1];
         assert_eq!(endpoint.provider().as_str(), "helius");
-        assert_eq!(endpoint.cluster().as_str(), "mainnet-beta");
+        assert_eq!(endpoint.cluster().as_str(), "mainnet");
         assert_eq!(endpoint.protocol(), ksp_onchain_transport_lib::WsProtocolKind::HeliusLaserStream);
         assert_eq!(endpoint.url().as_str(), "wss://mainnet.helius-rpc.com/?api-key=helius-api-key-canary");
     }

crates/ksp-job-backfill-lib/Cargo.toml

@@ -1,5 +1,5 @@
 # file: crates/ksp-job-backfill-lib/Cargo.toml
-# version: 4
+# version: 7
 
 [package]
 name = "ksp-job-backfill-lib"
@@ -13,6 +13,7 @@ ksp-core-lib = { path = "../ksp-core-lib" }
 ksp-job-api = { path = "../ksp-job-api" }
 ksp-logging-lib = { path = "../ksp-logging-lib" }
 ksp-onchain-transport-lib = { path = "../ksp-onchain-transport-lib" }
+ksp-raw-transaction-lib = { path = "../ksp-raw-transaction-lib" }
 ksp-store-lib = { path = "../ksp-store-lib", default-features = false }
 serde_json.workspace = true
 sha2.workspace = true
@@ -20,6 +21,9 @@ tokio = { workspace = true, features = ["macros", "sync"] }
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+tokio-tungstenite = { workspace = true, features = ["handshake"] }
+tonic = { workspace = true, features = ["codegen", "server"] }
+yellowstone-grpc-proto = { workspace = true, features = ["tonic"] }
 
 [lints]
 workspace = true

crates/ksp-job-backfill-lib/README.md

@@ -1,11 +1,11 @@
 <!-- file: crates/ksp-job-backfill-lib/README.md -->
-<!-- version: 1 -->
+<!-- version: 2 -->
 
 # ksp-job-backfill-lib
 
 `ksp-job-backfill-lib` implémente le premier job historique concret de KSP : un backfill borné de transactions Solana vers la couche RAW durable.
 
-La crate compose les contrats Job, Transport observé et Store backend-neutral sans posséder leurs politiques internes. Elle couvre l'admission, la découverte historique, l'hydratation `getTransaction`, la conversion RAW v1, la persistance atomique, la concurrence bornée, la frontier contiguë, le checkpoint caller-owned, l'annulation coopérative et les snapshots latest-value.
+La crate compose les contrats Job, Transport observé, common RAW et Store backend-neutral sans posséder leurs politiques internes. Elle couvre l'admission, la découverte historique, l'hydratation `getTransaction`, l'adaptation vers `ksp-raw-transaction-lib`, la persistance atomique, la concurrence bornée, la frontier contiguë, le checkpoint caller-owned, l'annulation coopérative et les snapshots latest-value.
 
 ## Identité
 
@@ -94,6 +94,7 @@ ksp-core-lib
 ksp-job-api
 ksp-logging-lib
 ksp-onchain-transport-lib
+ksp-raw-transaction-lib
 ksp-store-lib (default-features = false)
 futures-util
 serde_json

crates/ksp-job-backfill-lib/src/conversion.rs

@@ -1,18 +1,13 @@
 // file: crates/ksp-job-backfill-lib/src/conversion.rs
-// version: 4
+// version: 5
 
 use sha2::Digest; // rust-rules: trait-import
 
-/// KSP-owned source-independent RAW transaction format identifier produced by this Backfill vertical.
-pub const RAW_TRANSACTION_FORMAT_ID: &str = "ksp.solana.raw_transaction";
-/// Initial KSP-owned RAW transaction format version produced by this Backfill vertical.
-pub const RAW_TRANSACTION_FORMAT_VERSION: u32 = 1;
-
 const RAW_TRANSACTION_METHOD_CODE: &str = "getTransaction";
 const RAW_TRANSACTION_OBSERVATION_CONTRACT_VERSION: u32 = 1;
 const RAW_TRANSACTION_PROTOCOL_CODE: &str = "solana.http.json_rpc";
 
-/// Complete in-memory RAW transaction acquisition ready for the later Store persistence tranche.
+/// Complete in-memory RAW transaction acquisition ready for Store persistence.
 #[derive(Debug)]
 pub struct BackfillRawAcquisition {
     inner: Box<BackfillRawAcquisitionInner>,
@@ -20,35 +15,34 @@ pub struct BackfillRawAcquisition {
 
 #[derive(Debug)]
 struct BackfillRawAcquisitionInner {
-    transaction: ksp_store_lib::RawTransaction,
+    acquisition: ksp_raw_transaction_lib::RawTransactionAcquisition,
-    observation: ksp_store_lib::RawTransactionObservation,
 }
 
 impl crate::BackfillRawAcquisition {
-    /// Returns the canonical RAW transaction produced from the typed Transport response.
+    /// Returns the canonical RAW transaction produced through the source-neutral common layer.
     #[must_use]
-    pub const fn transaction(&self) -> &ksp_store_lib::RawTransaction {
+    pub fn transaction(&self) -> &ksp_store_lib::RawTransaction {
-        return &self.inner.transaction;
+        return self.inner.acquisition.transaction();
     }
 
-    /// Returns the acquisition observation whose provenance records the actual successful endpoint.
+    /// Returns the Backfill-owned acquisition observation linked by the common assembly layer.
     #[must_use]
-    pub const fn observation(&self) -> &ksp_store_lib::RawTransactionObservation {
+    pub fn observation(&self) -> &ksp_store_lib::RawTransactionObservation {
-        return &self.inner.observation;
+        return self.inner.acquisition.observation();
     }
 
-    /// Consumes the in-memory acquisition into the canonical transaction and its observation.
+    /// Consumes the in-memory acquisition into the canonical transaction and its Backfill-owned observation.
     #[must_use]
     pub fn into_parts(self) -> (ksp_store_lib::RawTransaction, ksp_store_lib::RawTransactionObservation) {
         let inner = *self.inner;
-        return (inner.transaction, inner.observation);
+        return inner.acquisition.into_parts();
     }
 }
 
 /// Result of hydrating one deterministic Backfill candidate through observed `getTransaction`.
 #[derive(Debug)]
 pub enum BackfillHydrationOutcome {
-    /// The RPC returned one complete transaction and conversion produced canonical RAW plus provenance.
+    /// The RPC returned one complete transaction and common conversion produced canonical RAW plus Backfill provenance.
     Available(crate::BackfillRawAcquisition),
     /// The RPC returned JSON `null`; only the canonical transaction identity exists and no provenance is fabricated.
     Missing(ksp_store_lib::RawTransactionReference),
@@ -71,11 +65,12 @@ impl crate::BackfillHydrationOutcome {
     }
 }
 
-/// Hydrates one candidate with the typed observed Transport path and converts it to canonical RAW v1.
+/// Hydrates one candidate with the typed observed Transport path and converts it through the common RAW v1 layer.
 ///
 /// The caller supplies the local receipt timestamp because wall-clock ownership remains outside this
-/// pure conversion tranche. Transport retains endpoint selection and retry. This function never
+/// pure conversion path. Transport retains endpoint selection and retry. Backfill retains campaign
-/// persists to Store; persistence begins in `pre.007`.
+/// provenance and observation-key ownership; the common crate owns signature parsing, RAW v1
+/// canonicalization, content hashing and transaction/observation assembly.
 pub async fn hydrate_backfill_candidate(
     transport: &ksp_onchain_transport_lib::HttpTransportPool,
     request: &crate::BackfillRequest,
@@ -105,12 +100,12 @@ pub async fn hydrate_backfill_candidate(
         std::option::Option::None => return std::result::Result::Ok(crate::BackfillHydrationOutcome::Missing(reference)),
     };
     let fields = CanonicalTransactionFields {
-        slot: transaction.slot(),
         block_time: transaction.block_time(),
-        transaction: transaction.transaction(),
         meta: transaction.meta(),
-        version: transaction.version(),
+        slot: transaction.slot(),
+        transaction: transaction.transaction(),
         transaction_index: transaction.transaction_index(),
+        version: transaction.version(),
     };
     let acquisition = convert_available_fields(request, reference, fields, provider.as_str(), endpoint.as_str(), received_at);
     return match acquisition {
@@ -119,49 +114,22 @@ pub async fn hydrate_backfill_candidate(
     };
 }
 
-/// Decodes one validated Base58 signature to exactly 64 canonical bytes without a Solana SDK dependency.
+/// Decodes one validated Base58 signature through the source-neutral common parser while preserving Backfill error semantics.
 pub(crate) fn decode_backfill_signature(signature: &crate::BackfillSignature) -> ksp_core_lib::Result<ksp_store_lib::RawTransactionSignature> {
-    let text = signature.as_str().as_bytes();
+    let parsed = ksp_raw_transaction_lib::parse_raw_transaction_signature(signature.as_str());
-    let mut decoded = [0_u8; 64];
+    return match parsed {
-    let mut leading_zeroes = 0_usize;
+        std::result::Result::Ok(signature) => std::result::Result::Ok(signature),
-    for byte in text {
+        std::result::Result::Err(_) => std::result::Result::Err(conversion_error("signature")),
-        if *byte != b'1' {
-            break;
-        }
-        leading_zeroes += 1;
-    }
-    for byte in text {
-        let digit = match base58_digit(*byte) {
-            std::option::Option::Some(digit) => digit,
-            std::option::Option::None => return std::result::Result::Err(conversion_error("signature")),
-        };
-        let mut carry = u32::from(digit);
-        for output in decoded.iter_mut().rev() {
-            let value = (u32::from(*output) * 58) + carry;
-            *output = (value & 0xff) as u8;
-            carry = value >> 8;
-        }
-        if carry != 0 {
-            return std::result::Result::Err(conversion_error("signature"));
-        }
-    }
-    let significant_len = match decoded.iter().position(|byte| return *byte != 0) {
-        std::option::Option::Some(index) => decoded.len() - index,
-        std::option::Option::None => 0,
     };
-    if leading_zeroes + significant_len != decoded.len() {
-        return std::result::Result::Err(conversion_error("signature"));
-    }
-    return std::result::Result::Ok(ksp_store_lib::RawTransactionSignature::new(decoded));
 }
 
 struct CanonicalTransactionFields<'a> {
-    slot: u64,
     block_time: std::option::Option<i64>,
-    transaction: &'a ksp_onchain_transport_lib::SolanaEncodedTransaction,
     meta: &'a ksp_onchain_transport_lib::SolanaWireField<serde_json::Value>,
-    version: &'a ksp_onchain_transport_lib::SolanaWireField<ksp_onchain_transport_lib::SolanaTransactionVersion>,
+    slot: u64,
+    transaction: &'a ksp_onchain_transport_lib::SolanaEncodedTransaction,
     transaction_index: &'a ksp_onchain_transport_lib::SolanaWireField<u32>,
+    version: &'a ksp_onchain_transport_lib::SolanaWireField<ksp_onchain_transport_lib::SolanaTransactionVersion>,
 }
 
 fn canonical_reference(request: &crate::BackfillRequest, candidate: &crate::BackfillCandidate) -> ksp_core_lib::Result<ksp_store_lib::RawTransactionReference> {
@@ -184,30 +152,9 @@ fn convert_available_fields(
     endpoint: &str,
     received_at: ksp_store_lib::RawTimestamp,
 ) -> ksp_core_lib::Result<crate::BackfillRawAcquisition> {
-    let block_time = convert_block_time(fields.block_time);
+    let transaction = canonical_transaction(&reference, fields);
-    let block_time = match block_time {
+    let transaction = match transaction {
-        std::result::Result::Ok(block_time) => block_time,
+        std::result::Result::Ok(transaction) => transaction,
-        std::result::Result::Err(error) => return std::result::Result::Err(error),
-    };
-    let bytes = canonical_payload_bytes(&fields);
-    let bytes = match bytes {
-        std::result::Result::Ok(bytes) => bytes,
-        std::result::Result::Err(error) => return std::result::Result::Err(error),
-    };
-    let hash: [u8; 32] = sha2::Sha256::digest(bytes.as_slice()).into();
-    let format_id = ksp_store_lib::RawFormatId::new(crate::RAW_TRANSACTION_FORMAT_ID);
-    let format_id = match format_id {
-        std::result::Result::Ok(format_id) => format_id,
-        std::result::Result::Err(_) => return std::result::Result::Err(conversion_error("payload.format_id")),
-    };
-    let payload = ksp_store_lib::RawPayload::try_new(
-        format_id,
-        crate::RAW_TRANSACTION_FORMAT_VERSION,
-        bytes.into_boxed_slice(),
-        ksp_store_lib::RawContentHash::new(hash),
-    );
-    let payload = match payload {
-        std::result::Result::Ok(payload) => payload,
         std::result::Result::Err(error) => return std::result::Result::Err(error),
     };
     let provenance = build_provenance(request, provider, endpoint, received_at);
@@ -215,182 +162,60 @@ fn convert_available_fields(
         std::result::Result::Ok(provenance) => provenance,
         std::result::Result::Err(error) => return std::result::Result::Err(error),
     };
-    let observation_key = observation_key(request, &reference, provider, endpoint);
+    let observation_key = observation_key(request, transaction.reference(), provider, endpoint);
-    let transaction = ksp_store_lib::RawTransaction::new(reference.clone(), fields.slot, block_time, payload);
+    let acquisition = ksp_raw_transaction_lib::assemble_raw_transaction_acquisition(transaction, observation_key, provenance);
-    let observation = ksp_store_lib::RawTransactionObservation::new(observation_key, reference, provenance);
+    return std::result::Result::Ok(crate::BackfillRawAcquisition { inner: Box::new(BackfillRawAcquisitionInner { acquisition }) });
-    return std::result::Result::Ok(crate::BackfillRawAcquisition { inner: Box::new(BackfillRawAcquisitionInner { transaction, observation }) });
 }
 
-fn convert_block_time(value: std::option::Option<i64>) -> ksp_core_lib::Result<std::option::Option<ksp_store_lib::RawTimestamp>> {
+fn canonical_transaction(
-    let seconds = match value {
+    reference: &ksp_store_lib::RawTransactionReference,
-        std::option::Option::Some(seconds) => seconds,
+    fields: CanonicalTransactionFields<'_>,
-        std::option::Option::None => return std::result::Result::Ok(std::option::Option::None),
+) -> ksp_core_lib::Result<ksp_store_lib::RawTransaction> {
-    };
+    let transaction_data = match fields.transaction {
-    let seconds = match u64::try_from(seconds) {
+        ksp_onchain_transport_lib::SolanaEncodedTransaction::Binary { data, encoding }
-        std::result::Result::Ok(seconds) => seconds,
+            if *encoding == ksp_onchain_transport_lib::SolanaTransactionBinaryEncoding::Base64 =>
-        std::result::Result::Err(_) => return std::result::Result::Err(conversion_error("block_time")),
+        {
-    };
+            data.clone()
-    let millis = match seconds.checked_mul(1_000) {
-        std::option::Option::Some(millis) => millis,
-        std::option::Option::None => return std::result::Result::Err(conversion_error("block_time")),
-    };
-    let timestamp = ksp_store_lib::RawTimestamp::from_unix_millis(millis);
-    return match timestamp {
-        std::result::Result::Ok(timestamp) => std::result::Result::Ok(std::option::Option::Some(timestamp)),
-        std::result::Result::Err(_) => std::result::Result::Err(conversion_error("block_time")),
-    };
-}
-
-fn canonical_payload_bytes(fields: &CanonicalTransactionFields<'_>) -> ksp_core_lib::Result<std::vec::Vec<u8>> {
-    let (transaction_data, transaction_encoding) = match fields.transaction {
-        ksp_onchain_transport_lib::SolanaEncodedTransaction::Binary { data, encoding } => {
-            if *encoding != ksp_onchain_transport_lib::SolanaTransactionBinaryEncoding::Base64 {
-                return std::result::Result::Err(conversion_error("transaction.encoding"));
-            }
-            (data.as_str(), "base64")
         },
-        ksp_onchain_transport_lib::SolanaEncodedTransaction::LegacyBinary(_) | ksp_onchain_transport_lib::SolanaEncodedTransaction::Json(_) => {
+        ksp_onchain_transport_lib::SolanaEncodedTransaction::Binary { .. }
+        | ksp_onchain_transport_lib::SolanaEncodedTransaction::LegacyBinary(_)
+        | ksp_onchain_transport_lib::SolanaEncodedTransaction::Json(_) => {
             return std::result::Result::Err(conversion_error("transaction.encoding"));
         },
     };
-    let mut bytes = std::vec::Vec::new();
+    let meta = map_wire_field(fields.meta, |value| return value.clone());
-    bytes.extend_from_slice(b"{\"transaction\":[");
+    let version = map_wire_field(fields.version, |value| {
-    if let std::result::Result::Err(error) = append_json_string(&mut bytes, transaction_data) {
-        return std::result::Result::Err(error);
-    }
-    bytes.push(b',');
-    if let std::result::Result::Err(error) = append_json_string(&mut bytes, transaction_encoding) {
-        return std::result::Result::Err(error);
-    }
-    bytes.push(b']');
-    if let std::result::Result::Err(error) = append_wire_value(&mut bytes, "meta", fields.meta, |output, value| return append_canonical_json(output, value)) {
-        return std::result::Result::Err(error);
-    }
-    let version_result = append_wire_value(&mut bytes, "version", fields.version, |output, value| {
         return match value {
-            ksp_onchain_transport_lib::SolanaTransactionVersion::Legacy => append_json_string(output, "legacy"),
+            ksp_onchain_transport_lib::SolanaTransactionVersion::Legacy => ksp_raw_transaction_lib::RawTransactionVersion::Legacy,
-            ksp_onchain_transport_lib::SolanaTransactionVersion::Number(number) => {
+            ksp_onchain_transport_lib::SolanaTransactionVersion::Number(number) => ksp_raw_transaction_lib::RawTransactionVersion::Number(*number),
-                output.extend_from_slice(number.to_string().as_bytes());
-                std::result::Result::Ok(())
-            },
         };
     });
-    if let std::result::Result::Err(error) = version_result {
+    let transaction_index = map_wire_field(fields.transaction_index, |value| return *value);
-        return std::result::Result::Err(error);
+    let material = ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64(
-    }
+        reference.network().clone(),
-    let transaction_index_result = append_wire_value(&mut bytes, "transactionIndex", fields.transaction_index, |output, value| {
+        reference.signature(),
-        output.extend_from_slice(value.to_string().as_bytes());
+        fields.slot,
-        return std::result::Result::Ok(());
+        fields.block_time,
-    });
+        transaction_data,
-    if let std::result::Result::Err(error) = transaction_index_result {
+        meta,
-        return std::result::Result::Err(error);
+        version,
-    }
+        transaction_index,
-    bytes.push(b'}');
+    );
-    return std::result::Result::Ok(bytes);
+    let canonical = ksp_raw_transaction_lib::canonicalize_raw_transaction(material);
+    return match canonical {
+        std::result::Result::Ok(transaction) => std::result::Result::Ok(transaction),
+        std::result::Result::Err(_) => std::result::Result::Err(conversion_error("common.canonicalization")),
+    };
 }
 
-fn append_wire_value<T, F>(
+fn map_wire_field<T, U, F>(field: &ksp_onchain_transport_lib::SolanaWireField<T>, mut map_value: F) -> ksp_raw_transaction_lib::RawTransactionWireField<U>
-    output: &mut std::vec::Vec<u8>,
-    key: &str,
-    field: &ksp_onchain_transport_lib::SolanaWireField<T>,
-    mut append_value: F,
-) -> ksp_core_lib::Result<()>
 where
-    F: FnMut(&mut std::vec::Vec<u8>, &T) -> ksp_core_lib::Result<()>,
+    F: FnMut(&T) -> U,
 {
     return match field {
-        ksp_onchain_transport_lib::SolanaWireField::Omitted => std::result::Result::Ok(()),
+        ksp_onchain_transport_lib::SolanaWireField::Omitted => ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
-        ksp_onchain_transport_lib::SolanaWireField::Null => {
+        ksp_onchain_transport_lib::SolanaWireField::Null => ksp_raw_transaction_lib::RawTransactionWireField::Null,
-            output.push(b',');
+        ksp_onchain_transport_lib::SolanaWireField::Value(value) => ksp_raw_transaction_lib::RawTransactionWireField::Value(map_value(value)),
-            let key_result = append_json_string(output, key);
-            if let std::result::Result::Err(error) = key_result {
-                return std::result::Result::Err(error);
-            }
-            output.extend_from_slice(b":null");
-            std::result::Result::Ok(())
-        },
-        ksp_onchain_transport_lib::SolanaWireField::Value(value) => {
-            output.push(b',');
-            let key_result = append_json_string(output, key);
-            if let std::result::Result::Err(error) = key_result {
-                return std::result::Result::Err(error);
-            }
-            output.push(b':');
-            append_value(output, value)
-        },
-    };
-}
-
-fn append_canonical_json(output: &mut std::vec::Vec<u8>, value: &serde_json::Value) -> ksp_core_lib::Result<()> {
-    return match value {
-        serde_json::Value::Null => {
-            output.extend_from_slice(b"null");
-            std::result::Result::Ok(())
-        },
-        serde_json::Value::Bool(value) => {
-            if *value {
-                output.extend_from_slice(b"true");
-            } else {
-                output.extend_from_slice(b"false");
-            }
-            std::result::Result::Ok(())
-        },
-        serde_json::Value::Number(value) => {
-            output.extend_from_slice(value.to_string().as_bytes());
-            std::result::Result::Ok(())
-        },
-        serde_json::Value::String(value) => append_json_string(output, value.as_str()),
-        serde_json::Value::Array(values) => {
-            output.push(b'[');
-            for (index, item) in values.iter().enumerate() {
-                if index != 0 {
-                    output.push(b',');
-                }
-                let item_result = append_canonical_json(output, item);
-                if let std::result::Result::Err(error) = item_result {
-                    return std::result::Result::Err(error);
-                }
-            }
-            output.push(b']');
-            std::result::Result::Ok(())
-        },
-        serde_json::Value::Object(values) => {
-            output.push(b'{');
-            let mut keys = values.keys().collect::<std::vec::Vec<_>>();
-            keys.sort_unstable();
-            for (index, key) in keys.iter().enumerate() {
-                if index != 0 {
-                    output.push(b',');
-                }
-                let key_result = append_json_string(output, key.as_str());
-                if let std::result::Result::Err(error) = key_result {
-                    return std::result::Result::Err(error);
-                }
-                output.push(b':');
-                let item = values.get(key.as_str());
-                let item = match item {
-                    std::option::Option::Some(item) => item,
-                    std::option::Option::None => return std::result::Result::Err(conversion_error("payload.meta")),
-                };
-                let item_result = append_canonical_json(output, item);
-                if let std::result::Result::Err(error) = item_result {
-                    return std::result::Result::Err(error);
-                }
-            }
-            output.push(b'}');
-            std::result::Result::Ok(())
-        },
-    };
-}
-
-fn append_json_string(output: &mut std::vec::Vec<u8>, value: &str) -> ksp_core_lib::Result<()> {
-    let encoded = serde_json::to_vec(value);
-    return match encoded {
-        std::result::Result::Ok(encoded) => {
-            output.extend_from_slice(encoded.as_slice());
-            std::result::Result::Ok(())
-        },
-        std::result::Result::Err(_) => std::result::Result::Err(conversion_error("payload.json")),
     };
 }
 
@@ -463,18 +288,6 @@ fn hash_bytes(hasher: &mut sha2::Sha256, value: &[u8]) {
     hasher.update(value);
 }
 
-fn base58_digit(byte: u8) -> std::option::Option<u8> {
-    return match byte {
-        b'1'..=b'9' => std::option::Option::Some(byte - b'1'),
-        b'A'..=b'H' => std::option::Option::Some((byte - b'A') + 9),
-        b'J'..=b'N' => std::option::Option::Some((byte - b'J') + 17),
-        b'P'..=b'Z' => std::option::Option::Some((byte - b'P') + 22),
-        b'a'..=b'k' => std::option::Option::Some((byte - b'a') + 33),
-        b'm'..=b'z' => std::option::Option::Some((byte - b'm') + 44),
-        _ => std::option::Option::None,
-    };
-}
-
 fn conversion_error(field: &'static str) -> ksp_core_lib::Error {
     return ksp_core_lib::Error::new(crate::ERROR_CODE_BACKFILL_RAW_CONVERSION_INVALID, "invalid deterministic Backfill RAW conversion")
         .with_context("field", field);

crates/ksp-job-backfill-lib/src/lib.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-job-backfill-lib/src/lib.rs
-// version: 6
+// version: 7
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -30,10 +30,6 @@ pub use self::checkpoint::BackfillCheckpoint;
 pub use self::conversion::BackfillHydrationOutcome;
 /// Complete in-memory RAW transaction acquisition ready for later Store persistence.
 pub use self::conversion::BackfillRawAcquisition;
-/// KSP-owned source-independent RAW transaction format identifier produced by this Backfill vertical.
-pub use self::conversion::RAW_TRANSACTION_FORMAT_ID;
-/// Initial KSP-owned RAW transaction format version produced by this Backfill vertical.
-pub use self::conversion::RAW_TRANSACTION_FORMAT_VERSION;
 /// Hydrates one candidate through observed Transport and converts a non-null response to canonical RAW v1.
 pub use self::conversion::hydrate_backfill_candidate;
 /// One deterministic transaction candidate produced by bounded discovery.
@@ -112,6 +108,10 @@ pub use self::runtime::BackfillJobRuntime;
 pub use self::runtime::BackfillJobSnapshot;
 /// Cloneable runtime-neutral-facing latest-value source for concrete Backfill snapshots.
 pub use self::runtime::BackfillSnapshotSource;
+/// KSP-owned source-independent RAW transaction format identifier re-exported from the common RAW layer.
+pub use ksp_raw_transaction_lib::RAW_TRANSACTION_FORMAT_ID;
+/// Frozen RAW transaction format version re-exported from the common RAW layer.
+pub use ksp_raw_transaction_lib::RAW_TRANSACTION_FORMAT_VERSION;
 
 /// Internal contiguous completion frontier used by bounded execution.
 pub(crate) use self::checkpoint::CompletionFrontier;

crates/ksp-job-backfill-lib/src/request.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-job-backfill-lib/src/request.rs
-// version: 6
+// version: 7
 
 use sha2::Digest; // rust-rules: trait-import
 
@@ -12,9 +12,9 @@ pub const MAX_BACKFILL_PAGES: usize = 10_000;
 /// Maximum page size admitted for one `getSignaturesForAddress` request.
 pub const MAX_BACKFILL_PAGE_SIZE: usize = 1_000;
 /// Maximum Base58 text length possible for one canonical 64-byte Solana signature.
-pub const MAX_BACKFILL_SIGNATURE_TEXT_BYTES: usize = 88;
+pub const MAX_BACKFILL_SIGNATURE_TEXT_BYTES: usize = ksp_raw_transaction_lib::MAX_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES;
 /// Minimum Base58 text length possible for one canonical 64-byte Solana signature.
-pub const MIN_BACKFILL_SIGNATURE_TEXT_BYTES: usize = 64;
+pub const MIN_BACKFILL_SIGNATURE_TEXT_BYTES: usize = ksp_raw_transaction_lib::MIN_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES;
 
 /// Commitment levels intentionally admitted by the historical Backfill vertical.
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]

crates/ksp-job-backfill-lib/tests/dependency_boundary.rs

@@ -1,23 +1,28 @@
 // file: crates/ksp-job-backfill-lib/tests/dependency_boundary.rs
-// version: 6
+// version: 9
 
 //! Dependency firewall canaries through the concrete cancellation and latest-value runtime tranche.
 
 #[test]
-fn pre_009_manifest_uses_only_planned_ksp_edges_and_private_tokio_runtime() {
+fn pre_003_manifest_adds_common_raw_edge_without_crossing_store_or_runtime_boundaries() {
     let manifest = include_str!("../Cargo.toml");
+    let production_manifest = match manifest.split_once("[dev-dependencies]") {
+        std::option::Option::Some((production, _)) => production,
+        std::option::Option::None => manifest,
+    };
     for required in [
         "futures-util = { workspace = true, features = [\"std\"] }",
         "ksp-core-lib = { path = \"../ksp-core-lib\" }",
         "ksp-job-api = { path = \"../ksp-job-api\" }",
         "ksp-logging-lib = { path = \"../ksp-logging-lib\" }",
         "ksp-onchain-transport-lib = { path = \"../ksp-onchain-transport-lib\" }",
+        "ksp-raw-transaction-lib = { path = \"../ksp-raw-transaction-lib\" }",
         "ksp-store-lib = { path = \"../ksp-store-lib\", default-features = false }",
         "serde_json.workspace = true",
         "sha2.workspace = true",
         "tokio = { workspace = true, features = [\"macros\", \"sync\"] }",
     ] {
-        assert!(manifest.contains(required), "required Backfill dependency missing: {required}");
+        assert!(production_manifest.contains(required), "required Backfill dependency missing: {required}");
     }
     for forbidden in [
         "ksp-config-lib",
@@ -32,13 +37,56 @@ fn pre_009_manifest_uses_only_planned_ksp_edges_and_private_tokio_runtime() {
         "serde = {",
         "tonic",
     ] {
-        assert!(!manifest.contains(forbidden), "forbidden Backfill dependency present: {forbidden}");
+        assert!(!production_manifest.contains(forbidden), "forbidden Backfill dependency present: {forbidden}");
     }
     let root = include_str!("../src/lib.rs");
     assert!(!root.contains("tokio::"), "Tokio implementation types must not leak through the public crate root");
     return;
 }
 
+#[test]
+fn pre_005_websocket_parity_dependency_stays_test_only() {
+    let manifest = include_str!("../Cargo.toml");
+    let parts = manifest.splitn(2, "[dev-dependencies]").collect::<std::vec::Vec<_>>();
+    let (dependencies, dev_dependencies) = match parts.as_slice() {
+        [dependencies, dev_dependencies] => (*dependencies, *dev_dependencies),
+        _ => {
+            assert_eq!(parts.len(), 2, "Backfill manifest must retain exactly one dev-dependencies section");
+            return;
+        },
+    };
+    assert!(!dependencies.contains("tokio-tungstenite"), "WebSocket parity client must not become a production Backfill dependency");
+    assert!(
+        dev_dependencies.contains("tokio-tungstenite = { workspace = true, features = [\"handshake\"] }"),
+        "WebSocket parity client must remain an explicit test-only dependency",
+    );
+    return;
+}
+
+#[test]
+fn pre_006_yellowstone_parity_dependencies_stay_test_only() {
+    let manifest = include_str!("../Cargo.toml");
+    let parts = manifest.splitn(2, "[dev-dependencies]").collect::<std::vec::Vec<_>>();
+    let (dependencies, dev_dependencies) = match parts.as_slice() {
+        [dependencies, dev_dependencies] => (*dependencies, *dev_dependencies),
+        _ => {
+            assert_eq!(parts.len(), 2, "Backfill manifest must retain exactly one dev-dependencies section");
+            return;
+        },
+    };
+    assert!(!dependencies.contains("tonic"), "Yellowstone parity server must not become a production Backfill dependency");
+    assert!(!dependencies.contains("yellowstone-grpc-proto"), "Yellowstone protobuf must not become a production Backfill dependency");
+    assert!(
+        dev_dependencies.contains("tonic = { workspace = true, features = [\"codegen\", \"server\"] }"),
+        "Yellowstone parity server must remain an explicit test-only dependency",
+    );
+    assert!(
+        dev_dependencies.contains("yellowstone-grpc-proto = { workspace = true, features = [\"tonic\"] }"),
+        "Yellowstone protobuf must remain an explicit test-only dependency",
+    );
+    return;
+}
+
 #[test]
 fn pre_009_production_sources_keep_transport_store_and_scheduler_ownership_separate() {
     let neutral_sources = [
@@ -56,7 +104,12 @@ fn pre_009_production_sources_keep_transport_store_and_scheduler_ownership_separ
         }
     }
     let conversion = include_str!("../src/conversion.rs");
-    assert!(conversion.contains("serde_json::"));
+    assert!(conversion.contains("ksp_raw_transaction_lib::canonicalize_raw_transaction"));
+    assert!(conversion.contains("ksp_raw_transaction_lib::assemble_raw_transaction_acquisition"));
+    assert!(conversion.contains("ksp_raw_transaction_lib::parse_raw_transaction_signature"));
+    assert!(!conversion.contains("fn append_canonical_json"));
+    assert!(!conversion.contains("fn base58_digit"));
+    assert!(!conversion.contains("RawPayload::try_new"));
     assert!(conversion.contains("get_transaction_observed"));
     assert!(conversion.contains("SolanaTransactionEncoding::Base64"));
     assert!(conversion.contains("std::option::Option::Some(0)"));

crates/ksp-job-backfill-lib/tests/hardening.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-job-backfill-lib/tests/hardening.rs
-// version: 4
+// version: 7
 
 //! Adversarial, security, visibility and external-boundary hardening canaries for `pre.010`.
 
@@ -268,13 +268,14 @@ fn pre_010_manifest_dependency_surface_is_exact_and_backend_neutral() {
             "ksp-job-api",
             "ksp-logging-lib",
             "ksp-onchain-transport-lib",
+            "ksp-raw-transaction-lib",
             "ksp-store-lib",
             "serde_json.workspace",
             "sha2.workspace",
             "tokio",
         ])
     );
-    assert_eq!(dev, std::collections::BTreeSet::from(["tokio"]));
+    assert_eq!(dev, std::collections::BTreeSet::from(["tokio", "tokio-tungstenite", "tonic", "yellowstone-grpc-proto"]));
     assert!(manifest.contains("ksp-store-lib = { path = \"../ksp-store-lib\", default-features = false }"));
     assert!(manifest.contains("tokio = { workspace = true, features = [\"macros\", \"sync\"] }"));
     assert!(!manifest.contains("ksp-store-postgres-lib"));
@@ -328,6 +329,7 @@ fn pre_010_lower_layers_have_no_dependency_return_to_job() {
         include_str!("../../ksp-core-lib/Cargo.toml"),
         include_str!("../../ksp-logging-lib/Cargo.toml"),
         include_str!("../../ksp-onchain-transport-lib/Cargo.toml"),
+        include_str!("../../ksp-raw-transaction-lib/Cargo.toml"),
         include_str!("../../ksp-store-api/Cargo.toml"),
         include_str!("../../ksp-store-lib/Cargo.toml"),
         include_str!("../../ksp-store-postgres-lib/Cargo.toml"),

crates/ksp-job-backfill-lib/tests/http_block_material.rs

@@ -0,0 +1,158 @@
+// file: crates/ksp-job-backfill-lib/tests/http_block_material.rs
+// version: 2
+
+//! Cross-layer canary for the future Worker-owned HTTP block adapter without changing production ownership.
+
+fn pool_for_url(url: &str) -> ksp_core_lib::Result<ksp_onchain_transport_lib::HttpTransportPool> {
+    let endpoint_url = match ksp_onchain_transport_lib::HttpEndpointUrl::parse(url) {
+        Ok(endpoint_url) => endpoint_url,
+        Err(error) => return Err(error),
+    };
+    let role = ksp_onchain_transport_lib::HttpEndpointRoleSettings::new(
+        ksp_onchain_transport_lib::HttpRoleName::new("default"),
+        true,
+        std::vec![ksp_onchain_transport_lib::HttpRequestKind::wildcard()],
+        10,
+        ksp_onchain_transport_lib::HttpRoleLimits::new(
+            std::option::Option::None,
+            std::option::Option::None,
+            std::option::Option::None,
+            std::option::Option::None,
+        ),
+    );
+    let endpoint = ksp_onchain_transport_lib::HttpEndpointSettings::new(
+        "http-block-fixture",
+        true,
+        ksp_onchain_transport_lib::HttpProviderName::new("fixture-provider"),
+        ksp_onchain_transport_lib::HttpClusterName::new("devnet"),
+        endpoint_url,
+        std::time::Duration::from_secs(1),
+        std::time::Duration::from_secs(1),
+        std::option::Option::Some(1),
+        std::vec![role],
+    );
+    return ksp_onchain_transport_lib::HttpTransportPool::new(ksp_onchain_transport_lib::HttpTransportSettings::new(
+        std::vec![endpoint],
+        ksp_onchain_transport_lib::HttpRetrySettings::new(0, std::time::Duration::from_millis(1), std::time::Duration::from_millis(1)),
+    ));
+}
+
+fn serve_once(body: &'static str) -> std::io::Result<(std::string::String, std::thread::JoinHandle<std::io::Result<()>>)> {
+    let listener = match std::net::TcpListener::bind("127.0.0.1:0") {
+        Ok(listener) => listener,
+        Err(error) => return Err(error),
+    };
+    let address = match listener.local_addr() {
+        Ok(address) => address,
+        Err(error) => return Err(error),
+    };
+    let handle = std::thread::spawn(move || {
+        let (mut stream, _) = match listener.accept() {
+            Ok(accepted) => accepted,
+            Err(error) => return Err(error),
+        };
+        let mut bytes = std::vec::Vec::new();
+        let mut buffer = [0_u8; 1024];
+        loop {
+            let count = match std::io::Read::read(&mut stream, &mut buffer) {
+                Ok(count) => count,
+                Err(error) => return Err(error),
+            };
+            if count == 0 {
+                break;
+            }
+            bytes.extend_from_slice(&buffer[..count]);
+            if bytes.windows(4).any(|window| return window == b"\r\n\r\n") {
+                break;
+            }
+        }
+        let response = format!("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}", body.len(), body);
+        if let Err(error) = std::io::Write::write_all(&mut stream, response.as_bytes()) {
+            return Err(error);
+        }
+        return Ok(());
+    });
+    return Ok((format!("http://{address}"), handle));
+}
+
+fn map_meta(field: &ksp_onchain_transport_lib::SolanaWireField<serde_json::Value>) -> ksp_raw_transaction_lib::RawTransactionWireField<serde_json::Value> {
+    return match field {
+        ksp_onchain_transport_lib::SolanaWireField::Omitted => ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+        ksp_onchain_transport_lib::SolanaWireField::Null => ksp_raw_transaction_lib::RawTransactionWireField::Null,
+        ksp_onchain_transport_lib::SolanaWireField::Value(value) => ksp_raw_transaction_lib::RawTransactionWireField::Value(value.clone()),
+    };
+}
+
+fn map_version(
+    field: &ksp_onchain_transport_lib::SolanaWireField<ksp_onchain_transport_lib::SolanaTransactionVersion>,
+) -> ksp_raw_transaction_lib::RawTransactionWireField<ksp_raw_transaction_lib::RawTransactionVersion> {
+    return match field {
+        ksp_onchain_transport_lib::SolanaWireField::Omitted => ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+        ksp_onchain_transport_lib::SolanaWireField::Null => ksp_raw_transaction_lib::RawTransactionWireField::Null,
+        ksp_onchain_transport_lib::SolanaWireField::Value(ksp_onchain_transport_lib::SolanaTransactionVersion::Legacy) => {
+            ksp_raw_transaction_lib::RawTransactionWireField::Value(ksp_raw_transaction_lib::RawTransactionVersion::Legacy)
+        },
+        ksp_onchain_transport_lib::SolanaWireField::Value(ksp_onchain_transport_lib::SolanaTransactionVersion::Number(number)) => {
+            ksp_raw_transaction_lib::RawTransactionWireField::Value(ksp_raw_transaction_lib::RawTransactionVersion::Number(*number))
+        },
+    };
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn pre_004_http_observed_block_projects_each_base64_transaction_to_common_material_without_new_production_edge() {
+    const BODY: &str = concat!(
+        "{\"jsonrpc\":\"2.0\",\"result\":{\"previousBlockhash\":\"previous\",\"blockhash\":\"block\",\"parentSlot\":430000122,",
+        "\"rewards\":[],\"numRewardPartitions\":0,\"blockTime\":1787072400,\"blockHeight\":410000000,",
+        "\"transactions\":[{\"transaction\":[\"AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+        "AAAAAA\",\"base64\"],\"meta\":{\"err\":null,\"fee\":5000},\"version\":\"legacy\"},",
+        "{\"transaction\":[\"AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEA\",",
+        "\"base64\"],\"meta\":{\"err\":null,\"fee\":6000},\"version\":0}]},\"id\":1}",
+    );
+    let (url, handle) = serve_once(BODY).expect("fixture server must start");
+    let pool = pool_for_url(url.as_str()).expect("fixture pool must build");
+    let config = ksp_onchain_transport_lib::SolanaGetBlockConfig::new(
+        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
+        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionEncoding::Base64),
+        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionDetails::Full),
+        std::option::Option::Some(0),
+        std::option::Option::Some(false),
+    );
+    let observed = pool
+        .get_block_observed(&ksp_onchain_transport_lib::HttpRoleName::new("default"), 430_000_123, std::option::Option::Some(&config))
+        .await
+        .expect("observed block fixture must succeed");
+    assert_eq!(observed.endpoint_name(), "http-block-fixture");
+    assert_eq!(observed.provider().as_str(), "fixture-provider");
+    let block = observed.value().as_ref().expect("fixture block must be present");
+    let transactions = block.transactions().value().expect("fixture transactions must be present");
+    assert_eq!(transactions.len(), 2);
+    let network = ksp_store_lib::RawNetworkId::new("devnet").expect("fixture network must be valid");
+    let expected_signatures = [[0_u8; 64], [1_u8; 64]];
+    for (index, transaction) in transactions.iter().enumerate() {
+        let (data, meta, version) = match transaction.transaction() {
+            ksp_onchain_transport_lib::SolanaEncodedTransaction::Binary {
+                data,
+                encoding: ksp_onchain_transport_lib::SolanaTransactionBinaryEncoding::Base64,
+            } => (data.as_str(), map_meta(transaction.meta()), map_version(transaction.version())),
+            _ => panic!("fixture must remain full Base64 transaction material"),
+        };
+        let transaction_index = u32::try_from(index).expect("fixture transaction index must fit u32");
+        let material = ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64_with_embedded_signature(
+            network.clone(),
+            430_000_123,
+            block.block_time(),
+            data,
+            meta,
+            version,
+            ksp_raw_transaction_lib::RawTransactionWireField::Value(transaction_index),
+        )
+        .expect("HTTP block material must map to common RAW material");
+        let raw = ksp_raw_transaction_lib::canonicalize_raw_transaction(material).expect("mapped HTTP block material must canonicalize");
+        assert_eq!(raw.reference().signature().as_bytes(), &expected_signatures[index]);
+        assert_eq!(raw.slot(), 430_000_123);
+        assert_eq!(raw.block_time().map(|value| return value.unix_millis()), std::option::Option::Some(1_787_072_400_000));
+        assert!(raw.payload().bytes().ends_with(format!("\"transactionIndex\":{transaction_index}}}").as_bytes()));
+    }
+    handle.join().expect("fixture server must join").expect("fixture server must complete successfully");
+    return;
+}

crates/ksp-job-backfill-lib/tests/ws_raw_parity.rs

@@ -0,0 +1,503 @@
+// file: crates/ksp-job-backfill-lib/tests/ws_raw_parity.rs
+// version: 3
+
+//! Cross-layer parity canaries qualifying standard `blockSubscribe` and Helius `transactionSubscribe` for RAW v1 ingestion.
+
+use futures_util::SinkExt; // rust-rules: trait-import
+use futures_util::StreamExt; // rust-rules: trait-import
+
+const FIXTURE_BLOCK_TIME_MILLIS: u64 = 1_787_072_400_000;
+const FIXTURE_SLOT: u64 = 430_000_123;
+const ZERO_SIGNATURE_TEXT: &str = "1111111111111111111111111111111111111111111111111111111111111111";
+const ZERO_TRANSACTION_BASE64: &str = "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+
+type FixtureWebSocket = tokio_tungstenite::WebSocketStream<tokio::net::TcpStream>;
+
+fn http_pool_for_url(url: &str) -> ksp_core_lib::Result<ksp_onchain_transport_lib::HttpTransportPool> {
+    let endpoint_url = match ksp_onchain_transport_lib::HttpEndpointUrl::parse(url) {
+        Ok(endpoint_url) => endpoint_url,
+        Err(error) => return Err(error),
+    };
+    let role = ksp_onchain_transport_lib::HttpEndpointRoleSettings::new(
+        ksp_onchain_transport_lib::HttpRoleName::new("default"),
+        true,
+        std::vec![ksp_onchain_transport_lib::HttpRequestKind::wildcard()],
+        10,
+        ksp_onchain_transport_lib::HttpRoleLimits::new(
+            std::option::Option::None,
+            std::option::Option::None,
+            std::option::Option::None,
+            std::option::Option::None,
+        ),
+    );
+    let endpoint = ksp_onchain_transport_lib::HttpEndpointSettings::new(
+        "ws-parity-http-fixture",
+        true,
+        ksp_onchain_transport_lib::HttpProviderName::new("fixture-http-provider"),
+        ksp_onchain_transport_lib::HttpClusterName::new("devnet"),
+        endpoint_url,
+        std::time::Duration::from_secs(1),
+        std::time::Duration::from_secs(1),
+        std::option::Option::Some(1),
+        std::vec![role],
+    );
+    return ksp_onchain_transport_lib::HttpTransportPool::new(ksp_onchain_transport_lib::HttpTransportSettings::new(
+        std::vec![endpoint],
+        ksp_onchain_transport_lib::HttpRetrySettings::new(0, std::time::Duration::from_millis(1), std::time::Duration::from_millis(1)),
+    ));
+}
+
+fn serve_http_once(body: &'static str) -> std::io::Result<(std::string::String, std::thread::JoinHandle<std::io::Result<()>>)> {
+    let listener = match std::net::TcpListener::bind("127.0.0.1:0") {
+        Ok(listener) => listener,
+        Err(error) => return Err(error),
+    };
+    let address = match listener.local_addr() {
+        Ok(address) => address,
+        Err(error) => return Err(error),
+    };
+    let handle = std::thread::spawn(move || {
+        let (mut stream, _) = match listener.accept() {
+            Ok(accepted) => accepted,
+            Err(error) => return Err(error),
+        };
+        let mut bytes = std::vec::Vec::new();
+        let mut buffer = [0_u8; 1024];
+        loop {
+            let count = match std::io::Read::read(&mut stream, &mut buffer) {
+                Ok(count) => count,
+                Err(error) => return Err(error),
+            };
+            if count == 0 {
+                break;
+            }
+            bytes.extend_from_slice(&buffer[..count]);
+            if bytes.windows(4).any(|window| return window == b"\r\n\r\n") {
+                break;
+            }
+        }
+        let response = format!("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}", body.len(), body);
+        if let Err(error) = std::io::Write::write_all(&mut stream, response.as_bytes()) {
+            return Err(error);
+        }
+        return Ok(());
+    });
+    return Ok((format!("http://{address}"), handle));
+}
+
+fn ws_endpoint(url: &str, protocol: ksp_onchain_transport_lib::WsProtocolKind) -> ksp_core_lib::Result<ksp_onchain_transport_lib::WsEndpointSettings> {
+    let parsed = match ksp_onchain_transport_lib::WsEndpointUrl::parse(url) {
+        Ok(parsed) => parsed,
+        Err(error) => return Err(error),
+    };
+    return Ok(ksp_onchain_transport_lib::WsEndpointSettings::new(
+        "ws-raw-parity-fixture",
+        true,
+        ksp_onchain_transport_lib::WsProviderName::new("fixture-ws-provider"),
+        ksp_onchain_transport_lib::WsClusterName::new("devnet"),
+        protocol,
+        parsed,
+        ksp_onchain_transport_lib::WsSessionSettings::default(),
+    ));
+}
+
+async fn read_ws_request(websocket: &mut FixtureWebSocket) -> std::result::Result<serde_json::Value, std::string::String> {
+    let message = match websocket.next().await {
+        std::option::Option::Some(std::result::Result::Ok(message)) => message,
+        std::option::Option::Some(std::result::Result::Err(_)) => return Err("fixture WebSocket request decode failed".to_owned()),
+        std::option::Option::None => return Err("fixture WebSocket request was absent".to_owned()),
+    };
+    let text = match message.to_text() {
+        Ok(text) => text,
+        Err(_) => return Err("fixture WebSocket request was not text".to_owned()),
+    };
+    return serde_json::from_str(text).map_err(|_| return "fixture WebSocket request JSON was invalid".to_owned());
+}
+
+async fn send_ws_json(websocket: &mut FixtureWebSocket, value: serde_json::Value) -> std::result::Result<(), std::string::String> {
+    return websocket
+        .send(tokio_tungstenite::tungstenite::Message::Text(value.to_string().into()))
+        .await
+        .map_err(|_| return "fixture WebSocket response send failed".to_owned());
+}
+
+async fn send_ws_result(
+    websocket: &mut FixtureWebSocket,
+    request: &serde_json::Value,
+    result: serde_json::Value,
+) -> std::result::Result<(), std::string::String> {
+    let id = match request.get("id").and_then(serde_json::Value::as_u64) {
+        std::option::Option::Some(id) => id,
+        std::option::Option::None => return Err("fixture request id was absent".to_owned()),
+    };
+    return send_ws_json(websocket, serde_json::json!({"jsonrpc":"2.0","id":id,"result":result})).await;
+}
+
+async fn wait_for_ws_close(websocket: &mut FixtureWebSocket) {
+    loop {
+        match websocket.next().await {
+            std::option::Option::Some(std::result::Result::Ok(tokio_tungstenite::tungstenite::Message::Close(_))) => return,
+            std::option::Option::Some(std::result::Result::Ok(_)) => {},
+            std::option::Option::Some(std::result::Result::Err(_)) | std::option::Option::None => return,
+        }
+    }
+}
+
+fn map_meta(field: &ksp_onchain_transport_lib::SolanaWireField<serde_json::Value>) -> ksp_raw_transaction_lib::RawTransactionWireField<serde_json::Value> {
+    return match field {
+        ksp_onchain_transport_lib::SolanaWireField::Omitted => ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+        ksp_onchain_transport_lib::SolanaWireField::Null => ksp_raw_transaction_lib::RawTransactionWireField::Null,
+        ksp_onchain_transport_lib::SolanaWireField::Value(value) => ksp_raw_transaction_lib::RawTransactionWireField::Value(value.clone()),
+    };
+}
+
+fn map_version(
+    field: &ksp_onchain_transport_lib::SolanaWireField<ksp_onchain_transport_lib::SolanaTransactionVersion>,
+) -> ksp_raw_transaction_lib::RawTransactionWireField<ksp_raw_transaction_lib::RawTransactionVersion> {
+    return match field {
+        ksp_onchain_transport_lib::SolanaWireField::Omitted => ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+        ksp_onchain_transport_lib::SolanaWireField::Null => ksp_raw_transaction_lib::RawTransactionWireField::Null,
+        ksp_onchain_transport_lib::SolanaWireField::Value(ksp_onchain_transport_lib::SolanaTransactionVersion::Legacy) => {
+            ksp_raw_transaction_lib::RawTransactionWireField::Value(ksp_raw_transaction_lib::RawTransactionVersion::Legacy)
+        },
+        ksp_onchain_transport_lib::SolanaWireField::Value(ksp_onchain_transport_lib::SolanaTransactionVersion::Number(number)) => {
+            ksp_raw_transaction_lib::RawTransactionWireField::Value(ksp_raw_transaction_lib::RawTransactionVersion::Number(*number))
+        },
+    };
+}
+
+fn raw_from_block_transaction(
+    network: ksp_store_lib::RawNetworkId,
+    slot: u64,
+    block_time: std::option::Option<i64>,
+    transaction: &ksp_onchain_transport_lib::SolanaBlockTransaction,
+    transaction_index: u32,
+) -> std::option::Option<ksp_store_lib::RawTransaction> {
+    let data = match transaction.transaction() {
+        ksp_onchain_transport_lib::SolanaEncodedTransaction::Binary { data, encoding: ksp_onchain_transport_lib::SolanaTransactionBinaryEncoding::Base64 } => {
+            data.as_str()
+        },
+        _ => return std::option::Option::None,
+    };
+    let material = match ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64_with_embedded_signature(
+        network,
+        slot,
+        block_time,
+        data,
+        map_meta(transaction.meta()),
+        map_version(transaction.version()),
+        ksp_raw_transaction_lib::RawTransactionWireField::Value(transaction_index),
+    ) {
+        Ok(material) => material,
+        Err(_) => return std::option::Option::None,
+    };
+    return ksp_raw_transaction_lib::canonicalize_raw_transaction(material).ok();
+}
+
+fn raw_from_confirmed_transaction(
+    network: ksp_store_lib::RawNetworkId,
+    transaction: &ksp_onchain_transport_lib::SolanaConfirmedTransaction,
+) -> std::option::Option<ksp_store_lib::RawTransaction> {
+    let data = match transaction.transaction() {
+        ksp_onchain_transport_lib::SolanaEncodedTransaction::Binary { data, encoding: ksp_onchain_transport_lib::SolanaTransactionBinaryEncoding::Base64 } => {
+            data.as_str()
+        },
+        _ => return std::option::Option::None,
+    };
+    let material = match ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64_with_embedded_signature(
+        network,
+        transaction.slot(),
+        transaction.block_time(),
+        data,
+        map_meta(transaction.meta()),
+        map_version(transaction.version()),
+        match transaction.transaction_index() {
+            ksp_onchain_transport_lib::SolanaWireField::Omitted => ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+            ksp_onchain_transport_lib::SolanaWireField::Null => ksp_raw_transaction_lib::RawTransactionWireField::Null,
+            ksp_onchain_transport_lib::SolanaWireField::Value(value) => ksp_raw_transaction_lib::RawTransactionWireField::Value(*value),
+        },
+    ) {
+        Ok(material) => material,
+        Err(_) => return std::option::Option::None,
+    };
+    return ksp_raw_transaction_lib::canonicalize_raw_transaction(material).ok();
+}
+
+fn raw_from_helius_full(
+    network: ksp_store_lib::RawNetworkId,
+    notification: &ksp_onchain_transport_lib::HeliusFullTransactionNotification,
+) -> std::option::Option<ksp_store_lib::RawTransaction> {
+    let object = match notification.transaction().as_object() {
+        std::option::Option::Some(object) => object,
+        std::option::Option::None => return std::option::Option::None,
+    };
+    let encoded = match object.get("transaction") {
+        std::option::Option::Some(value) => match value.as_array() {
+            std::option::Option::Some(encoded) => encoded,
+            std::option::Option::None => return std::option::Option::None,
+        },
+        std::option::Option::None => return std::option::Option::None,
+    };
+    if encoded.len() != 2 {
+        return std::option::Option::None;
+    }
+    let encoding = match encoded.get(1) {
+        std::option::Option::Some(value) => match value.as_str() {
+            std::option::Option::Some(encoding) => encoding,
+            std::option::Option::None => return std::option::Option::None,
+        },
+        std::option::Option::None => return std::option::Option::None,
+    };
+    if encoding != "base64" {
+        return std::option::Option::None;
+    }
+    let data = match encoded.first() {
+        std::option::Option::Some(value) => match value.as_str() {
+            std::option::Option::Some(data) => data,
+            std::option::Option::None => return std::option::Option::None,
+        },
+        std::option::Option::None => return std::option::Option::None,
+    };
+    let meta = match object.get("meta") {
+        std::option::Option::None => ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+        std::option::Option::Some(serde_json::Value::Null) => ksp_raw_transaction_lib::RawTransactionWireField::Null,
+        std::option::Option::Some(value) => ksp_raw_transaction_lib::RawTransactionWireField::Value(value.clone()),
+    };
+    let signature = match ksp_raw_transaction_lib::parse_raw_transaction_signature(notification.signature()) {
+        Ok(signature) => signature,
+        Err(_) => return std::option::Option::None,
+    };
+    let transaction_index = match u32::try_from(notification.transaction_index()) {
+        Ok(transaction_index) => transaction_index,
+        Err(_) => return std::option::Option::None,
+    };
+    let material = ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64(
+        network,
+        signature,
+        notification.slot(),
+        std::option::Option::None,
+        data,
+        meta,
+        ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+        ksp_raw_transaction_lib::RawTransactionWireField::Value(transaction_index),
+    );
+    return ksp_raw_transaction_lib::canonicalize_raw_transaction(material).ok();
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn pre_005_standard_block_subscribe_full_base64_matches_http_get_block_raw_v1_for_legacy_transaction() {
+    const HTTP_BODY: &str = concat!(
+        "{\"jsonrpc\":\"2.0\",\"result\":{\"previousBlockhash\":\"previous\",\"blockhash\":\"block\",\"parentSlot\":430000122,",
+        "\"rewards\":[],\"numRewardPartitions\":0,\"blockTime\":1787072400,\"blockHeight\":410000000,",
+        "\"transactions\":[{\"transaction\":[\"AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+        "AAAAAA\",\"base64\"],\"meta\":{\"err\":null,\"fee\":5000},\"version\":\"legacy\"}]},\"id\":1}",
+    );
+    let (http_url, http_server) = serve_http_once(HTTP_BODY).expect("HTTP parity fixture must start");
+    let http_pool = http_pool_for_url(http_url.as_str()).expect("HTTP parity pool must build");
+    let http_config = ksp_onchain_transport_lib::SolanaGetBlockConfig::new(
+        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
+        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionEncoding::Base64),
+        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionDetails::Full),
+        std::option::Option::Some(0),
+        std::option::Option::Some(false),
+    );
+    let http = http_pool
+        .get_block_observed(&ksp_onchain_transport_lib::HttpRoleName::new("default"), FIXTURE_SLOT, std::option::Option::Some(&http_config))
+        .await
+        .expect("HTTP block parity fixture must decode");
+    let http_block = http.value().as_ref().expect("HTTP parity block must be present").clone();
+    http_server.join().expect("HTTP parity fixture must join").expect("HTTP parity fixture must complete");
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.expect("WS parity listener must bind");
+    let address = listener.local_addr().expect("WS parity listener address must resolve");
+    let ws_block = serde_json::from_str::<serde_json::Value>(HTTP_BODY).expect("HTTP parity JSON must parse")["result"].clone();
+    let server = tokio::spawn(async move {
+        let (stream, _) = match listener.accept().await {
+            Ok(accepted) => accepted,
+            Err(_) => return Err("WS parity server accept failed".to_owned()),
+        };
+        let mut websocket = match tokio_tungstenite::accept_async(stream).await {
+            Ok(websocket) => websocket,
+            Err(_) => return Err("WS parity handshake failed".to_owned()),
+        };
+        let subscribe = match read_ws_request(&mut websocket).await {
+            Ok(subscribe) => subscribe,
+            Err(error) => return Err(error),
+        };
+        if subscribe.get("method") != std::option::Option::Some(&serde_json::json!("blockSubscribe")) {
+            return Err("WS parity server received unexpected subscribe method".to_owned());
+        }
+        if let Err(error) = send_ws_result(&mut websocket, &subscribe, serde_json::json!(501)).await {
+            return Err(error);
+        }
+        if let Err(error) = send_ws_json(
+            &mut websocket,
+            serde_json::json!({
+                "jsonrpc":"2.0",
+                "method":"blockNotification",
+                "params":{"subscription":501,"result":{"context":{"slot":FIXTURE_SLOT},"value":{"slot":FIXTURE_SLOT,"block":ws_block,"err":null}}}
+            }),
+        )
+        .await
+        {
+            return Err(error);
+        }
+        let unsubscribe = match read_ws_request(&mut websocket).await {
+            Ok(unsubscribe) => unsubscribe,
+            Err(error) => return Err(error),
+        };
+        if unsubscribe.get("method") != std::option::Option::Some(&serde_json::json!("blockUnsubscribe")) {
+            return Err("WS parity server received unexpected unsubscribe method".to_owned());
+        }
+        if let Err(error) = send_ws_result(&mut websocket, &unsubscribe, serde_json::json!(true)).await {
+            return Err(error);
+        }
+        wait_for_ws_close(&mut websocket).await;
+        return Ok::<(), std::string::String>(());
+    });
+    let endpoint = ws_endpoint(format!("ws://{address}").as_str(), ksp_onchain_transport_lib::WsProtocolKind::SolanaStandard)
+        .expect("standard WS parity endpoint must build");
+    let session = ksp_onchain_transport_lib::SolanaStandardWsSession::connect(endpoint).await.expect("standard WS parity session must connect");
+    let ws_config = ksp_onchain_transport_lib::SolanaBlockSubscribeConfig::new(
+        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
+        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionEncoding::Base64),
+        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionDetails::Full),
+        std::option::Option::Some(0),
+        std::option::Option::Some(false),
+    );
+    let mut subscription = session
+        .block_subscribe(&ksp_onchain_transport_lib::SolanaBlockSubscribeFilter::All, std::option::Option::Some(&ws_config))
+        .await
+        .expect("standard blockSubscribe parity subscription must register");
+    let notification = subscription
+        .recv()
+        .await
+        .expect("standard blockSubscribe parity notification must arrive")
+        .expect("standard blockSubscribe parity notification must decode");
+    let ws_block = notification.value().block().expect("standard blockSubscribe parity block must be present");
+    assert_eq!(ws_block, &http_block);
+    let network = ksp_store_lib::RawNetworkId::new("devnet").expect("parity fixture network must be valid");
+    let http_transaction =
+        http_block.transactions().value().expect("HTTP parity transactions must be present").first().expect("HTTP parity transaction must exist");
+    let ws_transaction = ws_block.transactions().value().expect("WS parity transactions must be present").first().expect("WS parity transaction must exist");
+    let http_raw = raw_from_block_transaction(network.clone(), FIXTURE_SLOT, http_block.block_time(), http_transaction, 0)
+        .expect("HTTP block transaction must canonicalize");
+    let ws_raw = raw_from_block_transaction(network, notification.value().slot(), ws_block.block_time(), ws_transaction, 0)
+        .expect("WS block transaction must canonicalize");
+    assert_eq!(ws_raw.reference(), http_raw.reference());
+    assert_eq!(ws_raw.slot(), http_raw.slot());
+    assert_eq!(ws_raw.block_time(), http_raw.block_time());
+    assert_eq!(ws_raw.payload().bytes(), http_raw.payload().bytes());
+    assert_eq!(ws_raw.payload().content_hash(), http_raw.payload().content_hash());
+    assert!(subscription.unsubscribe().await.expect("standard blockSubscribe parity unsubscribe must complete"));
+    session.close().await.expect("standard WS parity session must close");
+    server.await.expect("standard WS parity server task must join").expect("standard WS parity server must complete");
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn pre_005_helius_full_base64_without_block_time_and_version_requires_http_hydration_for_raw_v1() {
+    const HTTP_BODY: &str = concat!(
+        "{\"jsonrpc\":\"2.0\",\"result\":{\"slot\":430000123,\"blockTime\":1787072400,",
+        "\"transaction\":[\"AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\",\"base64\"],",
+        "\"meta\":{\"err\":null,\"fee\":5000},\"version\":\"legacy\",\"transactionIndex\":0},\"id\":1}",
+    );
+    let (http_url, http_server) = serve_http_once(HTTP_BODY).expect("Helius hydration HTTP fixture must start");
+    let http_pool = http_pool_for_url(http_url.as_str()).expect("Helius hydration HTTP pool must build");
+    let http_config = ksp_onchain_transport_lib::SolanaGetTransactionConfig::new(
+        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
+        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionEncoding::Base64),
+        std::option::Option::Some(0),
+    );
+    let http = http_pool
+        .get_transaction_observed(&ksp_onchain_transport_lib::HttpRoleName::new("default"), ZERO_SIGNATURE_TEXT, std::option::Option::Some(&http_config))
+        .await
+        .expect("Helius hydration HTTP fixture must decode");
+    let http_transaction = http.value().as_ref().expect("Helius hydration HTTP transaction must be present");
+    let network = ksp_store_lib::RawNetworkId::new("devnet").expect("Helius hydration fixture network must be valid");
+    let http_raw = raw_from_confirmed_transaction(network.clone(), http_transaction).expect("hydrated HTTP transaction must canonicalize");
+    http_server.join().expect("Helius hydration HTTP fixture must join").expect("Helius hydration HTTP fixture must complete");
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.expect("Helius parity listener must bind");
+    let address = listener.local_addr().expect("Helius parity listener address must resolve");
+    let server = tokio::spawn(async move {
+        let (stream, _) = match listener.accept().await {
+            Ok(accepted) => accepted,
+            Err(_) => return Err("Helius parity server accept failed".to_owned()),
+        };
+        let mut websocket = match tokio_tungstenite::accept_async(stream).await {
+            Ok(websocket) => websocket,
+            Err(_) => return Err("Helius parity handshake failed".to_owned()),
+        };
+        let subscribe = match read_ws_request(&mut websocket).await {
+            Ok(subscribe) => subscribe,
+            Err(error) => return Err(error),
+        };
+        if subscribe.get("method") != std::option::Option::Some(&serde_json::json!("transactionSubscribe")) {
+            return Err("Helius parity server received unexpected subscribe method".to_owned());
+        }
+        if let Err(error) = send_ws_result(&mut websocket, &subscribe, serde_json::json!(601)).await {
+            return Err(error);
+        }
+        if let Err(error) = send_ws_json(
+            &mut websocket,
+            serde_json::json!({
+                "jsonrpc":"2.0",
+                "method":"transactionNotification",
+                "params":{
+                    "subscription":601,
+                    "result":{
+                        "transaction":{"transaction":[ZERO_TRANSACTION_BASE64,"base64"],"meta":{"err":null,"fee":5000}},
+                        "signature":ZERO_SIGNATURE_TEXT,
+                        "slot":FIXTURE_SLOT,
+                        "transactionIndex":0
+                    }
+                }
+            }),
+        )
+        .await
+        {
+            return Err(error);
+        }
+        let unsubscribe = match read_ws_request(&mut websocket).await {
+            Ok(unsubscribe) => unsubscribe,
+            Err(error) => return Err(error),
+        };
+        if unsubscribe.get("method") != std::option::Option::Some(&serde_json::json!("transactionUnsubscribe")) {
+            return Err("Helius parity server received unexpected unsubscribe method".to_owned());
+        }
+        if let Err(error) = send_ws_result(&mut websocket, &unsubscribe, serde_json::json!(true)).await {
+            return Err(error);
+        }
+        wait_for_ws_close(&mut websocket).await;
+        return Ok::<(), std::string::String>(());
+    });
+    let endpoint = ws_endpoint(format!("ws://{address}").as_str(), ksp_onchain_transport_lib::WsProtocolKind::HeliusLaserStream)
+        .expect("Helius parity endpoint must build");
+    let session = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::connect(endpoint).await.expect("Helius parity session must connect");
+    let request = ksp_onchain_transport_lib::HeliusTransactionSubscribeRequest::new(
+        ksp_onchain_transport_lib::HeliusTransactionSubscribeFilter::default(),
+        std::option::Option::Some(ksp_onchain_transport_lib::HeliusTransactionSubscribeOptions::new(
+            std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
+            std::option::Option::Some(ksp_onchain_transport_lib::HeliusTransactionSubscribeEncoding::Base64),
+            std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionDetails::Full),
+            std::option::Option::Some(false),
+            std::option::Option::Some(0),
+        )),
+    );
+    let mut subscription = session.transaction_subscribe(&request).await.expect("Helius parity transaction subscription must register");
+    let notification = subscription.recv().await.expect("Helius parity notification must arrive").expect("Helius parity notification must decode");
+    assert!(matches!(&notification, ksp_onchain_transport_lib::HeliusTransactionNotification::Full(_)));
+    let full = match notification {
+        ksp_onchain_transport_lib::HeliusTransactionNotification::Full(full) => full,
+        _ => return,
+    };
+    let helius_raw = raw_from_helius_full(network, &full).expect("best-effort Helius full projection must canonicalize for negative parity proof");
+    assert_eq!(helius_raw.reference(), http_raw.reference());
+    assert_eq!(helius_raw.slot(), http_raw.slot());
+    assert!(helius_raw.block_time().is_none());
+    assert_eq!(http_raw.block_time().map(|value| return value.unix_millis()), std::option::Option::Some(FIXTURE_BLOCK_TIME_MILLIS),);
+    assert_ne!(helius_raw.block_time(), http_raw.block_time());
+    assert_ne!(helius_raw.payload().bytes(), http_raw.payload().bytes());
+    assert_ne!(helius_raw.payload().content_hash(), http_raw.payload().content_hash());
+    assert!(subscription.unsubscribe().await.expect("Helius parity transaction unsubscribe must complete"));
+    session.close().await.expect("Helius parity session must close");
+    server.await.expect("Helius parity server task must join").expect("Helius parity server must complete");
+}

crates/ksp-job-backfill-lib/tests/yellowstone_raw_parity.rs

@@ -0,0 +1,471 @@
+// file: crates/ksp-job-backfill-lib/tests/yellowstone_raw_parity.rs
+// version: 3
+
+//! Deterministic local Yellowstone gRPC parity canary for source-neutral RAW transaction v1 projection.
+
+struct FixtureStream<T> {
+    receiver: tokio::sync::mpsc::Receiver<T>,
+}
+
+impl<T> FixtureStream<T> {
+    fn new(receiver: tokio::sync::mpsc::Receiver<T>) -> Self {
+        return Self { receiver };
+    }
+}
+
+impl<T> futures_util::Stream for FixtureStream<T> {
+    type Item = T;
+
+    fn poll_next(self: std::pin::Pin<&mut Self>, context: &mut std::task::Context<'_>) -> std::task::Poll<std::option::Option<Self::Item>> {
+        return self.get_mut().receiver.poll_recv(context);
+    }
+}
+
+#[derive(Clone)]
+struct FixtureGeyser;
+
+#[allow(clippy::implicit_return)] // tonic::async_trait generates async wrapper tails outside the authored fixture bodies.
+#[tonic::async_trait]
+impl yellowstone_grpc_proto::geyser::geyser_server::Geyser for FixtureGeyser {
+    type SubscribeStream = FixtureStream<std::result::Result<yellowstone_grpc_proto::geyser::SubscribeUpdate, tonic::Status>>;
+
+    async fn subscribe(
+        &self,
+        request: tonic::Request<tonic::Streaming<yellowstone_grpc_proto::geyser::SubscribeRequest>>,
+    ) -> std::result::Result<tonic::Response<Self::SubscribeStream>, tonic::Status> {
+        let mut inbound = request.into_inner();
+        let (sender, receiver) = tokio::sync::mpsc::channel(4);
+        tokio::spawn(async move {
+            let initial = inbound.message().await;
+            if !matches!(initial, std::result::Result::Ok(std::option::Option::Some(_))) {
+                return;
+            }
+            if sender.send(std::result::Result::Ok(transaction_update())).await.is_err() {
+                return;
+            }
+            let _ = sender.send(std::result::Result::Ok(block_update())).await;
+        });
+        return std::result::Result::Ok(tonic::Response::new(FixtureStream::new(receiver)));
+    }
+
+    type SubscribeDeshredStream = futures_util::stream::Empty<std::result::Result<yellowstone_grpc_proto::geyser::SubscribeUpdateDeshred, tonic::Status>>;
+
+    async fn subscribe_deshred(
+        &self,
+        _request: tonic::Request<tonic::Streaming<yellowstone_grpc_proto::geyser::SubscribeDeshredRequest>>,
+    ) -> std::result::Result<tonic::Response<Self::SubscribeDeshredStream>, tonic::Status> {
+        return std::result::Result::Err(tonic::Status::unimplemented("deshred is outside the pre.006 fixture"));
+    }
+
+    type SubscribeGossipStream = futures_util::stream::Empty<std::result::Result<yellowstone_grpc_proto::geyser::SubscribeUpdateGossip, tonic::Status>>;
+
+    async fn subscribe_gossip(
+        &self,
+        _request: tonic::Request<yellowstone_grpc_proto::geyser::SubscribeGossipRequest>,
+    ) -> std::result::Result<tonic::Response<Self::SubscribeGossipStream>, tonic::Status> {
+        return std::result::Result::Err(tonic::Status::unimplemented("gossip is outside the pre.006 fixture"));
+    }
+
+    async fn subscribe_replay_info(
+        &self,
+        _request: tonic::Request<yellowstone_grpc_proto::geyser::SubscribeReplayInfoRequest>,
+    ) -> std::result::Result<tonic::Response<yellowstone_grpc_proto::geyser::SubscribeReplayInfoResponse>, tonic::Status> {
+        return std::result::Result::Err(tonic::Status::unimplemented("replay info is outside the pre.006 fixture"));
+    }
+
+    async fn ping(
+        &self,
+        _request: tonic::Request<yellowstone_grpc_proto::geyser::PingRequest>,
+    ) -> std::result::Result<tonic::Response<yellowstone_grpc_proto::geyser::PongResponse>, tonic::Status> {
+        return std::result::Result::Err(tonic::Status::unimplemented("unary is outside the pre.006 fixture"));
+    }
+
+    async fn get_latest_blockhash(
+        &self,
+        _request: tonic::Request<yellowstone_grpc_proto::geyser::GetLatestBlockhashRequest>,
+    ) -> std::result::Result<tonic::Response<yellowstone_grpc_proto::geyser::GetLatestBlockhashResponse>, tonic::Status> {
+        return std::result::Result::Err(tonic::Status::unimplemented("unary is outside the pre.006 fixture"));
+    }
+
+    async fn get_block_height(
+        &self,
+        _request: tonic::Request<yellowstone_grpc_proto::geyser::GetBlockHeightRequest>,
+    ) -> std::result::Result<tonic::Response<yellowstone_grpc_proto::geyser::GetBlockHeightResponse>, tonic::Status> {
+        return std::result::Result::Err(tonic::Status::unimplemented("unary is outside the pre.006 fixture"));
+    }
+
+    async fn get_slot(
+        &self,
+        _request: tonic::Request<yellowstone_grpc_proto::geyser::GetSlotRequest>,
+    ) -> std::result::Result<tonic::Response<yellowstone_grpc_proto::geyser::GetSlotResponse>, tonic::Status> {
+        return std::result::Result::Err(tonic::Status::unimplemented("unary is outside the pre.006 fixture"));
+    }
+
+    async fn is_blockhash_valid(
+        &self,
+        _request: tonic::Request<yellowstone_grpc_proto::geyser::IsBlockhashValidRequest>,
+    ) -> std::result::Result<tonic::Response<yellowstone_grpc_proto::geyser::IsBlockhashValidResponse>, tonic::Status> {
+        return std::result::Result::Err(tonic::Status::unimplemented("unary is outside the pre.006 fixture"));
+    }
+
+    async fn get_version(
+        &self,
+        _request: tonic::Request<yellowstone_grpc_proto::geyser::GetVersionRequest>,
+    ) -> std::result::Result<tonic::Response<yellowstone_grpc_proto::geyser::GetVersionResponse>, tonic::Status> {
+        return std::result::Result::Err(tonic::Status::unimplemented("unary is outside the pre.006 fixture"));
+    }
+}
+
+struct FixtureServer {
+    endpoint_url: std::string::String,
+    shutdown: std::option::Option<tokio::sync::oneshot::Sender<()>>,
+    task: tokio::task::JoinHandle<()>,
+}
+
+impl FixtureServer {
+    async fn start() -> std::result::Result<Self, &'static str> {
+        let bind_address = match "127.0.0.1:0".parse::<std::net::SocketAddr>() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => return std::result::Result::Err("fixture bind address must parse"),
+        };
+        let incoming = match tonic::transport::server::TcpIncoming::bind(bind_address) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => return std::result::Result::Err("fixture gRPC listener must bind"),
+        };
+        let local_address = match incoming.local_addr() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => return std::result::Result::Err("fixture gRPC listener must expose local address"),
+        };
+        let (shutdown, shutdown_receiver) = tokio::sync::oneshot::channel();
+        let task = tokio::spawn(async move {
+            let service = yellowstone_grpc_proto::geyser::geyser_server::GeyserServer::new(FixtureGeyser);
+            let result = tonic::transport::Server::builder()
+                .serve_with_incoming_shutdown(service, incoming, async move {
+                    let _ = shutdown_receiver.await;
+                })
+                .await;
+            assert!(result.is_ok());
+        });
+        return std::result::Result::Ok(Self { endpoint_url: format!("http://{local_address}"), shutdown: std::option::Option::Some(shutdown), task });
+    }
+
+    async fn stop(mut self) {
+        if let std::option::Option::Some(shutdown) = self.shutdown.take() {
+            let _ = shutdown.send(());
+        }
+        let result = self.task.await;
+        assert!(result.is_ok());
+    }
+}
+
+fn transaction_info() -> yellowstone_grpc_proto::geyser::SubscribeUpdateTransactionInfo {
+    return yellowstone_grpc_proto::geyser::SubscribeUpdateTransactionInfo {
+        signature: vec![9_u8; 64],
+        is_vote: false,
+        transaction: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::Transaction {
+            signatures: vec![vec![9_u8; 64]],
+            message: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::Message {
+                header: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::MessageHeader {
+                    num_required_signatures: 1,
+                    num_readonly_signed_accounts: 0,
+                    num_readonly_unsigned_accounts: 1,
+                }),
+                account_keys: vec![vec![1_u8; 32], vec![2_u8; 32]],
+                recent_blockhash: vec![3_u8; 32],
+                instructions: vec![yellowstone_grpc_proto::solana::storage::confirmed_block::CompiledInstruction {
+                    program_id_index: 1,
+                    accounts: vec![0_u8],
+                    data: vec![4_u8, 5, 6],
+                }],
+                versioned: true,
+                address_table_lookups: vec![],
+                config: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::TransactionConfig {
+                    priority_fee: std::option::Option::Some(7),
+                    compute_unit_limit: std::option::Option::Some(8),
+                    loaded_accounts_data_size_limit: std::option::Option::Some(9),
+                    heap_size: std::option::Option::Some(32_768),
+                }),
+            }),
+        }),
+        meta: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::TransactionStatusMeta {
+            fee: 5_000,
+            pre_balances: vec![100, 200],
+            post_balances: vec![90, 210],
+            compute_units_consumed: std::option::Option::Some(123),
+            cost_units: std::option::Option::Some(456),
+            ..std::default::Default::default()
+        }),
+        index: 3,
+    };
+}
+
+fn transaction_update() -> yellowstone_grpc_proto::geyser::SubscribeUpdate {
+    return yellowstone_grpc_proto::geyser::SubscribeUpdate {
+        filters: vec!["transactions-pre-006".to_owned()],
+        update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Transaction(
+            yellowstone_grpc_proto::geyser::SubscribeUpdateTransaction { transaction: std::option::Option::Some(transaction_info()), slot: 42 },
+        )),
+        created_at: std::option::Option::None,
+    };
+}
+
+fn block_update() -> yellowstone_grpc_proto::geyser::SubscribeUpdate {
+    return yellowstone_grpc_proto::geyser::SubscribeUpdate {
+        filters: vec!["blocks-pre-006".to_owned()],
+        update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Block(
+            yellowstone_grpc_proto::geyser::SubscribeUpdateBlock {
+                slot: 42,
+                blockhash: ksp_core_lib::Pubkey::new_from_array([21_u8; 32]).to_string(),
+                rewards: std::option::Option::None,
+                block_time: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::UnixTimestamp { timestamp: 1_787_104_000 }),
+                block_height: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::BlockHeight { block_height: 41 }),
+                transactions: vec![transaction_info()],
+                parent_slot: 41,
+                parent_blockhash: ksp_core_lib::Pubkey::new_from_array([22_u8; 32]).to_string(),
+                executed_transaction_count: 1,
+                updated_account_count: 0,
+                accounts: vec![],
+                entries_count: 0,
+                entries: vec![],
+            },
+        )),
+        created_at: std::option::Option::None,
+    };
+}
+
+fn fixture_settings(url: &str) -> ksp_core_lib::Result<ksp_onchain_transport_lib::YellowstoneGrpcEndpointSettings> {
+    let endpoint_url = match ksp_onchain_transport_lib::YellowstoneGrpcEndpointUrl::parse(url) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    return std::result::Result::Ok(ksp_onchain_transport_lib::YellowstoneGrpcEndpointSettings::new(
+        "pre-006-fixture",
+        true,
+        ksp_onchain_transport_lib::YellowstoneGrpcProviderName::new("fixture-provider"),
+        ksp_onchain_transport_lib::YellowstoneGrpcClusterName::new("devnet"),
+        endpoint_url,
+        ksp_onchain_transport_lib::YellowstoneGrpcSessionSettings::default(),
+    ));
+}
+
+fn project_wire(
+    transaction: &ksp_onchain_transport_lib::YellowstoneStoredTransaction,
+) -> ksp_core_lib::Result<ksp_raw_transaction_lib::RawSolanaTransactionWire> {
+    let message = transaction.message();
+    let header = message.header();
+    let required = match u8::try_from(header.num_required_signatures()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::result::Result::Err(projection_error("num_required_signatures")),
+    };
+    let readonly_signed = match u8::try_from(header.num_readonly_signed_accounts()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::result::Result::Err(projection_error("num_readonly_signed_accounts")),
+    };
+    let readonly_unsigned = match u8::try_from(header.num_readonly_unsigned_accounts()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::result::Result::Err(projection_error("num_readonly_unsigned_accounts")),
+    };
+    let version = if message.config().is_some() {
+        ksp_raw_transaction_lib::RawSolanaMessageVersion::V1
+    } else if message.versioned() {
+        ksp_raw_transaction_lib::RawSolanaMessageVersion::V0
+    } else {
+        ksp_raw_transaction_lib::RawSolanaMessageVersion::Legacy
+    };
+    let signatures = transaction.signatures().iter().map(|value| return *value.as_bytes()).collect();
+    let account_keys = message.account_keys().iter().map(solana_pubkey_bytes).collect();
+    let mut instructions = std::vec::Vec::with_capacity(message.instructions().len());
+    for instruction in message.instructions() {
+        let program_id_index = match u8::try_from(instruction.program_id_index()) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => return std::result::Result::Err(projection_error("program_id_index")),
+        };
+        instructions.push(ksp_raw_transaction_lib::RawSolanaCompiledInstruction::new(
+            program_id_index,
+            instruction.accounts().to_vec(),
+            instruction.data().to_vec(),
+        ));
+    }
+    let address_table_lookups = message
+        .address_table_lookups()
+        .iter()
+        .map(|lookup| {
+            return ksp_raw_transaction_lib::RawSolanaAddressTableLookup::new(
+                lookup.account_key().to_bytes(),
+                lookup.writable_indexes().to_vec(),
+                lookup.readonly_indexes().to_vec(),
+            );
+        })
+        .collect();
+    let config = message.config().map(|value| {
+        return ksp_raw_transaction_lib::RawSolanaTransactionConfig::new(
+            value.priority_fee(),
+            value.compute_unit_limit(),
+            value.loaded_accounts_data_size_limit(),
+            value.heap_size(),
+        );
+    });
+    let raw_message = ksp_raw_transaction_lib::RawSolanaTransactionMessage::new(
+        version,
+        ksp_raw_transaction_lib::RawSolanaMessageHeader::new(required, readonly_signed, readonly_unsigned),
+        account_keys,
+        *message.recent_blockhash().as_bytes(),
+        instructions,
+        address_table_lookups,
+        config,
+    );
+    return std::result::Result::Ok(ksp_raw_transaction_lib::RawSolanaTransactionWire::new(signatures, raw_message));
+}
+
+fn solana_pubkey_bytes(value: &ksp_core_lib::Pubkey) -> [u8; 32] {
+    return value.to_bytes();
+}
+
+fn projection_error(field: &'static str) -> ksp_core_lib::Error {
+    return ksp_core_lib::Error::new(ksp_core_lib::ErrorCode::new("test", "yellowstone_raw_projection"), "Yellowstone fixture field does not fit common wire")
+        .with_context("field", field);
+}
+
+fn error_code_text(error: &ksp_core_lib::Error) -> std::string::String {
+    return format!("{}.{}", error.code().domain(), error.code().code());
+}
+
+fn expected_v1_wire() -> ksp_raw_transaction_lib::RawSolanaTransactionWire {
+    let message = ksp_raw_transaction_lib::RawSolanaTransactionMessage::new(
+        ksp_raw_transaction_lib::RawSolanaMessageVersion::V1,
+        ksp_raw_transaction_lib::RawSolanaMessageHeader::new(1, 0, 1),
+        vec![[1_u8; 32], [2_u8; 32]],
+        [3_u8; 32],
+        vec![ksp_raw_transaction_lib::RawSolanaCompiledInstruction::new(1, vec![0_u8], vec![4_u8, 5, 6])],
+        vec![],
+        std::option::Option::Some(ksp_raw_transaction_lib::RawSolanaTransactionConfig::new(
+            std::option::Option::Some(7),
+            std::option::Option::Some(8),
+            std::option::Option::Some(9),
+            std::option::Option::Some(32_768),
+        )),
+    );
+    return ksp_raw_transaction_lib::RawSolanaTransactionWire::new(vec![[9_u8; 64]], message);
+}
+
+fn fail_test(message: std::string::String) {
+    assert!(message.is_empty(), "{message}");
+}
+
+#[tokio::test]
+async fn pre_006_yellowstone_transaction_and_block_preserve_exact_v1_wire_and_block_time() {
+    let server = match FixtureServer::start().await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            assert!(error.is_empty(), "fixture server start failed: {error}");
+            return;
+        },
+    };
+    let settings = match fixture_settings(server.endpoint_url.as_str()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            fail_test(format!("fixture settings failed: {}", error_code_text(&error)));
+            return;
+        },
+    };
+    let channel = match ksp_onchain_transport_lib::YellowstoneGrpcChannel::connect(&settings).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            fail_test(format!("fixture channel connect failed: {}", error_code_text(&error)));
+            return;
+        },
+    };
+    let request = ksp_onchain_transport_lib::YellowstoneSubscribeRequest::new();
+    let mut session = match channel.open_standard_subscribe(request).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            fail_test(format!("fixture subscribe failed: {}", error_code_text(&error)));
+            return;
+        },
+    };
+    let expected = match ksp_raw_transaction_lib::serialize_solana_transaction_wire(&expected_v1_wire()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            fail_test(format!("expected V1 wire serialization failed: {}", error_code_text(&error)));
+            return;
+        },
+    };
+    let transaction = match session.next_update().await {
+        std::result::Result::Ok(std::option::Option::Some(value)) => value,
+        std::result::Result::Ok(std::option::Option::None) => {
+            fail_test("transaction update must be present".to_owned());
+            return;
+        },
+        std::result::Result::Err(error) => {
+            fail_test(format!("transaction update decode failed: {}", error_code_text(&error)));
+            return;
+        },
+    };
+    let transaction = match transaction {
+        ksp_onchain_transport_lib::YellowstoneSubscribeUpdate::Transaction(value) => value,
+        _ => {
+            fail_test("first Yellowstone fixture update must be a transaction".to_owned());
+            return;
+        },
+    };
+    assert_eq!(transaction.slot(), 42);
+    assert_eq!(transaction.transaction().index(), 3);
+    assert_eq!(transaction.transaction().meta().fee(), 5_000);
+    let transaction_wire = match project_wire(transaction.transaction().transaction()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            fail_test(format!("transaction projection failed: {}", error_code_text(&error)));
+            return;
+        },
+    };
+    let transaction_bytes = match ksp_raw_transaction_lib::serialize_solana_transaction_wire(&transaction_wire) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            fail_test(format!("transaction V1 wire serialization failed: {}", error_code_text(&error)));
+            return;
+        },
+    };
+    assert_eq!(transaction_bytes, expected);
+    let block = match session.next_update().await {
+        std::result::Result::Ok(std::option::Option::Some(value)) => value,
+        std::result::Result::Ok(std::option::Option::None) => {
+            fail_test("block update must be present".to_owned());
+            return;
+        },
+        std::result::Result::Err(error) => {
+            fail_test(format!("block update decode failed: {}", error_code_text(&error)));
+            return;
+        },
+    };
+    let block = match block {
+        ksp_onchain_transport_lib::YellowstoneSubscribeUpdate::Block(value) => value,
+        _ => {
+            fail_test("second Yellowstone fixture update must be a block".to_owned());
+            return;
+        },
+    };
+    assert_eq!(block.slot(), 42);
+    assert_eq!(block.block_time(), std::option::Option::Some(1_787_104_000));
+    assert_eq!(block.transactions().len(), 1);
+    assert_eq!(block.transactions()[0].index(), 3);
+    let block_wire = match project_wire(block.transactions()[0].transaction()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            fail_test(format!("block transaction projection failed: {}", error_code_text(&error)));
+            return;
+        },
+    };
+    let block_bytes = match ksp_raw_transaction_lib::serialize_solana_transaction_wire(&block_wire) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            fail_test(format!("block V1 wire serialization failed: {}", error_code_text(&error)));
+            return;
+        },
+    };
+    assert_eq!(block_bytes, expected);
+    assert_eq!(block_bytes, transaction_bytes);
+    assert!(transaction.transaction().meta().error().is_none());
+    assert_eq!(block.transactions()[0].meta().fee(), transaction.transaction().meta().fee());
+    assert!(session.close().await.is_ok());
+    server.stop().await;
+}

crates/ksp-job-backfill-lib/unit_tests/conversion.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-job-backfill-lib/unit_tests/conversion.rs
-// version: 2
+// version: 3
 
 fn signature_text() -> std::option::Option<crate::BackfillSignature> {
     return match crate::BackfillSignature::new("1".repeat(64)) {
@@ -46,6 +46,14 @@ fn candidate(network: &str, signature: crate::BackfillSignature) -> std::option:
     return std::option::Option::Some(crate::BackfillCandidate::new(crate::BackfillCandidateIdentity::new(network, signature), std::option::Option::Some(42)));
 }
 
+fn raw_reference(network: &str) -> std::option::Option<ksp_store_lib::RawTransactionReference> {
+    let network = match ksp_store_lib::RawNetworkId::new(network) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    return std::option::Option::Some(ksp_store_lib::RawTransactionReference::new(network, ksp_store_lib::RawTransactionSignature::new([0_u8; 64])));
+}
+
 fn received_at() -> std::option::Option<ksp_store_lib::RawTimestamp> {
     return match ksp_store_lib::RawTimestamp::from_unix_millis(1_700_000_001_000) {
         std::result::Result::Ok(value) => std::option::Option::Some(value),
@@ -169,21 +177,26 @@ fn pre_006_wire_omission_and_null_produce_distinct_canonical_bytes() {
     let version_null = ksp_onchain_transport_lib::SolanaWireField::Null;
     let transaction_index_omitted = ksp_onchain_transport_lib::SolanaWireField::Omitted;
     let transaction_index_null = ksp_onchain_transport_lib::SolanaWireField::Null;
-    let omitted = super::canonical_payload_bytes(&fields(&transaction, &meta_omitted, &version_omitted, &transaction_index_omitted, std::option::Option::None));
+    let reference = match raw_reference("devnet") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let omitted =
+        super::canonical_transaction(&reference, fields(&transaction, &meta_omitted, &version_omitted, &transaction_index_omitted, std::option::Option::None));
     assert!(omitted.is_ok());
     let omitted = match omitted {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return,
     };
-    assert_eq!(omitted, b"{\"transaction\":[\"AQID\",\"base64\"]}");
+    assert_eq!(omitted.payload().bytes(), b"{\"transaction\":[\"AQID\",\"base64\"]}");
-    let nulls = super::canonical_payload_bytes(&fields(&transaction, &meta_null, &version_null, &transaction_index_null, std::option::Option::None));
+    let nulls = super::canonical_transaction(&reference, fields(&transaction, &meta_null, &version_null, &transaction_index_null, std::option::Option::None));
     assert!(nulls.is_ok());
     let nulls = match nulls {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return,
     };
-    assert_eq!(nulls, b"{\"transaction\":[\"AQID\",\"base64\"],\"meta\":null,\"version\":null,\"transactionIndex\":null}");
+    assert_eq!(nulls.payload().bytes(), b"{\"transaction\":[\"AQID\",\"base64\"],\"meta\":null,\"version\":null,\"transactionIndex\":null}");
-    assert_ne!(omitted, nulls);
+    assert_ne!(omitted.payload().bytes(), nulls.payload().bytes());
     return;
 }
 
@@ -198,8 +211,12 @@ fn pre_006_non_base64_transaction_shapes_are_rejected() {
     let meta = ksp_onchain_transport_lib::SolanaWireField::Omitted;
     let version = ksp_onchain_transport_lib::SolanaWireField::Omitted;
     let transaction_index = ksp_onchain_transport_lib::SolanaWireField::Omitted;
+    let reference = match raw_reference("devnet") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
     for transaction in [&base58, &legacy, &json] {
-        let result = super::canonical_payload_bytes(&fields(transaction, &meta, &version, &transaction_index, std::option::Option::None));
+        let result = super::canonical_transaction(&reference, fields(transaction, &meta, &version, &transaction_index, std::option::Option::None));
         assert!(result.is_err());
         if let std::result::Result::Err(error) = result {
             assert_eq!(error.code(), crate::ERROR_CODE_BACKFILL_RAW_CONVERSION_INVALID);
@@ -210,12 +227,26 @@ fn pre_006_non_base64_transaction_shapes_are_rejected() {
 
 #[test]
 fn pre_006_negative_and_unrepresentable_block_times_are_terminal_conversion_errors() {
-    let negative = super::convert_block_time(std::option::Option::Some(-1));
+    let reference = match raw_reference("devnet") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let transaction = ksp_onchain_transport_lib::SolanaEncodedTransaction::Binary {
+        data: "AQID".to_owned(),
+        encoding: ksp_onchain_transport_lib::SolanaTransactionBinaryEncoding::Base64,
+    };
+    let meta = ksp_onchain_transport_lib::SolanaWireField::Omitted;
+    let version = ksp_onchain_transport_lib::SolanaWireField::Omitted;
+    let transaction_index = ksp_onchain_transport_lib::SolanaWireField::Omitted;
+    let negative = super::canonical_transaction(&reference, fields(&transaction, &meta, &version, &transaction_index, std::option::Option::Some(-1)));
     assert!(negative.is_err());
-    let oversized = super::convert_block_time(std::option::Option::Some(i64::MAX));
+    let oversized = super::canonical_transaction(&reference, fields(&transaction, &meta, &version, &transaction_index, std::option::Option::Some(i64::MAX)));
     assert!(oversized.is_err());
-    let absent = super::convert_block_time(std::option::Option::None);
+    let absent = super::canonical_transaction(&reference, fields(&transaction, &meta, &version, &transaction_index, std::option::Option::None));
-    assert!(matches!(absent, std::result::Result::Ok(std::option::Option::None)));
+    assert!(absent.is_ok());
+    if let std::result::Result::Ok(absent) = absent {
+        assert!(absent.block_time().is_none());
+    }
     return;
 }
 
@@ -242,6 +273,12 @@ fn pre_006_observation_key_is_deterministic_and_endpoint_specific() {
     let other_endpoint = super::observation_key(&request, &reference, "provider", "endpoint-b");
     let other_provider = super::observation_key(&request, &reference, "provider-2", "endpoint-a");
     assert_eq!(first, same);
+    assert_eq!(
+        first.as_bytes(),
+        &[
+            184, 85, 15, 15, 33, 101, 243, 112, 222, 145, 139, 212, 251, 14, 199, 130, 57, 26, 253, 221, 184, 140, 87, 240, 16, 116, 62, 0, 11, 19, 103, 2
+        ]
+    );
     assert_ne!(first, other_endpoint);
     assert_ne!(first, other_provider);
     return;
@@ -294,6 +331,15 @@ fn pre_006_missing_outcome_contains_only_network_scoped_reference() {
     return;
 }
 
+#[test]
+fn pre_003_backfill_uses_common_raw_v1_contract_without_changing_frozen_identity() {
+    assert_eq!(crate::RAW_TRANSACTION_FORMAT_ID, ksp_raw_transaction_lib::RAW_TRANSACTION_FORMAT_ID);
+    assert_eq!(crate::RAW_TRANSACTION_FORMAT_VERSION, ksp_raw_transaction_lib::RAW_TRANSACTION_FORMAT_VERSION);
+    assert_eq!(crate::MIN_BACKFILL_SIGNATURE_TEXT_BYTES, ksp_raw_transaction_lib::MIN_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES);
+    assert_eq!(crate::MAX_BACKFILL_SIGNATURE_TEXT_BYTES, ksp_raw_transaction_lib::MAX_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES);
+    return;
+}
+
 #[test]
 fn pre_006_fix_001_raw_acquisition_uses_one_private_indirection() {
     assert_eq!(std::mem::size_of::<crate::BackfillRawAcquisition>(), std::mem::size_of::<usize>(),);

crates/ksp-job-backfill-lib/unit_tests/request.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-job-backfill-lib/unit_tests/request.rs
-// version: 2
+// version: 3
 
 fn signature(character: char) -> std::option::Option<crate::BackfillSignature> {
     return match crate::BackfillSignature::new(character.to_string().repeat(crate::MIN_BACKFILL_SIGNATURE_TEXT_BYTES)) {
@@ -235,7 +235,7 @@ fn pre_005_scope_kind_and_anchor_are_distinct_semantics() {
 
 #[test]
 fn pre_011_resume_reissues_checkpoint_for_new_job_without_changing_scope_semantics() {
-    let network = match network("mainnet-beta") {
+    let network = match network("mainnet") {
         std::option::Option::Some(value) => value,
         std::option::Option::None => return,
     };

crates/ksp-onchain-transport-lib/USAGE.md

@@ -1,5 +1,5 @@
 <!-- file: crates/ksp-onchain-transport-lib/USAGE.md -->
-<!-- version: 23 -->
+<!-- version: 25 -->
 
 # Utilisation de `ksp-onchain-transport-lib`
 
@@ -281,7 +281,7 @@ let grpc_endpoint = match ksp_onchain_transport_lib::YellowstoneGrpcEndpointSett
     "publicnode_mainnet_yellowstone",
     true,
     ksp_onchain_transport_lib::YellowstoneGrpcProviderName::new("publicnode"),
-    ksp_onchain_transport_lib::YellowstoneGrpcClusterName::new("mainnet-beta"),
+    ksp_onchain_transport_lib::YellowstoneGrpcClusterName::new("mainnet"),
     grpc_url,
     ksp_onchain_transport_lib::YellowstoneGrpcSessionSettings::default(),
 )
@@ -449,7 +449,9 @@ let inflation_rate = pool.get_inflation_rate(&role).await;
 let stake_minimum = pool.get_stake_minimum_delegation(&role, Some(&context)).await;
 ```
 
-`getBlock` possède également une forme bare-encoding legacy séparée et deprecated. Les valeurs Economics restent celles du runtime : le consumer ne doit pas supposer localement un taux d'inflation ou un minimum de délégation constant.
+`getBlock` possède également une forme bare-encoding legacy séparée et deprecated. Pour les consumers qui doivent conserver la provenance exacte d’un pool multi-endpoint, `get_block_observed(...)` exécute la même forme moderne et retourne la valeur typée avec le nom sûr de l’endpoint et le provider réellement gagnants après sélection/retry/reroute. Cette projection n’expose ni URL, ni headers, ni body HTTP brut. Une réponse RPC `null` reste `None` dans la valeur observée.
+
+Lorsque `transactionDetails = full` et `encoding = base64`, chaque `SolanaBlockTransaction` conserve le transaction wire Base64, `meta` et `version`. Le consumer peut alors projeter ces DTOs vers sa couche métier sans faire dépendre Transport d’une canonicalisation RAW particulière. Les valeurs Economics restent celles du runtime : le consumer ne doit pas supposer localement un taux d'inflation ou un minimum de délégation constant.
 
 ## 6. Exécution JSON-RPC standard générique
 

crates/ksp-onchain-transport-lib/fixtures/http/get_block.observed_material.success.json

@@ -0,0 +1 @@
+{"jsonrpc":"2.0","result":{"previousBlockhash":"previous-blockhash-fixture","blockhash":"blockhash-fixture","parentSlot":430000122,"rewards":[],"numRewardPartitions":0,"blockTime":1787072400,"blockHeight":410000000,"transactions":[{"transaction":["AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","base64"],"meta":{"err":null,"fee":5000},"version":"legacy"}]},"id":1}

crates/ksp-onchain-transport-lib/src/rpc_blocks.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-onchain-transport-lib/src/rpc_blocks.rs
-// version: 7
+// version: 8
 
 const MAX_GET_BLOCKS_RANGE: u64 = 500_000;
 const MAX_GET_RECENT_PERFORMANCE_SAMPLES: u64 = 720;
@@ -591,25 +591,42 @@ impl crate::HttpTransportPool {
         slot: u64,
         config: std::option::Option<&crate::SolanaGetBlockConfig>,
     ) -> ksp_core_lib::Result<std::option::Option<crate::SolanaConfirmedBlock>> {
-        if let std::option::Option::Some(config) = config
+        let params = get_block_params(slot, config);
-            && config.commitment() == std::option::Option::Some(crate::SolanaCommitment::Processed)
+        let params = match params {
-        {
+            std::result::Result::Ok(params) => params,
-            return std::result::Result::Err(
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
-                ksp_core_lib::Error::new(
+        };
-                    crate::ERROR_CODE_INVALID_RPC_PARAMETERS,
-                    "getBlock commitment must be confirmed or finalized when explicitly provided",
-                )
-                .with_context("rpc_method", "getBlock")
-                .with_context("commitment", "processed"),
-            );
-        }
-        let mut params = std::vec![serde_json::json!(slot)];
-        if let std::option::Option::Some(config) = config {
-            params.push((*config).to_json_value());
-        }
         return self.execute_get_block(role, params).await;
     }
 
+    /// Executes the current object-form `getBlock` request and reports the safe identity of the endpoint that produced the successful response.
+    ///
+    /// Routing, admission, timeout and retry behavior are identical to [`Self::get_block`]. The returned observation never contains an endpoint URL,
+    /// HTTP headers or a raw HTTP body.
+    pub async fn get_block_observed(
+        &self,
+        role: &crate::HttpRoleName,
+        slot: u64,
+        config: std::option::Option<&crate::SolanaGetBlockConfig>,
+    ) -> ksp_core_lib::Result<crate::HttpObservedValue<std::option::Option<crate::SolanaConfirmedBlock>>> {
+        let params = get_block_params(slot, config);
+        let params = match params {
+            std::result::Result::Ok(params) => params,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let observed = self.execute_blocks_rpc_observed("getBlock", role, params).await;
+        let observed = match observed {
+            std::result::Result::Ok(observed) => observed,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let (value, endpoint_name, provider) = observed.into_parts();
+        let block = decode_get_block(value);
+        return match block {
+            std::result::Result::Ok(block) => std::result::Result::Ok(crate::HttpObservedValue::new(block, endpoint_name, provider)),
+            std::result::Result::Err(error) => std::result::Result::Err(error),
+        };
+    }
+
     /// Executes the deprecated bare-encoding `getBlock` request form retained by Solana RPC for backwards compatibility.
     #[deprecated(note = "use HttpTransportPool::get_block with SolanaGetBlockConfig; the bare encoding request form is deprecated")]
     pub async fn get_block_legacy(
@@ -635,16 +652,8 @@ impl crate::HttpTransportPool {
         params: std::vec::Vec<serde_json::Value>,
     ) -> ksp_core_lib::Result<std::option::Option<crate::SolanaConfirmedBlock>> {
         let value = self.execute_blocks_rpc("getBlock", role, params).await;
-        let value = match value {
+        return match value {
-            std::result::Result::Ok(value) => value,
+            std::result::Result::Ok(value) => decode_get_block(value),
-            std::result::Result::Err(error) => return std::result::Result::Err(error),
-        };
-        if value.is_null() {
-            return std::result::Result::Ok(std::option::Option::None);
-        }
-        let block = crate::SolanaConfirmedBlock::decode_wire("getBlock", value);
-        return match block {
-            std::result::Result::Ok(block) => std::result::Result::Ok(std::option::Option::Some(block)),
             std::result::Result::Err(error) => std::result::Result::Err(error),
         };
     }
@@ -829,6 +838,48 @@ impl crate::HttpTransportPool {
         };
         return self.execute_standard_rpc(role, method, params).await;
     }
+
+    async fn execute_blocks_rpc_observed(
+        &self,
+        method_name: &'static str,
+        role: &crate::HttpRoleName,
+        params: std::vec::Vec<serde_json::Value>,
+    ) -> ksp_core_lib::Result<crate::HttpObservedValue<serde_json::Value>> {
+        let method = blocks_descriptor(method_name);
+        let method = match method {
+            std::result::Result::Ok(method) => method,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        return self.execute_standard_rpc_observed(role, method, params).await;
+    }
+}
+
+fn decode_get_block(value: serde_json::Value) -> ksp_core_lib::Result<std::option::Option<crate::SolanaConfirmedBlock>> {
+    if value.is_null() {
+        return std::result::Result::Ok(std::option::Option::None);
+    }
+    let block = crate::SolanaConfirmedBlock::decode_wire("getBlock", value);
+    return match block {
+        std::result::Result::Ok(block) => std::result::Result::Ok(std::option::Option::Some(block)),
+        std::result::Result::Err(error) => std::result::Result::Err(error),
+    };
+}
+
+fn get_block_params(slot: u64, config: std::option::Option<&crate::SolanaGetBlockConfig>) -> ksp_core_lib::Result<std::vec::Vec<serde_json::Value>> {
+    if let std::option::Option::Some(config) = config
+        && config.commitment() == std::option::Option::Some(crate::SolanaCommitment::Processed)
+    {
+        return std::result::Result::Err(
+            ksp_core_lib::Error::new(crate::ERROR_CODE_INVALID_RPC_PARAMETERS, "getBlock commitment must be confirmed or finalized when explicitly provided")
+                .with_context("rpc_method", "getBlock")
+                .with_context("commitment", "processed"),
+        );
+    }
+    let mut params = std::vec![serde_json::json!(slot)];
+    if let std::option::Option::Some(config) = config {
+        params.push((*config).to_json_value());
+    }
+    return std::result::Result::Ok(params);
 }
 
 #[derive(serde::Deserialize)]

crates/ksp-onchain-transport-lib/tests/public_api.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-onchain-transport-lib/tests/public_api.rs
-// version: 49
+// version: 50
 
 //! Integration tests for the public `ksp-onchain-transport-lib` consumer contract.
 
@@ -1021,3 +1021,10 @@ fn public_v0_2_9_pre_010_yellowstone_reconnect_snapshot_is_available_from_crate_
     let _observed = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshot::last_observed_slot;
     let _terminal = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshot::terminal_error_code;
 }
+
+#[test]
+fn public_v0_3_10_pre_004_observed_get_block_surface_is_available_from_crate_root() {
+    let method = ksp_onchain_transport_lib::HttpTransportPool::get_block_observed;
+    let _ = method;
+    return;
+}

crates/ksp-onchain-transport-lib/tests/release_completeness.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-onchain-transport-lib/tests/release_completeness.rs
-// version: 41
+// version: 42
 
 //! Release-level completeness canaries for staged HTTP and WebSocket Transport coverage.
 
@@ -1000,14 +1000,10 @@ fn release_v0_2_8_pre_010_live_smoke_policy_preserves_secret_and_dependency_owne
 #[test]
 fn release_v0_2_9_pre_002_materializes_minimal_yellowstone_engine_without_provider_or_ws_coupling() {
     let manifest_directory = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
-    let workspace = manifest_directory.parent().and_then(std::path::Path::parent).expect("Transport test must resolve workspace root");
-    let root_manifest = std::fs::read_to_string(workspace.join("Cargo.toml")).expect("workspace manifest must be readable");
     let transport_manifest = std::fs::read_to_string(manifest_directory.join("Cargo.toml")).expect("Transport manifest must be readable");
     let settings_source = include_str!("../src/grpc_settings.rs");
     let channel_source = include_str!("../src/grpc_channel.rs");
     let crate_root = include_str!("../src/lib.rs");
-    assert!(root_manifest.contains("tonic = { version = \"^0.14\", default-features = false }"));
-    assert!(root_manifest.contains("yellowstone-grpc-proto = { version = \"^12.6\", default-features = false }"));
     assert!(transport_manifest.contains("tonic = { workspace = true, features = [\"channel\""));
     assert!(transport_manifest.contains("yellowstone-grpc-proto.workspace = true"));
     assert!(!transport_manifest.contains("yellowstone-grpc-client"));
@@ -1028,15 +1024,11 @@ fn release_v0_2_9_pre_002_materializes_minimal_yellowstone_engine_without_provid
 #[test]
 fn release_v0_2_9_pre_003_adds_tls_metadata_and_exactly_seven_standard_unary_methods_without_subscribe() {
     let manifest_directory = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
-    let workspace = manifest_directory.parent().and_then(std::path::Path::parent).expect("Transport test must resolve workspace root");
-    let root_manifest = std::fs::read_to_string(workspace.join("Cargo.toml")).expect("workspace manifest must be readable");
     let transport_manifest = std::fs::read_to_string(manifest_directory.join("Cargo.toml")).expect("Transport manifest must be readable");
     let settings_source = include_str!("../src/grpc_settings.rs");
     let channel_source = include_str!("../src/grpc_channel.rs");
     let unary_source = include_str!("../src/grpc_unary.rs");
     let crate_root = include_str!("../src/lib.rs");
-    assert!(root_manifest.contains("http = { version = \"^1.5\", default-features = false }"));
-    assert!(root_manifest.contains("tonic-prost = { version = \"^0.14\", default-features = false }"));
     assert!(transport_manifest.contains("tonic = { workspace = true, features = [\"channel\", \"tls-aws-lc\", \"tls-webpki-roots\"] }"));
     assert!(transport_manifest.contains("tonic = { workspace = true, features = [\"codegen\", \"server\"] }"));
     assert!(transport_manifest.contains("tonic-prost.workspace = true"));

crates/ksp-onchain-transport-lib/tests/yellowstone_publicnode_smoke.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-onchain-transport-lib/tests/yellowstone_publicnode_smoke.rs
-// version: 5
+// version: 6
 
 //! Opt-in live PublicNode Mainnet/Testnet smokes for authenticated provider-neutral Yellowstone gRPC Subscribe.
 
@@ -146,13 +146,8 @@ async fn assert_publicnode_slot_stream(name: &str, cluster: &str, url: &str, x_t
 #[ignore = "opt-in live PublicNode Mainnet Yellowstone gRPC smoke; reads the first personal x-token line from stdin and performs an external TLS/Subscribe request"]
 async fn publicnode_mainnet_yellowstone_streams_slots_with_network_scoped_secret_x_token() {
     let tokens = publicnode_x_tokens();
-    assert_publicnode_slot_stream(
+    assert_publicnode_slot_stream("publicnode_mainnet_yellowstone", "mainnet", "https://solana-yellowstone-grpc.publicnode.com:443", tokens.mainnet.as_str())
-        "publicnode_mainnet_yellowstone",
+        .await;
-        "mainnet-beta",
-        "https://solana-yellowstone-grpc.publicnode.com:443",
-        tokens.mainnet.as_str(),
-    )
-    .await;
 }
 
 #[tokio::test(flavor = "current_thread")]

crates/ksp-onchain-transport-lib/unit_tests/grpc_stream.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-onchain-transport-lib/unit_tests/grpc_stream.rs
-// version: 3
+// version: 4
 
 #[derive(Clone, Copy)]
 enum FixtureMode {
@@ -171,6 +171,15 @@ impl yellowstone_grpc_proto::geyser::geyser_server::Geyser for FixtureGeyser {
         return std::result::Result::Err(tonic::Status::unimplemented("deshred is outside KSP 0.2.9"));
     }
 
+    type SubscribeGossipStream = futures_util::stream::Empty<std::result::Result<yellowstone_grpc_proto::geyser::SubscribeUpdateGossip, tonic::Status>>;
+
+    async fn subscribe_gossip(
+        &self,
+        _request: tonic::Request<yellowstone_grpc_proto::geyser::SubscribeGossipRequest>,
+    ) -> std::result::Result<tonic::Response<Self::SubscribeGossipStream>, tonic::Status> {
+        return std::result::Result::Err(tonic::Status::unimplemented("gossip is outside KSP 0.2.9"));
+    }
+
     async fn subscribe_replay_info(
         &self,
         request: tonic::Request<yellowstone_grpc_proto::geyser::SubscribeReplayInfoRequest>,

crates/ksp-onchain-transport-lib/unit_tests/grpc_unary.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-onchain-transport-lib/unit_tests/grpc_unary.rs
-// version: 3
+// version: 4
 
 #[derive(Clone, Default)]
 struct FixtureGeyser;
@@ -31,6 +31,19 @@ impl yellowstone_grpc_proto::geyser::geyser_server::Geyser for FixtureGeyser {
         return std::result::Result::Err(tonic::Status::unimplemented("deshred is outside KSP 0.2.9"));
     }
 
+    type SubscribeGossipStream = std::pin::Pin<
+        std::boxed::Box<
+            dyn futures_util::Stream<Item = std::result::Result<yellowstone_grpc_proto::geyser::SubscribeUpdateGossip, tonic::Status>> + Send + 'static,
+        >,
+    >;
+
+    async fn subscribe_gossip(
+        &self,
+        _request: tonic::Request<yellowstone_grpc_proto::geyser::SubscribeGossipRequest>,
+    ) -> std::result::Result<tonic::Response<Self::SubscribeGossipStream>, tonic::Status> {
+        return std::result::Result::Err(tonic::Status::unimplemented("gossip is outside KSP 0.2.9"));
+    }
+
     async fn subscribe_replay_info(
         &self,
         request: tonic::Request<yellowstone_grpc_proto::geyser::SubscribeReplayInfoRequest>,
@@ -128,7 +141,7 @@ impl yellowstone_grpc_proto::geyser::geyser_server::Geyser for FixtureGeyser {
             return std::result::Result::Err(error);
         }
         return std::result::Result::Ok(tonic::Response::new(yellowstone_grpc_proto::geyser::GetVersionResponse {
-            version: "fixture-yellowstone-12.6".to_owned(),
+            version: "fixture-yellowstone-12.7".to_owned(),
         }));
     }
 }
@@ -238,7 +251,7 @@ async fn yellowstone_unary_fixture_covers_all_seven_standard_methods_and_metadat
     assert_eq!(validity.slot(), 404);
     assert!(validity.valid());
     let version = client.get_version().await.expect("version fixture must succeed");
-    assert_eq!(version.version(), "fixture-yellowstone-12.6");
+    assert_eq!(version.version(), "fixture-yellowstone-12.7");
     let rendered = format!("{client:?} {channel:?}");
     assert!(!rendered.contains("GRPC-SECRET-CANARY"));
     assert!(!rendered.contains(server.endpoint_url.as_str()));

crates/ksp-onchain-transport-lib/unit_tests/rpc_blocks.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-onchain-transport-lib/unit_tests/rpc_blocks.rs
-// version: 6
+// version: 7
 
 #[test]
 fn transaction_details_and_get_block_config_preserve_all_modern_options() {
@@ -188,6 +188,35 @@ fn serve_once(body: &'static str) -> (std::string::String, std::thread::JoinHand
     return (format!("http://{address}"), handle);
 }
 
+fn serve_status_and_count(status_line: &'static str) -> (std::string::String, std::thread::JoinHandle<(usize, std::string::String)>) {
+    let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("fixture listener must bind");
+    let address = listener.local_addr().expect("fixture listener address must resolve");
+    let handle = std::thread::spawn(move || {
+        let (mut stream, _) = listener.accept().expect("fixture server must accept first request");
+        let first_request = read_request(&mut stream);
+        let response = format!("HTTP/1.1 {status_line}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n");
+        std::io::Write::write_all(&mut stream, response.as_bytes()).expect("fixture response must write");
+        let mut count = 1_usize;
+        listener.set_nonblocking(true).expect("fixture listener must become nonblocking");
+        let deadline = std::time::Instant::now() + std::time::Duration::from_millis(120);
+        while std::time::Instant::now() < deadline {
+            match listener.accept() {
+                std::result::Result::Ok((mut retry_stream, _)) => {
+                    let _ = read_request(&mut retry_stream);
+                    std::io::Write::write_all(&mut retry_stream, response.as_bytes()).expect("fixture retry response must write");
+                    count = count.saturating_add(1);
+                },
+                std::result::Result::Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
+                    std::thread::sleep(std::time::Duration::from_millis(5));
+                },
+                std::result::Result::Err(error) => panic!("fixture listener failed while counting retries: {error}"),
+            }
+        }
+        return (count, first_request);
+    });
+    return (format!("http://{address}"), handle);
+}
+
 fn read_request(stream: &mut std::net::TcpStream) -> std::string::String {
     let mut bytes = std::vec::Vec::new();
     let mut buffer = [0_u8; 1024];
@@ -784,3 +813,92 @@ async fn typed_get_block_rejects_processed_commitment_before_io() {
     assert_eq!(error.context()[1].key(), "commitment");
     assert_eq!(error.context()[1].value(), "processed");
 }
+
+#[tokio::test(flavor = "current_thread")]
+async fn pre_004_get_block_observed_reports_actual_winner_after_retry_reroute() {
+    let (first_url, first_handle) = serve_status_and_count("429 Too Many Requests");
+    let (winner_url, winner_handle) = serve_once(include_str!("../fixtures/http/get_block.observed_material.success.json"));
+    let urls = [(first_url.as_str(), "first-endpoint", "first-provider"), (winner_url.as_str(), "winner-endpoint", "winner-provider")];
+    let mut endpoints = std::vec::Vec::with_capacity(urls.len());
+    for (url, endpoint_name, provider) in urls {
+        let role = crate::HttpEndpointRoleSettings::new(
+            crate::HttpRoleName::new("default"),
+            true,
+            std::vec![crate::HttpRequestKind::wildcard()],
+            10,
+            crate::HttpRoleLimits::new(std::option::Option::None, std::option::Option::None, std::option::Option::None, std::option::Option::None),
+        );
+        endpoints.push(crate::HttpEndpointSettings::new(
+            endpoint_name,
+            true,
+            crate::HttpProviderName::new(provider),
+            crate::HttpClusterName::new("local"),
+            crate::HttpEndpointUrl::parse(url).expect("fixture URL must parse"),
+            std::time::Duration::from_millis(100),
+            std::time::Duration::from_secs(1),
+            std::option::Option::Some(1),
+            std::vec![role],
+        ));
+    }
+    let pool = crate::HttpTransportPool::new(crate::HttpTransportSettings::new(
+        endpoints,
+        crate::HttpRetrySettings::new(1, std::time::Duration::from_millis(1), std::time::Duration::from_millis(2)),
+    ))
+    .expect("observed fixture pool must build");
+    let config = crate::SolanaGetBlockConfig::new(
+        std::option::Option::Some(crate::SolanaCommitment::Confirmed),
+        std::option::Option::Some(crate::SolanaTransactionEncoding::Base64),
+        std::option::Option::Some(crate::SolanaTransactionDetails::Full),
+        std::option::Option::Some(0),
+        std::option::Option::Some(false),
+    );
+    let observed = pool
+        .get_block_observed(&crate::HttpRoleName::new("default"), 430_000_123, std::option::Option::Some(&config))
+        .await
+        .expect("retry-safe observed getBlock must succeed on the second endpoint");
+    assert_eq!(observed.endpoint_name(), "winner-endpoint");
+    assert_eq!(observed.provider().as_str(), "winner-provider");
+    let block = observed.value().as_ref().expect("winning response must contain a block");
+    let transactions = block.transactions().value().expect("winning block must contain transactions");
+    assert_eq!(transactions.len(), 1);
+    assert!(matches!(
+        transactions[0].transaction(),
+        crate::SolanaEncodedTransaction::Binary { encoding: crate::SolanaTransactionBinaryEncoding::Base64, .. }
+    ));
+    let rendered = format!("{observed:?}");
+    assert!(rendered.contains("winner-endpoint"));
+    assert!(rendered.contains("winner-provider"));
+    assert!(rendered.contains("<available>"));
+    assert!(!rendered.contains("AQAAAAAAAA"));
+    let (first_count, first_request) = first_handle.join().expect("first fixture server must join");
+    assert_eq!(first_count, 1);
+    assert_eq!(request_body(first_request.as_str())["method"], serde_json::json!("getBlock"));
+    let winner_request = winner_handle.join().expect("winner fixture server must join");
+    assert_eq!(request_body(winner_request.as_str())["method"], serde_json::json!("getBlock"));
+    return;
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn pre_004_get_block_observed_preserves_null_and_reuses_get_block_validation() {
+    let (url, handle) = serve_once(include_str!("../fixtures/http/get_block.null.json"));
+    let pool = pool_for_url(url.as_str());
+    let observed = pool
+        .get_block_observed(&crate::HttpRoleName::new("default"), 430_000_123, std::option::Option::None)
+        .await
+        .expect("observed null getBlock must succeed");
+    assert!(observed.value().is_none());
+    assert_eq!(observed.endpoint_name(), "fixture");
+    assert_eq!(observed.provider().as_str(), "fixture");
+    handle.join().expect("fixture server must join");
+    let processed = crate::SolanaGetBlockConfig::new(
+        std::option::Option::Some(crate::SolanaCommitment::Processed),
+        std::option::Option::Some(crate::SolanaTransactionEncoding::Base64),
+        std::option::Option::Some(crate::SolanaTransactionDetails::Full),
+        std::option::Option::Some(0),
+        std::option::Option::Some(false),
+    );
+    let result = pool.get_block_observed(&crate::HttpRoleName::new("default"), 1, std::option::Option::Some(&processed)).await;
+    let error = result.expect_err("processed observed getBlock commitment must reject before I/O");
+    assert_eq!(error.code(), crate::ERROR_CODE_INVALID_RPC_PARAMETERS);
+    return;
+}

crates/ksp-raw-transaction-lib/Cargo.toml

@@ -0,0 +1,18 @@
+# file: crates/ksp-raw-transaction-lib/Cargo.toml
+# version: 2
+
+[package]
+name = "ksp-raw-transaction-lib"
+version.workspace = true
+edition.workspace = true
+repository.workspace = true
+
+[dependencies]
+base64.workspace = true
+ksp-core-lib = { path = "../ksp-core-lib" }
+ksp-store-api = { path = "../ksp-store-api" }
+serde_json = { workspace = true }
+sha2 = { workspace = true }
+
+[lints]
+workspace = true

crates/ksp-raw-transaction-lib/README.md

@@ -0,0 +1,97 @@
+<!-- file: crates/ksp-raw-transaction-lib/README.md -->
+<!-- version: 1 -->
+
+# ksp-raw-transaction-lib
+
+`ksp-raw-transaction-lib` fournit la lower-layer KSP source-neutral commune aux producteurs de `RawTransaction`.
+
+La crate transforme un matériau transactionnel complet déjà acquis en représentation RAW canonique KSP, fournit les primitives de parsing de signature et de sérialisation wire Solana nécessaires aux voies qualifiées, puis permet d'associer la transaction canonique à une observation/provenance possédée par le producer.
+
+Elle ne possède aucun Transport, Config, Job, Worker, runtime async, Store runtime ou backend physique.
+
+## Responsabilités
+
+La façade crate-root expose quatre familles de contrats.
+
+### Canonicalisation RAW Transaction
+
+- `RawTransactionMaterial` ;
+- `RawTransactionWireField<T>` pour préserver distinctement omission, `null` explicite et valeur ;
+- `RawTransactionVersion` ;
+- `canonicalize_raw_transaction` ;
+- `RAW_TRANSACTION_FORMAT_ID` et `RAW_TRANSACTION_FORMAT_VERSION`.
+
+La canonicalisation produit un `ksp_store_api::RawTransaction` avec payload KSP déterministe et SHA-256 de contenu. Le producer reste responsable de fournir un matériau source-neutral complet ; la crate n'effectue aucune I/O réseau.
+
+### Signature Solana
+
+- `parse_raw_transaction_signature` valide et décode une signature Base58 bornée vers exactement 64 bytes ;
+- `extract_raw_transaction_signature_from_binary_base64` extrait la première signature canonique d'un wire transactionnel Base64 complet ;
+- les bornes textuelles publiques permettent l'admission avant décodage.
+
+Les diagnostics ne recopient pas la signature hostile.
+
+### Wire transactionnel source-neutral
+
+La surface `RawSolana*` représente et sérialise les messages transactionnels Solana Legacy, V0 et V1 nécessaires à la common RAW :
+
+- `RawSolanaMessageVersion` ;
+- `RawSolanaMessageHeader` ;
+- `RawSolanaCompiledInstruction` ;
+- `RawSolanaAddressTableLookup` ;
+- `RawSolanaTransactionConfig` ;
+- `RawSolanaTransactionMessage` ;
+- `RawSolanaTransactionWire` ;
+- `serialize_solana_transaction_wire` et `serialize_solana_transaction_wire_base64`.
+
+Cette surface est un contrat de wire commun, pas un decoder Program et pas une façade Transport.
+
+### Acquisition canonique + observation
+
+`assemble_raw_transaction_acquisition` associe une transaction canonique à :
+
+- une `RawObservationKey` déterministe possédée par le producer ;
+- une `RawAcquisitionProvenance` sûre possédée par le producer.
+
+Le résultat `RawTransactionAcquisition` contient exactement une entité canonique et une observation liée. Il ne persiste rien lui-même.
+
+## Frontières
+
+```text
+Transport / fixture / import / producer
+              |
+              v
+      matériau source-neutral
+              |
+              v
+   ksp-raw-transaction-lib
+       |              |
+       |              +-> exact Solana wire helpers
+       v
+RawTransaction + RawTransactionObservation
+       |
+       v
+producer runtime -> ksp-store-lib / capability Store appropriée
+```
+
+Interdictions structurelles :
+
+```text
+ksp-raw-transaction-lib -X-> ksp-onchain-transport-lib
+ksp-raw-transaction-lib -X-> ksp-config-lib
+ksp-raw-transaction-lib -X-> ksp-job-api / ksp-job-backfill-lib
+ksp-raw-transaction-lib -X-> ksp-worker-api / worker concret
+ksp-raw-transaction-lib -X-> ksp-store-lib / backend physique
+```
+
+Le graphe normal reste limité à `ksp-core-lib`, `ksp-store-api`, `base64`, `serde_json` et `sha2`.
+
+## Relation avec STRUCTURAL
+
+Cette crate appartient à **RAW**. Elle ne réalise pas la décomposition Store D2 `RAW -> STRUCTURAL`. La future couche STRUCTURAL consommera le RAW persistant et le décomposera en unités Solana génériques plus fines avant tout décodage Program.
+
+## Documentation
+
+- [`USAGE.md`](USAGE.md) — utilisation durable de la façade publique ;
+- [`../../docs/architecture/008-DATA_MATERIALIZATION_AND_STORE.md`](../../docs/architecture/008-DATA_MATERIALIZATION_AND_STORE.md) — frontières RAW / STRUCTURAL / DECODED / DOMAIN ;
+- [`../../docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md`](../../docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md) — qualification des sources `RawTransaction`.

crates/ksp-raw-transaction-lib/USAGE.md

@@ -0,0 +1,153 @@
+<!-- file: crates/ksp-raw-transaction-lib/USAGE.md -->
+<!-- version: 1 -->
+
+# Utilisation de ksp-raw-transaction-lib
+
+Cette page décrit la façade publique durable de `ksp-raw-transaction-lib`. Les consumers utilisent uniquement les exports du crate-root.
+
+## Parser une signature transactionnelle
+
+Lorsqu'une source fournit une signature Base58 textuelle, la convertir avec le parser commun plutôt que de dupliquer le décodage :
+
+```rust
+fn parse_signature(value: &str) -> ksp_core_lib::Result<ksp_store_api::RawTransactionSignature> {
+    return ksp_raw_transaction_lib::parse_raw_transaction_signature(value);
+}
+```
+
+Le résultat contient exactement 64 bytes canoniques. Les entrées vides, hors bornes, Base58 invalides ou de longueur décodée incorrecte sont rejetées sans recopier la valeur hostile dans l'erreur.
+
+Lorsqu'un wire Base64 complet contient déjà son tableau de signatures, utiliser :
+
+```rust
+fn embedded_signature(value: &str) -> ksp_core_lib::Result<ksp_store_api::RawTransactionSignature> {
+    return ksp_raw_transaction_lib::extract_raw_transaction_signature_from_binary_base64(value);
+}
+```
+
+## Construire et sérialiser un wire Solana source-neutral
+
+Le producer peut projeter son DTO Transport/protobuf vers les types `RawSolana*`, puis utiliser le sérialiseur commun. Exemple V1 minimal :
+
+```rust
+fn serialize_v1() -> ksp_core_lib::Result<std::string::String> {
+    let message = ksp_raw_transaction_lib::RawSolanaTransactionMessage::new(
+        ksp_raw_transaction_lib::RawSolanaMessageVersion::V1,
+        ksp_raw_transaction_lib::RawSolanaMessageHeader::new(1, 0, 0),
+        vec![[1_u8; 32]],
+        [2_u8; 32],
+        vec![ksp_raw_transaction_lib::RawSolanaCompiledInstruction::new(0, vec![0], vec![3])],
+        vec![],
+        std::option::Option::Some(ksp_raw_transaction_lib::RawSolanaTransactionConfig::default()),
+    );
+    let wire = ksp_raw_transaction_lib::RawSolanaTransactionWire::new(vec![[4_u8; 64]], message);
+    return ksp_raw_transaction_lib::serialize_solana_transaction_wire_base64(&wire);
+}
+```
+
+Pour Legacy ou V0, choisir `RawSolanaMessageVersion::Legacy` ou `V0` et fournir uniquement les éléments admis par cette version. Le sérialiseur valide les invariants structurels avant de produire les bytes.
+
+`RawSolanaAddressTableLookup` représente les lookups V0. `RawSolanaTransactionConfig` représente la configuration inline V1 ; le cas explicite où toutes ses options valent `None` reste sémantiquement présent.
+
+## Construire le matériau RAW canonique
+
+Une fois le wire transactionnel Base64 et les métadonnées source-neutral disponibles, construire `RawTransactionMaterial`. Les états wire doivent conserver la différence entre champ absent, `null` explicite et valeur :
+
+```rust
+fn material(
+    network: ksp_store_api::RawNetworkId,
+    signature: ksp_store_api::RawTransactionSignature,
+    transaction_base64: std::string::String,
+) -> ksp_raw_transaction_lib::RawTransactionMaterial {
+    return ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64(
+        network,
+        signature,
+        42,
+        std::option::Option::None,
+        transaction_base64,
+        ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+        ksp_raw_transaction_lib::RawTransactionWireField::Value(ksp_raw_transaction_lib::RawTransactionVersion::Legacy),
+        ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+    );
+}
+```
+
+Pour une source où la signature doit être extraite du wire lui-même, `RawTransactionMaterial::binary_base64_with_embedded_signature` évite un second parser producer-owned.
+
+## Canonicaliser vers RawTransaction
+
+La canonicalisation est déterministe pour un même matériau complet :
+
+```rust
+fn canonicalize(
+    material: ksp_raw_transaction_lib::RawTransactionMaterial,
+) -> ksp_core_lib::Result<ksp_store_api::RawTransaction> {
+    return ksp_raw_transaction_lib::canonicalize_raw_transaction(material);
+}
+```
+
+La crate :
+
+- canonicalise les sous-arbres JSON significatifs ;
+- conserve les états omission / `null` / valeur ;
+- construit le payload au format KSP RAW Transaction ;
+- calcule son SHA-256 ;
+- applique les bornes communes avant construction du modèle Store.
+
+Elle ne persiste pas la transaction et ne choisit aucune politique de retry, endpoint ou source.
+
+## Associer l'observation du producer
+
+Le producer construit sa provenance avec les types Store API, puis assemble l'entité et l'observation :
+
+```rust
+fn acquisition(
+    transaction: ksp_store_api::RawTransaction,
+) -> ksp_core_lib::Result<ksp_raw_transaction_lib::RawTransactionAcquisition> {
+    let provider = match ksp_store_api::RawProvenanceCode::new("example") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let protocol = match ksp_store_api::RawProvenanceCode::new("solana.http") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let method = match ksp_store_api::RawProvenanceCode::new("get_transaction") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let received_at = match ksp_store_api::RawTimestamp::from_unix_millis(1_700_000_000_000) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let provenance = ksp_store_api::RawAcquisitionProvenance::new(
+        provider,
+        protocol,
+        method,
+        ksp_store_api::RawAcquisitionOrigin::Live,
+        received_at,
+    );
+    return std::result::Result::Ok(ksp_raw_transaction_lib::assemble_raw_transaction_acquisition(
+        transaction,
+        ksp_store_api::RawObservationKey::new([7_u8; 32]),
+        provenance,
+    ));
+}
+```
+
+La clé d'observation doit être déterministe selon la politique du producer. Plusieurs sources peuvent produire des observations différentes pour la même identité canonique `(network, signature)`.
+
+## Persister depuis un Job ou un Worker
+
+La common crate ne dépend pas du Store runtime. Le lifecycle host concret récupère les deux parties puis appelle la façade Store appropriée :
+
+```rust
+let (transaction, observation) = acquisition.into_parts();
+// Le Job/Worker concret transmet ensuite transaction + observation à ksp-store-lib.
+```
+
+Ne pas introduire `ksp-store-lib`, Transport, Config, Job ou Worker dans `ksp-raw-transaction-lib` pour simplifier cet appel. La direction de dépendance reste du producer vers la common RAW, puis du producer vers le Store runtime.
+
+## Frontière avec STRUCTURAL
+
+Ne pas utiliser cette crate pour décoder des Programs ou pour produire directement des unités STRUCTURAL. Son résultat reste D1 RAW. La décomposition `RAW -> STRUCTURAL` appartient à une couche ultérieure et réutilise le RAW durable comme input.

crates/ksp-raw-transaction-lib/src/acquisition.rs

@@ -0,0 +1,49 @@
+// file: crates/ksp-raw-transaction-lib/src/acquisition.rs
+// version: 1
+
+/// Complete source-neutral RAW transaction acquisition containing one canonical entity and one producer-owned observation.
+pub struct RawTransactionAcquisition {
+    observation: ksp_store_api::RawTransactionObservation,
+    transaction: ksp_store_api::RawTransaction,
+}
+
+impl crate::RawTransactionAcquisition {
+    /// Returns the producer-owned acquisition observation linked to the canonical transaction.
+    #[must_use]
+    pub const fn observation(&self) -> &ksp_store_api::RawTransactionObservation {
+        return &self.observation;
+    }
+
+    /// Returns the canonical source-independent RAW transaction.
+    #[must_use]
+    pub const fn transaction(&self) -> &ksp_store_api::RawTransaction {
+        return &self.transaction;
+    }
+
+    /// Consumes this acquisition into its canonical transaction and observation.
+    #[must_use]
+    pub fn into_parts(self) -> (ksp_store_api::RawTransaction, ksp_store_api::RawTransactionObservation) {
+        return (self.transaction, self.observation);
+    }
+}
+
+impl std::fmt::Debug for crate::RawTransactionAcquisition {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        return formatter.write_str("RawTransactionAcquisition(..)");
+    }
+}
+
+/// Assembles one canonical transaction with a producer-owned observation key and safe acquisition provenance.
+#[must_use]
+pub fn assemble_raw_transaction_acquisition(
+    transaction: ksp_store_api::RawTransaction,
+    observation_key: ksp_store_api::RawObservationKey,
+    provenance: ksp_store_api::RawAcquisitionProvenance,
+) -> crate::RawTransactionAcquisition {
+    let observation = ksp_store_api::RawTransactionObservation::new(observation_key, transaction.reference().clone(), provenance);
+    return crate::RawTransactionAcquisition { observation, transaction };
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/acquisition.rs"]
+mod tests;

crates/ksp-raw-transaction-lib/src/canonical.rs

@@ -0,0 +1,325 @@
+// file: crates/ksp-raw-transaction-lib/src/canonical.rs
+// version: 2
+
+use sha2::Digest; // rust-rules: trait-import
+
+/// KSP-owned source-independent RAW transaction format identifier.
+pub const RAW_TRANSACTION_FORMAT_ID: &str = "ksp.solana.raw_transaction";
+/// Frozen KSP-owned RAW transaction format version.
+pub const RAW_TRANSACTION_FORMAT_VERSION: u32 = 1;
+
+/// Source-wire presence state preserving omitted, explicit null and concrete values independently.
+#[non_exhaustive]
+pub enum RawTransactionWireField<T> {
+    /// The source field was omitted entirely.
+    Omitted,
+    /// The source field was explicitly present as JSON/protocol null.
+    Null,
+    /// The source field carried one concrete value.
+    Value(T),
+}
+
+impl<T> std::fmt::Debug for crate::RawTransactionWireField<T> {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        return match self {
+            Self::Omitted => formatter.write_str("Omitted"),
+            Self::Null => formatter.write_str("Null"),
+            Self::Value(_) => formatter.write_str("Value(..)"),
+        };
+    }
+}
+
+/// Canonical Solana transaction version admitted by RAW transaction format v1.
+#[non_exhaustive]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum RawTransactionVersion {
+    /// Legacy unversioned transaction representation.
+    Legacy,
+    /// Explicit versioned transaction number admitted by the current Solana wire contract.
+    Number(u8),
+}
+
+/// Complete source-neutral material required to construct one canonical RAW transaction.
+pub struct RawTransactionMaterial {
+    block_time: std::option::Option<i64>,
+    meta: crate::RawTransactionWireField<serde_json::Value>,
+    network: ksp_store_api::RawNetworkId,
+    signature: ksp_store_api::RawTransactionSignature,
+    slot: u64,
+    transaction_data: std::string::String,
+    transaction_index: crate::RawTransactionWireField<u32>,
+    version: crate::RawTransactionWireField<crate::RawTransactionVersion>,
+}
+
+impl crate::RawTransactionMaterial {
+    /// Creates complete source-neutral material for the frozen RAW v1 binary Base64 body path.
+    #[must_use]
+    pub fn binary_base64(
+        network: ksp_store_api::RawNetworkId,
+        signature: ksp_store_api::RawTransactionSignature,
+        slot: u64,
+        block_time: std::option::Option<i64>,
+        transaction_data: impl std::convert::Into<std::string::String>,
+        meta: crate::RawTransactionWireField<serde_json::Value>,
+        version: crate::RawTransactionWireField<crate::RawTransactionVersion>,
+        transaction_index: crate::RawTransactionWireField<u32>,
+    ) -> Self {
+        return Self {
+            block_time,
+            meta,
+            network,
+            signature,
+            slot,
+            transaction_data: transaction_data.into(),
+            transaction_index,
+            version,
+        };
+    }
+
+    /// Creates complete source-neutral RAW v1 material from a Base64 transaction wire that embeds its own canonical signature array.
+    pub fn binary_base64_with_embedded_signature(
+        network: ksp_store_api::RawNetworkId,
+        slot: u64,
+        block_time: std::option::Option<i64>,
+        transaction_data: impl std::convert::Into<std::string::String>,
+        meta: crate::RawTransactionWireField<serde_json::Value>,
+        version: crate::RawTransactionWireField<crate::RawTransactionVersion>,
+        transaction_index: crate::RawTransactionWireField<u32>,
+    ) -> ksp_core_lib::Result<Self> {
+        let transaction_data = transaction_data.into();
+        let signature = crate::extract_raw_transaction_signature_from_binary_base64(transaction_data.as_str());
+        return match signature {
+            std::result::Result::Ok(signature) => {
+                std::result::Result::Ok(Self { block_time, meta, network, signature, slot, transaction_data, transaction_index, version })
+            },
+            std::result::Result::Err(error) => std::result::Result::Err(error),
+        };
+    }
+}
+
+impl std::fmt::Debug for crate::RawTransactionMaterial {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        return formatter
+            .debug_struct("RawTransactionMaterial")
+            .field("network", &self.network)
+            .field("slot", &self.slot)
+            .field("block_time", &self.block_time)
+            .field("transaction_data_len", &self.transaction_data.len())
+            .field("meta", &wire_field_state(&self.meta))
+            .field("version", &wire_field_state(&self.version))
+            .field("transaction_index", &wire_field_state(&self.transaction_index))
+            .finish_non_exhaustive();
+    }
+}
+
+/// Canonicalizes complete source-neutral transaction material into the frozen KSP RAW transaction v1 representation.
+pub fn canonicalize_raw_transaction(material: crate::RawTransactionMaterial) -> ksp_core_lib::Result<ksp_store_api::RawTransaction> {
+    let block_time = convert_block_time(material.block_time);
+    let block_time = match block_time {
+        std::result::Result::Ok(block_time) => block_time,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let bytes = canonical_payload_bytes(&material);
+    let bytes = match bytes {
+        std::result::Result::Ok(bytes) => bytes,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    if bytes.is_empty() || bytes.len() > ksp_store_api::MAX_RAW_PAYLOAD_BYTES {
+        return std::result::Result::Err(crate::canonicalization_error("payload.bytes"));
+    }
+    let hash: [u8; 32] = sha2::Sha256::digest(bytes.as_slice()).into();
+    let format_id = ksp_store_api::RawFormatId::new(crate::RAW_TRANSACTION_FORMAT_ID);
+    let format_id = match format_id {
+        std::result::Result::Ok(format_id) => format_id,
+        std::result::Result::Err(_) => return std::result::Result::Err(crate::canonicalization_error("payload.format_id")),
+    };
+    let payload = ksp_store_api::RawPayload::try_new(
+        format_id,
+        crate::RAW_TRANSACTION_FORMAT_VERSION,
+        bytes.into_boxed_slice(),
+        ksp_store_api::RawContentHash::new(hash),
+    );
+    let payload = match payload {
+        std::result::Result::Ok(payload) => payload,
+        std::result::Result::Err(_) => return std::result::Result::Err(crate::canonicalization_error("payload")),
+    };
+    let reference = ksp_store_api::RawTransactionReference::new(material.network, material.signature);
+    return std::result::Result::Ok(ksp_store_api::RawTransaction::new(reference, material.slot, block_time, payload));
+}
+
+fn append_canonical_json(output: &mut std::vec::Vec<u8>, value: &serde_json::Value) -> ksp_core_lib::Result<()> {
+    return match value {
+        serde_json::Value::Null => {
+            output.extend_from_slice(b"null");
+            std::result::Result::Ok(())
+        },
+        serde_json::Value::Bool(value) => {
+            if *value {
+                output.extend_from_slice(b"true");
+            } else {
+                output.extend_from_slice(b"false");
+            }
+            std::result::Result::Ok(())
+        },
+        serde_json::Value::Number(value) => {
+            output.extend_from_slice(value.to_string().as_bytes());
+            std::result::Result::Ok(())
+        },
+        serde_json::Value::String(value) => append_json_string(output, value.as_str()),
+        serde_json::Value::Array(values) => {
+            output.push(b'[');
+            for (index, item) in values.iter().enumerate() {
+                if index != 0 {
+                    output.push(b',');
+                }
+                let item_result = append_canonical_json(output, item);
+                if let std::result::Result::Err(error) = item_result {
+                    return std::result::Result::Err(error);
+                }
+            }
+            output.push(b']');
+            std::result::Result::Ok(())
+        },
+        serde_json::Value::Object(values) => {
+            output.push(b'{');
+            let mut keys = values.keys().collect::<std::vec::Vec<_>>();
+            keys.sort_unstable();
+            for (index, key) in keys.iter().enumerate() {
+                if index != 0 {
+                    output.push(b',');
+                }
+                let key_result = append_json_string(output, key.as_str());
+                if let std::result::Result::Err(error) = key_result {
+                    return std::result::Result::Err(error);
+                }
+                output.push(b':');
+                let item = values.get(key.as_str());
+                let item = match item {
+                    std::option::Option::Some(item) => item,
+                    std::option::Option::None => return std::result::Result::Err(crate::canonicalization_error("payload.meta")),
+                };
+                let item_result = append_canonical_json(output, item);
+                if let std::result::Result::Err(error) = item_result {
+                    return std::result::Result::Err(error);
+                }
+            }
+            output.push(b'}');
+            std::result::Result::Ok(())
+        },
+    };
+}
+
+fn append_json_string(output: &mut std::vec::Vec<u8>, value: &str) -> ksp_core_lib::Result<()> {
+    let encoded = serde_json::to_vec(value);
+    return match encoded {
+        std::result::Result::Ok(encoded) => {
+            output.extend_from_slice(encoded.as_slice());
+            std::result::Result::Ok(())
+        },
+        std::result::Result::Err(_) => std::result::Result::Err(crate::canonicalization_error("payload.json")),
+    };
+}
+
+fn append_wire_value<T, F>(
+    output: &mut std::vec::Vec<u8>,
+    key: &str,
+    field: &crate::RawTransactionWireField<T>,
+    mut append_value: F,
+) -> ksp_core_lib::Result<()>
+where
+    F: FnMut(&mut std::vec::Vec<u8>, &T) -> ksp_core_lib::Result<()>,
+{
+    return match field {
+        crate::RawTransactionWireField::Omitted => std::result::Result::Ok(()),
+        crate::RawTransactionWireField::Null => {
+            output.push(b',');
+            let key_result = append_json_string(output, key);
+            if let std::result::Result::Err(error) = key_result {
+                return std::result::Result::Err(error);
+            }
+            output.extend_from_slice(b":null");
+            std::result::Result::Ok(())
+        },
+        crate::RawTransactionWireField::Value(value) => {
+            output.push(b',');
+            let key_result = append_json_string(output, key);
+            if let std::result::Result::Err(error) = key_result {
+                return std::result::Result::Err(error);
+            }
+            output.push(b':');
+            append_value(output, value)
+        },
+    };
+}
+
+fn canonical_payload_bytes(material: &crate::RawTransactionMaterial) -> ksp_core_lib::Result<std::vec::Vec<u8>> {
+    let mut bytes = std::vec::Vec::new();
+    bytes.extend_from_slice(b"{\"transaction\":[");
+    let transaction_result = append_json_string(&mut bytes, material.transaction_data.as_str());
+    if let std::result::Result::Err(error) = transaction_result {
+        return std::result::Result::Err(error);
+    }
+    bytes.push(b',');
+    let encoding_result = append_json_string(&mut bytes, "base64");
+    if let std::result::Result::Err(error) = encoding_result {
+        return std::result::Result::Err(error);
+    }
+    bytes.push(b']');
+    let meta_result = append_wire_value(&mut bytes, "meta", &material.meta, |output, value| return append_canonical_json(output, value));
+    if let std::result::Result::Err(error) = meta_result {
+        return std::result::Result::Err(error);
+    }
+    let version_result = append_wire_value(&mut bytes, "version", &material.version, |output, value| {
+        return match value {
+            crate::RawTransactionVersion::Legacy => append_json_string(output, "legacy"),
+            crate::RawTransactionVersion::Number(number) => {
+                output.extend_from_slice(number.to_string().as_bytes());
+                std::result::Result::Ok(())
+            },
+        };
+    });
+    if let std::result::Result::Err(error) = version_result {
+        return std::result::Result::Err(error);
+    }
+    let transaction_index_result = append_wire_value(&mut bytes, "transactionIndex", &material.transaction_index, |output, value| {
+        output.extend_from_slice(value.to_string().as_bytes());
+        return std::result::Result::Ok(());
+    });
+    if let std::result::Result::Err(error) = transaction_index_result {
+        return std::result::Result::Err(error);
+    }
+    bytes.push(b'}');
+    return std::result::Result::Ok(bytes);
+}
+
+fn convert_block_time(value: std::option::Option<i64>) -> ksp_core_lib::Result<std::option::Option<ksp_store_api::RawTimestamp>> {
+    let seconds = match value {
+        std::option::Option::Some(seconds) => seconds,
+        std::option::Option::None => return std::result::Result::Ok(std::option::Option::None),
+    };
+    let seconds = match u64::try_from(seconds) {
+        std::result::Result::Ok(seconds) => seconds,
+        std::result::Result::Err(_) => return std::result::Result::Err(crate::material_error("block_time")),
+    };
+    let millis = match seconds.checked_mul(1_000) {
+        std::option::Option::Some(millis) => millis,
+        std::option::Option::None => return std::result::Result::Err(crate::material_error("block_time")),
+    };
+    let timestamp = ksp_store_api::RawTimestamp::from_unix_millis(millis);
+    return match timestamp {
+        std::result::Result::Ok(timestamp) => std::result::Result::Ok(std::option::Option::Some(timestamp)),
+        std::result::Result::Err(_) => std::result::Result::Err(crate::material_error("block_time")),
+    };
+}
+
+fn wire_field_state<T>(field: &crate::RawTransactionWireField<T>) -> &'static str {
+    return match field {
+        crate::RawTransactionWireField::Omitted => "omitted",
+        crate::RawTransactionWireField::Null => "null",
+        crate::RawTransactionWireField::Value(_) => "value",
+    };
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/canonical.rs"]
+mod tests;

crates/ksp-raw-transaction-lib/src/error.rs

@@ -0,0 +1,27 @@
+// file: crates/ksp-raw-transaction-lib/src/error.rs
+// version: 2
+
+/// Error code used when RAW v1 canonical payload construction cannot preserve the frozen format contract.
+pub const ERROR_CODE_RAW_TRANSACTION_CANONICALIZATION_INVALID: ksp_core_lib::ErrorCode =
+    ksp_core_lib::ErrorCode::new("raw_transaction", "canonicalization_invalid");
+/// Error code used when source-neutral RAW transaction material violates a bounded semantic invariant.
+pub const ERROR_CODE_RAW_TRANSACTION_MATERIAL_INVALID: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("raw_transaction", "material_invalid");
+/// Error code used when Solana transaction signature material cannot resolve to exactly 64 canonical bytes.
+pub const ERROR_CODE_RAW_TRANSACTION_SIGNATURE_INVALID: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("raw_transaction", "signature_invalid");
+
+/// Creates a safe canonicalization error without copying source payload material.
+pub(crate) fn canonicalization_error(field: &'static str) -> ksp_core_lib::Error {
+    return ksp_core_lib::Error::new(crate::ERROR_CODE_RAW_TRANSACTION_CANONICALIZATION_INVALID, "invalid canonical RAW transaction representation")
+        .with_context("field", field);
+}
+
+/// Creates a safe source-material error without copying source payload material.
+pub(crate) fn material_error(field: &'static str) -> ksp_core_lib::Error {
+    return ksp_core_lib::Error::new(crate::ERROR_CODE_RAW_TRANSACTION_MATERIAL_INVALID, "invalid source-neutral RAW transaction material")
+        .with_context("field", field);
+}
+
+/// Creates a safe signature error without copying source signature or transaction material.
+pub(crate) fn signature_error() -> ksp_core_lib::Error {
+    return ksp_core_lib::Error::new(crate::ERROR_CODE_RAW_TRANSACTION_SIGNATURE_INVALID, "invalid canonical Solana transaction signature");
+}

crates/ksp-raw-transaction-lib/src/lib.rs

@@ -0,0 +1,75 @@
+// file: crates/ksp-raw-transaction-lib/src/lib.rs
+// version: 3
+
+#![warn(missing_docs)]
+#![deny(unreachable_pub)]
+#![forbid(unsafe_code)]
+
+//! Source-neutral canonicalization of complete Solana transactions into KSP RAW transaction v1.
+//!
+//! This lower layer owns the frozen RAW transaction format, textual signature parsing, canonical
+//! JSON construction, content hashing and assembly of one canonical transaction with one
+//! producer-owned observation. It owns no Transport, Config, Job, Worker, async runtime or Store
+//! backend behavior.
+
+mod acquisition;
+mod canonical;
+mod error;
+mod signature;
+mod wire;
+
+/// Complete source-neutral RAW transaction acquisition containing one canonical entity and one producer-owned observation.
+pub use self::acquisition::RawTransactionAcquisition;
+/// Assembles one canonical transaction with a producer-owned observation key and safe acquisition provenance.
+pub use self::acquisition::assemble_raw_transaction_acquisition;
+/// KSP-owned source-independent RAW transaction format identifier.
+pub use self::canonical::RAW_TRANSACTION_FORMAT_ID;
+/// Frozen KSP-owned RAW transaction format version.
+pub use self::canonical::RAW_TRANSACTION_FORMAT_VERSION;
+/// Complete source-neutral material required to construct one canonical RAW transaction.
+pub use self::canonical::RawTransactionMaterial;
+/// Canonical Solana transaction version admitted by RAW transaction format v1.
+pub use self::canonical::RawTransactionVersion;
+/// Source-wire presence state preserving omitted, explicit null and concrete values independently.
+pub use self::canonical::RawTransactionWireField;
+/// Canonicalizes complete source-neutral transaction material into the frozen KSP RAW transaction v1 representation.
+pub use self::canonical::canonicalize_raw_transaction;
+/// Error code used when RAW v1 canonical payload construction cannot preserve the frozen format contract.
+pub use self::error::ERROR_CODE_RAW_TRANSACTION_CANONICALIZATION_INVALID;
+/// Error code used when source-neutral RAW transaction material violates a bounded semantic invariant.
+pub use self::error::ERROR_CODE_RAW_TRANSACTION_MATERIAL_INVALID;
+/// Error code used when Solana transaction signature material cannot resolve to exactly 64 canonical bytes.
+pub use self::error::ERROR_CODE_RAW_TRANSACTION_SIGNATURE_INVALID;
+/// Maximum UTF-8 byte length admitted for one textual Base58 Solana transaction signature.
+pub use self::signature::MAX_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES;
+/// Minimum UTF-8 byte length admitted for one textual Base58 Solana transaction signature.
+pub use self::signature::MIN_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES;
+/// Extracts the first canonical 64-byte Solana signature from one complete Base64 transaction wire.
+pub use self::signature::extract_raw_transaction_signature_from_binary_base64;
+/// Parses one bounded Base58 Solana transaction signature to exactly 64 canonical bytes.
+pub use self::signature::parse_raw_transaction_signature;
+/// One source-neutral v0 address-table lookup.
+pub use self::wire::RawSolanaAddressTableLookup;
+/// One source-neutral compiled Solana instruction.
+pub use self::wire::RawSolanaCompiledInstruction;
+/// Source-neutral Solana message header.
+pub use self::wire::RawSolanaMessageHeader;
+/// Source-neutral Solana transaction message version.
+pub use self::wire::RawSolanaMessageVersion;
+/// Optional source-neutral Transaction V1 inline configuration.
+pub use self::wire::RawSolanaTransactionConfig;
+/// Complete source-neutral Solana transaction message.
+pub use self::wire::RawSolanaTransactionMessage;
+/// Complete source-neutral Solana transaction wire material.
+pub use self::wire::RawSolanaTransactionWire;
+/// Serializes one source-neutral Solana transaction to exact canonical wire bytes.
+pub use self::wire::serialize_solana_transaction_wire;
+/// Serializes one source-neutral Solana transaction to canonical padded standard Base64.
+pub use self::wire::serialize_solana_transaction_wire_base64;
+
+/// Creates a safe canonicalization error without copying source payload material.
+pub(crate) use self::error::canonicalization_error;
+/// Creates a safe source-material error without copying source payload material.
+pub(crate) use self::error::material_error;
+/// Creates a safe signature error without copying textual signature material.
+pub(crate) use self::error::signature_error;

crates/ksp-raw-transaction-lib/src/signature.rs

@@ -0,0 +1,290 @@
+// file: crates/ksp-raw-transaction-lib/src/signature.rs
+// version: 3
+
+use base64::Engine; // rust-rules: trait-import
+
+/// Maximum UTF-8 byte length admitted for one textual Base58 Solana transaction signature.
+pub const MAX_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES: usize = 88;
+/// Minimum UTF-8 byte length admitted for one textual Base58 Solana transaction signature.
+pub const MIN_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES: usize = 64;
+
+/// Parses one bounded Base58 Solana transaction signature to exactly 64 canonical bytes.
+pub fn parse_raw_transaction_signature(value: &str) -> ksp_core_lib::Result<ksp_store_api::RawTransactionSignature> {
+    let text = value.as_bytes();
+    if text.len() < crate::MIN_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES || text.len() > crate::MAX_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES {
+        return std::result::Result::Err(
+            crate::signature_error()
+                .with_context("actual_len", text.len().to_string())
+                .with_context("minimum_len", crate::MIN_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES.to_string())
+                .with_context("maximum_len", crate::MAX_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES.to_string()),
+        );
+    }
+    let mut decoded = [0_u8; 64];
+    let mut leading_zeroes = 0_usize;
+    for byte in text {
+        if *byte != b'1' {
+            break;
+        }
+        leading_zeroes += 1;
+    }
+    for byte in text {
+        let digit = match base58_digit(*byte) {
+            std::option::Option::Some(digit) => digit,
+            std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+        };
+        let mut carry = u32::from(digit);
+        for output in decoded.iter_mut().rev() {
+            let expanded = (u32::from(*output) * 58) + carry;
+            *output = (expanded & 0xff) as u8;
+            carry = expanded >> 8;
+        }
+        if carry != 0 {
+            return std::result::Result::Err(crate::signature_error());
+        }
+    }
+    let significant_len = match decoded.iter().position(|byte| return *byte != 0) {
+        std::option::Option::Some(index) => decoded.len() - index,
+        std::option::Option::None => 0,
+    };
+    if leading_zeroes + significant_len != decoded.len() {
+        return std::result::Result::Err(crate::signature_error());
+    }
+    return std::result::Result::Ok(ksp_store_api::RawTransactionSignature::new(decoded));
+}
+
+/// Extracts the first canonical 64-byte Solana signature from one complete Base64-encoded transaction wire.
+///
+/// The compact signature-count prefix must use its canonical short-vector representation, contain at least one signature,
+/// and the decoded transaction must retain message bytes after the declared signature array.
+pub fn extract_raw_transaction_signature_from_binary_base64(value: &str) -> ksp_core_lib::Result<ksp_store_api::RawTransactionSignature> {
+    if value.is_empty() || value.len() > ksp_store_api::MAX_RAW_PAYLOAD_BYTES {
+        return std::result::Result::Err(crate::signature_error());
+    }
+    let decoded = base64::engine::general_purpose::STANDARD.decode(value);
+    let decoded = match decoded {
+        std::result::Result::Ok(decoded) => decoded,
+        std::result::Result::Err(_) => return std::result::Result::Err(crate::signature_error()),
+    };
+    if base64::engine::general_purpose::STANDARD.encode(decoded.as_slice()) != value {
+        return std::result::Result::Err(crate::signature_error());
+    }
+    if decoded.first() == std::option::Option::Some(&0x81) {
+        return extract_v1_signature(decoded.as_slice());
+    }
+    return extract_legacy_or_v0_signature(decoded.as_slice());
+}
+
+fn extract_legacy_or_v0_signature(decoded: &[u8]) -> ksp_core_lib::Result<ksp_store_api::RawTransactionSignature> {
+    let prefix = decode_signature_count(decoded);
+    let (signature_count, prefix_len) = match prefix {
+        std::result::Result::Ok(prefix) => prefix,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    if signature_count == 0 {
+        return std::result::Result::Err(crate::signature_error());
+    }
+    let signatures_len = match signature_count.checked_mul(64) {
+        std::option::Option::Some(length) => length,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let message_offset = match prefix_len.checked_add(signatures_len) {
+        std::option::Option::Some(offset) => offset,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    if message_offset >= decoded.len() {
+        return std::result::Result::Err(crate::signature_error());
+    }
+    return copy_signature(decoded, prefix_len);
+}
+
+fn extract_v1_signature(decoded: &[u8]) -> ksp_core_lib::Result<ksp_store_api::RawTransactionSignature> {
+    if decoded.len() > 4_096 || decoded.len() < 42 {
+        return std::result::Result::Err(crate::signature_error());
+    }
+    let required_signatures = match decoded.get(1) {
+        std::option::Option::Some(value) => usize::from(*value),
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let readonly_signed = match decoded.get(2) {
+        std::option::Option::Some(value) => usize::from(*value),
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let readonly_unsigned = match decoded.get(3) {
+        std::option::Option::Some(value) => usize::from(*value),
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    if required_signatures == 0 || required_signatures > 12 || readonly_signed >= required_signatures {
+        return std::result::Result::Err(crate::signature_error());
+    }
+    let mask_bytes = match decoded.get(4..8) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let mask = u32::from_le_bytes([mask_bytes[0], mask_bytes[1], mask_bytes[2], mask_bytes[3]]);
+    if mask & !0x1f != 0 || matches!(mask & 0b11, 1 | 2) {
+        return std::result::Result::Err(crate::signature_error());
+    }
+    let instruction_count = match decoded.get(40) {
+        std::option::Option::Some(value) => usize::from(*value),
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let address_count = match decoded.get(41) {
+        std::option::Option::Some(value) => usize::from(*value),
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    if instruction_count > 64 || address_count > 64 || address_count < required_signatures + readonly_unsigned {
+        return std::result::Result::Err(crate::signature_error());
+    }
+    let addresses_len = match address_count.checked_mul(32) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let mut offset = match 42_usize.checked_add(addresses_len) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let config_len = config_value_length(mask);
+    offset = match offset.checked_add(config_len) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let headers_len = match instruction_count.checked_mul(4) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let headers_end = match offset.checked_add(headers_len) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    if headers_end > decoded.len() {
+        return std::result::Result::Err(crate::signature_error());
+    }
+    let mut payload_len = 0_usize;
+    for index in 0..instruction_count {
+        let header_offset = offset + (index * 4);
+        let program_index = usize::from(decoded[header_offset]);
+        let account_index_count = usize::from(decoded[header_offset + 1]);
+        let data_len = u16::from_le_bytes([decoded[header_offset + 2], decoded[header_offset + 3]]);
+        if program_index >= address_count {
+            return std::result::Result::Err(crate::signature_error());
+        }
+        payload_len = match payload_len.checked_add(account_index_count).and_then(|value| return value.checked_add(usize::from(data_len))) {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+        };
+    }
+    let payload_end = match headers_end.checked_add(payload_len) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let payload = match decoded.get(headers_end..payload_end) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let mut payload_offset = 0_usize;
+    for index in 0..instruction_count {
+        let header_offset = offset + (index * 4);
+        let account_index_count = usize::from(decoded[header_offset + 1]);
+        let data_len = usize::from(u16::from_le_bytes([decoded[header_offset + 2], decoded[header_offset + 3]]));
+        let account_end = match payload_offset.checked_add(account_index_count) {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+        };
+        let account_indexes = match payload.get(payload_offset..account_end) {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+        };
+        if account_indexes.iter().any(|value| return usize::from(*value) >= address_count) {
+            return std::result::Result::Err(crate::signature_error());
+        }
+        payload_offset = match account_end.checked_add(data_len) {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+        };
+    }
+    let signatures_len = match required_signatures.checked_mul(64) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let expected_end = match payload_end.checked_add(signatures_len) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    if expected_end != decoded.len() {
+        return std::result::Result::Err(crate::signature_error());
+    }
+    return copy_signature(decoded, payload_end);
+}
+
+fn config_value_length(mask: u32) -> usize {
+    let mut length = 0_usize;
+    if mask & 0b11 == 0b11 {
+        length += 8;
+    }
+    if mask & (1_u32 << 2) != 0 {
+        length += 4;
+    }
+    if mask & (1_u32 << 3) != 0 {
+        length += 4;
+    }
+    if mask & (1_u32 << 4) != 0 {
+        length += 4;
+    }
+    return length;
+}
+
+fn copy_signature(decoded: &[u8], offset: usize) -> ksp_core_lib::Result<ksp_store_api::RawTransactionSignature> {
+    let first_end = match offset.checked_add(64) {
+        std::option::Option::Some(end) => end,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let first = match decoded.get(offset..first_end) {
+        std::option::Option::Some(first) => first,
+        std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+    };
+    let mut signature = [0_u8; 64];
+    signature.copy_from_slice(first);
+    return std::result::Result::Ok(ksp_store_api::RawTransactionSignature::new(signature));
+}
+
+fn decode_signature_count(bytes: &[u8]) -> ksp_core_lib::Result<(usize, usize)> {
+    let mut value = 0_usize;
+    for index in 0..3_usize {
+        let byte = match bytes.get(index) {
+            std::option::Option::Some(byte) => *byte,
+            std::option::Option::None => return std::result::Result::Err(crate::signature_error()),
+        };
+        let payload = usize::from(byte & 0x7f);
+        let shift = index * 7;
+        value |= payload << shift;
+        if byte & 0x80 == 0 {
+            if index != 0 {
+                let minimum = 1_usize << shift;
+                if value < minimum {
+                    return std::result::Result::Err(crate::signature_error());
+                }
+            }
+            if value > usize::from(u16::MAX) {
+                return std::result::Result::Err(crate::signature_error());
+            }
+            return std::result::Result::Ok((value, index + 1));
+        }
+    }
+    return std::result::Result::Err(crate::signature_error());
+}
+
+fn base58_digit(byte: u8) -> std::option::Option<u8> {
+    return match byte {
+        b'1'..=b'9' => std::option::Option::Some(byte - b'1'),
+        b'A'..=b'H' => std::option::Option::Some((byte - b'A') + 9),
+        b'J'..=b'N' => std::option::Option::Some((byte - b'J') + 17),
+        b'P'..=b'Z' => std::option::Option::Some((byte - b'P') + 22),
+        b'a'..=b'k' => std::option::Option::Some((byte - b'a') + 33),
+        b'm'..=b'z' => std::option::Option::Some((byte - b'm') + 44),
+        _ => std::option::Option::None,
+    };
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/signature.rs"]
+mod tests;

crates/ksp-raw-transaction-lib/src/wire.rs

@@ -0,0 +1,545 @@
+// file: crates/ksp-raw-transaction-lib/src/wire.rs
+// version: 3
+
+use base64::Engine; // rust-rules: trait-import
+
+const MAX_LEGACY_SHORT_VECTOR_VALUE: usize = u16::MAX as usize;
+const MAX_V1_ADDRESS_COUNT: usize = 64;
+const MAX_V1_INSTRUCTION_COUNT: usize = 64;
+const MAX_V1_SIGNATURE_COUNT: usize = 12;
+const MAX_V1_TRANSACTION_BYTES: usize = 4_096;
+
+/// Source-neutral Solana transaction message version used by the exact wire serializer.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum RawSolanaMessageVersion {
+    /// Legacy Solana message without a version prefix.
+    Legacy,
+    /// Versioned transaction message v0, prefixed with `0x80`.
+    V0,
+    /// Transaction V1 / SIMD-0385 message, prefixed with `0x81`.
+    V1,
+}
+
+/// Exact three-byte Solana message header.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct RawSolanaMessageHeader {
+    num_required_signatures: u8,
+    num_readonly_signed_accounts: u8,
+    num_readonly_unsigned_accounts: u8,
+}
+
+impl crate::RawSolanaMessageHeader {
+    /// Creates an exact Solana message header.
+    #[must_use]
+    pub const fn new(num_required_signatures: u8, num_readonly_signed_accounts: u8, num_readonly_unsigned_accounts: u8) -> Self {
+        return Self { num_required_signatures, num_readonly_signed_accounts, num_readonly_unsigned_accounts };
+    }
+
+    /// Returns the required signature count.
+    #[must_use]
+    pub const fn num_required_signatures(self) -> u8 {
+        return self.num_required_signatures;
+    }
+
+    /// Returns the readonly signed-account count.
+    #[must_use]
+    pub const fn num_readonly_signed_accounts(self) -> u8 {
+        return self.num_readonly_signed_accounts;
+    }
+
+    /// Returns the readonly unsigned-account count.
+    #[must_use]
+    pub const fn num_readonly_unsigned_accounts(self) -> u8 {
+        return self.num_readonly_unsigned_accounts;
+    }
+}
+
+/// One source-neutral compiled Solana instruction.
+#[derive(Clone, Eq, PartialEq)]
+pub struct RawSolanaCompiledInstruction {
+    program_id_index: u8,
+    accounts: std::vec::Vec<u8>,
+    data: std::vec::Vec<u8>,
+}
+
+impl crate::RawSolanaCompiledInstruction {
+    /// Creates one compiled instruction while preserving exact ordered account indexes and data bytes.
+    #[must_use]
+    pub fn new(program_id_index: u8, accounts: std::vec::Vec<u8>, data: std::vec::Vec<u8>) -> Self {
+        return Self { program_id_index, accounts, data };
+    }
+
+    /// Returns the program account index.
+    #[must_use]
+    pub const fn program_id_index(&self) -> u8 {
+        return self.program_id_index;
+    }
+
+    /// Returns ordered account indexes.
+    #[must_use]
+    pub fn accounts(&self) -> &[u8] {
+        return self.accounts.as_slice();
+    }
+
+    /// Returns exact instruction data bytes.
+    #[must_use]
+    pub fn data(&self) -> &[u8] {
+        return self.data.as_slice();
+    }
+}
+
+impl std::fmt::Debug for crate::RawSolanaCompiledInstruction {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        return formatter
+            .debug_struct("RawSolanaCompiledInstruction")
+            .field("program_id_index", &self.program_id_index)
+            .field("account_index_count", &self.accounts.len())
+            .field("data_length", &self.data.len())
+            .finish();
+    }
+}
+
+/// One source-neutral v0 address-table lookup.
+#[derive(Clone, Eq, PartialEq)]
+pub struct RawSolanaAddressTableLookup {
+    account_key: [u8; 32],
+    writable_indexes: std::vec::Vec<u8>,
+    readonly_indexes: std::vec::Vec<u8>,
+}
+
+impl crate::RawSolanaAddressTableLookup {
+    /// Creates one exact v0 address-table lookup.
+    #[must_use]
+    pub fn new(account_key: [u8; 32], writable_indexes: std::vec::Vec<u8>, readonly_indexes: std::vec::Vec<u8>) -> Self {
+        return Self { account_key, writable_indexes, readonly_indexes };
+    }
+
+    /// Returns the lookup-table account key bytes.
+    #[must_use]
+    pub const fn account_key(&self) -> &[u8; 32] {
+        return &self.account_key;
+    }
+
+    /// Returns ordered writable lookup indexes.
+    #[must_use]
+    pub fn writable_indexes(&self) -> &[u8] {
+        return self.writable_indexes.as_slice();
+    }
+
+    /// Returns ordered readonly lookup indexes.
+    #[must_use]
+    pub fn readonly_indexes(&self) -> &[u8] {
+        return self.readonly_indexes.as_slice();
+    }
+}
+
+impl std::fmt::Debug for crate::RawSolanaAddressTableLookup {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        return formatter
+            .debug_struct("RawSolanaAddressTableLookup")
+            .field("writable_index_count", &self.writable_indexes.len())
+            .field("readonly_index_count", &self.readonly_indexes.len())
+            .finish_non_exhaustive();
+    }
+}
+
+/// Optional inline budget configuration carried by Solana Transaction V1.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct RawSolanaTransactionConfig {
+    priority_fee: std::option::Option<u64>,
+    compute_unit_limit: std::option::Option<u32>,
+    loaded_accounts_data_size_limit: std::option::Option<u32>,
+    heap_size: std::option::Option<u32>,
+}
+
+impl crate::RawSolanaTransactionConfig {
+    /// Creates an explicit Transaction V1 configuration, including the meaningful all-`None` case.
+    #[must_use]
+    pub const fn new(
+        priority_fee: std::option::Option<u64>,
+        compute_unit_limit: std::option::Option<u32>,
+        loaded_accounts_data_size_limit: std::option::Option<u32>,
+        heap_size: std::option::Option<u32>,
+    ) -> Self {
+        return Self { priority_fee, compute_unit_limit, loaded_accounts_data_size_limit, heap_size };
+    }
+
+    /// Returns the optional priority fee.
+    #[must_use]
+    pub const fn priority_fee(self) -> std::option::Option<u64> {
+        return self.priority_fee;
+    }
+
+    /// Returns the optional compute-unit limit.
+    #[must_use]
+    pub const fn compute_unit_limit(self) -> std::option::Option<u32> {
+        return self.compute_unit_limit;
+    }
+
+    /// Returns the optional loaded-account-data-size limit.
+    #[must_use]
+    pub const fn loaded_accounts_data_size_limit(self) -> std::option::Option<u32> {
+        return self.loaded_accounts_data_size_limit;
+    }
+
+    /// Returns the optional heap-size override.
+    #[must_use]
+    pub const fn heap_size(self) -> std::option::Option<u32> {
+        return self.heap_size;
+    }
+}
+
+/// Complete source-neutral Solana transaction message required for exact wire serialization.
+#[derive(Clone, Eq, PartialEq)]
+pub struct RawSolanaTransactionMessage {
+    version: crate::RawSolanaMessageVersion,
+    header: crate::RawSolanaMessageHeader,
+    account_keys: std::vec::Vec<[u8; 32]>,
+    recent_blockhash: [u8; 32],
+    instructions: std::vec::Vec<crate::RawSolanaCompiledInstruction>,
+    address_table_lookups: std::vec::Vec<crate::RawSolanaAddressTableLookup>,
+    config: std::option::Option<crate::RawSolanaTransactionConfig>,
+}
+
+impl crate::RawSolanaTransactionMessage {
+    /// Creates one exact source-neutral message.
+    #[must_use]
+    pub fn new(
+        version: crate::RawSolanaMessageVersion,
+        header: crate::RawSolanaMessageHeader,
+        account_keys: std::vec::Vec<[u8; 32]>,
+        recent_blockhash: [u8; 32],
+        instructions: std::vec::Vec<crate::RawSolanaCompiledInstruction>,
+        address_table_lookups: std::vec::Vec<crate::RawSolanaAddressTableLookup>,
+        config: std::option::Option<crate::RawSolanaTransactionConfig>,
+    ) -> Self {
+        return Self { version, header, account_keys, recent_blockhash, instructions, address_table_lookups, config };
+    }
+
+    /// Returns the message version.
+    #[must_use]
+    pub const fn version(&self) -> crate::RawSolanaMessageVersion {
+        return self.version;
+    }
+
+    /// Returns the message header.
+    #[must_use]
+    pub const fn header(&self) -> crate::RawSolanaMessageHeader {
+        return self.header;
+    }
+
+    /// Returns ordered static account key bytes.
+    #[must_use]
+    pub fn account_keys(&self) -> &[[u8; 32]] {
+        return self.account_keys.as_slice();
+    }
+
+    /// Returns the recent blockhash bytes.
+    #[must_use]
+    pub const fn recent_blockhash(&self) -> &[u8; 32] {
+        return &self.recent_blockhash;
+    }
+
+    /// Returns ordered compiled instructions.
+    #[must_use]
+    pub fn instructions(&self) -> &[crate::RawSolanaCompiledInstruction] {
+        return self.instructions.as_slice();
+    }
+
+    /// Returns ordered v0 address-table lookups.
+    #[must_use]
+    pub fn address_table_lookups(&self) -> &[crate::RawSolanaAddressTableLookup] {
+        return self.address_table_lookups.as_slice();
+    }
+
+    /// Returns optional V1 inline configuration.
+    #[must_use]
+    pub const fn config(&self) -> std::option::Option<crate::RawSolanaTransactionConfig> {
+        return self.config;
+    }
+}
+
+impl std::fmt::Debug for crate::RawSolanaTransactionMessage {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        return formatter
+            .debug_struct("RawSolanaTransactionMessage")
+            .field("version", &self.version)
+            .field("header", &self.header)
+            .field("account_key_count", &self.account_keys.len())
+            .field("instruction_count", &self.instructions.len())
+            .field("address_table_lookup_count", &self.address_table_lookups.len())
+            .field("has_config", &self.config.is_some())
+            .finish();
+    }
+}
+
+/// Complete source-neutral Solana transaction wire material.
+#[derive(Clone, Eq, PartialEq)]
+pub struct RawSolanaTransactionWire {
+    signatures: std::vec::Vec<[u8; 64]>,
+    message: crate::RawSolanaTransactionMessage,
+}
+
+impl crate::RawSolanaTransactionWire {
+    /// Creates one complete transaction wire.
+    #[must_use]
+    pub fn new(signatures: std::vec::Vec<[u8; 64]>, message: crate::RawSolanaTransactionMessage) -> Self {
+        return Self { signatures, message };
+    }
+
+    /// Returns ordered signature bytes.
+    #[must_use]
+    pub fn signatures(&self) -> &[[u8; 64]] {
+        return self.signatures.as_slice();
+    }
+
+    /// Returns the exact source-neutral message.
+    #[must_use]
+    pub const fn message(&self) -> &crate::RawSolanaTransactionMessage {
+        return &self.message;
+    }
+}
+
+impl std::fmt::Debug for crate::RawSolanaTransactionWire {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        return formatter.debug_struct("RawSolanaTransactionWire").field("signature_count", &self.signatures.len()).field("message", &self.message).finish();
+    }
+}
+
+/// Serializes one source-neutral Solana transaction to exact canonical wire bytes.
+pub fn serialize_solana_transaction_wire(transaction: &crate::RawSolanaTransactionWire) -> ksp_core_lib::Result<std::vec::Vec<u8>> {
+    if let std::result::Result::Err(error) = validate_transaction(transaction) {
+        return std::result::Result::Err(error);
+    }
+    let mut output = std::vec::Vec::new();
+    match transaction.message().version() {
+        crate::RawSolanaMessageVersion::Legacy | crate::RawSolanaMessageVersion::V0 => {
+            if let std::result::Result::Err(error) = encode_short_vec(transaction.signatures().len(), &mut output) {
+                return std::result::Result::Err(error);
+            }
+            for signature in transaction.signatures() {
+                output.extend_from_slice(signature);
+            }
+            if transaction.message().version() == crate::RawSolanaMessageVersion::V0 {
+                output.push(0x80);
+            }
+            if let std::result::Result::Err(error) = encode_legacy_or_v0_message(transaction.message(), &mut output) {
+                return std::result::Result::Err(error);
+            }
+        },
+        crate::RawSolanaMessageVersion::V1 => {
+            if let std::result::Result::Err(error) = encode_v1_message(transaction, &mut output) {
+                return std::result::Result::Err(error);
+            }
+        },
+    }
+    if output.len() > ksp_store_api::MAX_RAW_PAYLOAD_BYTES {
+        return std::result::Result::Err(crate::material_error("wire.bytes").with_context("actual_len", output.len().to_string()));
+    }
+    if transaction.message().version() == crate::RawSolanaMessageVersion::V1 && output.len() > MAX_V1_TRANSACTION_BYTES {
+        return std::result::Result::Err(crate::material_error("wire.bytes").with_context("actual_len", output.len().to_string()));
+    }
+    return std::result::Result::Ok(output);
+}
+
+/// Serializes one source-neutral Solana transaction and returns canonical padded standard Base64.
+pub fn serialize_solana_transaction_wire_base64(transaction: &crate::RawSolanaTransactionWire) -> ksp_core_lib::Result<std::string::String> {
+    let bytes = match crate::serialize_solana_transaction_wire(transaction) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    return std::result::Result::Ok(base64::engine::general_purpose::STANDARD.encode(bytes));
+}
+
+fn validate_transaction(transaction: &crate::RawSolanaTransactionWire) -> ksp_core_lib::Result<()> {
+    let message = transaction.message();
+    let required_signatures = usize::from(message.header().num_required_signatures());
+    if required_signatures == 0 || transaction.signatures().len() != required_signatures {
+        return std::result::Result::Err(crate::material_error("wire"));
+    }
+    if usize::from(message.header().num_readonly_signed_accounts()) >= required_signatures {
+        return std::result::Result::Err(crate::material_error("wire"));
+    }
+    if message.account_keys().len() < required_signatures + usize::from(message.header().num_readonly_unsigned_accounts()) {
+        return std::result::Result::Err(crate::material_error("wire"));
+    }
+    let loaded_count = message.address_table_lookups().iter().fold(0_usize, |count, lookup| {
+        return count.saturating_add(lookup.writable_indexes().len()).saturating_add(lookup.readonly_indexes().len());
+    });
+    let account_count = message.account_keys().len().saturating_add(loaded_count);
+    for instruction in message.instructions() {
+        if usize::from(instruction.program_id_index()) >= account_count {
+            return std::result::Result::Err(crate::material_error("wire"));
+        }
+        for account_index in instruction.accounts() {
+            if usize::from(*account_index) >= account_count {
+                return std::result::Result::Err(crate::material_error("wire"));
+            }
+        }
+    }
+    match message.version() {
+        crate::RawSolanaMessageVersion::Legacy => {
+            if !message.address_table_lookups().is_empty() || message.config().is_some() {
+                return std::result::Result::Err(crate::material_error("wire"));
+            }
+        },
+        crate::RawSolanaMessageVersion::V0 => {
+            if message.config().is_some() {
+                return std::result::Result::Err(crate::material_error("wire"));
+            }
+        },
+        crate::RawSolanaMessageVersion::V1 => {
+            if message.config().is_none() || !message.address_table_lookups().is_empty() {
+                return std::result::Result::Err(crate::material_error("wire"));
+            }
+            if transaction.signatures().len() > MAX_V1_SIGNATURE_COUNT
+                || message.account_keys().len() > MAX_V1_ADDRESS_COUNT
+                || message.instructions().len() > MAX_V1_INSTRUCTION_COUNT
+            {
+                return std::result::Result::Err(crate::material_error("wire"));
+            }
+            for (index, account) in message.account_keys().iter().enumerate() {
+                if message.account_keys()[..index].contains(account) {
+                    return std::result::Result::Err(crate::material_error("wire"));
+                }
+            }
+            for instruction in message.instructions() {
+                if instruction.accounts().len() > usize::from(u8::MAX) || instruction.data().len() > usize::from(u16::MAX) {
+                    return std::result::Result::Err(crate::material_error("wire"));
+                }
+            }
+            if let std::option::Option::Some(heap_size) = message.config().and_then(crate::RawSolanaTransactionConfig::heap_size)
+                && (!(32_768..=262_144).contains(&heap_size) || heap_size % 1_024 != 0)
+            {
+                return std::result::Result::Err(crate::material_error("wire"));
+            }
+        },
+    }
+    return std::result::Result::Ok(());
+}
+
+fn encode_legacy_or_v0_message(message: &crate::RawSolanaTransactionMessage, output: &mut std::vec::Vec<u8>) -> ksp_core_lib::Result<()> {
+    encode_header(message.header(), output);
+    if let std::result::Result::Err(error) = encode_short_vec(message.account_keys().len(), output) {
+        return std::result::Result::Err(error);
+    }
+    for account_key in message.account_keys() {
+        output.extend_from_slice(account_key);
+    }
+    output.extend_from_slice(message.recent_blockhash());
+    if let std::result::Result::Err(error) = encode_short_vec(message.instructions().len(), output) {
+        return std::result::Result::Err(error);
+    }
+    for instruction in message.instructions() {
+        output.push(instruction.program_id_index());
+        if let std::result::Result::Err(error) = encode_short_vec(instruction.accounts().len(), output) {
+            return std::result::Result::Err(error);
+        }
+        output.extend_from_slice(instruction.accounts());
+        if let std::result::Result::Err(error) = encode_short_vec(instruction.data().len(), output) {
+            return std::result::Result::Err(error);
+        }
+        output.extend_from_slice(instruction.data());
+    }
+    if message.version() == crate::RawSolanaMessageVersion::V0 {
+        if let std::result::Result::Err(error) = encode_short_vec(message.address_table_lookups().len(), output) {
+            return std::result::Result::Err(error);
+        }
+        for lookup in message.address_table_lookups() {
+            output.extend_from_slice(lookup.account_key());
+            if let std::result::Result::Err(error) = encode_short_vec(lookup.writable_indexes().len(), output) {
+                return std::result::Result::Err(error);
+            }
+            output.extend_from_slice(lookup.writable_indexes());
+            if let std::result::Result::Err(error) = encode_short_vec(lookup.readonly_indexes().len(), output) {
+                return std::result::Result::Err(error);
+            }
+            output.extend_from_slice(lookup.readonly_indexes());
+        }
+    }
+    return std::result::Result::Ok(());
+}
+
+fn encode_v1_message(transaction: &crate::RawSolanaTransactionWire, output: &mut std::vec::Vec<u8>) -> ksp_core_lib::Result<()> {
+    let message = transaction.message();
+    let config = match message.config() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::result::Result::Err(crate::material_error("wire")),
+    };
+    output.push(0x81);
+    encode_header(message.header(), output);
+    let mut mask = 0_u32;
+    if config.priority_fee().is_some() {
+        mask |= 0b11;
+    }
+    if config.compute_unit_limit().is_some() {
+        mask |= 1_u32 << 2;
+    }
+    if config.loaded_accounts_data_size_limit().is_some() {
+        mask |= 1_u32 << 3;
+    }
+    if config.heap_size().is_some() {
+        mask |= 1_u32 << 4;
+    }
+    output.extend_from_slice(&mask.to_le_bytes());
+    output.extend_from_slice(message.recent_blockhash());
+    output.push(message.instructions().len() as u8);
+    output.push(message.account_keys().len() as u8);
+    for account_key in message.account_keys() {
+        output.extend_from_slice(account_key);
+    }
+    if let std::option::Option::Some(value) = config.priority_fee() {
+        output.extend_from_slice(&value.to_le_bytes());
+    }
+    if let std::option::Option::Some(value) = config.compute_unit_limit() {
+        output.extend_from_slice(&value.to_le_bytes());
+    }
+    if let std::option::Option::Some(value) = config.loaded_accounts_data_size_limit() {
+        output.extend_from_slice(&value.to_le_bytes());
+    }
+    if let std::option::Option::Some(value) = config.heap_size() {
+        output.extend_from_slice(&value.to_le_bytes());
+    }
+    for instruction in message.instructions() {
+        output.push(instruction.program_id_index());
+        output.push(instruction.accounts().len() as u8);
+        output.extend_from_slice(&(instruction.data().len() as u16).to_le_bytes());
+    }
+    for instruction in message.instructions() {
+        output.extend_from_slice(instruction.accounts());
+        output.extend_from_slice(instruction.data());
+    }
+    for signature in transaction.signatures() {
+        output.extend_from_slice(signature);
+    }
+    return std::result::Result::Ok(());
+}
+
+fn encode_header(header: crate::RawSolanaMessageHeader, output: &mut std::vec::Vec<u8>) {
+    output.push(header.num_required_signatures());
+    output.push(header.num_readonly_signed_accounts());
+    output.push(header.num_readonly_unsigned_accounts());
+}
+
+fn encode_short_vec(value: usize, output: &mut std::vec::Vec<u8>) -> ksp_core_lib::Result<()> {
+    if value > MAX_LEGACY_SHORT_VECTOR_VALUE {
+        return std::result::Result::Err(crate::material_error("wire"));
+    }
+    let mut remaining = value;
+    loop {
+        let mut byte = (remaining & 0x7f) as u8;
+        remaining >>= 7;
+        if remaining != 0 {
+            byte |= 0x80;
+        }
+        output.push(byte);
+        if remaining == 0 {
+            break;
+        }
+    }
+    return std::result::Result::Ok(());
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/wire.rs"]
+mod tests;

crates/ksp-raw-transaction-lib/tests/dependency_boundary.rs

@@ -0,0 +1,55 @@
+// file: crates/ksp-raw-transaction-lib/tests/dependency_boundary.rs
+// version: 4
+
+//! Dependency-boundary canaries for the common RAW Transaction foundation.
+
+fn manifest() -> std::string::String {
+    return std::fs::read_to_string(std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("Cargo.toml")).unwrap_or_default();
+}
+
+fn production_sources() -> std::string::String {
+    let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
+    let mut combined = std::string::String::new();
+    for name in ["acquisition.rs", "canonical.rs", "error.rs", "lib.rs", "signature.rs", "wire.rs"] {
+        let source = std::fs::read_to_string(root.join(name)).unwrap_or_default();
+        combined.push_str(source.as_str());
+    }
+    return combined;
+}
+
+#[test]
+fn pre_004_manifest_adds_only_base64_to_the_exact_common_dependency_surface() {
+    let manifest = manifest();
+    assert!(manifest.contains("base64.workspace = true"));
+    assert!(manifest.contains("ksp-core-lib = { path = \"../ksp-core-lib\" }"));
+    assert!(manifest.contains("ksp-store-api = { path = \"../ksp-store-api\" }"));
+    assert!(manifest.contains("serde_json = { workspace = true }"));
+    assert!(manifest.contains("sha2 = { workspace = true }"));
+    for forbidden in
+        ["ksp-store-lib", "ksp-onchain-transport-lib", "ksp-config-lib", "ksp-job-api", "ksp-job-backfill-lib", "ksp-worker-api", "tokio", "futures"]
+    {
+        assert!(!manifest.contains(forbidden));
+    }
+    return;
+}
+
+#[test]
+fn pre_002_production_sources_keep_transport_runtime_job_worker_and_backend_out() {
+    let sources = production_sources();
+    for forbidden in [
+        "ksp_store_lib",
+        "ksp_onchain_transport_lib",
+        "ksp_config_lib",
+        "ksp_job_api",
+        "ksp_job_backfill_lib",
+        "ksp_worker_api",
+        "ksp_store_postgres_lib",
+        "tokio::",
+        "futures::",
+        "reqwest::",
+        "tonic::",
+    ] {
+        assert!(!sources.contains(forbidden));
+    }
+    return;
+}

crates/ksp-raw-transaction-lib/tests/public_api.rs

@@ -0,0 +1,122 @@
+// file: crates/ksp-raw-transaction-lib/tests/public_api.rs
+// version: 4
+
+//! Integration canaries for the public common RAW Transaction crate-root surface.
+
+#[test]
+fn pre_002_common_raw_contract_is_consumable_from_crate_root() {
+    assert_eq!(ksp_raw_transaction_lib::RAW_TRANSACTION_FORMAT_ID, "ksp.solana.raw_transaction");
+    assert_eq!(ksp_raw_transaction_lib::RAW_TRANSACTION_FORMAT_VERSION, 1);
+    assert_eq!(ksp_raw_transaction_lib::MIN_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES, 64);
+    assert_eq!(ksp_raw_transaction_lib::MAX_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES, 88);
+    let network = match ksp_store_api::RawNetworkId::new("devnet") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let signature = match ksp_raw_transaction_lib::parse_raw_transaction_signature("1".repeat(64).as_str()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let material = ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64(
+        network,
+        signature,
+        5,
+        std::option::Option::None,
+        "AQID",
+        ksp_raw_transaction_lib::RawTransactionWireField::Null,
+        ksp_raw_transaction_lib::RawTransactionWireField::Value(ksp_raw_transaction_lib::RawTransactionVersion::Legacy),
+        ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+    );
+    let transaction = ksp_raw_transaction_lib::canonicalize_raw_transaction(material);
+    assert!(transaction.is_ok());
+    return;
+}
+
+#[test]
+fn pre_002_acquisition_assembly_accepts_store_api_producer_owned_metadata() {
+    let network = match ksp_store_api::RawNetworkId::new("devnet") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let signature = match ksp_raw_transaction_lib::parse_raw_transaction_signature("1".repeat(64).as_str()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let material = ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64(
+        network,
+        signature,
+        5,
+        std::option::Option::None,
+        "AQID",
+        ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+        ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+        ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+    );
+    let transaction = match ksp_raw_transaction_lib::canonicalize_raw_transaction(material) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let provider = match ksp_store_api::RawProvenanceCode::new("fixture") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let protocol = match ksp_store_api::RawProvenanceCode::new("fixture.protocol") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let method = match ksp_store_api::RawProvenanceCode::new("fixture.method") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let received_at = match ksp_store_api::RawTimestamp::from_unix_millis(1) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let provenance = ksp_store_api::RawAcquisitionProvenance::new(provider, protocol, method, ksp_store_api::RawAcquisitionOrigin::Import, received_at);
+    let acquisition = ksp_raw_transaction_lib::assemble_raw_transaction_acquisition(transaction, ksp_store_api::RawObservationKey::new([9_u8; 32]), provenance);
+    assert_eq!(acquisition.transaction().reference(), acquisition.observation().transaction());
+    return;
+}
+
+#[test]
+fn pre_004_embedded_signature_and_block_material_contract_are_available_from_crate_root() {
+    let encoded = "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+    let signature = ksp_raw_transaction_lib::extract_raw_transaction_signature_from_binary_base64(encoded);
+    assert!(signature.is_ok());
+    let network = ksp_store_api::RawNetworkId::new("devnet");
+    assert!(network.is_ok());
+    if let std::result::Result::Ok(network) = network {
+        let material = ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64_with_embedded_signature(
+            network,
+            1,
+            std::option::Option::None,
+            encoded,
+            ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+            ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+            ksp_raw_transaction_lib::RawTransactionWireField::Value(0),
+        );
+        assert!(material.is_ok());
+    }
+    return;
+}
+
+#[test]
+fn pre_006_source_neutral_wire_contract_is_available_from_crate_root() {
+    let message = ksp_raw_transaction_lib::RawSolanaTransactionMessage::new(
+        ksp_raw_transaction_lib::RawSolanaMessageVersion::V1,
+        ksp_raw_transaction_lib::RawSolanaMessageHeader::new(1, 0, 0),
+        vec![[1_u8; 32]],
+        [2_u8; 32],
+        vec![ksp_raw_transaction_lib::RawSolanaCompiledInstruction::new(0, vec![0], vec![3])],
+        vec![],
+        std::option::Option::Some(ksp_raw_transaction_lib::RawSolanaTransactionConfig::default()),
+    );
+    let wire = ksp_raw_transaction_lib::RawSolanaTransactionWire::new(vec![[4_u8; 64]], message);
+    let encoded = ksp_raw_transaction_lib::serialize_solana_transaction_wire_base64(&wire);
+    assert!(encoded.is_ok());
+    if let std::result::Result::Ok(encoded) = encoded {
+        assert!(encoded.starts_with("gQ"));
+        assert!(ksp_raw_transaction_lib::extract_raw_transaction_signature_from_binary_base64(encoded.as_str()).is_ok());
+    }
+    return;
+}

crates/ksp-raw-transaction-lib/tests/release_completeness.rs

@@ -0,0 +1,41 @@
+// file: crates/ksp-raw-transaction-lib/tests/release_completeness.rs
+// version: 3
+
+//! Release-completeness canaries for the common RAW Transaction foundation.
+
+#[test]
+fn pre_002_production_module_inventory_is_exact() {
+    let source_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
+    let entries = match std::fs::read_dir(source_root) {
+        std::result::Result::Ok(entries) => entries,
+        std::result::Result::Err(_) => return,
+    };
+    let mut names = std::vec::Vec::new();
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.extension().and_then(std::ffi::OsStr::to_str) != std::option::Option::Some("rs") {
+            continue;
+        }
+        let std::option::Option::Some(name) = path.file_name().and_then(std::ffi::OsStr::to_str) else {
+            continue;
+        };
+        names.push(name.to_owned());
+    }
+    names.sort();
+    let expected = ["acquisition.rs", "canonical.rs", "error.rs", "lib.rs", "signature.rs", "wire.rs"];
+    assert_eq!(names.len(), expected.len());
+    for (actual, expected_name) in names.iter().zip(expected.iter()) {
+        assert_eq!(actual.as_str(), *expected_name);
+    }
+    return;
+}
+
+#[test]
+fn pre_002_common_surface_contains_no_worker_job_or_transport_dependency_or_public_module() {
+    let lib = std::fs::read_to_string(std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/lib.rs")).unwrap_or_default();
+    assert!(!lib.contains("pub mod "));
+    for forbidden in ["ksp_worker", "ksp_job", "ksp_onchain_transport", "ksp_config", "ksp_store_lib", "ksp_store_postgres"] {
+        assert!(!lib.contains(forbidden));
+    }
+    return;
+}

crates/ksp-raw-transaction-lib/tests/security_hardening.rs

@@ -0,0 +1,28 @@
+// file: crates/ksp-raw-transaction-lib/tests/security_hardening.rs
+// version: 2
+
+//! Adversarial canaries for the common RAW Transaction foundation.
+
+#[test]
+fn pre_002_signature_errors_never_echo_hostile_input() {
+    let hostile = format!("{}0", "A".repeat(63));
+    let result = ksp_raw_transaction_lib::parse_raw_transaction_signature(hostile.as_str());
+    assert!(result.is_err());
+    if let std::result::Result::Err(error) = result {
+        assert_eq!(error.code(), ksp_raw_transaction_lib::ERROR_CODE_RAW_TRANSACTION_SIGNATURE_INVALID);
+        assert!(!std::format!("{error:?}").contains(hostile.as_str()));
+        assert!(!error.to_string().contains(hostile.as_str()));
+    }
+    return;
+}
+
+#[test]
+fn pre_002_public_error_codes_are_stable_and_domain_scoped() {
+    assert_eq!(ksp_raw_transaction_lib::ERROR_CODE_RAW_TRANSACTION_CANONICALIZATION_INVALID.domain(), "raw_transaction");
+    assert_eq!(ksp_raw_transaction_lib::ERROR_CODE_RAW_TRANSACTION_CANONICALIZATION_INVALID.code(), "canonicalization_invalid");
+    assert_eq!(ksp_raw_transaction_lib::ERROR_CODE_RAW_TRANSACTION_MATERIAL_INVALID.domain(), "raw_transaction");
+    assert_eq!(ksp_raw_transaction_lib::ERROR_CODE_RAW_TRANSACTION_MATERIAL_INVALID.code(), "material_invalid");
+    assert_eq!(ksp_raw_transaction_lib::ERROR_CODE_RAW_TRANSACTION_SIGNATURE_INVALID.domain(), "raw_transaction");
+    assert_eq!(ksp_raw_transaction_lib::ERROR_CODE_RAW_TRANSACTION_SIGNATURE_INVALID.code(), "signature_invalid");
+    return;
+}

crates/ksp-raw-transaction-lib/unit_tests/acquisition.rs

@@ -0,0 +1,73 @@
+// file: crates/ksp-raw-transaction-lib/unit_tests/acquisition.rs
+// version: 1
+
+fn canonical_transaction() -> std::option::Option<ksp_store_api::RawTransaction> {
+    let network = match ksp_store_api::RawNetworkId::new("devnet") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let signature = match crate::parse_raw_transaction_signature("1".repeat(64).as_str()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let material = crate::RawTransactionMaterial::binary_base64(
+        network,
+        signature,
+        42,
+        std::option::Option::None,
+        "AQID",
+        crate::RawTransactionWireField::Omitted,
+        crate::RawTransactionWireField::Omitted,
+        crate::RawTransactionWireField::Omitted,
+    );
+    return match crate::canonicalize_raw_transaction(material) {
+        std::result::Result::Ok(value) => std::option::Option::Some(value),
+        std::result::Result::Err(_) => std::option::Option::None,
+    };
+}
+
+fn provenance() -> std::option::Option<ksp_store_api::RawAcquisitionProvenance> {
+    let provider = match ksp_store_api::RawProvenanceCode::new("fixture") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let protocol = match ksp_store_api::RawProvenanceCode::new("fixture.protocol") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let method = match ksp_store_api::RawProvenanceCode::new("fixture.method") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let received_at = match ksp_store_api::RawTimestamp::from_unix_millis(1_700_000_000_000) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    return std::option::Option::Some(ksp_store_api::RawAcquisitionProvenance::new(
+        provider,
+        protocol,
+        method,
+        ksp_store_api::RawAcquisitionOrigin::Import,
+        received_at,
+    ));
+}
+
+#[test]
+fn pre_002_acquisition_preserves_producer_key_and_exact_transaction_reference() {
+    let transaction = match canonical_transaction() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let provenance = match provenance() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let key = ksp_store_api::RawObservationKey::new([7_u8; 32]);
+    let acquisition = crate::assemble_raw_transaction_acquisition(transaction, key, provenance);
+    assert_eq!(acquisition.observation().observation_key(), key);
+    assert_eq!(acquisition.observation().transaction(), acquisition.transaction().reference());
+    assert_eq!(std::format!("{acquisition:?}"), "RawTransactionAcquisition(..)");
+    let (transaction, observation) = acquisition.into_parts();
+    assert_eq!(observation.transaction(), transaction.reference());
+    return;
+}

crates/ksp-raw-transaction-lib/unit_tests/canonical.rs

@@ -0,0 +1,247 @@
+// file: crates/ksp-raw-transaction-lib/unit_tests/canonical.rs
+// version: 2
+
+fn network() -> std::option::Option<ksp_store_api::RawNetworkId> {
+    return match ksp_store_api::RawNetworkId::new("devnet") {
+        std::result::Result::Ok(value) => std::option::Option::Some(value),
+        std::result::Result::Err(_) => std::option::Option::None,
+    };
+}
+
+fn signature() -> std::option::Option<ksp_store_api::RawTransactionSignature> {
+    let result = crate::parse_raw_transaction_signature("1".repeat(64).as_str());
+    return match result {
+        std::result::Result::Ok(value) => std::option::Option::Some(value),
+        std::result::Result::Err(_) => std::option::Option::None,
+    };
+}
+
+fn material(
+    block_time: std::option::Option<i64>,
+    transaction_data: std::string::String,
+    meta: crate::RawTransactionWireField<serde_json::Value>,
+    version: crate::RawTransactionWireField<crate::RawTransactionVersion>,
+    transaction_index: crate::RawTransactionWireField<u32>,
+) -> std::option::Option<crate::RawTransactionMaterial> {
+    let network = match network() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::option::Option::None,
+    };
+    let signature = match signature() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::option::Option::None,
+    };
+    return std::option::Option::Some(crate::RawTransactionMaterial::binary_base64(
+        network,
+        signature,
+        123,
+        block_time,
+        transaction_data,
+        meta,
+        version,
+        transaction_index,
+    ));
+}
+
+#[test]
+fn pre_002_canonical_raw_v1_golden_bytes_and_hash_are_exact() {
+    let material = match material(
+        std::option::Option::Some(1_700_000_000),
+        "AQID".to_owned(),
+        crate::RawTransactionWireField::Value(serde_json::json!({"z": 1, "a": {"y": true, "x": null}})),
+        crate::RawTransactionWireField::Value(crate::RawTransactionVersion::Legacy),
+        crate::RawTransactionWireField::Value(7_u32),
+    ) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let transaction = crate::canonicalize_raw_transaction(material);
+    assert!(transaction.is_ok());
+    let transaction = match transaction {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let expected = b"{\"transaction\":[\"AQID\",\"base64\"],\"meta\":{\"a\":{\"x\":null,\"y\":true},\"z\":1},\"version\":\"legacy\",\"transactionIndex\":7}";
+    assert_eq!(transaction.payload().bytes(), expected);
+    assert_eq!(transaction.payload().byte_len(), 112);
+    assert_eq!(transaction.payload().format_id().as_str(), crate::RAW_TRANSACTION_FORMAT_ID);
+    assert_eq!(transaction.payload().format_version(), crate::RAW_TRANSACTION_FORMAT_VERSION);
+    assert_eq!(
+        transaction.payload().content_hash().as_bytes(),
+        &[
+            34, 7, 146, 210, 177, 93, 38, 47, 218, 36, 44, 178, 32, 119, 78, 233, 221, 239, 254, 191, 4, 220, 250, 218, 188, 248, 239, 118, 169, 177, 167, 195
+        ]
+    );
+    assert_eq!(transaction.slot(), 123);
+    assert_eq!(transaction.block_time().map(|value| return value.unix_millis()), std::option::Option::Some(1_700_000_000_000));
+    assert_eq!(transaction.reference().network().as_str(), "devnet");
+    assert_eq!(transaction.reference().signature().as_bytes(), &[0_u8; 64]);
+    return;
+}
+
+#[test]
+fn pre_002_wire_omitted_null_and_value_states_remain_distinct() {
+    let omitted = match material(
+        std::option::Option::None,
+        "AQID".to_owned(),
+        crate::RawTransactionWireField::Omitted,
+        crate::RawTransactionWireField::Omitted,
+        crate::RawTransactionWireField::Omitted,
+    ) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let omitted = super::canonical_payload_bytes(&omitted);
+    assert!(omitted.is_ok());
+    if let std::result::Result::Ok(omitted) = omitted {
+        assert_eq!(omitted, b"{\"transaction\":[\"AQID\",\"base64\"]}");
+    }
+    let nulls = match material(
+        std::option::Option::None,
+        "AQID".to_owned(),
+        crate::RawTransactionWireField::Null,
+        crate::RawTransactionWireField::Null,
+        crate::RawTransactionWireField::Null,
+    ) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let nulls = super::canonical_payload_bytes(&nulls);
+    assert!(nulls.is_ok());
+    if let std::result::Result::Ok(nulls) = nulls {
+        assert_eq!(nulls, b"{\"transaction\":[\"AQID\",\"base64\"],\"meta\":null,\"version\":null,\"transactionIndex\":null}");
+    }
+    return;
+}
+
+#[test]
+fn pre_002_canonical_json_sorts_objects_preserves_arrays_and_escapes_strings() {
+    let meta = serde_json::json!({
+        "z": [3, 2, 1],
+        "quote": "a\"b\\c\n",
+        "a": {"n": -12.5, "b": false, "a": true}
+    });
+    let material = match material(
+        std::option::Option::None,
+        "A\"B".to_owned(),
+        crate::RawTransactionWireField::Value(meta),
+        crate::RawTransactionWireField::Value(crate::RawTransactionVersion::Number(0)),
+        crate::RawTransactionWireField::Value(u32::MAX),
+    ) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let bytes = super::canonical_payload_bytes(&material);
+    assert!(bytes.is_ok());
+    if let std::result::Result::Ok(bytes) = bytes {
+        let expected = b"{\"transaction\":[\"A\\\"B\",\"base64\"],\"meta\":{\"a\":{\"a\":true,\"b\":false,\"n\":-12.5},\"quote\":\"a\\\"b\\\\c\\n\",\"z\":[3,2,1]},\"version\":0,\"transactionIndex\":4294967295}";
+        assert_eq!(bytes, expected);
+    }
+    return;
+}
+
+#[test]
+fn pre_002_block_time_rejects_negative_overflow_and_store_maximum_overrun() {
+    for block_time in [-1_i64, i64::MAX, 253_402_300_800_i64] {
+        let material = match material(
+            std::option::Option::Some(block_time),
+            "AQID".to_owned(),
+            crate::RawTransactionWireField::Omitted,
+            crate::RawTransactionWireField::Omitted,
+            crate::RawTransactionWireField::Omitted,
+        ) {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => return,
+        };
+        let result = crate::canonicalize_raw_transaction(material);
+        assert!(result.is_err());
+        if let std::result::Result::Err(error) = result {
+            assert_eq!(error.code(), crate::ERROR_CODE_RAW_TRANSACTION_MATERIAL_INVALID);
+        }
+    }
+    let maximum = match material(
+        std::option::Option::Some(253_402_300_799_i64),
+        "AQID".to_owned(),
+        crate::RawTransactionWireField::Omitted,
+        crate::RawTransactionWireField::Omitted,
+        crate::RawTransactionWireField::Omitted,
+    ) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let maximum = crate::canonicalize_raw_transaction(maximum);
+    assert!(maximum.is_ok());
+    if let std::result::Result::Ok(maximum) = maximum {
+        assert_eq!(maximum.block_time().map(|value| return value.unix_millis()), std::option::Option::Some(253_402_300_799_000));
+    }
+    return;
+}
+
+#[test]
+fn pre_002_payload_bound_is_enforced_by_common_before_store_construction() {
+    let material = match material(
+        std::option::Option::None,
+        "A".repeat(ksp_store_api::MAX_RAW_PAYLOAD_BYTES),
+        crate::RawTransactionWireField::Omitted,
+        crate::RawTransactionWireField::Omitted,
+        crate::RawTransactionWireField::Omitted,
+    ) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let result = crate::canonicalize_raw_transaction(material);
+    assert!(result.is_err());
+    if let std::result::Result::Err(error) = result {
+        assert_eq!(error.code(), crate::ERROR_CODE_RAW_TRANSACTION_CANONICALIZATION_INVALID);
+    }
+    return;
+}
+
+#[test]
+fn pre_002_material_and_wire_debug_do_not_render_transaction_or_meta_material() {
+    let secret_transaction = "SECRET_TRANSACTION_BODY";
+    let secret_meta = "SECRET_META_VALUE";
+    let material = match material(
+        std::option::Option::None,
+        secret_transaction.to_owned(),
+        crate::RawTransactionWireField::Value(serde_json::json!({"secret": secret_meta})),
+        crate::RawTransactionWireField::Value(crate::RawTransactionVersion::Legacy),
+        crate::RawTransactionWireField::Value(1_u32),
+    ) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let debug = std::format!("{material:?}");
+    assert!(!debug.contains(secret_transaction));
+    assert!(!debug.contains(secret_meta));
+    assert_eq!(std::format!("{:?}", crate::RawTransactionWireField::Value(secret_meta)), "Value(..)");
+    return;
+}
+
+#[test]
+fn pre_004_embedded_signature_material_preserves_block_fields_and_canonicalizes() {
+    let network = match ksp_store_api::RawNetworkId::new("devnet") {
+        std::result::Result::Ok(network) => network,
+        std::result::Result::Err(_) => return,
+    };
+    let material = crate::RawTransactionMaterial::binary_base64_with_embedded_signature(
+        network,
+        430_000_123,
+        std::option::Option::Some(1_787_072_400),
+        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+        crate::RawTransactionWireField::Value(serde_json::json!({"err":null,"fee":5000})),
+        crate::RawTransactionWireField::Value(crate::RawTransactionVersion::Legacy),
+        crate::RawTransactionWireField::Value(0_u32),
+    );
+    assert!(material.is_ok());
+    let transaction = match material.and_then(crate::canonicalize_raw_transaction) {
+        std::result::Result::Ok(transaction) => transaction,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(transaction.reference().signature().as_bytes(), &[0_u8; 64]);
+    assert_eq!(transaction.slot(), 430_000_123);
+    assert_eq!(transaction.block_time().map(|value| return value.unix_millis()), std::option::Option::Some(1_787_072_400_000));
+    assert!(transaction.payload().bytes().starts_with(b"{\"transaction\":[\"AQAAAA"));
+    assert!(transaction.payload().bytes().ends_with(b"\"version\":\"legacy\",\"transactionIndex\":0}"));
+    return;
+}

crates/ksp-raw-transaction-lib/unit_tests/signature.rs

@@ -0,0 +1,81 @@
+// file: crates/ksp-raw-transaction-lib/unit_tests/signature.rs
+// version: 3
+
+use base64::Engine; // rust-rules: trait-import
+
+#[test]
+fn pre_002_signature_parser_accepts_exact_sixty_four_zero_bytes() {
+    let text = "1".repeat(crate::MIN_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES);
+    let signature = crate::parse_raw_transaction_signature(text.as_str());
+    assert!(signature.is_ok());
+    if let std::result::Result::Ok(signature) = signature {
+        assert_eq!(signature.as_bytes(), &[0_u8; 64]);
+    }
+    return;
+}
+
+#[test]
+fn pre_002_signature_parser_rejects_text_bounds_invalid_base58_and_noncanonical_lengths() {
+    for text in [
+        "1".repeat(crate::MIN_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES - 1),
+        "1".repeat(crate::MAX_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES + 1),
+        format!("{}0", "1".repeat(crate::MIN_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES - 1)),
+        "1".repeat(65),
+        "z".repeat(crate::MAX_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES),
+    ] {
+        let result = crate::parse_raw_transaction_signature(text.as_str());
+        assert!(result.is_err());
+        if let std::result::Result::Err(error) = result {
+            assert_eq!(error.code(), crate::ERROR_CODE_RAW_TRANSACTION_SIGNATURE_INVALID);
+            let debug = std::format!("{error:?}");
+            assert!(!debug.contains(text.as_str()));
+        }
+    }
+    return;
+}
+
+#[test]
+fn pre_004_embedded_signature_extracts_first_signature_from_canonical_transaction_base64() {
+    let encoded = "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+    let signature = crate::extract_raw_transaction_signature_from_binary_base64(encoded);
+    assert!(signature.is_ok());
+    if let std::result::Result::Ok(signature) = signature {
+        assert_eq!(signature.as_bytes(), &[0_u8; 64]);
+    }
+    return;
+}
+
+#[test]
+fn pre_004_embedded_signature_rejects_invalid_base64_noncanonical_short_vec_and_truncation() {
+    for encoded in [
+        "not-base64",
+        "gQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
+        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
+        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
+    ] {
+        let result = crate::extract_raw_transaction_signature_from_binary_base64(encoded);
+        assert!(result.is_err());
+        if let std::result::Result::Err(error) = result {
+            assert_eq!(error.code(), crate::ERROR_CODE_RAW_TRANSACTION_SIGNATURE_INVALID);
+            assert!(!error.to_string().contains(encoded));
+        }
+    }
+    return;
+}
+
+#[test]
+fn pre_006_embedded_signature_extracts_terminal_v1_signature_and_rejects_trailing_bytes() {
+    let encoded = "gQEAAR8AAABRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQECQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQgcAAAAAAAAACAAAAAkAAAAAgAAAAQEDAAABAgOqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq";
+    let signature = crate::extract_raw_transaction_signature_from_binary_base64(encoded);
+    assert!(signature.is_ok());
+    if let std::result::Result::Ok(signature) = signature {
+        assert_eq!(signature.as_bytes(), &[0xaa_u8; 64]);
+    }
+    let decoded = base64::engine::general_purpose::STANDARD.decode(encoded);
+    assert!(decoded.is_ok());
+    if let std::result::Result::Ok(mut decoded) = decoded {
+        decoded.push(0);
+        let trailing = base64::engine::general_purpose::STANDARD.encode(decoded);
+        assert!(crate::extract_raw_transaction_signature_from_binary_base64(trailing.as_str()).is_err());
+    }
+}

crates/ksp-raw-transaction-lib/unit_tests/wire.rs

@@ -0,0 +1,122 @@
+// file: crates/ksp-raw-transaction-lib/unit_tests/wire.rs
+// version: 2
+
+const LEGACY_GOLDEN_BASE64: &str = "AREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREBAAECISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIjExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExAQEBAAKquw==";
+const V0_GOLDEN_BASE64: &str = "ARISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhISEhKAAQAAASMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIBAAEBAcwBJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQBAAA=";
+const V1_EMPTY_CONFIG_GOLDEN_BASE64: &str = "gQEAAAAAAABSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUlJSUgABQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0Orq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6ur";
+const V1_GOLDEN_BASE64: &str = "gQEAAR8AAABRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQECQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQgcAAAAAAAAACAAAAAkAAAAAgAAAAQEDAAABAgOqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq";
+
+fn legacy_wire() -> crate::RawSolanaTransactionWire {
+    let message = crate::RawSolanaTransactionMessage::new(
+        crate::RawSolanaMessageVersion::Legacy,
+        crate::RawSolanaMessageHeader::new(1, 0, 1),
+        vec![[0x21_u8; 32], [0x22_u8; 32]],
+        [0x31_u8; 32],
+        vec![crate::RawSolanaCompiledInstruction::new(1, vec![0], vec![0xaa, 0xbb])],
+        vec![],
+        std::option::Option::None,
+    );
+    return crate::RawSolanaTransactionWire::new(vec![[0x11_u8; 64]], message);
+}
+
+fn v0_wire() -> crate::RawSolanaTransactionWire {
+    let message = crate::RawSolanaTransactionMessage::new(
+        crate::RawSolanaMessageVersion::V0,
+        crate::RawSolanaMessageHeader::new(1, 0, 0),
+        vec![[0x23_u8; 32]],
+        [0x32_u8; 32],
+        vec![crate::RawSolanaCompiledInstruction::new(0, vec![1], vec![0xcc])],
+        vec![crate::RawSolanaAddressTableLookup::new([0x24_u8; 32], vec![0], vec![])],
+        std::option::Option::None,
+    );
+    return crate::RawSolanaTransactionWire::new(vec![[0x12_u8; 64]], message);
+}
+
+fn v1_wire() -> crate::RawSolanaTransactionWire {
+    let message = crate::RawSolanaTransactionMessage::new(
+        crate::RawSolanaMessageVersion::V1,
+        crate::RawSolanaMessageHeader::new(1, 0, 1),
+        vec![[0x41_u8; 32], [0x42_u8; 32]],
+        [0x51_u8; 32],
+        vec![crate::RawSolanaCompiledInstruction::new(1, vec![0], vec![1, 2, 3])],
+        vec![],
+        std::option::Option::Some(crate::RawSolanaTransactionConfig::new(
+            std::option::Option::Some(7),
+            std::option::Option::Some(8),
+            std::option::Option::Some(9),
+            std::option::Option::Some(32_768),
+        )),
+    );
+    return crate::RawSolanaTransactionWire::new(vec![[0xaa_u8; 64]], message);
+}
+
+fn v1_empty_config_wire() -> crate::RawSolanaTransactionWire {
+    let message = crate::RawSolanaTransactionMessage::new(
+        crate::RawSolanaMessageVersion::V1,
+        crate::RawSolanaMessageHeader::new(1, 0, 0),
+        vec![[0x43_u8; 32]],
+        [0x52_u8; 32],
+        vec![],
+        vec![],
+        std::option::Option::Some(crate::RawSolanaTransactionConfig::default()),
+    );
+    return crate::RawSolanaTransactionWire::new(vec![[0xab_u8; 64]], message);
+}
+
+#[test]
+fn pre_006_legacy_v0_and_v1_wire_goldens_are_exact() {
+    let legacy = crate::serialize_solana_transaction_wire_base64(&legacy_wire());
+    let v0 = crate::serialize_solana_transaction_wire_base64(&v0_wire());
+    let v1 = crate::serialize_solana_transaction_wire_base64(&v1_wire());
+    let v1_empty = crate::serialize_solana_transaction_wire_base64(&v1_empty_config_wire());
+    assert!(matches!(legacy.as_deref(), std::result::Result::Ok(value) if value == LEGACY_GOLDEN_BASE64));
+    assert!(matches!(v0.as_deref(), std::result::Result::Ok(value) if value == V0_GOLDEN_BASE64));
+    assert!(matches!(v1.as_deref(), std::result::Result::Ok(value) if value == V1_GOLDEN_BASE64));
+    assert!(matches!(v1_empty.as_deref(), std::result::Result::Ok(value) if value == V1_EMPTY_CONFIG_GOLDEN_BASE64));
+    let v1_bytes = crate::serialize_solana_transaction_wire(&v1_wire());
+    assert!(v1_bytes.is_ok());
+    if let std::result::Result::Ok(v1_bytes) = v1_bytes {
+        assert_eq!(v1_bytes.len(), 198);
+        assert_eq!(v1_bytes.first(), std::option::Option::Some(&0x81));
+        assert_eq!(v1_bytes.get(v1_bytes.len() - 64..), std::option::Option::Some([0xaa_u8; 64].as_slice()));
+    }
+}
+
+#[test]
+fn pre_006_v1_structural_guards_reject_alt_duplicates_and_missing_config() {
+    let mut missing_config = v1_wire();
+    missing_config.message.config = std::option::Option::None;
+    assert!(crate::serialize_solana_transaction_wire(&missing_config).is_err());
+    let mut with_lookup = v1_wire();
+    with_lookup.message.address_table_lookups.push(crate::RawSolanaAddressTableLookup::new([9_u8; 32], vec![], vec![]));
+    assert!(crate::serialize_solana_transaction_wire(&with_lookup).is_err());
+    let mut duplicate = v1_wire();
+    duplicate.message.account_keys[1] = duplicate.message.account_keys[0];
+    assert!(crate::serialize_solana_transaction_wire(&duplicate).is_err());
+}
+
+#[test]
+fn pre_006_v1_program_index_zero_is_valid_and_bounds_remain_enforced() {
+    let message = crate::RawSolanaTransactionMessage::new(
+        crate::RawSolanaMessageVersion::V1,
+        crate::RawSolanaMessageHeader::new(1, 0, 0),
+        vec![[1_u8; 32]],
+        [2_u8; 32],
+        vec![crate::RawSolanaCompiledInstruction::new(0, vec![0], vec![])],
+        vec![],
+        std::option::Option::Some(crate::RawSolanaTransactionConfig::default()),
+    );
+    let wire = crate::RawSolanaTransactionWire::new(vec![[3_u8; 64]], message);
+    assert!(crate::serialize_solana_transaction_wire(&wire).is_ok());
+    let too_many_addresses = crate::RawSolanaTransactionMessage::new(
+        crate::RawSolanaMessageVersion::V1,
+        crate::RawSolanaMessageHeader::new(1, 0, 0),
+        (0_u8..65_u8).map(|value| return [value; 32]).collect(),
+        [2_u8; 32],
+        vec![],
+        vec![],
+        std::option::Option::Some(crate::RawSolanaTransactionConfig::default()),
+    );
+    let wire = crate::RawSolanaTransactionWire::new(vec![[3_u8; 64]], too_many_addresses);
+    assert!(crate::serialize_solana_transaction_wire(&wire).is_err());
+}

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

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/tests/public_api.rs
-// version: 8
+// version: 9
 
 //! Integration canaries for the public `ksp-store-api` surface.
 
@@ -30,7 +30,7 @@ fn public_pre_002_core_facade_remains_available_from_crate_root() {
 
 #[test]
 fn public_pre_003_raw_transaction_and_observation_are_constructible_from_crate_root() {
-    let network = match ksp_store_api::RawNetworkId::new("mainnet-beta".to_owned()) {
+    let network = match ksp_store_api::RawNetworkId::new("mainnet".to_owned()) {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return,
     };
@@ -65,7 +65,7 @@ fn public_pre_003_raw_transaction_and_observation_are_constructible_from_crate_r
     let observation = ksp_store_api::RawTransactionObservation::new(ksp_store_api::RawObservationKey::new([3_u8; 32]), reference, provenance);
     assert_eq!(transaction.slot(), 123);
     assert_eq!(transaction.payload().bytes(), &[1_u8, 2_u8, 3_u8]);
-    assert_eq!(observation.transaction().network().as_str(), "mainnet-beta");
+    assert_eq!(observation.transaction().network().as_str(), "mainnet");
     assert_eq!(observation.provenance().acquisition_method().as_str(), "getTransaction");
     assert_eq!(ksp_store_api::ERROR_CODE_RAW_PAYLOAD_INVALID.domain(), "store_api");
     return;
@@ -83,7 +83,7 @@ fn public_pre_003_surface_keeps_backend_and_structural_types_out() {
 
 #[test]
 fn public_pre_004_raw_account_state_and_observation_are_constructible_from_crate_root() {
-    let network = match ksp_store_api::RawNetworkId::new("mainnet-beta".to_owned()) {
+    let network = match ksp_store_api::RawNetworkId::new("mainnet".to_owned()) {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return,
     };
@@ -159,7 +159,7 @@ fn public_pre_006_query_outcome_and_retention_contracts_are_available_from_crate
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return,
     };
-    let network = match ksp_store_api::RawNetworkId::new("mainnet-beta".to_owned()) {
+    let network = match ksp_store_api::RawNetworkId::new("mainnet".to_owned()) {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return,
     };

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

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/tests/security_hardening.rs
-// version: 2
+// version: 3
 
 //! Adversarial and retention-race canaries for the Store API RAW foundation.
 
@@ -62,7 +62,7 @@ fn pre_007_raw_debug_surfaces_do_not_render_payload_hash_signature_or_account_by
     };
     assert!(!std::format!("{payload:?}").contains(HOSTILE_MARKER));
     assert_eq!(std::format!("{:?}", payload.content_hash()), "RawContentHash(..)");
-    let network = match ksp_store_api::RawNetworkId::new("mainnet-beta".to_owned()) {
+    let network = match ksp_store_api::RawNetworkId::new("mainnet".to_owned()) {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return,
     };
@@ -125,7 +125,7 @@ fn pre_007_retention_outcome_distinguishes_lost_compare_and_transition_race() {
 
 #[test]
 fn v0_3_8_pre_003_inspection_summaries_and_counts_reject_payload_shaped_or_inconsistent_state() {
-    let network = match ksp_store_api::RawNetworkId::new("mainnet-beta".to_owned()) {
+    let network = match ksp_store_api::RawNetworkId::new("mainnet".to_owned()) {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return,
     };

crates/ksp-store-api/unit_tests/model/raw_account.rs

@@ -1,8 +1,8 @@
 // file: crates/ksp-store-api/unit_tests/model/raw_account.rs
-// version: 1
+// version: 2
 
 fn network() -> std::option::Option<crate::RawNetworkId> {
-    return match crate::RawNetworkId::new("mainnet-beta".to_owned()) {
+    return match crate::RawNetworkId::new("mainnet".to_owned()) {
         std::result::Result::Ok(value) => std::option::Option::Some(value),
         std::result::Result::Err(_) => std::option::Option::None,
     };

crates/ksp-store-api/unit_tests/model/raw_inspection.rs

@@ -1,10 +1,10 @@
 // file: crates/ksp-store-api/unit_tests/model/raw_inspection.rs
-// version: 2
+// version: 3
 
 //! Unit tests for backend-neutral RAW inspection contracts.
 
 fn network() -> std::option::Option<crate::RawNetworkId> {
-    return match crate::RawNetworkId::new("mainnet-beta".to_owned()) {
+    return match crate::RawNetworkId::new("mainnet".to_owned()) {
         std::result::Result::Ok(value) => std::option::Option::Some(value),
         std::result::Result::Err(_) => std::option::Option::None,
     };
@@ -61,7 +61,7 @@ fn inspection_queries_keep_backend_neutral_filters_and_random_access_page() {
     };
     let transaction =
         crate::RawTransactionInspectionQuery::new(network.clone(), slots, crate::RawSortDirection::Descending, crate::RawInspectionPageRequest::new(50, limit));
-    assert_eq!(transaction.network().as_str(), "mainnet-beta");
+    assert_eq!(transaction.network().as_str(), "mainnet");
     assert_eq!(transaction.page().offset(), 50);
     assert_eq!(transaction.slots().end_inclusive(), std::option::Option::Some(20));
     assert_eq!(transaction.direction(), crate::RawSortDirection::Descending);

crates/ksp-store-api/unit_tests/model/raw_pagination.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/unit_tests/model/raw_pagination.rs
-// version: 1
+// version: 2
 
 #[test]
 fn page_limit_rejects_only_zero_and_keeps_no_ksp_policy_maximum() {
@@ -32,7 +32,7 @@ fn cursor_is_opaque_bounded_and_debug_does_not_render_bytes() {
 
 #[test]
 fn transaction_query_preserves_caller_limit_range_direction_and_network() {
-    let network = match crate::RawNetworkId::new("mainnet-beta".to_owned()) {
+    let network = match crate::RawNetworkId::new("mainnet".to_owned()) {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return,
     };
@@ -45,7 +45,7 @@ fn transaction_query_preserves_caller_limit_range_direction_and_network() {
         std::result::Result::Err(_) => return,
     };
     let query = crate::RawTransactionQuery::new(network, slots, crate::RawSortDirection::Ascending, crate::RawPageRequest::first(limit));
-    assert_eq!(query.network().as_str(), "mainnet-beta");
+    assert_eq!(query.network().as_str(), "mainnet");
     assert_eq!(query.slots().start_inclusive(), std::option::Option::Some(10));
     assert_eq!(query.page().limit().get(), 5_000_000);
     assert_eq!(query.direction(), crate::RawSortDirection::Ascending);

crates/ksp-store-api/unit_tests/model/raw_primitives.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/unit_tests/model/raw_primitives.rs
-// version: 1
+// version: 2
 
 fn code(value: &str) -> std::option::Option<crate::RawProvenanceCode> {
     return match crate::RawProvenanceCode::new(value.to_owned()) {
@@ -17,7 +17,7 @@ fn timestamp(unix_millis: u64) -> std::option::Option<crate::RawTimestamp> {
 
 #[test]
 fn raw_codes_are_bounded_nonempty_and_reject_url_like_or_control_values() {
-    let network = crate::RawNetworkId::new("mainnet-beta".to_owned());
+    let network = crate::RawNetworkId::new("mainnet".to_owned());
     assert!(network.is_ok());
     let format = crate::RawFormatId::new("ksp.solana.raw_transaction".to_owned());
     assert!(format.is_ok());

crates/ksp-store-api/unit_tests/model/raw_retention.rs

@@ -1,8 +1,8 @@
 // file: crates/ksp-store-api/unit_tests/model/raw_retention.rs
-// version: 2
+// version: 3
 
 fn reference() -> std::option::Option<crate::RawTransactionReference> {
-    let network = match crate::RawNetworkId::new("mainnet-beta".to_owned()) {
+    let network = match crate::RawNetworkId::new("mainnet".to_owned()) {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return std::option::Option::None,
     };

crates/ksp-store-api/unit_tests/model/raw_transaction.rs

@@ -1,8 +1,8 @@
 // file: crates/ksp-store-api/unit_tests/model/raw_transaction.rs
-// version: 1
+// version: 2
 
 fn network() -> std::option::Option<crate::RawNetworkId> {
-    return match crate::RawNetworkId::new("mainnet-beta".to_owned()) {
+    return match crate::RawNetworkId::new("mainnet".to_owned()) {
         std::result::Result::Ok(value) => std::option::Option::Some(value),
         std::result::Result::Err(_) => std::option::Option::None,
     };
@@ -57,7 +57,7 @@ fn raw_transaction_identity_is_network_plus_signature_and_payload_remains_whole(
     let signature = crate::RawTransactionSignature::new([9_u8; 64]);
     let reference = crate::RawTransactionReference::new(network, signature);
     let transaction = crate::RawTransaction::new(reference, 42, std::option::Option::None, payload);
-    assert_eq!(transaction.reference().network().as_str(), "mainnet-beta");
+    assert_eq!(transaction.reference().network().as_str(), "mainnet");
     assert_eq!(transaction.reference().signature(), signature);
     assert_eq!(transaction.slot(), 42);
     assert!(transaction.block_time().is_none());

crates/ksp-store-postgres-lib/unit_tests/raw_account.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-postgres-lib/unit_tests/raw_account.rs
-// version: 7
+// version: 8
 
 fn network() -> ksp_store_api::RawNetworkId {
     return match ksp_store_api::RawNetworkId::new("devnet") {
@@ -311,7 +311,7 @@ fn pre_004_account_observation_rejects_hostile_rows_without_echoing_values() {
 #[test]
 fn pre_004_account_wrong_network_guard_is_pre_io_and_static() {
     let backend = network();
-    let foreign = match ksp_store_api::RawNetworkId::new("mainnet-beta") {
+    let foreign = match ksp_store_api::RawNetworkId::new("mainnet") {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => panic!("valid foreign network rejected: {error:?}"),
     };
@@ -343,7 +343,7 @@ fn pre_005_account_acquisition_input_guard_requires_network_and_exact_reference(
         std::result::Result::Err(error) => panic!("valid account observation rejected: {error:?}"),
     };
     assert!(super::ensure_acquisition_inputs(&backend, &valid_state, &valid_observation).is_ok());
-    let foreign = match ksp_store_api::RawNetworkId::new("mainnet-beta") {
+    let foreign = match ksp_store_api::RawNetworkId::new("mainnet") {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => panic!("valid foreign network rejected: {error:?}"),
     };
@@ -437,7 +437,7 @@ fn pre_005_account_origin_encoding_is_exact_and_static() {
 #[test]
 fn pre_006_additional_observation_input_guard_rejects_wrong_network_before_io() {
     let backend = network();
-    let foreign = match ksp_store_api::RawNetworkId::new("mainnet-beta") {
+    let foreign = match ksp_store_api::RawNetworkId::new("mainnet") {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => panic!("valid foreign network rejected: {error:?}"),
     };
@@ -532,7 +532,7 @@ fn pre_007_account_cursor_rejects_replay_across_query_context_and_transaction_fa
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => panic!("valid account cursor encoding rejected: {error:?}"),
     };
-    let other_network = page_query("mainnet-beta", Some(pubkey), Some(10), Some(20), ksp_store_api::RawSortDirection::Ascending);
+    let other_network = page_query("mainnet", Some(pubkey), Some(10), Some(20), ksp_store_api::RawSortDirection::Ascending);
     let other_pubkey =
         page_query("devnet", Some(ksp_store_api::Pubkey::new_from_array([6_u8; 32])), Some(10), Some(20), ksp_store_api::RawSortDirection::Ascending);
     let other_direction = page_query("devnet", Some(pubkey), Some(10), Some(20), ksp_store_api::RawSortDirection::Descending);

crates/ksp-store-postgres-lib/unit_tests/raw_transaction.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-postgres-lib/unit_tests/raw_transaction.rs
-// version: 5
+// version: 6
 
 fn network() -> ksp_store_api::RawNetworkId {
     return match ksp_store_api::RawNetworkId::new("devnet") {
@@ -271,7 +271,7 @@ fn v0_3_8_pre_004_inspection_summary_rejects_physical_retention_shape_residue()
 #[test]
 fn pre_004_wrong_network_is_rejected_by_the_private_pre_io_guard() {
     let backend_network = network();
-    let other_network = match ksp_store_api::RawNetworkId::new("mainnet-beta") {
+    let other_network = match ksp_store_api::RawNetworkId::new("mainnet") {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => panic!("valid alternate network rejected: {error:?}"),
     };
@@ -330,7 +330,7 @@ fn pre_005_atomic_acquisition_pre_io_guard_requires_backend_network_and_exact_re
     let mismatched = observation(other_reference, 4, "publicnode");
     let mismatch = super::ensure_acquisition_inputs(&backend_network, &raw_transaction, &mismatched);
     assert_eq!(mismatch.err().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::Conflict));
-    let other_network = match ksp_store_api::RawNetworkId::new("mainnet-beta") {
+    let other_network = match ksp_store_api::RawNetworkId::new("mainnet") {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => panic!("valid alternate network rejected: {error:?}"),
     };
@@ -508,7 +508,7 @@ fn pre_006_cursor_v1_rejects_replay_across_network_direction_and_range() {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => panic!("valid cursor encoding rejected: {error:?}"),
     };
-    let other_network = page_query("mainnet-beta", Some(10), Some(20), ksp_store_api::RawSortDirection::Ascending, None);
+    let other_network = page_query("mainnet", Some(10), Some(20), ksp_store_api::RawSortDirection::Ascending, None);
     let other_direction = page_query("devnet", Some(10), Some(20), ksp_store_api::RawSortDirection::Descending, None);
     let other_range = page_query("devnet", Some(11), Some(20), ksp_store_api::RawSortDirection::Ascending, None);
     for candidate in [&other_network, &other_direction, &other_range] {
@@ -640,7 +640,7 @@ fn pre_007_compacted_transitions_are_rejected_by_the_pre_io_guard() {
 #[test]
 fn pre_007_retention_transition_pre_io_guard_rejects_wrong_network() {
     let backend_network = network();
-    let other_network = match ksp_store_api::RawNetworkId::new("mainnet-beta") {
+    let other_network = match ksp_store_api::RawNetworkId::new("mainnet") {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => panic!("valid alternate network rejected: {error:?}"),
     };

crates/ksp-worker-api/Cargo.toml

@@ -0,0 +1,14 @@
+# file: crates/ksp-worker-api/Cargo.toml
+# version: 1
+
+[package]
+name = "ksp-worker-api"
+version.workspace = true
+edition.workspace = true
+repository.workspace = true
+
+[dependencies]
+ksp-core-lib = { path = "../ksp-core-lib" }
+
+[lints]
+workspace = true

crates/ksp-worker-api/README.md

@@ -0,0 +1,69 @@
+<!-- file: crates/ksp-worker-api/README.md -->
+<!-- version: 2 -->
+
+# ksp-worker-api
+
+`ksp-worker-api` fournit les contrats passifs et runtime-neutral communs aux services continus KSP. Elle décrit un Worker observable ; elle n'est ni un runtime de Worker ni une API métier d'acquisition.
+
+La crate possède l'identité logique d'un Worker, son lifecycle continu, une classification minimale de health/activity, l'intention de stop coopératif et un contrat latest-value fixe pour l'observation. Elle ne possède aucun runtime concret, aucune politique de restart, aucun Job, aucun Transport, aucun Store et aucun contrat Solana.
+
+## Responsabilités
+
+La façade crate-root expose :
+
+- `WorkerId` et `WorkerKindCode`, bornés et validés ;
+- `WorkerState`, `WorkerHealth` et `WorkerActivity` ;
+- `WorkerLifecycle`, propriétaire des transitions admises ;
+- `WorkerStopToken`, cloneable et idempotent ;
+- `WorkerSnapshotSequence`, strictement monotone et sans wrap silencieux ;
+- `WorkerSnapshot`, forme commune fixe sans payload métier ;
+- `WorkerSnapshotSource`, contrat object-safe de lecture courante et attente d'une valeur plus récente ;
+- les codes d'erreur Worker et les types `Error`/`Result` communs de Core.
+
+## Lifecycle
+
+Le lifecycle admis reste explicitement borné :
+
+```text
+Created  -> Starting | Stopped
+Starting -> Running | Stopping | Faulted(ErrorCode)
+Running  -> Stopping | Faulted(ErrorCode)
+Stopping -> Stopped | Faulted(ErrorCode)
+Stopped  -> terminal
+Faulted  -> terminal
+```
+
+`Stopped` et `Faulted` sont terminaux et immuables. Une transition invalide retourne `ERROR_CODE_WORKER_TRANSITION_INVALID` sans modifier l'état source.
+
+## Observation latest-value
+
+`WorkerSnapshotSource` n'impose ni callback, ni queue d'événements, ni runtime async particulier. Un listener lit d'abord `current()`, mémorise la `WorkerSnapshotSequence`, puis appelle `wait_for_change()` s'il doit attendre une valeur plus récente.
+
+Les mises à jour intermédiaires peuvent être coalescées : le contrat porte sur la dernière valeur complète, pas sur la livraison de chaque événement. Le snapshot commun ne contient que l'identité, la séquence, le lifecycle, la health et l'activity.
+
+## Stop
+
+`WorkerStopToken` représente uniquement une intention coopérative partagée. Il ne tue pas une tâche, ne ferme pas un socket et ne décide pas du résultat terminal. Le runtime concret observe cette intention puis pilote `WorkerLifecycle` selon sa politique de shutdown.
+
+## Contrôle runtime et restart
+
+La crate ne possède aucune opération runtime générique `start()`, `stop()`, `restart()`, aucun scheduler, retry/backoff, process manager ou handle d'exécution. `WorkerLifecycle` expose uniquement les transitions d'état détenues par le producer concret ; `WorkerStopToken` exprime uniquement une intention coopérative.
+
+Un lifecycle/source terminal n'est jamais réanimé ni rebinding vers une nouvelle exécution. Démarrage, arrêt effectif, drain, join, recréation et supervision appartiennent au Worker concret, au caller ou à une couche de contrôle supérieure.
+
+## Firewall
+
+La dépendance normale est volontairement minimale :
+
+```text
+ksp-worker-api
+    -> ksp-core-lib
+```
+
+La crate ne dépend pas de `ksp-job-api`, Tokio, Futures, serde, Logging, Config, Interface, Transport, Store, Tauri ou d'un SDK provider.
+
+## Documentation
+
+- [`USAGE.md`](USAGE.md) — utilisation durable des contrats Worker ;
+- [`../../docs/architecture/003-COMPONENT_CONTRACTS.md`](../../docs/architecture/003-COMPONENT_CONTRACTS.md) — contrats de composants ;
+- [`../../docs/architecture/009-ACQUISITION_WORKERS_AND_JOBS.md`](../../docs/architecture/009-ACQUISITION_WORKERS_AND_JOBS.md) — séparation Worker/Job et ownership d'acquisition.

crates/ksp-worker-api/USAGE.md

@@ -0,0 +1,149 @@
+<!-- file: crates/ksp-worker-api/USAGE.md -->
+<!-- version: 2 -->
+
+# Utilisation de ksp-worker-api
+
+Cette page décrit la façade publique durable de `ksp-worker-api`. Les consumers utilisent uniquement les exports du crate-root.
+
+## Construire une identité Worker
+
+```rust
+fn worker_identity() -> ksp_worker_api::Result<(ksp_worker_api::WorkerId, ksp_worker_api::WorkerKindCode)> {
+    let id = match ksp_worker_api::WorkerId::new("raw-ingest-mainnet-0001") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let kind = match ksp_worker_api::WorkerKindCode::new("raw_transaction_ingest") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    return std::result::Result::Ok((id, kind));
+}
+```
+
+`WorkerId` identifie une instance logique observée par un lifecycle/source donné. `WorkerKindCode` identifie une famille de Workers. Les deux sont bornés et utilisent un alphabet sûr. Le `Debug` de `WorkerId` masque sa valeur.
+
+## Piloter un lifecycle passif
+
+Le lifecycle ne démarre aucun runtime. L'exemple suivant représente uniquement les transitions publiées par un producer concret lorsqu'il entre en exécution :
+
+```rust
+fn running_lifecycle(id: ksp_worker_api::WorkerId, kind: ksp_worker_api::WorkerKindCode) -> ksp_worker_api::Result<ksp_worker_api::WorkerLifecycle> {
+    let mut lifecycle = ksp_worker_api::WorkerLifecycle::new(id, kind);
+    if let std::result::Result::Err(error) = lifecycle.start() {
+        return std::result::Result::Err(error);
+    }
+    if let std::result::Result::Err(error) = lifecycle.mark_running() {
+        return std::result::Result::Err(error);
+    }
+    return std::result::Result::Ok(lifecycle);
+}
+```
+
+Le producer possède l'autorité de transition. Il ne force jamais un état directement. Une transition invalide retourne une erreur stable et conserve l'état courant.
+
+Pour un shutdown coopératif après observation du token :
+
+```rust
+if let std::result::Result::Err(error) = lifecycle.mark_stopping() {
+    return std::result::Result::Err(error);
+}
+if let std::result::Result::Err(error) = lifecycle.mark_stopped() {
+    return std::result::Result::Err(error);
+}
+```
+
+Pour un fault terminal :
+
+```rust
+const IO_FAULT: ksp_worker_api::ErrorCode = ksp_worker_api::ErrorCode::new("example_worker", "io_fault");
+if let std::result::Result::Err(error) = lifecycle.fault(IO_FAULT) {
+    return std::result::Result::Err(error);
+}
+```
+
+`Stopped` et `Faulted(ErrorCode)` sont terminaux. Un ancien lifecycle terminal ne représente jamais une nouvelle exécution.
+
+## Distinguer lifecycle, health et activity
+
+`WorkerState` décrit la phase du service. `WorkerHealth` décrit sa qualité opérationnelle. `WorkerActivity` indique seulement `Unknown`, `Idle` ou `Active`.
+
+```rust
+let snapshot = ksp_worker_api::WorkerSnapshot::new(
+    lifecycle.id().clone(),
+    lifecycle.kind().clone(),
+    ksp_worker_api::WorkerSnapshotSequence::initial(),
+    lifecycle.state(),
+    ksp_worker_api::WorkerHealth::Healthy,
+    ksp_worker_api::WorkerActivity::Idle,
+);
+```
+
+Le snapshot commun ne porte ni pourcentage, ni total, ni backlog, ni slot, ni transaction, ni métrique métier. Une API Worker concrète peut exposer séparément ses propres métriques.
+
+## Partager une intention de stop
+
+```rust
+let token = ksp_worker_api::WorkerStopToken::new();
+let listener = token.clone();
+
+assert!(!listener.is_stop_requested());
+assert!(token.request_stop());
+assert!(listener.is_stop_requested());
+assert!(!token.request_stop());
+```
+
+Le premier appel qui change l'intention retourne `true`. Les demandes suivantes sont idempotentes et retournent `false`.
+
+Le token n'est pas une primitive de kill et ne garantit aucun délai de shutdown. Timeout, drain, join et retry appartiennent au runtime/caller.
+
+## Démarrer et arrêter un Worker concret
+
+`ksp-worker-api` n'expose volontairement aucune commande runtime universelle. Une crate concrète peut fournir une surface `start`/`stop` adaptée à son domaine, mais elle utilise les contrats communs pour publier son identité, ses transitions, son état courant et l'intention de stop.
+
+Un Worker concret ne doit donc pas transformer `WorkerLifecycle` en handle d'exécution ni ajouter des paramètres métier au contrat générique. Les paramètres/configurations propres à une famille de Workers restent dans cette famille ou dans sa couche de composition.
+
+## Observer un snapshot latest-value
+
+Un consumer portable peut travailler directement avec le trait object-safe :
+
+```rust
+async fn observe(source: &dyn ksp_worker_api::WorkerSnapshotSource) {
+    let current = source.current();
+    let observed = current.sequence();
+    let newer = source.wait_for_change(observed).await;
+    assert!(newer.sequence().is_after(observed));
+}
+```
+
+`wait_for_change` retourne la dernière valeur complète disponible après coalescence éventuelle. Un consumer ne doit pas supposer qu'il recevra chaque mise à jour intermédiaire.
+
+Un listener tardif commence par `current()`. Tant que la source existe, son snapshot terminal courant reste lisible.
+
+## Faire avancer une séquence
+
+```rust
+let first = ksp_worker_api::WorkerSnapshotSequence::initial();
+let second = match first.next() {
+    std::result::Result::Ok(value) => value,
+    std::result::Result::Err(error) => return std::result::Result::Err(error),
+};
+assert!(second.is_after(first));
+```
+
+L'épuisement de `u64` est une erreur explicite ; la séquence ne wrappe jamais silencieusement.
+
+## Frontières à respecter
+
+Ne pas ajouter à `ksp-worker-api` :
+
+```text
+runtime Tokio/Futures concret
+Job lifecycle ou checkpoint/backfill
+Transport, Store, Config ou Logging
+DTO Solana/provider
+restart/retry/scheduler/process manager
+payload métier dans WorkerSnapshot
+```
+
+Ces responsabilités appartiennent aux Workers concrets et aux couches de composition/contrôle supérieures.

crates/ksp-worker-api/src/error.rs

@@ -0,0 +1,12 @@
+// file: crates/ksp-worker-api/src/error.rs
+// version: 1
+
+/// Error code used when a Worker identifier violates its bounded safe-code contract.
+pub const ERROR_CODE_WORKER_ID_INVALID: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("worker_api", "worker_id_invalid");
+/// Error code used when a Worker kind code violates its bounded safe-code contract.
+pub const ERROR_CODE_WORKER_KIND_INVALID: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("worker_api", "worker_kind_invalid");
+/// Error code used when a Worker snapshot sequence cannot advance without wrapping.
+pub const ERROR_CODE_WORKER_SNAPSHOT_SEQUENCE_EXHAUSTED: ksp_core_lib::ErrorCode =
+    ksp_core_lib::ErrorCode::new("worker_api", "worker_snapshot_sequence_exhausted");
+/// Error code used when a requested Worker lifecycle transition is not allowed.
+pub const ERROR_CODE_WORKER_TRANSITION_INVALID: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("worker_api", "worker_transition_invalid");

crates/ksp-worker-api/src/identity.rs

@@ -0,0 +1,76 @@
+// file: crates/ksp-worker-api/src/identity.rs
+// version: 2
+
+/// Maximum UTF-8 byte length admitted for one Worker identifier.
+pub const MAX_WORKER_ID_BYTES: usize = 128;
+/// Maximum UTF-8 byte length admitted for one Worker kind code.
+pub const MAX_WORKER_KIND_CODE_BYTES: usize = 128;
+
+/// Bounded caller-supplied identity of one logical Worker instance.
+#[derive(Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct WorkerId(std::string::String);
+
+impl crate::WorkerId {
+    /// Creates one non-empty Worker identifier using the KSP safe-code alphabet.
+    pub fn new(value: impl std::convert::Into<std::string::String>) -> crate::Result<Self> {
+        let value = value.into();
+        if !valid_worker_code(value.as_str(), crate::MAX_WORKER_ID_BYTES) {
+            return std::result::Result::Err(identity_error(crate::ERROR_CODE_WORKER_ID_INVALID, "worker_id"));
+        }
+        return std::result::Result::Ok(Self(value));
+    }
+
+    /// Returns the validated Worker identifier.
+    #[must_use]
+    pub fn as_str(&self) -> &str {
+        return self.0.as_str();
+    }
+}
+
+impl std::fmt::Debug for crate::WorkerId {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        return formatter.write_str("WorkerId(..)");
+    }
+}
+
+/// Bounded stable code identifying one concrete family of Workers.
+#[derive(Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct WorkerKindCode(std::string::String);
+
+impl crate::WorkerKindCode {
+    /// Creates one non-empty Worker kind using the KSP safe-code alphabet.
+    pub fn new(value: impl std::convert::Into<std::string::String>) -> crate::Result<Self> {
+        let value = value.into();
+        if !valid_worker_code(value.as_str(), crate::MAX_WORKER_KIND_CODE_BYTES) {
+            return std::result::Result::Err(identity_error(crate::ERROR_CODE_WORKER_KIND_INVALID, "worker_kind"));
+        }
+        return std::result::Result::Ok(Self(value));
+    }
+
+    /// Returns the validated stable Worker kind code.
+    #[must_use]
+    pub fn as_str(&self) -> &str {
+        return self.0.as_str();
+    }
+}
+
+impl std::fmt::Debug for crate::WorkerKindCode {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        return formatter.debug_tuple("WorkerKindCode").field(&self.0).finish();
+    }
+}
+
+fn identity_error(code: crate::ErrorCode, field: &'static str) -> crate::Error {
+    return crate::Error::new(code, "invalid bounded Worker identity").with_context("field", field);
+}
+
+fn valid_worker_code(value: &str, maximum_len: usize) -> bool {
+    if value.is_empty() || value.len() > maximum_len {
+        return false;
+    }
+    return value.bytes().all(|byte| return byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'-' | b'.' | b':'));
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/identity.rs"]
+mod tests;

crates/ksp-worker-api/src/lib.rs

@@ -0,0 +1,62 @@
+// file: crates/ksp-worker-api/src/lib.rs
+// version: 1
+
+#![warn(missing_docs)]
+#![deny(unreachable_pub)]
+#![forbid(unsafe_code)]
+
+//! Passive runtime-neutral lifecycle contracts for continuous KSP Workers.
+//!
+//! This foundation owns bounded Worker identity, explicit continuous lifecycle
+//! transitions, cooperative stop intent and a fixed latest-value observation
+//! contract. Concrete runtimes, restart policy, Transport, Store, Config, Jobs
+//! and domain-specific Worker behavior remain outside this crate.
+
+mod error;
+mod identity;
+mod lifecycle;
+mod snapshot;
+mod stop;
+
+/// Error code used when a Worker identifier violates its bounded safe-code contract.
+pub use self::error::ERROR_CODE_WORKER_ID_INVALID;
+/// Error code used when a Worker kind code violates its bounded safe-code contract.
+pub use self::error::ERROR_CODE_WORKER_KIND_INVALID;
+/// Error code used when a Worker snapshot sequence cannot advance without wrapping.
+pub use self::error::ERROR_CODE_WORKER_SNAPSHOT_SEQUENCE_EXHAUSTED;
+/// Error code used when a requested Worker lifecycle transition is not allowed.
+pub use self::error::ERROR_CODE_WORKER_TRANSITION_INVALID;
+/// Maximum UTF-8 byte length admitted for one Worker identifier.
+pub use self::identity::MAX_WORKER_ID_BYTES;
+/// Maximum UTF-8 byte length admitted for one Worker kind code.
+pub use self::identity::MAX_WORKER_KIND_CODE_BYTES;
+/// Bounded caller-supplied identity of one logical Worker instance.
+pub use self::identity::WorkerId;
+/// Bounded stable code identifying one concrete family of Workers.
+pub use self::identity::WorkerKindCode;
+/// Minimal generic activity classification for a continuous Worker.
+pub use self::lifecycle::WorkerActivity;
+/// Operational health classification independent from Worker lifecycle phase.
+pub use self::lifecycle::WorkerHealth;
+/// Passive owner of one Worker identity and its validated lifecycle state.
+pub use self::lifecycle::WorkerLifecycle;
+/// Current lifecycle state of one continuous Worker.
+pub use self::lifecycle::WorkerState;
+/// Fixed common latest-value snapshot exposed by every Worker implementation.
+pub use self::snapshot::WorkerSnapshot;
+/// Runtime-neutral future returned while observing a latest-value Worker snapshot source.
+pub use self::snapshot::WorkerSnapshotFuture;
+/// Monotone sequence attached to one latest-value Worker snapshot stream.
+pub use self::snapshot::WorkerSnapshotSequence;
+/// Runtime-neutral read and change-wait contract for one latest-value Worker snapshot stream.
+pub use self::snapshot::WorkerSnapshotSource;
+/// Runtime-neutral cloneable token carrying cooperative Worker stop intent.
+pub use self::stop::WorkerStopToken;
+/// Common KSP error type used by Worker-facing contracts.
+pub use ksp_core_lib::Error;
+/// Stable structured code identifying a KSP error category and condition.
+pub use ksp_core_lib::ErrorCode;
+/// Structured contextual field attached to a KSP error.
+pub use ksp_core_lib::ErrorContext;
+/// Common KSP result alias using [`Error`].
+pub use ksp_core_lib::Result;

crates/ksp-worker-api/src/lifecycle.rs

@@ -0,0 +1,199 @@
+// file: crates/ksp-worker-api/src/lifecycle.rs
+// version: 2
+
+/// Current lifecycle state of one continuous Worker.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[non_exhaustive]
+pub enum WorkerState {
+    /// The Worker exists but has not started initialization.
+    Created,
+    /// The Worker is initializing resources before entering steady service.
+    Starting,
+    /// The Worker is actively providing its continuous service.
+    Running,
+    /// The Worker observed stop intent and is draining or releasing resources.
+    Stopping,
+    /// The Worker reached its normal terminal stopped state.
+    Stopped,
+    /// The Worker reached a terminal fault classified by one stable KSP error code.
+    Faulted(crate::ErrorCode),
+}
+
+impl crate::WorkerState {
+    /// Returns the stable safe lifecycle code without rendering Worker data.
+    #[must_use]
+    pub const fn code(&self) -> &'static str {
+        return match self {
+            Self::Created => "created",
+            Self::Starting => "starting",
+            Self::Running => "running",
+            Self::Stopping => "stopping",
+            Self::Stopped => "stopped",
+            Self::Faulted(_) => "faulted",
+        };
+    }
+
+    /// Returns the terminal fault code when the state is [`Self::Faulted`].
+    #[must_use]
+    pub const fn fault_code(&self) -> std::option::Option<crate::ErrorCode> {
+        return match self {
+            Self::Faulted(code) => std::option::Option::Some(*code),
+            _ => std::option::Option::None,
+        };
+    }
+
+    /// Reports whether no later lifecycle transition is permitted.
+    #[must_use]
+    pub const fn is_terminal(&self) -> bool {
+        return matches!(self, Self::Stopped | Self::Faulted(_));
+    }
+}
+
+/// Operational health classification independent from Worker lifecycle phase.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[non_exhaustive]
+pub enum WorkerHealth {
+    /// Health has not yet been established or cannot currently be classified.
+    Unknown,
+    /// The Worker is operating within its expected healthy envelope.
+    Healthy,
+    /// The Worker is operating with a known degradation while service remains available.
+    Degraded,
+    /// The Worker is currently unable to satisfy its expected service health contract.
+    Unhealthy,
+}
+
+impl crate::WorkerHealth {
+    /// Returns the stable safe code for this health classification.
+    #[must_use]
+    pub const fn code(&self) -> &'static str {
+        return match self {
+            Self::Unknown => "unknown",
+            Self::Healthy => "healthy",
+            Self::Degraded => "degraded",
+            Self::Unhealthy => "unhealthy",
+        };
+    }
+}
+
+/// Minimal generic activity classification for a continuous Worker.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[non_exhaustive]
+pub enum WorkerActivity {
+    /// Activity has not yet been established or cannot currently be classified.
+    Unknown,
+    /// The Worker is alive but not currently processing concrete work.
+    Idle,
+    /// The Worker is currently processing concrete work.
+    Active,
+}
+
+impl crate::WorkerActivity {
+    /// Returns the stable safe code for this activity classification.
+    #[must_use]
+    pub const fn code(&self) -> &'static str {
+        return match self {
+            Self::Unknown => "unknown",
+            Self::Idle => "idle",
+            Self::Active => "active",
+        };
+    }
+}
+
+/// Passive owner of one Worker identity and its validated lifecycle state.
+#[derive(Eq, PartialEq)]
+pub struct WorkerLifecycle {
+    id: crate::WorkerId,
+    kind: crate::WorkerKindCode,
+    state: crate::WorkerState,
+}
+
+impl crate::WorkerLifecycle {
+    /// Creates one lifecycle in [`WorkerState::Created`] state.
+    #[must_use]
+    pub const fn new(id: crate::WorkerId, kind: crate::WorkerKindCode) -> Self {
+        return Self { id, kind, state: crate::WorkerState::Created };
+    }
+
+    /// Returns the logical Worker identity.
+    #[must_use]
+    pub const fn id(&self) -> &crate::WorkerId {
+        return &self.id;
+    }
+
+    /// Returns the stable Worker family code.
+    #[must_use]
+    pub const fn kind(&self) -> &crate::WorkerKindCode {
+        return &self.kind;
+    }
+
+    /// Returns the current lifecycle state.
+    #[must_use]
+    pub const fn state(&self) -> crate::WorkerState {
+        return self.state;
+    }
+
+    /// Begins initialization of a newly created Worker.
+    pub fn start(&mut self) -> crate::Result<()> {
+        return self.transition(crate::WorkerState::Starting);
+    }
+
+    /// Records that initialization completed and steady service is running.
+    pub fn mark_running(&mut self) -> crate::Result<()> {
+        return self.transition(crate::WorkerState::Running);
+    }
+
+    /// Records that a starting or running Worker observed cooperative stop intent.
+    pub fn mark_stopping(&mut self) -> crate::Result<()> {
+        return self.transition(crate::WorkerState::Stopping);
+    }
+
+    /// Records normal terminal stop after draining, or before initialization began.
+    pub fn mark_stopped(&mut self) -> crate::Result<()> {
+        return self.transition(crate::WorkerState::Stopped);
+    }
+
+    /// Records a terminal fault using only a stable KSP error code.
+    pub fn fault(&mut self, code: crate::ErrorCode) -> crate::Result<()> {
+        return self.transition(crate::WorkerState::Faulted(code));
+    }
+
+    fn transition(&mut self, target: crate::WorkerState) -> crate::Result<()> {
+        if !allowed_transition(self.state, target) {
+            return std::result::Result::Err(transition_error(self.state, target));
+        }
+        self.state = target;
+        return std::result::Result::Ok(());
+    }
+}
+
+impl std::fmt::Debug for crate::WorkerLifecycle {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        return formatter.debug_struct("WorkerLifecycle").field("id", &self.id).field("kind", &self.kind).field("state", &self.state).finish();
+    }
+}
+
+fn allowed_transition(source: crate::WorkerState, target: crate::WorkerState) -> bool {
+    return matches!(
+        (source, target),
+        (crate::WorkerState::Created, crate::WorkerState::Starting)
+            | (crate::WorkerState::Created, crate::WorkerState::Stopped)
+            | (crate::WorkerState::Starting, crate::WorkerState::Running)
+            | (crate::WorkerState::Starting, crate::WorkerState::Stopping)
+            | (crate::WorkerState::Starting, crate::WorkerState::Faulted(_))
+            | (crate::WorkerState::Running, crate::WorkerState::Stopping)
+            | (crate::WorkerState::Running, crate::WorkerState::Faulted(_))
+            | (crate::WorkerState::Stopping, crate::WorkerState::Stopped)
+            | (crate::WorkerState::Stopping, crate::WorkerState::Faulted(_))
+    );
+}
+
+fn transition_error(source: crate::WorkerState, target: crate::WorkerState) -> crate::Error {
+    return crate::Error::new(crate::ERROR_CODE_WORKER_TRANSITION_INVALID, "invalid Worker lifecycle transition")
+        .with_context("source_state", source.code())
+        .with_context("target_state", target.code());
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/lifecycle.rs"]
+mod tests;

crates/ksp-worker-api/src/snapshot.rs

@@ -0,0 +1,143 @@
+// file: crates/ksp-worker-api/src/snapshot.rs
+// version: 3
+
+/// Monotone sequence attached to one latest-value Worker snapshot stream.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct WorkerSnapshotSequence(u64);
+
+impl crate::WorkerSnapshotSequence {
+    /// Creates the initial sequence position for one Worker snapshot stream.
+    #[must_use]
+    pub const fn initial() -> Self {
+        return Self(0);
+    }
+
+    /// Returns the opaque numeric position carried by this sequence.
+    #[must_use]
+    pub const fn value(&self) -> u64 {
+        return self.0;
+    }
+
+    /// Advances the sequence exactly once or reports exhaustion without wrapping.
+    pub fn next(&self) -> crate::Result<Self> {
+        let next = match self.0.checked_add(1) {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => {
+                return std::result::Result::Err(
+                    crate::Error::new(crate::ERROR_CODE_WORKER_SNAPSHOT_SEQUENCE_EXHAUSTED, "Worker snapshot sequence exhausted")
+                        .with_context("sequence", self.0.to_string()),
+                );
+            },
+        };
+        return std::result::Result::Ok(Self(next));
+    }
+
+    /// Reports whether this sequence is strictly newer than an observed sequence.
+    #[must_use]
+    pub const fn is_after(&self, observed: Self) -> bool {
+        return self.0 > observed.0;
+    }
+
+    #[cfg(test)]
+    const fn exhausted_for_test() -> Self {
+        return Self(u64::MAX);
+    }
+}
+
+/// Fixed common latest-value snapshot exposed by every Worker implementation.
+#[derive(Clone, Eq, PartialEq)]
+pub struct WorkerSnapshot {
+    id: crate::WorkerId,
+    kind: crate::WorkerKindCode,
+    sequence: crate::WorkerSnapshotSequence,
+    state: crate::WorkerState,
+    health: crate::WorkerHealth,
+    activity: crate::WorkerActivity,
+}
+
+impl crate::WorkerSnapshot {
+    /// Creates one immutable common Worker snapshot from already validated values.
+    #[must_use]
+    pub const fn new(
+        id: crate::WorkerId,
+        kind: crate::WorkerKindCode,
+        sequence: crate::WorkerSnapshotSequence,
+        state: crate::WorkerState,
+        health: crate::WorkerHealth,
+        activity: crate::WorkerActivity,
+    ) -> Self {
+        return Self { id, kind, sequence, state, health, activity };
+    }
+
+    /// Returns the logical Worker identity.
+    #[must_use]
+    pub const fn id(&self) -> &crate::WorkerId {
+        return &self.id;
+    }
+
+    /// Returns the stable Worker family code.
+    #[must_use]
+    pub const fn kind(&self) -> &crate::WorkerKindCode {
+        return &self.kind;
+    }
+
+    /// Returns the monotone sequence of this latest value.
+    #[must_use]
+    pub const fn sequence(&self) -> crate::WorkerSnapshotSequence {
+        return self.sequence;
+    }
+
+    /// Returns the lifecycle state represented by this snapshot.
+    #[must_use]
+    pub const fn state(&self) -> crate::WorkerState {
+        return self.state;
+    }
+
+    /// Returns the operational health represented by this snapshot.
+    #[must_use]
+    pub const fn health(&self) -> crate::WorkerHealth {
+        return self.health;
+    }
+
+    /// Returns the generic activity represented by this snapshot.
+    #[must_use]
+    pub const fn activity(&self) -> crate::WorkerActivity {
+        return self.activity;
+    }
+}
+
+impl std::fmt::Debug for crate::WorkerSnapshot {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        return formatter
+            .debug_struct("WorkerSnapshot")
+            .field("id", &self.id)
+            .field("kind", &self.kind)
+            .field("sequence", &self.sequence)
+            .field("state", &self.state)
+            .field("health", &self.health)
+            .field("activity", &self.activity)
+            .finish();
+    }
+}
+
+/// Runtime-neutral future returned while observing a latest-value Worker snapshot source.
+pub type WorkerSnapshotFuture<'a> = std::pin::Pin<std::boxed::Box<dyn std::future::Future<Output = crate::WorkerSnapshot> + std::marker::Send + 'a>>;
+
+/// Runtime-neutral read and change-wait contract for one latest-value Worker snapshot stream.
+pub trait WorkerSnapshotSource: std::marker::Send + std::marker::Sync {
+    /// Returns the complete current common Worker snapshot without replaying prior updates.
+    #[must_use]
+    fn current(&self) -> crate::WorkerSnapshot;
+
+    /// Waits for a snapshot newer than `observed`, returning the complete current value after coalescing intermediate updates.
+    fn wait_for_change(&self, observed: crate::WorkerSnapshotSequence) -> crate::WorkerSnapshotFuture<'_>;
+}
+
+#[cfg(test)]
+fn exhausted_snapshot_sequence() -> crate::WorkerSnapshotSequence {
+    return crate::WorkerSnapshotSequence::exhausted_for_test();
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/snapshot.rs"]
+mod tests;

crates/ksp-worker-api/src/stop.rs

@@ -0,0 +1,44 @@
+// file: crates/ksp-worker-api/src/stop.rs
+// version: 2
+
+/// Runtime-neutral cloneable token carrying cooperative Worker stop intent.
+#[derive(Clone)]
+pub struct WorkerStopToken {
+    requested: std::sync::Arc<std::sync::atomic::AtomicBool>,
+}
+
+impl crate::WorkerStopToken {
+    /// Creates a token with no stop request.
+    #[must_use]
+    pub fn new() -> Self {
+        return Self { requested: std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)) };
+    }
+
+    /// Requests stop and returns `true` only for the first request shared by all clones.
+    #[must_use]
+    pub fn request_stop(&self) -> bool {
+        return !self.requested.swap(true, std::sync::atomic::Ordering::AcqRel);
+    }
+
+    /// Reports whether stop has been requested through any clone.
+    #[must_use]
+    pub fn is_stop_requested(&self) -> bool {
+        return self.requested.load(std::sync::atomic::Ordering::Acquire);
+    }
+}
+
+impl std::default::Default for crate::WorkerStopToken {
+    fn default() -> Self {
+        return Self::new();
+    }
+}
+
+impl std::fmt::Debug for crate::WorkerStopToken {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        return formatter.debug_struct("WorkerStopToken").field("stop_requested", &self.is_stop_requested()).finish();
+    }
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/stop.rs"]
+mod tests;

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

@@ -0,0 +1,128 @@
+// file: crates/ksp-worker-api/tests/dependency_boundary.rs
+// version: 3
+
+//! Dependency and runtime-neutrality canaries for the Worker API foundation.
+
+#[test]
+fn pre_002_manifest_has_exact_core_only_dependency_graph() {
+    let manifest = include_str!("../Cargo.toml");
+    assert!(!manifest.contains("[features]"));
+    assert!(!manifest.contains("[dev-dependencies]"));
+    assert!(!manifest.contains("[build-dependencies]"));
+    assert_eq!(manifest.matches("[dependencies]").count(), 1);
+    let dependencies_tail = manifest.split("[dependencies]").nth(1);
+    assert!(dependencies_tail.is_some());
+    let dependencies_tail = match dependencies_tail {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let dependencies = match dependencies_tail.split("[lints]").next() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    assert_eq!(manifest_dependency_names(dependencies), std::vec!["ksp-core-lib"]);
+    return;
+}
+
+#[test]
+fn pre_002_production_sources_forbid_job_runtime_domain_and_wire_dependencies() {
+    let sources = [
+        include_str!("../src/error.rs"),
+        include_str!("../src/identity.rs"),
+        include_str!("../src/lib.rs"),
+        include_str!("../src/lifecycle.rs"),
+        include_str!("../src/snapshot.rs"),
+        include_str!("../src/stop.rs"),
+    ];
+    for source in sources {
+        for forbidden in [
+            "ksp_config_lib::",
+            "ksp_interface_lib::",
+            "ksp_job_api::",
+            "ksp_logging_lib::",
+            "ksp_offchain_transport_lib::",
+            "ksp_onchain_transport_lib::",
+            "ksp_store_api::",
+            "ksp_store_lib::",
+            "reqwest::",
+            "serde::",
+            "serde_json::",
+            "solana_",
+            "tauri::",
+            "tokio::",
+            "tonic::",
+            concat!("tracing", "::"),
+        ] {
+            assert!(!source.contains(forbidden), "forbidden Worker API dependency path detected: {forbidden}");
+        }
+    }
+    return;
+}
+
+#[test]
+fn pre_002_fix_001_shared_visible_items_use_crate_root_facade_inside_owner_modules() {
+    let identity = include_str!("../src/identity.rs");
+    let lifecycle = include_str!("../src/lifecycle.rs");
+    let snapshot = include_str!("../src/snapshot.rs");
+    let stop = include_str!("../src/stop.rs");
+    for expected in [
+        "impl crate::WorkerId {",
+        "impl std::fmt::Debug for crate::WorkerId {",
+        "impl crate::WorkerKindCode {",
+        "impl std::fmt::Debug for crate::WorkerKindCode {",
+    ] {
+        assert!(identity.contains(expected), "missing crate-root Worker identity impl target: {expected}");
+    }
+    for expected in [
+        "impl crate::WorkerActivity {",
+        "impl crate::WorkerHealth {",
+        "impl crate::WorkerLifecycle {",
+        "impl crate::WorkerState {",
+        "impl std::fmt::Debug for crate::WorkerLifecycle {",
+    ] {
+        assert!(lifecycle.contains(expected), "missing crate-root Worker lifecycle impl target: {expected}");
+    }
+    for expected in ["impl crate::WorkerSnapshotSequence {", "impl crate::WorkerSnapshot {", "impl std::fmt::Debug for crate::WorkerSnapshot {"] {
+        assert!(snapshot.contains(expected), "missing crate-root Worker snapshot reference: {expected}");
+    }
+    for expected in [
+        "impl crate::WorkerStopToken {",
+        "impl std::default::Default for crate::WorkerStopToken {",
+        "impl std::fmt::Debug for crate::WorkerStopToken {",
+    ] {
+        assert!(stop.contains(expected), "missing crate-root Worker stop impl target: {expected}");
+    }
+    return;
+}
+
+#[test]
+fn pre_002_fix_002_private_tuple_constructor_stays_inside_owner_impl() {
+    let snapshot = include_str!("../src/snapshot.rs");
+    assert!(snapshot.contains("const fn exhausted_for_test() -> Self {"));
+    assert!(snapshot.contains("return Self(u64::MAX);"));
+    assert!(snapshot.contains("return crate::WorkerSnapshotSequence::exhausted_for_test();"));
+    assert!(!snapshot.contains("return crate::WorkerSnapshotSequence(u64::MAX);"));
+    return;
+}
+
+fn manifest_dependency_names(section: &str) -> std::vec::Vec<&str> {
+    let mut names = std::vec::Vec::new();
+    for line in section.lines() {
+        let content = match line.split('#').next() {
+            std::option::Option::Some(value) => value.trim(),
+            std::option::Option::None => continue,
+        };
+        if content.is_empty() {
+            continue;
+        }
+        let name = match content.split('=').next() {
+            std::option::Option::Some(value) => value.trim().trim_end_matches(".workspace"),
+            std::option::Option::None => continue,
+        };
+        if !name.is_empty() {
+            names.push(name);
+        }
+    }
+    names.sort_unstable();
+    return names;
+}

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

@@ -0,0 +1,52 @@
+// file: crates/ksp-worker-api/tests/public_api.rs
+// version: 1
+
+//! External-consumer canaries for the Worker API crate-root facade.
+
+#[test]
+fn pre_002_identity_lifecycle_stop_and_snapshot_are_consumable_from_crate_root() {
+    let id = ksp_worker_api::WorkerId::new("worker-public-001");
+    let kind = ksp_worker_api::WorkerKindCode::new("example_worker");
+    assert!(id.is_ok());
+    assert!(kind.is_ok());
+    let id = match id {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let kind = match kind {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let mut lifecycle = ksp_worker_api::WorkerLifecycle::new(id.clone(), kind.clone());
+    assert_eq!(lifecycle.state(), ksp_worker_api::WorkerState::Created);
+    assert!(lifecycle.start().is_ok());
+    assert!(lifecycle.mark_running().is_ok());
+    let stop = ksp_worker_api::WorkerStopToken::new();
+    assert!(stop.request_stop());
+    assert!(lifecycle.mark_stopping().is_ok());
+    let snapshot = ksp_worker_api::WorkerSnapshot::new(
+        id,
+        kind,
+        ksp_worker_api::WorkerSnapshotSequence::initial(),
+        lifecycle.state(),
+        ksp_worker_api::WorkerHealth::Healthy,
+        ksp_worker_api::WorkerActivity::Idle,
+    );
+    assert_eq!(snapshot.state(), ksp_worker_api::WorkerState::Stopping);
+    assert_eq!(snapshot.health(), ksp_worker_api::WorkerHealth::Healthy);
+    assert_eq!(snapshot.activity(), ksp_worker_api::WorkerActivity::Idle);
+    return;
+}
+
+#[test]
+fn pre_002_public_bounds_and_error_codes_are_exact() {
+    assert_eq!(ksp_worker_api::MAX_WORKER_ID_BYTES, 128);
+    assert_eq!(ksp_worker_api::MAX_WORKER_KIND_CODE_BYTES, 128);
+    assert_eq!(ksp_worker_api::ERROR_CODE_WORKER_ID_INVALID.domain(), "worker_api");
+    assert_eq!(ksp_worker_api::ERROR_CODE_WORKER_ID_INVALID.code(), "worker_id_invalid");
+    assert_eq!(ksp_worker_api::ERROR_CODE_WORKER_KIND_INVALID.domain(), "worker_api");
+    assert_eq!(ksp_worker_api::ERROR_CODE_WORKER_KIND_INVALID.code(), "worker_kind_invalid");
+    assert_eq!(ksp_worker_api::ERROR_CODE_WORKER_TRANSITION_INVALID.code(), "worker_transition_invalid");
+    assert_eq!(ksp_worker_api::ERROR_CODE_WORKER_SNAPSHOT_SEQUENCE_EXHAUSTED.code(), "worker_snapshot_sequence_exhausted");
+    return;
+}

crates/ksp-worker-api/tests/release_completeness.rs

@@ -0,0 +1,161 @@
+// file: crates/ksp-worker-api/tests/release_completeness.rs
+// version: 1
+
+//! Exact frozen-surface and domain-firewall canaries for `ksp-worker-api`.
+
+#[test]
+fn pre_003_crate_root_export_inventory_is_exact() {
+    let crate_root = include_str!("../src/lib.rs");
+    let mut actual = std::vec::Vec::new();
+    for line in crate_root.lines() {
+        let trimmed = line.trim();
+        if trimmed.starts_with("pub use ") {
+            actual.push(trimmed);
+        }
+    }
+    actual.sort_unstable();
+    let mut expected = std::vec![
+        "pub use self::error::ERROR_CODE_WORKER_ID_INVALID;",
+        "pub use self::error::ERROR_CODE_WORKER_KIND_INVALID;",
+        "pub use self::error::ERROR_CODE_WORKER_SNAPSHOT_SEQUENCE_EXHAUSTED;",
+        "pub use self::error::ERROR_CODE_WORKER_TRANSITION_INVALID;",
+        "pub use self::identity::MAX_WORKER_ID_BYTES;",
+        "pub use self::identity::MAX_WORKER_KIND_CODE_BYTES;",
+        "pub use self::identity::WorkerId;",
+        "pub use self::identity::WorkerKindCode;",
+        "pub use self::lifecycle::WorkerActivity;",
+        "pub use self::lifecycle::WorkerHealth;",
+        "pub use self::lifecycle::WorkerLifecycle;",
+        "pub use self::lifecycle::WorkerState;",
+        "pub use self::snapshot::WorkerSnapshot;",
+        "pub use self::snapshot::WorkerSnapshotFuture;",
+        "pub use self::snapshot::WorkerSnapshotSequence;",
+        "pub use self::snapshot::WorkerSnapshotSource;",
+        "pub use self::stop::WorkerStopToken;",
+        "pub use ksp_core_lib::Error;",
+        "pub use ksp_core_lib::ErrorCode;",
+        "pub use ksp_core_lib::ErrorContext;",
+        "pub use ksp_core_lib::Result;",
+    ];
+    expected.sort_unstable();
+    assert_eq!(actual, expected);
+    assert!(!crate_root.contains("pub mod "));
+    return;
+}
+
+#[test]
+fn pre_003_production_module_inventory_is_exact() -> std::io::Result<()> {
+    let source_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
+    let entries = match std::fs::read_dir(source_root) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let mut names = std::vec::Vec::new();
+    for entry in entries {
+        let entry = match entry {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let file_type = match entry.file_type() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        if !file_type.is_file() {
+            continue;
+        }
+        let name = match entry.file_name().into_string() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => continue,
+        };
+        if name.ends_with(".rs") {
+            names.push(name);
+        }
+    }
+    names.sort_unstable();
+    assert_eq!(names, std::vec!["error.rs", "identity.rs", "lib.rs", "lifecycle.rs", "snapshot.rs", "stop.rs"]);
+    return std::result::Result::Ok(());
+}
+
+#[test]
+fn pre_003_fixed_snapshot_shape_contains_only_common_worker_dimensions() {
+    let snapshot = include_str!("../src/snapshot.rs");
+    let struct_start = match snapshot.find("pub struct WorkerSnapshot {") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let after_start = &snapshot[struct_start..];
+    let struct_end = match after_start.find("\n}") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let definition = &after_start[..struct_end];
+    for required in ["id:", "kind:", "sequence:", "state:", "health:", "activity:"] {
+        assert!(definition.contains(required), "missing frozen Worker snapshot field: {required}");
+    }
+    for forbidden in ["String", "Vec<", "payload", "slot", "signature", "provider", "endpoint", "checkpoint", "backfill", "transaction"] {
+        assert!(!definition.contains(forbidden), "domain or arbitrary payload leaked into frozen Worker snapshot: {forbidden}");
+    }
+    let fields = definition.lines().filter(|line| {
+        let line = line.trim_start();
+        return line.starts_with("id:")
+            || line.starts_with("kind:")
+            || line.starts_with("sequence:")
+            || line.starts_with("state:")
+            || line.starts_with("health:")
+            || line.starts_with("activity:");
+    });
+    assert_eq!(fields.count(), 6);
+    return;
+}
+
+#[test]
+fn pre_003_surface_remains_runtime_neutral_job_independent_and_domain_free() {
+    let sources = [
+        include_str!("../src/error.rs"),
+        include_str!("../src/identity.rs"),
+        include_str!("../src/lib.rs"),
+        include_str!("../src/lifecycle.rs"),
+        include_str!("../src/snapshot.rs"),
+        include_str!("../src/stop.rs"),
+    ];
+    for source in sources {
+        for forbidden in [
+            "Backfill",
+            "RawTransaction",
+            "WorkerHandle",
+            "checkpoint",
+            "endpoint",
+            "futures::",
+            "futures_util::",
+            "ksp_config_lib::",
+            "ksp_interface_lib::",
+            "ksp_job_api::",
+            "ksp_logging_lib::",
+            "ksp_offchain_transport_lib::",
+            "ksp_onchain_transport_lib::",
+            "ksp_store_api::",
+            "ksp_store_lib::",
+            "provider",
+            "reqwest::",
+            "serde::",
+            "serde_json::",
+            "slot",
+            "solana_",
+            "tauri::",
+            "tokio::",
+            "tonic::",
+            concat!("tracing", "::"),
+        ] {
+            assert!(!source.contains(forbidden), "forbidden frozen Worker API concern detected: {forbidden}");
+        }
+    }
+    let snapshot = include_str!("../src/snapshot.rs");
+    assert!(snapshot.contains("pub trait WorkerSnapshotSource: std::marker::Send + std::marker::Sync"));
+    assert!(snapshot.contains("std::future::Future"));
+    assert!(!snapshot.contains("std::sync::mpsc"));
+    assert!(!snapshot.contains("VecDeque"));
+    let lifecycle = include_str!("../src/lifecycle.rs");
+    assert!(lifecycle.contains("#[derive(Eq, PartialEq)]\npub struct WorkerLifecycle"));
+    assert!(!lifecycle.contains("#[derive(Clone, Eq, PartialEq)]\npub struct WorkerLifecycle"));
+    return;
+}

crates/ksp-worker-api/tests/security_hardening.rs

@@ -0,0 +1,185 @@
+// file: crates/ksp-worker-api/tests/security_hardening.rs
+// version: 1
+
+//! Adversarial lifecycle, stop and redaction canaries for the frozen Worker API.
+
+const HOSTILE_MARKER: &str = "WORKER-IDENTITY-SECRET-CANARY";
+const TEST_FAULT: ksp_worker_api::ErrorCode = ksp_worker_api::ErrorCode::new("worker_test", "fault");
+
+fn running_lifecycle(id_value: &str) -> std::option::Option<ksp_worker_api::WorkerLifecycle> {
+    let id = match ksp_worker_api::WorkerId::new(id_value) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let kind = match ksp_worker_api::WorkerKindCode::new("continuous_worker") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let mut lifecycle = ksp_worker_api::WorkerLifecycle::new(id, kind);
+    if lifecycle.start().is_err() {
+        return std::option::Option::None;
+    }
+    if lifecycle.mark_running().is_err() {
+        return std::option::Option::None;
+    }
+    return std::option::Option::Some(lifecycle);
+}
+
+fn assert_all_mutators_reject(lifecycle: &mut ksp_worker_api::WorkerLifecycle, terminal: ksp_worker_api::WorkerState) {
+    assert!(lifecycle.start().is_err());
+    assert!(lifecycle.mark_running().is_err());
+    assert!(lifecycle.mark_stopping().is_err());
+    assert!(lifecycle.mark_stopped().is_err());
+    assert!(lifecycle.fault(TEST_FAULT).is_err());
+    assert_eq!(lifecycle.state(), terminal);
+    return;
+}
+
+#[test]
+fn pre_003_worker_identity_lifecycle_and_snapshot_debug_redact_hostile_identity() {
+    let lifecycle = running_lifecycle(HOSTILE_MARKER);
+    assert!(lifecycle.is_some());
+    let lifecycle = match lifecycle {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let id = lifecycle.id();
+    assert_eq!(std::format!("{id:?}"), "WorkerId(..)");
+    let lifecycle_debug = std::format!("{lifecycle:?}");
+    assert!(lifecycle_debug.contains("WorkerLifecycle"));
+    assert!(lifecycle_debug.contains("continuous_worker"));
+    assert!(lifecycle_debug.contains("Running"));
+    assert!(!lifecycle_debug.contains(HOSTILE_MARKER));
+    let snapshot = ksp_worker_api::WorkerSnapshot::new(
+        lifecycle.id().clone(),
+        lifecycle.kind().clone(),
+        ksp_worker_api::WorkerSnapshotSequence::initial(),
+        lifecycle.state(),
+        ksp_worker_api::WorkerHealth::Healthy,
+        ksp_worker_api::WorkerActivity::Active,
+    );
+    let snapshot_debug = std::format!("{snapshot:?}");
+    assert!(snapshot_debug.contains("WorkerSnapshot"));
+    assert!(snapshot_debug.contains("continuous_worker"));
+    assert!(snapshot_debug.contains("Healthy"));
+    assert!(snapshot_debug.contains("Active"));
+    assert!(!snapshot_debug.contains(HOSTILE_MARKER));
+    return;
+}
+
+#[test]
+fn pre_003_identity_errors_never_echo_hostile_values() {
+    let hostile = "WORKER-SECRET/CANARY";
+    let rejected = ksp_worker_api::WorkerId::new(hostile);
+    assert!(rejected.is_err());
+    let error = match rejected {
+        std::result::Result::Err(value) => value,
+        std::result::Result::Ok(_) => return,
+    };
+    assert_eq!(error.code(), ksp_worker_api::ERROR_CODE_WORKER_ID_INVALID);
+    assert!(!std::format!("{error}").contains(hostile));
+    assert!(!std::format!("{error:?}").contains(hostile));
+    for context in error.context() {
+        assert!(!context.value().contains(hostile));
+    }
+    return;
+}
+
+#[test]
+fn pre_003_stopped_and_faulted_are_immutable_under_all_public_mutators() {
+    let id = match ksp_worker_api::WorkerId::new("terminal-created") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let kind = match ksp_worker_api::WorkerKindCode::new("terminal_worker") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let mut stopped = ksp_worker_api::WorkerLifecycle::new(id, kind);
+    assert!(stopped.mark_stopped().is_ok());
+    assert_all_mutators_reject(&mut stopped, ksp_worker_api::WorkerState::Stopped);
+    let faulted = running_lifecycle("terminal-faulted");
+    assert!(faulted.is_some());
+    let mut faulted = match faulted {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    assert!(faulted.fault(TEST_FAULT).is_ok());
+    assert_all_mutators_reject(&mut faulted, ksp_worker_api::WorkerState::Faulted(TEST_FAULT));
+    return;
+}
+
+#[test]
+fn pre_003_stop_fault_terminal_orders_are_first_valid_terminal_wins() {
+    let direct_fault = running_lifecycle("race-direct-fault");
+    assert!(direct_fault.is_some());
+    let mut direct_fault = match direct_fault {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    assert!(direct_fault.fault(TEST_FAULT).is_ok());
+    assert!(direct_fault.mark_stopping().is_err());
+    assert_eq!(direct_fault.state(), ksp_worker_api::WorkerState::Faulted(TEST_FAULT));
+    let stopping_fault = running_lifecycle("race-stopping-fault");
+    assert!(stopping_fault.is_some());
+    let mut stopping_fault = match stopping_fault {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    assert!(stopping_fault.mark_stopping().is_ok());
+    assert!(stopping_fault.fault(TEST_FAULT).is_ok());
+    assert!(stopping_fault.mark_stopped().is_err());
+    assert_eq!(stopping_fault.state(), ksp_worker_api::WorkerState::Faulted(TEST_FAULT));
+    let stopping_stopped = running_lifecycle("race-stopping-stopped");
+    assert!(stopping_stopped.is_some());
+    let mut stopping_stopped = match stopping_stopped {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    assert!(stopping_stopped.mark_stopping().is_ok());
+    assert!(stopping_stopped.mark_stopped().is_ok());
+    assert!(stopping_stopped.fault(TEST_FAULT).is_err());
+    assert_eq!(stopping_stopped.state(), ksp_worker_api::WorkerState::Stopped);
+    return;
+}
+
+#[test]
+fn pre_003_stop_token_is_send_sync_cross_thread_and_cannot_reanimate_terminal_lifecycle() {
+    fn require_send_sync<T: std::marker::Send + std::marker::Sync>() {}
+    require_send_sync::<ksp_worker_api::WorkerStopToken>();
+    let lifecycle = running_lifecycle("cross-thread-stop");
+    assert!(lifecycle.is_some());
+    let mut lifecycle = match lifecycle {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    assert!(lifecycle.fault(TEST_FAULT).is_ok());
+    let token = ksp_worker_api::WorkerStopToken::new();
+    let worker_token = token.clone();
+    let thread = std::thread::spawn(move || return worker_token.request_stop());
+    let first = match thread.join() {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert!(first);
+    assert!(token.is_stop_requested());
+    assert!(!token.request_stop());
+    assert!(lifecycle.mark_stopping().is_err());
+    assert_eq!(lifecycle.state(), ksp_worker_api::WorkerState::Faulted(TEST_FAULT));
+    return;
+}
+
+#[test]
+fn pre_003_public_worker_primitives_keep_promised_send_sync_contracts() {
+    fn require_send_sync<T: std::marker::Send + std::marker::Sync>() {}
+    require_send_sync::<ksp_worker_api::WorkerId>();
+    require_send_sync::<ksp_worker_api::WorkerKindCode>();
+    require_send_sync::<ksp_worker_api::WorkerState>();
+    require_send_sync::<ksp_worker_api::WorkerHealth>();
+    require_send_sync::<ksp_worker_api::WorkerActivity>();
+    require_send_sync::<ksp_worker_api::WorkerLifecycle>();
+    require_send_sync::<ksp_worker_api::WorkerSnapshotSequence>();
+    require_send_sync::<ksp_worker_api::WorkerSnapshot>();
+    require_send_sync::<ksp_worker_api::WorkerStopToken>();
+    return;
+}

crates/ksp-worker-api/tests/snapshot_source.rs

@@ -0,0 +1,219 @@
+// file: crates/ksp-worker-api/tests/snapshot_source.rs
+// version: 1
+
+//! External std-only latest-value source, object-safety and resynchronization canaries.
+
+#[derive(Clone)]
+struct TestSnapshotSource {
+    state: std::sync::Arc<TestState>,
+}
+
+struct TestState {
+    current: std::sync::Mutex<TestInner>,
+}
+
+struct TestInner {
+    snapshot: ksp_worker_api::WorkerSnapshot,
+    waiters: std::vec::Vec<std::task::Waker>,
+}
+
+impl TestSnapshotSource {
+    fn new(snapshot: ksp_worker_api::WorkerSnapshot) -> Self {
+        return Self {
+            state: std::sync::Arc::new(TestState { current: std::sync::Mutex::new(TestInner { snapshot, waiters: std::vec::Vec::new() }) }),
+        };
+    }
+
+    fn publish(&self, state: ksp_worker_api::WorkerState, health: ksp_worker_api::WorkerHealth, activity: ksp_worker_api::WorkerActivity) -> bool {
+        let mut current = match self.state.current.lock() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(poisoned) => poisoned.into_inner(),
+        };
+        let sequence = match current.snapshot.sequence().next() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => return false,
+        };
+        let id = current.snapshot.id().clone();
+        let kind = current.snapshot.kind().clone();
+        current.snapshot = ksp_worker_api::WorkerSnapshot::new(id, kind, sequence, state, health, activity);
+        let waiters = std::mem::take(&mut current.waiters);
+        std::mem::drop(current);
+        for waiter in waiters {
+            waiter.wake();
+        }
+        return true;
+    }
+}
+
+struct TestWaitFuture<'a> {
+    source: &'a TestSnapshotSource,
+    observed: ksp_worker_api::WorkerSnapshotSequence,
+}
+
+impl std::future::Future for TestWaitFuture<'_> {
+    type Output = ksp_worker_api::WorkerSnapshot;
+
+    fn poll(self: std::pin::Pin<&mut Self>, context: &mut std::task::Context<'_>) -> std::task::Poll<Self::Output> {
+        let mut current = match self.source.state.current.lock() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(poisoned) => poisoned.into_inner(),
+        };
+        if current.snapshot.sequence().is_after(self.observed) {
+            return std::task::Poll::Ready(current.snapshot.clone());
+        }
+        if !current.waiters.iter().any(|registered| return registered.will_wake(context.waker())) {
+            current.waiters.push(context.waker().clone());
+        }
+        return std::task::Poll::Pending;
+    }
+}
+
+impl ksp_worker_api::WorkerSnapshotSource for TestSnapshotSource {
+    fn current(&self) -> ksp_worker_api::WorkerSnapshot {
+        let current = match self.state.current.lock() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(poisoned) => poisoned.into_inner(),
+        };
+        return current.snapshot.clone();
+    }
+
+    fn wait_for_change(&self, observed: ksp_worker_api::WorkerSnapshotSequence) -> ksp_worker_api::WorkerSnapshotFuture<'_> {
+        return std::boxed::Box::pin(TestWaitFuture { source: self, observed });
+    }
+}
+
+struct WakeProbe {
+    woken: std::sync::atomic::AtomicBool,
+}
+
+impl WakeProbe {
+    fn new() -> Self {
+        return Self { woken: std::sync::atomic::AtomicBool::new(false) };
+    }
+
+    fn is_woken(&self) -> bool {
+        return self.woken.load(std::sync::atomic::Ordering::Acquire);
+    }
+}
+
+impl std::task::Wake for WakeProbe {
+    fn wake(self: std::sync::Arc<Self>) {
+        self.woken.store(true, std::sync::atomic::Ordering::Release);
+        return;
+    }
+}
+
+fn poll_snapshot(future: &mut ksp_worker_api::WorkerSnapshotFuture<'_>, wake: &std::sync::Arc<WakeProbe>) -> std::task::Poll<ksp_worker_api::WorkerSnapshot> {
+    let waker = std::task::Waker::from(wake.clone());
+    let mut context = std::task::Context::from_waker(&waker);
+    return std::future::Future::poll(future.as_mut(), &mut context);
+}
+
+fn initial_snapshot() -> std::option::Option<ksp_worker_api::WorkerSnapshot> {
+    let id = match ksp_worker_api::WorkerId::new("external-source-001") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let kind = match ksp_worker_api::WorkerKindCode::new("external_test_worker") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    return std::option::Option::Some(ksp_worker_api::WorkerSnapshot::new(
+        id,
+        kind,
+        ksp_worker_api::WorkerSnapshotSequence::initial(),
+        ksp_worker_api::WorkerState::Running,
+        ksp_worker_api::WorkerHealth::Healthy,
+        ksp_worker_api::WorkerActivity::Idle,
+    ));
+}
+
+#[test]
+fn pre_003_snapshot_source_is_object_safe_send_sync_and_externally_implementable() {
+    fn require_send_sync<T: std::marker::Send + std::marker::Sync>() {}
+    require_send_sync::<TestSnapshotSource>();
+    let snapshot = initial_snapshot();
+    assert!(snapshot.is_some());
+    let source = match snapshot {
+        std::option::Option::Some(value) => TestSnapshotSource::new(value),
+        std::option::Option::None => return,
+    };
+    let object: &dyn ksp_worker_api::WorkerSnapshotSource = &source;
+    let current = object.current();
+    assert_eq!(current.sequence().value(), 0);
+    let mut wait = object.wait_for_change(current.sequence());
+    fn require_send<T: std::marker::Send>(_: &T) {}
+    require_send(&wait);
+    let wake = std::sync::Arc::new(WakeProbe::new());
+    assert!(matches!(poll_snapshot(&mut wait, &wake), std::task::Poll::Pending));
+    assert!(source.publish(ksp_worker_api::WorkerState::Running, ksp_worker_api::WorkerHealth::Healthy, ksp_worker_api::WorkerActivity::Active));
+    assert!(wake.is_woken());
+    let changed = poll_snapshot(&mut wait, &wake);
+    assert!(matches!(changed, std::task::Poll::Ready(_)));
+    return;
+}
+
+#[test]
+fn pre_003_slow_and_independent_listeners_coalesce_to_latest_value() {
+    let snapshot = initial_snapshot();
+    assert!(snapshot.is_some());
+    let source = match snapshot {
+        std::option::Option::Some(value) => TestSnapshotSource::new(value),
+        std::option::Option::None => return,
+    };
+    let observed = ksp_worker_api::WorkerSnapshotSource::current(&source).sequence();
+    let mut slow = ksp_worker_api::WorkerSnapshotSource::wait_for_change(&source, observed);
+    let mut fast = ksp_worker_api::WorkerSnapshotSource::wait_for_change(&source, observed);
+    let slow_wake = std::sync::Arc::new(WakeProbe::new());
+    let fast_wake = std::sync::Arc::new(WakeProbe::new());
+    assert!(matches!(poll_snapshot(&mut slow, &slow_wake), std::task::Poll::Pending));
+    assert!(matches!(poll_snapshot(&mut fast, &fast_wake), std::task::Poll::Pending));
+    assert!(source.publish(ksp_worker_api::WorkerState::Running, ksp_worker_api::WorkerHealth::Degraded, ksp_worker_api::WorkerActivity::Active));
+    assert!(slow_wake.is_woken());
+    assert!(fast_wake.is_woken());
+    let fast_value = match poll_snapshot(&mut fast, &fast_wake) {
+        std::task::Poll::Ready(value) => value,
+        std::task::Poll::Pending => return,
+    };
+    assert_eq!(fast_value.sequence().value(), 1);
+    assert_eq!(fast_value.health(), ksp_worker_api::WorkerHealth::Degraded);
+    assert!(source.publish(ksp_worker_api::WorkerState::Running, ksp_worker_api::WorkerHealth::Healthy, ksp_worker_api::WorkerActivity::Idle));
+    let slow_value = match poll_snapshot(&mut slow, &slow_wake) {
+        std::task::Poll::Ready(value) => value,
+        std::task::Poll::Pending => return,
+    };
+    assert_eq!(slow_value.sequence().value(), 2);
+    assert_eq!(slow_value.health(), ksp_worker_api::WorkerHealth::Healthy);
+    assert_eq!(slow_value.activity(), ksp_worker_api::WorkerActivity::Idle);
+    return;
+}
+
+#[test]
+fn pre_003_late_listener_resynchronizes_and_terminal_snapshot_remains_current() {
+    let snapshot = initial_snapshot();
+    assert!(snapshot.is_some());
+    let source = match snapshot {
+        std::option::Option::Some(value) => TestSnapshotSource::new(value),
+        std::option::Option::None => return,
+    };
+    assert!(source.publish(ksp_worker_api::WorkerState::Running, ksp_worker_api::WorkerHealth::Degraded, ksp_worker_api::WorkerActivity::Active));
+    assert!(source.publish(ksp_worker_api::WorkerState::Stopping, ksp_worker_api::WorkerHealth::Healthy, ksp_worker_api::WorkerActivity::Idle));
+    let current = ksp_worker_api::WorkerSnapshotSource::current(&source);
+    assert_eq!(current.sequence().value(), 2);
+    assert_eq!(current.state(), ksp_worker_api::WorkerState::Stopping);
+    let mut wait = ksp_worker_api::WorkerSnapshotSource::wait_for_change(&source, current.sequence());
+    let wake = std::sync::Arc::new(WakeProbe::new());
+    assert!(matches!(poll_snapshot(&mut wait, &wake), std::task::Poll::Pending));
+    assert!(source.publish(ksp_worker_api::WorkerState::Stopped, ksp_worker_api::WorkerHealth::Healthy, ksp_worker_api::WorkerActivity::Idle));
+    assert!(wake.is_woken());
+    let terminal = match poll_snapshot(&mut wait, &wake) {
+        std::task::Poll::Ready(value) => value,
+        std::task::Poll::Pending => return,
+    };
+    assert_eq!(terminal.sequence().value(), 3);
+    assert_eq!(terminal.state(), ksp_worker_api::WorkerState::Stopped);
+    assert!(terminal.state().is_terminal());
+    let retained = ksp_worker_api::WorkerSnapshotSource::current(&source);
+    assert_eq!(retained, terminal);
+    return;
+}

crates/ksp-worker-api/unit_tests/identity.rs

@@ -0,0 +1,64 @@
+// file: crates/ksp-worker-api/unit_tests/identity.rs
+// version: 1
+
+#[test]
+fn pre_002_identity_accepts_safe_codes_at_exact_bounds() {
+    let worker_id = crate::WorkerId::new("a".repeat(crate::MAX_WORKER_ID_BYTES));
+    let kind = crate::WorkerKindCode::new("continuous.raw:example-1");
+    assert!(worker_id.is_ok());
+    assert!(kind.is_ok());
+    let worker_id = match worker_id {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let kind = match kind {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(worker_id.as_str().len(), crate::MAX_WORKER_ID_BYTES);
+    assert_eq!(kind.as_str(), "continuous.raw:example-1");
+    return;
+}
+
+#[test]
+fn pre_002_identity_rejects_empty_oversized_and_unsafe_values() {
+    for value in [
+        std::string::String::new(),
+        "a".repeat(crate::MAX_WORKER_ID_BYTES + 1),
+        "unsafe/value".to_string(),
+        "unsafe\\value".to_string(),
+        "space value".to_string(),
+        "unicode-é".to_string(),
+    ] {
+        let rejected = crate::WorkerId::new(value);
+        assert!(rejected.is_err());
+        let error = match rejected {
+            std::result::Result::Err(value) => value,
+            std::result::Result::Ok(_) => continue,
+        };
+        assert_eq!(error.code(), crate::ERROR_CODE_WORKER_ID_INVALID);
+        assert_eq!(error.context().len(), 1);
+        assert_eq!(error.context()[0].key(), "field");
+        assert_eq!(error.context()[0].value(), "worker_id");
+    }
+    for value in [std::string::String::new(), "b".repeat(crate::MAX_WORKER_KIND_CODE_BYTES + 1), "worker kind".to_string()] {
+        let rejected = crate::WorkerKindCode::new(value);
+        assert!(rejected.is_err());
+        let error = match rejected {
+            std::result::Result::Err(value) => value,
+            std::result::Result::Ok(_) => continue,
+        };
+        assert_eq!(error.code(), crate::ERROR_CODE_WORKER_KIND_INVALID);
+        assert_eq!(error.context()[0].value(), "worker_kind");
+    }
+    return;
+}
+
+#[test]
+fn pre_002_private_validator_uses_exact_safe_code_alphabet() {
+    assert!(super::valid_worker_code("AZaz09_.:-", 10));
+    for rejected in ["slash/value", "back\\slash", "space value", "line\nbreak", "é"] {
+        assert!(!super::valid_worker_code(rejected, crate::MAX_WORKER_ID_BYTES));
+    }
+    return;
+}

crates/ksp-worker-api/unit_tests/lifecycle.rs

@@ -0,0 +1,151 @@
+// file: crates/ksp-worker-api/unit_tests/lifecycle.rs
+// version: 1
+
+const TEST_FAULT: crate::ErrorCode = crate::ErrorCode::new("worker_test", "fault");
+
+fn new_lifecycle() -> std::option::Option<crate::WorkerLifecycle> {
+    let id = match crate::WorkerId::new("worker-001") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    let kind = match crate::WorkerKindCode::new("continuous_worker") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::option::Option::None,
+    };
+    return std::option::Option::Some(crate::WorkerLifecycle::new(id, kind));
+}
+
+#[test]
+fn pre_002_lifecycle_accepts_every_planned_terminal_path() {
+    let lifecycle = new_lifecycle();
+    assert!(lifecycle.is_some());
+    let mut lifecycle = match lifecycle {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    assert!(lifecycle.mark_stopped().is_ok());
+    assert_eq!(lifecycle.state(), crate::WorkerState::Stopped);
+    assert!(lifecycle.state().is_terminal());
+    let lifecycle = new_lifecycle();
+    assert!(lifecycle.is_some());
+    let mut lifecycle = match lifecycle {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    assert!(lifecycle.start().is_ok());
+    assert!(lifecycle.mark_running().is_ok());
+    assert!(lifecycle.mark_stopping().is_ok());
+    assert!(lifecycle.mark_stopped().is_ok());
+    assert_eq!(lifecycle.state(), crate::WorkerState::Stopped);
+    for fault_from_running in [false, true] {
+        let lifecycle = new_lifecycle();
+        assert!(lifecycle.is_some());
+        let mut lifecycle = match lifecycle {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => return,
+        };
+        assert!(lifecycle.start().is_ok());
+        if fault_from_running {
+            assert!(lifecycle.mark_running().is_ok());
+        }
+        assert!(lifecycle.fault(TEST_FAULT).is_ok());
+        assert_eq!(lifecycle.state(), crate::WorkerState::Faulted(TEST_FAULT));
+        assert_eq!(lifecycle.state().fault_code(), std::option::Option::Some(TEST_FAULT));
+    }
+    return;
+}
+
+#[test]
+fn pre_002_stopping_allows_normal_stop_or_fault() {
+    for terminal in [crate::WorkerState::Stopped, crate::WorkerState::Faulted(TEST_FAULT)] {
+        let lifecycle = new_lifecycle();
+        assert!(lifecycle.is_some());
+        let mut lifecycle = match lifecycle {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => return,
+        };
+        assert!(lifecycle.start().is_ok());
+        assert!(lifecycle.mark_running().is_ok());
+        assert!(lifecycle.mark_stopping().is_ok());
+        let result = match terminal {
+            crate::WorkerState::Stopped => lifecycle.mark_stopped(),
+            crate::WorkerState::Faulted(code) => lifecycle.fault(code),
+            _ => return,
+        };
+        assert!(result.is_ok());
+        assert_eq!(lifecycle.state(), terminal);
+    }
+    return;
+}
+
+#[test]
+fn pre_002_invalid_transition_preserves_source_state_and_reports_safe_context() {
+    let lifecycle = new_lifecycle();
+    assert!(lifecycle.is_some());
+    let mut lifecycle = match lifecycle {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let rejected = lifecycle.mark_running();
+    assert!(rejected.is_err());
+    assert_eq!(lifecycle.state(), crate::WorkerState::Created);
+    let error = match rejected {
+        std::result::Result::Err(value) => value,
+        std::result::Result::Ok(_) => return,
+    };
+    assert_eq!(error.code(), crate::ERROR_CODE_WORKER_TRANSITION_INVALID);
+    assert_eq!(error.context().len(), 2);
+    assert_eq!(error.context()[0].key(), "source_state");
+    assert_eq!(error.context()[0].value(), "created");
+    assert_eq!(error.context()[1].key(), "target_state");
+    assert_eq!(error.context()[1].value(), "running");
+    return;
+}
+
+#[test]
+fn pre_002_transition_matrix_is_exact() {
+    let states = [
+        crate::WorkerState::Created,
+        crate::WorkerState::Starting,
+        crate::WorkerState::Running,
+        crate::WorkerState::Stopping,
+        crate::WorkerState::Stopped,
+        crate::WorkerState::Faulted(TEST_FAULT),
+    ];
+    for source in states {
+        for target in states {
+            let expected = matches!(
+                (source, target),
+                (crate::WorkerState::Created, crate::WorkerState::Starting)
+                    | (crate::WorkerState::Created, crate::WorkerState::Stopped)
+                    | (crate::WorkerState::Starting, crate::WorkerState::Running)
+                    | (crate::WorkerState::Starting, crate::WorkerState::Stopping)
+                    | (crate::WorkerState::Starting, crate::WorkerState::Faulted(_))
+                    | (crate::WorkerState::Running, crate::WorkerState::Stopping)
+                    | (crate::WorkerState::Running, crate::WorkerState::Faulted(_))
+                    | (crate::WorkerState::Stopping, crate::WorkerState::Stopped)
+                    | (crate::WorkerState::Stopping, crate::WorkerState::Faulted(_))
+            );
+            assert_eq!(super::allowed_transition(source, target), expected, "unexpected transition matrix cell: {source:?} -> {target:?}");
+        }
+    }
+    return;
+}
+
+#[test]
+fn pre_002_health_activity_and_state_codes_are_stable() {
+    assert_eq!(crate::WorkerState::Created.code(), "created");
+    assert_eq!(crate::WorkerState::Starting.code(), "starting");
+    assert_eq!(crate::WorkerState::Running.code(), "running");
+    assert_eq!(crate::WorkerState::Stopping.code(), "stopping");
+    assert_eq!(crate::WorkerState::Stopped.code(), "stopped");
+    assert_eq!(crate::WorkerState::Faulted(TEST_FAULT).code(), "faulted");
+    assert_eq!(crate::WorkerHealth::Unknown.code(), "unknown");
+    assert_eq!(crate::WorkerHealth::Healthy.code(), "healthy");
+    assert_eq!(crate::WorkerHealth::Degraded.code(), "degraded");
+    assert_eq!(crate::WorkerHealth::Unhealthy.code(), "unhealthy");
+    assert_eq!(crate::WorkerActivity::Unknown.code(), "unknown");
+    assert_eq!(crate::WorkerActivity::Idle.code(), "idle");
+    assert_eq!(crate::WorkerActivity::Active.code(), "active");
+    return;
+}

crates/ksp-worker-api/unit_tests/snapshot.rs

@@ -0,0 +1,66 @@
+// file: crates/ksp-worker-api/unit_tests/snapshot.rs
+// version: 1
+
+#[test]
+fn pre_002_snapshot_sequence_advances_strictly_and_orders_positions() {
+    let first = crate::WorkerSnapshotSequence::initial();
+    assert_eq!(first.value(), 0);
+    let second = first.next();
+    assert!(second.is_ok());
+    let second = match second {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(second.value(), 1);
+    assert!(second.is_after(first));
+    assert!(!first.is_after(second));
+    assert!(!first.is_after(first));
+    return;
+}
+
+#[test]
+fn pre_002_snapshot_sequence_exhaustion_is_explicit_and_non_wrapping() {
+    let exhausted = super::exhausted_snapshot_sequence();
+    let result = exhausted.next();
+    assert!(result.is_err());
+    let error = match result {
+        std::result::Result::Err(value) => value,
+        std::result::Result::Ok(_) => return,
+    };
+    assert_eq!(error.code(), crate::ERROR_CODE_WORKER_SNAPSHOT_SEQUENCE_EXHAUSTED);
+    assert_eq!(error.context().len(), 1);
+    assert_eq!(error.context()[0].key(), "sequence");
+    assert_eq!(error.context()[0].value(), u64::MAX.to_string());
+    return;
+}
+
+#[test]
+fn pre_002_snapshot_preserves_exact_common_dimensions() {
+    let id = crate::WorkerId::new("worker-001");
+    let kind = crate::WorkerKindCode::new("example_worker");
+    assert!(id.is_ok());
+    assert!(kind.is_ok());
+    let id = match id {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let kind = match kind {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let snapshot = crate::WorkerSnapshot::new(
+        id,
+        kind,
+        crate::WorkerSnapshotSequence::initial(),
+        crate::WorkerState::Running,
+        crate::WorkerHealth::Healthy,
+        crate::WorkerActivity::Active,
+    );
+    assert_eq!(snapshot.id().as_str(), "worker-001");
+    assert_eq!(snapshot.kind().as_str(), "example_worker");
+    assert_eq!(snapshot.sequence().value(), 0);
+    assert_eq!(snapshot.state(), crate::WorkerState::Running);
+    assert_eq!(snapshot.health(), crate::WorkerHealth::Healthy);
+    assert_eq!(snapshot.activity(), crate::WorkerActivity::Active);
+    return;
+}

crates/ksp-worker-api/unit_tests/stop.rs

@@ -0,0 +1,22 @@
+// file: crates/ksp-worker-api/unit_tests/stop.rs
+// version: 1
+
+#[test]
+fn pre_002_stop_token_is_shared_and_idempotent() {
+    let token = crate::WorkerStopToken::new();
+    let clone = token.clone();
+    assert!(!token.is_stop_requested());
+    assert!(clone.request_stop());
+    assert!(token.is_stop_requested());
+    assert!(!token.request_stop());
+    assert!(!clone.request_stop());
+    return;
+}
+
+#[test]
+fn pre_002_default_stop_token_starts_without_stop_request() {
+    let token = crate::WorkerStopToken::default();
+    assert!(!token.is_stop_requested());
+    assert_eq!(std::format!("{token:?}"), "WorkerStopToken { stop_requested: false }");
+    return;
+}

deltas/0.3.10/pre.001.md

@@ -0,0 +1,263 @@
+<!-- file: deltas/0.3.10/pre.001.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.10-pre.001 — audit/sizing RAW Transaction + Worker ingest
+
+## Base
+
+```text
+archive : khadhroony-solana-project-v0.3.9.zip
+SHA-256 : 41ef2589a11410aabfb329d387f0008e116006da60ada0802e5f72bc30d3466f
+ZIP bytes : 7859118
+ZIP entries : 1855
+unzip -t : PASS
+workspace members : 19
+workspace.package.version base : 0.3.9
+```
+
+Le ZIP a été contrôlé sans path traversal/entrée absolue, symlink, `.git/`, `target/`, `node_modules/`, `Cargo.lock`, `.env` ou fichier de clé privée détecté.
+
+## Type de livraison
+
+```text
+ksp-general-0.3.10-pre.001.zip
+```
+
+Le type `general` est obligatoire parce que `Cargo.toml` racine est synchronisé vers `0.3.10-pre.1` par `VER-ID-009`. L’archive d’échange ne doit contenir que les fichiers ajoutés/modifiés et le delta, conformément à `VER-ARCHIVE-004`.
+
+## Baseline exécutée avant modification
+
+```text
+python3 scripts/audit_rust_workspace_rules.py
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+KSP workspace Rust rule audit: clean
+
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas
+Markdown table audit: clean (332 table(s), 750 file(s))
+```
+
+`cargo` n’est pas installé dans l’environnement d’assemblage. Aucun gate Cargo local n’est déclaré PASS. Le journal opérateur stable `0.3.9` reste une preuve externe distincte.
+
+## Objectif
+
+Exécuter le gate d’ouverture `0.3.10-pre.001` demandé par le prompt `029` : vérifier intégralement la base `v0.3.9`, auditer l’extraction RAW commune et les capabilities live, réévaluer `TR-B..TR-F`, fixer les frontières Common/Worker/Transport/Config/Store, puis dimensionner les tranches suivantes sans commencer l’implémentation lourde.
+
+## Mission exécutée
+
+`pre.001` reste une tranche de planification, conformément au prompt `029` :
+
+```text
+lecture règles/architecture obligatoires
+inventaire workspace/manifests/features
+extraction RAW commune auditée
+capability matrix Worker implementation-ready
+TR-B..TR-F réévalués
+fraîcheur Solana/Yellowstone/providers revalidée
+runtime/source supervision décidés
+continuité/gap repair décidés
+snapshot concret décidé
+Config/secrets boundary décidée
+threat model et preuves définis
+dependency graph cible fixé
+prereleases redimensionnées
+```
+
+Aucune implémentation lourde des deux nouvelles crates n’est commencée.
+
+## Décisions principales
+
+### Common RAW
+
+```text
+crate : ksp-raw-transaction-lib
+RAW format : ksp.solana.raw_transaction v1 inchangé
+common deps : ksp-core-lib + ksp-store-lib(default-features=false) + serde_json + sha2
+aucun Transport/Config/Job/Worker/runtime/backend
+RawObservationKey reste producer-owned
+Backfill conserve son observation key/job_id/scope_fingerprint/origin
+```
+
+Golden confirmé :
+
+```text
+byte_len = 112
+sha256 = 220792d2b15d262fda242cb220774ee9ddeffebf04dcfadabcf8ef76a9b1a7c3
+```
+
+Toute source full doit prouver une parité byte-for-byte avec RAW v1 avant persistence directe ; sinon elle reste discovery + hydration.
+
+### Worker concret
+
+```text
+crate : ksp-worker-raw-transaction-ingest-lib
+caller-owned Tokio runtime
+Worker-owned source/supervisor tasks
+bounded channels uniquement
+multi-source simultané
+Store idempotence comme vérité de convergence
+observations distinctes conservées
+content conflict terminal
+repair borné au run frontier
+reconnect != replay
+aucun paramètre historique métier au start
+```
+
+### Transport gaps
+
+```text
+TR-B confirmé : get_block_observed
+TR-C confirmé/scindé : common material + adapters Worker + Transport change only if DTO lacks fidelity
+TR-D confirmé : provenance durable full-material + source runtime snapshot
+TR-E confirmé : reuse from_slot/replay info, aucun second Yellowstone client
+TR-F réservé : EARLY seulement si protocole/accès/rôle RAW prouvés
+```
+
+### Config
+
+```text
+aucun edge Worker -> Config
+std.transport V3 actuel réutilisé
+pas de nouveau document métier Worker imposé en 0.3.10
+adaptation Config seulement si un manque Transport concret l’exige
+secrets restent Config-owned et redacted
+```
+
+## Fraîcheur externe
+
+Vérifié le 5 septembre 2026 :
+
+```text
+yellowstone-grpc-proto latest = 12.7.0 (2026-08-29)
+workspace stable = ^12.7 -> aucun bump initial
+Yellowstone block from_slot replay a reçu un fix upstream en juillet 2026 -> smoke block replay obligatoire
+Helius transactionSubscribe courant ; Helius blockSubscribe explicitement non supporté
+Helius LaserStream replay 24 h documenté
+PublicNode Yellowstone Mainnet/Testnet visible ; replay depth non prouvée
+OrbitFlare gRPC Devnet disponible Free/Developer
+QuickNode gRPC Scale+ ; port 443/x-token ; port 10000 sunset 2026-10-01
+Alchemy replay docs contradictoires 6000 vs 432000 slots -> aucune constante KSP
+Jito ShredStream shutdown annoncé pour 2026-09-05 -> SUNSET, non retenu TR-F
+```
+
+## Plan recalibré
+
+```text
+pre.002 common RAW foundation
+pre.003 Backfill migration
+pre.004 observed block + HTTP block material
+pre.005 WS/Helius full parity
+pre.006 Yellowstone parity
+pre.007 Worker runtime foundation
+pre.008 Yellowstone live/replay
+pre.009 WS/HTTP live
+pre.010 multi-source persistence/hardening
+pre.011 gap repair
+pre.012 Config/profiles + smokes accessibles
+pre.013 EARLY si prouvé, sinon consolidation
+pre.014 gate technique/live final
+pre.015 réconciliation documentaire
+pre.016 préparation publication
+rel.001 stable
+```
+
+## Fichiers ajoutés
+
+```text
+docs/plans/031-V0_3_10_RAW_TRANSACTION_INGEST_PLAN.md
+docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md
+deltas/0.3.10/pre.001.md
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+```
+
+`Cargo.toml` :
+
+```text
+file version 489 -> 490
+workspace.package.version 0.3.9 -> 0.3.10-pre.1
+```
+
+Ce bump est requis par `VER-ID-009` pour toute prerelease non-fix, même lorsque la tranche est documentaire.
+
+## Fichiers supprimés
+
+```text
+aucun
+```
+
+## Validation après modification
+
+Audits statiques réellement exécutés après matérialisation de `pre.001` :
+
+```text
+python3 scripts/audit_rust_workspace_rules.py
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+KSP workspace Rust rule audit: clean
+
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas
+Markdown table audit: clean (339 table(s), 753 file(s))
+```
+
+Le premier passage Markdown post-modification a détecté 32 erreurs d’alignement uniquement dans les nouvelles tables. Elles ont été corrigées selon la règle KSP, puis le gate complet ci-dessus a été relancé jusqu’à PASS.
+
+La comparaison byte-à-byte contre le contenu du ZIP stable, après suppression du cache Python d’audit, donne exactement :
+
+```text
+ajoutés :
+  deltas/0.3.10/pre.001.md
+  docs/plans/031-V0_3_10_RAW_TRANSACTION_INGEST_PLAN.md
+  docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md
+modifié :
+  Cargo.toml
+supprimé :
+  aucun
+```
+
+Les commandes Cargo/Tauri ne sont pas exécutables dans l’environnement d’assemblage courant (`cargo` absent). Elles restent donc explicitement `NON EXÉCUTÉES LOCALEMENT` pour ce delta ; aucune preuve opérateur antérieure n’est transformée en PASS local.
+
+## Validations non exécutées localement
+
+```text
+cargo fmt --all
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test --workspace --all-targets --all-features
+cargo tree --duplicates
+builds Tauri
+smokes live opt-in
+```
+
+Motif : toolchain Cargo absent du sandbox d’assemblage et aucune credential/provider live n’est injectée. Les preuves stables fournies par l’opérateur sont conservées comme contexte externe distinct ; elles ne remplacent pas les gates futurs de `0.3.10`.
+
+## Questions ouvertes
+
+Aucune question de boundary ne bloque `pre.002`. Restent volontairement à résoudre par preuve pendant les tranches prévues :
+
+```text
+parité byte-for-byte RAW v1 des sources WS/Helius/Yellowstone full
+profondeur replay réellement observable par provider au moment du smoke
+nécessité éventuelle d’un profil/rôle Transport supplémentaire pour un smoke accessible
+admission d’une source EARLY seulement si protocole, accès et rôle RAW sont effectivement prouvés
+```
+
+Ces points ne doivent pas être anticipés par des constantes, des claims lossless ou une RAW v2.
+
+## Non inclus
+
+```text
+aucune nouvelle crate créée
+aucun Rust modifié
+aucun Transport/Config/Store code modifié
+aucun kbot3 ouvert ou copié
+aucun Worker live
+aucun RAW v2
+aucun CHANGELOG/ROADMAP modifié
+aucun prompt 0.3.11 créé
+aucun Cargo gate déclaré localement
+```

deltas/0.3.10/pre.002-fix.001.md

@@ -0,0 +1,138 @@
+<!-- file: deltas/0.3.10/pre.002-fix.001.md -->
+<!-- version: 1 -->
+
+# Delta `0.3.10-pre.002-fix.001` — correction des canaris d’intégration RAW et du gate Clippy
+
+## Base requise
+
+```text
+livraison : 0.3.10-pre.002
+workspace.package.version = 0.3.10-pre.2
+```
+
+Le delta historique `deltas/0.3.10/pre.002.md` reste inchangé. Le présent fix trace séparément les défauts révélés par la validation opérateur du 2026-09-06.
+
+## Résultat opérateur de la base
+
+La validation communiquée confirme :
+
+```text
+cargo fmt --all : exécuté
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+KSP workspace Rust rule audit: clean
+Markdown table audit: clean (339 table(s), 754 file(s))
+cargo check --workspace : PASS
+cargo test -p ksp-raw-transaction-lib : PASS
+```
+
+Les tests de `ksp-raw-transaction-lib` passent fonctionnellement :
+
+```text
+9 tests unitaires : PASS
+8 tests d’intégration : PASS
+0 échec
+```
+
+Les graphes communiqués confirment la frontière prévue :
+
+```text
+ksp-core-lib
+ksp-store-api
+serde_json
+sha2
+```
+
+Aucun runtime, Transport, Config, Job, Worker ou backend Store n’apparaît dans le graphe normal de la common crate.
+
+## Motif du fix
+
+Le gate strict :
+
+```bash
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+```
+
+échoue exclusivement sur les nouveaux tests d’intégration de `ksp-raw-transaction-lib`.
+
+### Rustdoc de crate manquante
+
+Quatre fichiers `tests/*.rs` n’avaient pas de documentation de crate :
+
+```text
+crates/ksp-raw-transaction-lib/tests/dependency_boundary.rs
+crates/ksp-raw-transaction-lib/tests/public_api.rs
+crates/ksp-raw-transaction-lib/tests/release_completeness.rs
+crates/ksp-raw-transaction-lib/tests/security_hardening.rs
+```
+
+Avec `missing_docs` promu en erreur par `-D warnings`, chaque binaire de test d’intégration doit documenter sa crate.
+
+Correction : ajout d’une rustdoc `//! ...` conforme aux autres tests d’intégration KSP. Aucun `#[allow(missing_docs)]` n’est ajouté.
+
+### `clippy::collapsible_if`
+
+Le canari d’inventaire des modules production utilisait deux conditions imbriquées pour filtrer les fichiers `.rs` puis extraire leur nom.
+
+Correction : filtrage anticipé avec `continue`, puis `let ... else`, sans `#[allow(clippy::collapsible_if)]` et sans changement de l’inventaire attendu.
+
+## Version Cargo
+
+Ce fix modifie du Rust de test. Le signal technique Cargo est donc synchronisé :
+
+```text
+0.3.10-pre.2 -> 0.3.10-pre.2.fix.1
+```
+
+Le header du `Cargo.toml` racine passe de `491` à `492`.
+
+## Invariants volontairement inchangés
+
+```text
+RAW_TRANSACTION_FORMAT_ID = ksp.solana.raw_transaction
+RAW_TRANSACTION_FORMAT_VERSION = 1
+golden byte_len = 112
+golden sha256 = 220792d2b15d262fda242cb220774ee9ddeffebf04dcfadabcf8ef76a9b1a7c3
+RawObservationKey = producer-owned
+dépendances common = core + store-api + serde_json + sha2
+aucune migration Backfill
+aucun Worker
+aucune nouvelle feature
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-raw-transaction-lib/tests/dependency_boundary.rs
+crates/ksp-raw-transaction-lib/tests/public_api.rs
+crates/ksp-raw-transaction-lib/tests/release_completeness.rs
+crates/ksp-raw-transaction-lib/tests/security_hardening.rs
+docs/plans/031-V0_3_10_RAW_TRANSACTION_INGEST_PLAN.md
+docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md
+```
+
+## Fichier ajouté
+
+```text
+deltas/0.3.10/pre.002-fix.001.md
+```
+
+## Fichiers supprimés
+
+Aucun.
+
+## Validation à rejouer
+
+```bash
+cargo fmt --all
+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 -p ksp-raw-transaction-lib
+cargo tree -p ksp-raw-transaction-lib --edges normal
+cargo tree -p ksp-raw-transaction-lib -e features
+```
+
+`pre.003` reste bloquée tant que ce gate n’est pas intégralement vert.

deltas/0.3.10/pre.002.md

@@ -0,0 +1,261 @@
+<!-- file: deltas/0.3.10/pre.002.md -->
+<!-- version: 1 -->
+
+# Delta `0.3.10-pre.002` — fondation RAW Transaction commune
+
+## Base requise
+
+```text
+0.3.10-pre.001
+workspace.package.version = 0.3.10-pre.1
+```
+
+Le gate opérateur communiqué pour `pre.001` passe `cargo fmt --all`, les audits Rust/Markdown, `cargo check --workspace` et Clippy workspace `--all-targets --all-features -- -D warnings`. Le message ne fournit pas de `cargo test` supplémentaire ; aucun test non communiqué n’est déclaré exécuté.
+
+## Objectif
+
+Créer uniquement `ksp-raw-transaction-lib` comme lower-layer commune de canonicalisation RAW Transaction v1 : matériau source-neutral, parser de signature, canonical JSON, SHA-256 et assemblage transaction/observation. Aucun Worker et aucune migration du Backfill dans cette tranche.
+
+## Version
+
+Cette tranche est une prerelease non-fix :
+
+```text
+workspace.package.version = 0.3.10-pre.2
+```
+
+Le `Cargo.toml` racine passe du header `490` au header `491` et ajoute `crates/ksp-raw-transaction-lib` aux membres du workspace.
+
+## Correction normative du plan `pre.001`
+
+Le sizing `pre.001` avait retenu `ksp-store-lib(default-features=false)` pour la common crate. La relecture au moment de matérialiser la frontière révèle une règle plus spécifique :
+
+```text
+DEP-PIPE-006
+Le pipeline raw ingestion peut dépendre des modèles homogènes de
+ksp-onchain-transport-lib et de ksp-store-api, mais pas de ksp-store-lib.
+```
+
+La dépendance est donc corrigée vers `ksp-store-api`. Cette correction ne change aucun invariant RAW ; elle retire au contraire la façade/runtime Store de la lower-layer réutilisable.
+
+## Dépendances exactes
+
+```text
+ksp-raw-transaction-lib
+    -> ksp-core-lib
+    -> ksp-store-api
+    -> serde_json
+    -> sha2
+```
+
+Absents de la crate :
+
+```text
+ksp-store-lib
+ksp-store-postgres-lib
+ksp-onchain-transport-lib
+ksp-config-lib
+ksp-job-api
+ksp-job-backfill-lib
+ksp-worker-api
+Tokio / futures
+provider SDK
+```
+
+## Surface publique
+
+```text
+RAW_TRANSACTION_FORMAT_ID = ksp.solana.raw_transaction
+RAW_TRANSACTION_FORMAT_VERSION = 1
+MIN_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES = 64
+MAX_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES = 88
+
+RawTransactionMaterial
+RawTransactionWireField<T>
+RawTransactionVersion
+RawTransactionAcquisition
+
+parse_raw_transaction_signature(...)
+canonicalize_raw_transaction(...)
+assemble_raw_transaction_acquisition(...)
+
+ERROR_CODE_RAW_TRANSACTION_CANONICALIZATION_INVALID
+ERROR_CODE_RAW_TRANSACTION_MATERIAL_INVALID
+ERROR_CODE_RAW_TRANSACTION_SIGNATURE_INVALID
+```
+
+Tous les modules restent privés et les éléments consommables sont réexportés au crate-root.
+
+## Contrat matérialisé
+
+### Signature
+
+Le parser reçoit un texte Base58 borné de `64..=88` octets et n’accepte que les représentations décodant exactement vers `64` octets. Aucun Solana SDK ou codec externe n’est ajouté.
+
+Les erreurs ne recopient jamais la signature hostile ; seules les longueurs numériques sûres peuvent apparaître en contexte.
+
+### Matériau source-neutral
+
+`RawTransactionMaterial::binary_base64(...)` reçoit :
+
+```text
+network
+signature canonique 64 bytes
+slot u64
+block_time Option<i64>
+transaction data binaire Base64 déjà obtenu de la source
+meta omitted/null/value
+version omitted/null/value (legacy ou u8)
+transactionIndex omitted/null/value u32
+```
+
+Aucun type Transport/provider n’entre dans la common crate. La représentation interne peut être étendue ultérieurement pour Yellowstone uniquement lorsqu’une parité RAW v1 sera démontrée.
+
+### Canonicalisation RAW v1
+
+La sortie conserve exactement :
+
+```text
+ordre top-level : transaction -> meta -> version -> transactionIndex
+transaction = [data, "base64"]
+tri récursif des clés d’objets JSON
+ordre des arrays conservé
+omitted != null != value
+block_time hors payload, converti en RawTimestamp
+SHA-256 sur les bytes canoniques exacts
+format id/version gelés
+```
+
+Golden verrouillé :
+
+```text
+bytes = {"transaction":["AQID","base64"],"meta":{"a":{"x":null,"y":true},"z":1},"version":"legacy","transactionIndex":7}
+byte_len = 112
+sha256 = 220792d2b15d262fda242cb220774ee9ddeffebf04dcfadabcf8ef76a9b1a7c3
+```
+
+### Observation producer-owned
+
+`assemble_raw_transaction_acquisition(...)` reçoit la `RawObservationKey` déjà choisie par le producteur et construit l’observation sur la référence exacte de la transaction. Aucun domaine de clé Backfill ou Worker n’est introduit dans common.
+
+## Tests ajoutés
+
+Tests unitaires :
+
+```text
+signature exacte 64 bytes
+signature bornes / caractère Base58 invalide / overflow / longueur décodée non canonique
+golden bytes + hash RAW v1
+omitted/null/value
+golden JSON récursif / arrays / escaping / nombres
+block_time négatif / overflow / maximum
+borne payload
+Debug material/wire redacted
+assemblage acquisition + observation key producer-owned
+```
+
+Tests d’intégration :
+
+```text
+dependency boundary exacte
+absence runtime/Transport/Config/Job/Worker/backend
+consommation crate-root externe
+assemblage avec modèles Store API
+inventaire modules production
+absence de contrat Worker/Backfill/Transport dans la façade
+error codes stables
+signature hostile non recopiée
+```
+
+## Fichiers ajoutés
+
+```text
+crates/ksp-raw-transaction-lib/Cargo.toml
+crates/ksp-raw-transaction-lib/src/acquisition.rs
+crates/ksp-raw-transaction-lib/src/canonical.rs
+crates/ksp-raw-transaction-lib/src/error.rs
+crates/ksp-raw-transaction-lib/src/lib.rs
+crates/ksp-raw-transaction-lib/src/signature.rs
+crates/ksp-raw-transaction-lib/unit_tests/acquisition.rs
+crates/ksp-raw-transaction-lib/unit_tests/canonical.rs
+crates/ksp-raw-transaction-lib/unit_tests/signature.rs
+crates/ksp-raw-transaction-lib/tests/dependency_boundary.rs
+crates/ksp-raw-transaction-lib/tests/public_api.rs
+crates/ksp-raw-transaction-lib/tests/release_completeness.rs
+crates/ksp-raw-transaction-lib/tests/security_hardening.rs
+deltas/0.3.10/pre.002.md
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+docs/plans/031-V0_3_10_RAW_TRANSACTION_INGEST_PLAN.md
+docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md
+```
+
+## Fichiers supprimés
+
+Aucun.
+
+## Documentation volontairement différée
+
+`README.md` et `USAGE.md` de la nouvelle crate ne sont pas finalisés dans cette tranche de fondation. La réconciliation version-neutral reste réservée au couloir documentaire `pre.015`, après parité cross-source, migration Backfill et freeze fonctionnelle.
+
+## Validations exécutées dans l’environnement d’assemblage
+
+```text
+python3 scripts/audit_rust_workspace_rules.py
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+KSP workspace Rust rule audit: clean
+
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas
+Markdown table audit: clean (339 table(s), 754 file(s))
+
+contrôle TOML : 20 membres workspace, nouvelle crate présente
+contrôle manifest common : dépendances exactes core/store-api/serde_json/sha2, aucune feature/dev/build dependency
+```
+
+L’environnement d’assemblage ne fournit ni `cargo`, ni `rustc`, ni `rustfmt`. Aucun gate Cargo de `pre.002` n’est donc déclaré PASS localement.
+
+## Gate opérateur demandé
+
+```bash
+cargo fmt --all
+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 -p ksp-raw-transaction-lib
+cargo tree -p ksp-raw-transaction-lib --edges normal
+cargo tree -p ksp-raw-transaction-lib -e features
+```
+
+## Validations non exécutées localement
+
+```text
+cargo fmt --all
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test -p ksp-raw-transaction-lib
+cargo tree -p ksp-raw-transaction-lib --edges normal
+cargo tree -p ksp-raw-transaction-lib -e features
+smokes live : non pertinents pour cette tranche purement déterministe
+```
+
+## Décisions prises
+
+```text
+RAW v1 reste unique et inchangé
+ksp-store-api remplace ksp-store-lib dans common pour conformité DEP-PIPE-006
+RawObservationKey reste producer-owned
+aucun type Transport dans common
+aucun async/runtime dans common
+aucune migration Backfill avant pre.003
+aucun Worker avant pre.007 selon le plan recalibré
+```
+
+## Questions ouvertes
+
+Aucune question ne bloque `pre.003` après un gate opérateur vert. Les projections structurées WS/Helius/Yellowstone restent volontairement différées jusqu’aux tranches de parité prévues ; elles ne doivent pas modifier RAW v1 par anticipation.

deltas/0.3.10/pre.003.md

@@ -0,0 +1,236 @@
+<!-- file: deltas/0.3.10/pre.003.md -->
+<!-- version: 1 -->
+
+# Delta `0.3.10-pre.003` — migration du Backfill vers la common RAW Transaction
+
+## Base requise
+
+```text
+0.3.10-pre.002-fix.001
+workspace.package.version = 0.3.10-pre.2.fix.1
+```
+
+Le gate opérateur communiqué le 2026-09-06 ferme intégralement la base : audits statiques propres, `cargo check --workspace` PASS, Clippy workspace `--all-targets --all-features -- -D warnings` PASS, `cargo test -p ksp-raw-transaction-lib` PASS avec 9 tests unitaires et 8 tests d’intégration, arbres normal/features conformes.
+
+## Objectif
+
+Migrer uniquement `ksp-job-backfill-lib` vers `ksp-raw-transaction-lib` sans modifier le comportement de campagne : common devient propriétaire du parser Base58, de RAW v1, du hash payload et de l’assemblage transaction/observation ; Backfill conserve Transport, provenance, observation key, Job scope et Store persistence.
+
+Aucun Worker, aucune nouvelle source Transport et aucune extension du format RAW ne sont introduits.
+
+## Version
+
+```text
+workspace.package.version = 0.3.10-pre.3
+```
+
+Le header du `Cargo.toml` racine passe de `492` à `493`. Le nombre de membres workspace reste `20`.
+
+## Migration de dépendance
+
+`ksp-job-backfill-lib` ajoute :
+
+```text
+ksp-raw-transaction-lib = { path = "../ksp-raw-transaction-lib" }
+```
+
+Le reste de son graphe runtime est conservé. `serde_json` reste nécessaire au type Transport `SolanaWireField<serde_json::Value>`. `sha2` reste nécessaire aux fingerprints et à la `RawObservationKey` Backfill ; il n’est plus utilisé pour le hash du payload RAW.
+
+## Chemin RAW après migration
+
+```text
+BackfillSignature
+    -> parse_raw_transaction_signature
+    -> RawTransactionSignature
+
+getTransaction observed
+    -> adapter SolanaEncodedTransaction/SolanaWireField
+    -> RawTransactionMaterial::binary_base64
+    -> canonicalize_raw_transaction
+    -> RawTransaction
+
+Backfill provenance + Backfill RawObservationKey
+    -> assemble_raw_transaction_acquisition
+    -> BackfillRawAcquisition
+    -> Store persistence existante
+```
+
+Les erreurs du parser/canonicalizer common sont remappées au boundary Backfill vers :
+
+```text
+ERROR_CODE_BACKFILL_RAW_CONVERSION_INVALID
+```
+
+Le Job ne change donc pas de domaine d’erreur externe par effet de la migration.
+
+## Code privé supprimé du Backfill
+
+La migration retire de `conversion.rs` les implémentations locales de :
+
+```text
+base58_digit(...)
+algorithme de décodage Base58 64-byte
+convert_block_time(...)
+canonical_payload_bytes(...)
+append_wire_value(...)
+append_canonical_json(...)
+append_json_string(...)
+RawPayload::try_new + SHA-256 du payload
+construction directe RawTransactionObservation
+```
+
+`CanonicalTransactionFields` reste un adapter Transport privé ; il ne définit aucun format RAW.
+
+## Propriété Backfill conservée
+
+Le Backfill continue de posséder :
+
+```text
+getTransaction observed / rôle HTTP
+provider gagnant
+endpoint gagnant
+commitment
+job_id
+scope_fingerprint
+RawAcquisitionOrigin::Backfill
+capture_session
+observation contract version = 1
+algorithme RawObservationKey Backfill
+persistence Store
+sémantique Missing
+```
+
+La common crate ne reçoit donc aucun vocabulaire de campagne.
+
+## Parité déterministe
+
+Le golden historique reste inchangé :
+
+```text
+format_id = ksp.solana.raw_transaction
+format_version = 1
+bytes = {"transaction":["AQID","base64"],"meta":{"a":{"x":null,"y":true},"z":1},"version":"legacy","transactionIndex":7}
+byte_len = 112
+sha256 = 220792d2b15d262fda242cb220774ee9ddeffebf04dcfadabcf8ef76a9b1a7c3
+```
+
+La provenance historique reste :
+
+```text
+provider = publicnode
+protocol = solana.http.json_rpc
+method = getTransaction
+endpoint = devnet-primary
+commitment = finalized
+capture_session = backfill:pre006
+origin = Backfill
+```
+
+Le canari d’observation key est désormais exact :
+
+```text
+provider = provider
+endpoint = endpoint-a
+key = b8550f0f2165f370de918bd4fb0ec782391afdddb88c57f010743e000b136702
+```
+
+## Canaris mis à jour
+
+```text
+BackfillSignature délègue au parser common
+bornes Backfill == bornes common
+format id/version Backfill == common
+wire omitted/null reste distinct via common
+non-Base64 reste rejeté avec error code Backfill
+block_time invalide reste terminal avec error code Backfill
+golden bytes/hash/provenance inchangés
+observation key exacte inchangée
+manifest Backfill exige l’edge common
+conversion.rs exige parser + canonicalizer + assembler common
+conversion.rs interdit canonical JSON/Base58/RawPayload privés
+lower-layer common interdit toute dépendance retour vers Job
+```
+
+## Fichiers ajoutés
+
+```text
+deltas/0.3.10/pre.003.md
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-job-backfill-lib/Cargo.toml
+crates/ksp-job-backfill-lib/README.md
+crates/ksp-job-backfill-lib/src/conversion.rs
+crates/ksp-job-backfill-lib/src/lib.rs
+crates/ksp-job-backfill-lib/src/request.rs
+crates/ksp-job-backfill-lib/tests/dependency_boundary.rs
+crates/ksp-job-backfill-lib/tests/hardening.rs
+crates/ksp-job-backfill-lib/unit_tests/conversion.rs
+docs/plans/031-V0_3_10_RAW_TRANSACTION_INGEST_PLAN.md
+docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md
+```
+
+## Fichiers supprimés
+
+Aucun.
+
+## Validations exécutées dans l’environnement d’assemblage
+
+```text
+python3 scripts/audit_rust_workspace_rules.py
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+KSP workspace Rust rule audit: clean
+
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas
+Markdown table audit: clean (339 table(s), 756 file(s))
+```
+
+L’environnement d’assemblage ne fournit ni `cargo`, ni `rustc`, ni `rustfmt`.
+
+## Gate opérateur demandé
+
+```bash
+cargo fmt --all
+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 -p ksp-raw-transaction-lib
+cargo test -p ksp-job-backfill-lib
+cargo tree -p ksp-job-backfill-lib --edges normal
+cargo tree -p ksp-job-backfill-lib -e features
+```
+
+## Validations non exécutées localement
+
+```text
+cargo fmt --all
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test -p ksp-raw-transaction-lib
+cargo test -p ksp-job-backfill-lib
+cargo tree -p ksp-job-backfill-lib --edges normal
+cargo tree -p ksp-job-backfill-lib -e features
+smokes live : non pertinents pour cette tranche de migration déterministe
+```
+
+## Décisions prises
+
+```text
+common possède parser + canonical RAW v1 + payload hash + assembly
+Backfill conserve observation key/provenance/campagne
+les erreurs common sont remappées vers le code Backfill historique
+les constantes publiques RAW du Backfill sont des reexports common
+les bornes publiques de signature Backfill suivent les constantes common
+aucun changement du Store persistence path
+aucun changement de source/acquisition réseau
+aucun Worker avant la tranche planifiée
+```
+
+## Questions ouvertes
+
+Aucune question ne bloque le gate de `pre.003`. `pre.004` reste strictement dédiée à `get_block_observed` et au matériau HTTP block après validation opérateur complète de cette migration.

deltas/0.3.10/pre.004-fix.001.md

@@ -0,0 +1,165 @@
+<!-- file: deltas/0.3.10/pre.004-fix.001.md -->
+<!-- version: 1 -->
+
+# Delta `0.3.10-pre.004-fix.001` — correction du canari HTTP block et du gate Clippy
+
+## Base requise
+
+```text
+livraison : 0.3.10-pre.004
+workspace.package.version = 0.3.10-pre.4
+```
+
+Le delta historique `deltas/0.3.10/pre.004.md` reste inchangé. Le présent fix trace séparément le défaut révélé par la validation opérateur du 2026-09-06.
+
+## Résultat opérateur de la base
+
+La validation communiquée confirme :
+
+```text
+cargo fmt --all : exécuté
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+KSP workspace Rust rule audit: clean
+Markdown table audit: clean (339 table(s), 757 file(s))
+cargo check --workspace : PASS
+cargo clippy --workspace --all-targets --all-features -- -D warnings : FAIL
+cargo test -p ksp-raw-transaction-lib : PASS
+cargo test -p ksp-onchain-transport-lib : PASS
+cargo test -p ksp-job-backfill-lib --test http_block_material : PASS
+```
+
+Les tests fonctionnels communiqués confirment notamment :
+
+```text
+ksp-raw-transaction-lib : 12 unit + 9 intégration, 0 échec
+ksp-onchain-transport-lib : 387 unit + 51 public API + 43 release completeness + 4 doctests, 0 échec
+http_block_material : 1 test, PASS
+smokes live Transport : ignorés comme prévu
+```
+
+Les arbres normaux communiqués conservent les frontières prévues : la common RAW dépend de `base64`, `ksp-core-lib`, `ksp-store-api`, `serde_json`, `sha2`, et `ksp-onchain-transport-lib` ne dépend pas de `ksp-raw-transaction-lib`.
+
+## Motif du fix
+
+Le gate strict :
+
+```bash
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+```
+
+échoue exclusivement sur sept `clippy::expect_used` dans les deux helpers privés du nouveau test d’intégration :
+
+```text
+pool_for_url(...)
+serve_once(...)
+```
+
+Les usages concernés sont :
+
+```text
+parsing HttpEndpointUrl
+construction HttpTransportPool
+bind du listener local
+lecture de local_addr
+accept de la connexion fixture
+read de la requête fixture
+write de la réponse fixture
+```
+
+La configuration commune autorise `expect` dans les fonctions de test, mais ces helpers ne portent pas eux-mêmes l’attribut `#[test]`/`#[tokio::test]` et sont donc correctement rejetés par Clippy.
+
+## Correction
+
+Aucun lint n’est désactivé.
+
+`pool_for_url(...)` retourne désormais explicitement :
+
+```text
+ksp_core_lib::Result<HttpTransportPool>
+```
+
+et propage les deux erreurs possibles par `match` explicite.
+
+`serve_once(...)` retourne désormais :
+
+```text
+std::io::Result<(String, JoinHandle<std::io::Result<()>>)> 
+```
+
+Le bind, `local_addr`, `accept`, `read` et `write_all` retournent leurs erreurs par contrôle de flux explicite. Les assertions/`expect()` de fixture restent uniquement dans le corps `#[tokio::test]`, conformément à `allow-expect-in-tests = true`.
+
+## Version Cargo
+
+Ce fix modifie du Rust de test. Le signal technique Cargo est donc synchronisé :
+
+```text
+0.3.10-pre.4 -> 0.3.10-pre.4.fix.1
+```
+
+Le header du `Cargo.toml` racine passe de `494` à `495`.
+
+## Invariants volontairement inchangés
+
+```text
+get_block_observed : inchangé
+winner provider/endpoint : inchangé
+RAW_TRANSACTION_FORMAT_ID = ksp.solana.raw_transaction
+RAW_TRANSACTION_FORMAT_VERSION = 1
+extraction Base64/short_vec : inchangée
+projection 2 transactions / index 0-1 : inchangée
+TR-C2 : adapter productif toujours Worker-owned
+aucun changement de code production
+aucune dépendance ou feature ajoutée
+aucun nouveau Worker
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-job-backfill-lib/tests/http_block_material.rs
+docs/plans/031-V0_3_10_RAW_TRANSACTION_INGEST_PLAN.md
+docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md
+```
+
+## Fichier ajouté
+
+```text
+deltas/0.3.10/pre.004-fix.001.md
+```
+
+## Fichiers supprimés
+
+Aucun.
+
+## Validations exécutées dans l’environnement d’assemblage
+
+```text
+python3 scripts/audit_rust_workspace_rules.py
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+KSP workspace Rust rule audit: clean
+
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas
+Markdown table audit: clean (339 table(s), 758 file(s))
+```
+
+L’environnement d’assemblage ne fournit ni `cargo`, ni `rustc`, ni `rustfmt`; aucun gate Cargo du fix n’est donc déclaré PASS localement.
+
+## Validation à rejouer
+
+```bash
+cargo fmt --all
+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 -p ksp-raw-transaction-lib
+cargo test -p ksp-onchain-transport-lib
+cargo test -p ksp-job-backfill-lib --test http_block_material
+cargo tree -p ksp-raw-transaction-lib --edges normal
+cargo tree -p ksp-onchain-transport-lib --edges normal
+```
+
+`pre.005` reste bloquée tant que ce gate n’est pas intégralement vert.

deltas/0.3.10/pre.004.md

@@ -0,0 +1,279 @@
+<!-- file: deltas/0.3.10/pre.004.md -->
+<!-- version: 1 -->
+
+# Delta `0.3.10-pre.004` — HTTP observed block + matériau RAW block
+
+## Base requise
+
+```text
+0.3.10-pre.003
+workspace.package.version = 0.3.10-pre.3
+```
+
+Le gate opérateur communiqué le 2026-09-06 ferme intégralement `pre.003` : audits statiques propres, `cargo check --workspace` PASS, Clippy workspace `--all-targets --all-features -- -D warnings` PASS, tests de `ksp-raw-transaction-lib` PASS, tests de `ksp-job-backfill-lib` PASS avec 51 tests unitaires et 20 tests d’intégration, arbres normal/features conformes.
+
+## Objectif
+
+Fermer `TR-B` et la preuve HTTP block de `TR-C` sans ouvrir le Worker :
+
+```text
+getBlock pool HTTP
+    -> valeur observée + provider/endpoint winner
+    -> SolanaConfirmedBlock
+    -> N SolanaBlockTransaction full Base64
+    -> matériau RAW source-neutral
+```
+
+La tranche ne crée aucun adapter productif Transport -> common. Conformément à `TR-C2`, cet adapter reste producer-owned et sera matérialisé dans le futur `ksp-worker-raw-transaction-ingest-lib`.
+
+## Version
+
+```text
+workspace.package.version = 0.3.10-pre.4
+```
+
+Le header du `Cargo.toml` racine passe de `493` à `494`. Le nombre de membres workspace reste `20`.
+
+## `get_block_observed`
+
+`ksp-onchain-transport-lib` ajoute :
+
+```text
+HttpTransportPool::get_block_observed(...)
+```
+
+Le wrapper :
+
+```text
+réutilise exactement la validation/config moderne de get_block
+utilise le routing/admission/timeout/retry standard du pool
+retourne HttpObservedValue<Option<SolanaConfirmedBlock>>
+conserve endpoint_name + provider du winner réel après retry/reroute
+préserve result = null comme None
+n’expose ni URL, ni headers, ni raw HTTP body
+réutilise le décodage typé SolanaConfirmedBlock
+```
+
+`get_block(...)` et `get_block_observed(...)` partagent désormais le même helper privé de paramètres et la même validation du commitment `processed`.
+
+## Provenance winner déterministe
+
+Le canari Transport configure deux endpoints :
+
+```text
+endpoint 1 -> HTTP 429
+endpoint 2 -> getBlock success
+```
+
+La valeur observée doit reporter exclusivement :
+
+```text
+endpoint_name = winner-endpoint
+provider = winner-provider
+```
+
+Le Debug conserve uniquement la projection sûre et ne rend pas le transaction wire Base64.
+
+## Matériau Base64 source-neutral
+
+`ksp-raw-transaction-lib` ajoute `base64` à son graphe common et expose :
+
+```text
+extract_raw_transaction_signature_from_binary_base64(...)
+RawTransactionMaterial::binary_base64_with_embedded_signature(...)
+```
+
+L’extracteur lit directement le wire transaction Solana Base64 sans dépendance à une crate transaction runtime :
+
+```text
+borne la représentation textuelle avant décodage
+exige Base64 STANDARD canonique
+lit un short_vec de signature count borné et canonique
+refuse count = 0
+refuse short_vec tronqué/non canonique
+refuse tableau de signatures tronqué
+exige au moins un byte de message après les signatures déclarées
+retourne uniquement la première signature exacte de 64 octets
+ne copie jamais le transaction wire dans erreur/Debug
+```
+
+Le constructeur common réutilise cette signature puis conserve les dimensions RAW v1 existantes :
+
+```text
+network
+slot
+block_time
+transaction Base64
+meta omitted/null/value
+version omitted/null/legacy/number
+transaction_index
+```
+
+Le format canonique reste strictement `ksp.solana.raw_transaction` v1.
+
+## Preuve cross-layer sans nouveau couplage de production
+
+Le nouveau canari test-only :
+
+```text
+crates/ksp-job-backfill-lib/tests/http_block_material.rs
+```
+
+utilise une crate qui dépend déjà de Transport et de common pour prouver la composition future sans créer d’edge architectural supplémentaire :
+
+```text
+get_block_observed
+    -> SolanaConfirmedBlock
+    -> 2 SolanaBlockTransaction distinctes
+    -> full Base64 + meta + version + transactionIndex 0/1
+    -> RawTransactionMaterial::binary_base64_with_embedded_signature
+    -> canonicalize_raw_transaction
+```
+
+Les deux transaction wires minimales font `66` octets chacune et utilisent des signatures distinctes :
+
+```text
+transaction 0 -> signature [0; 64]
+transaction 1 -> signature [1; 64]
+```
+
+Le canari vérifie que ces signatures et les index 0/1 restent associés à la bonne transaction, avec le slot et le block time communs du bloc.
+
+Cette preuve reste strictement test-only. Aucun symbole `ksp_raw_transaction_lib` n’est ajouté aux sources de production de `ksp-onchain-transport-lib`.
+
+## Dépendances common
+
+Le graphe runtime direct de `ksp-raw-transaction-lib` devient exactement :
+
+```text
+base64
+ksp-core-lib
+ksp-store-api
+serde_json
+sha2
+```
+
+Restent interdits :
+
+```text
+ksp-store-lib
+ksp-onchain-transport-lib
+ksp-config-lib
+ksp-job-api
+ksp-job-backfill-lib
+ksp-worker-api
+tokio
+futures
+```
+
+La règle `DEP-PIPE-006` reste donc respectée.
+
+## Documentation durable
+
+`crates/ksp-onchain-transport-lib/USAGE.md` documente la différence entre :
+
+```text
+get_block(...)
+get_block_observed(...)
+```
+
+sans transformer le guide en journal de prerelease.
+
+`docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md` ferme `TR-B`, conserve `TR-C2` producer-owned et corrige le graphe common vers `ksp-store-api`.
+
+Le plan `031` et la validation `027` enregistrent également la fermeture opérateur de `pre.003` et le périmètre exact de `pre.004`.
+
+## Fichiers ajoutés
+
+```text
+crates/ksp-job-backfill-lib/tests/http_block_material.rs
+crates/ksp-onchain-transport-lib/fixtures/http/get_block.observed_material.success.json
+deltas/0.3.10/pre.004.md
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-onchain-transport-lib/USAGE.md
+crates/ksp-onchain-transport-lib/src/rpc_blocks.rs
+crates/ksp-onchain-transport-lib/tests/public_api.rs
+crates/ksp-onchain-transport-lib/unit_tests/rpc_blocks.rs
+crates/ksp-raw-transaction-lib/Cargo.toml
+crates/ksp-raw-transaction-lib/src/canonical.rs
+crates/ksp-raw-transaction-lib/src/error.rs
+crates/ksp-raw-transaction-lib/src/lib.rs
+crates/ksp-raw-transaction-lib/src/signature.rs
+crates/ksp-raw-transaction-lib/tests/dependency_boundary.rs
+crates/ksp-raw-transaction-lib/tests/public_api.rs
+crates/ksp-raw-transaction-lib/unit_tests/canonical.rs
+crates/ksp-raw-transaction-lib/unit_tests/signature.rs
+docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md
+docs/plans/031-V0_3_10_RAW_TRANSACTION_INGEST_PLAN.md
+docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md
+```
+
+## Fichiers supprimés
+
+Aucun.
+
+## Validations exécutées dans l’environnement d’assemblage
+
+```text
+python3 scripts/audit_rust_workspace_rules.py
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+KSP workspace Rust rule audit: clean
+
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas
+Markdown table audit: clean (339 table(s), 757 file(s))
+```
+
+L’environnement d’assemblage ne fournit ni `cargo`, ni `rustc`, ni `rustfmt`.
+
+## Gate opérateur demandé
+
+```bash
+cargo fmt --all
+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 -p ksp-raw-transaction-lib
+cargo test -p ksp-onchain-transport-lib
+cargo test -p ksp-job-backfill-lib --test http_block_material
+cargo tree -p ksp-raw-transaction-lib --edges normal
+cargo tree -p ksp-onchain-transport-lib --edges normal
+```
+
+## Validations non exécutées localement
+
+```text
+cargo fmt --all
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test -p ksp-raw-transaction-lib
+cargo test -p ksp-onchain-transport-lib
+cargo test -p ksp-job-backfill-lib --test http_block_material
+cargo tree -p ksp-raw-transaction-lib --edges normal
+cargo tree -p ksp-onchain-transport-lib --edges normal
+smokes live : non requis pour cette tranche déterministe
+```
+
+## Décisions prises
+
+```text
+TR-B est fermé par get_block_observed
+get_block et get_block_observed partagent validation + décodage
+la common extrait la signature d’un transaction wire Base64 complet
+aucune dépendance Solana transaction runtime n’est ajoutée à la common
+aucun adapter productif Transport -> common dans Transport
+TR-C2 reste Worker-owned
+la preuve block -> common est cross-layer et test-only
+RAW v1 reste inchangé
+aucun Worker live n’est ouvert dans pre.004
+```
+
+## Questions ouvertes
+
+Aucune question ne bloque le gate de `pre.004`. `pre.005` reste dédiée à la parité WS `blockSubscribe` + Helius `transactionSubscribe`, avec golden parity ou fallback hydration explicitement qualifié selon la représentation réellement disponible.

deltas/0.3.10/pre.005-fix.001.md

@@ -0,0 +1,92 @@
+<!-- file: deltas/0.3.10/pre.005-fix.001.md -->
+<!-- version: 1 -->
+
+# Delta `0.3.10-pre.005-fix.001` — correction de typage du canari WS RAW parity
+
+## Base requise
+
+```text
+0.3.10-pre.005
+```
+
+## Motif du fix
+
+Le premier rejeu opérateur de `pre.005` valide les audits statiques, `cargo check --workspace`, la common RAW, la suite Transport complète et les arbres Cargo, mais Clippy strict et la suite Backfill s’arrêtent sur une unique erreur de compilation `E0308` dans `tests/ws_raw_parity.rs`.
+
+Le canari comparait :
+
+```text
+RawTransaction::block_time().unix_millis() -> u64
+FIXTURE_BLOCK_TIME * 1_000                 -> i64
+```
+
+L’assertion produisait donc `Option<u64> != Option<i64>` au niveau du type.
+
+## Correction
+
+La constante de fixture devient directement :
+
+```text
+FIXTURE_BLOCK_TIME_MILLIS: u64 = 1_787_072_400_000
+```
+
+L’assertion compare désormais `Option<u64>` à `Option<u64>` sans cast, conversion runtime, `unwrap`, `expect` ou modification du comportement testé.
+
+## Invariants inchangés
+
+```text
+blockSubscribe standard confirmed/full/base64 legacy-v0 -> golden RAW-direct positif
+Helius transactionSubscribe full/base64 -> signal + hydration HTTP
+RAW v1 bytes/hash contracts
+TR-C2 Worker-owned
+tokio-tungstenite strictement dev-only
+aucun code de production modifié
+aucune dépendance ni feature modifiée
+```
+
+## Version technique
+
+```text
+workspace.package.version = 0.3.10-pre.5.fix.1
+Cargo.toml header          = 497
+workspace members          = 20
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-job-backfill-lib/tests/ws_raw_parity.rs
+docs/plans/031-V0_3_10_RAW_TRANSACTION_INGEST_PLAN.md
+docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md
+```
+
+## Fichier ajouté
+
+```text
+deltas/0.3.10/pre.005-fix.001.md
+```
+
+## Audits d’assemblage
+
+```text
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+KSP workspace Rust rule audit: clean
+Markdown table audit: clean (339 table(s), 760 file(s))
+```
+
+## Gate opérateur à rejouer
+
+```bash
+cargo fmt --all
+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 -p ksp-raw-transaction-lib
+cargo test -p ksp-onchain-transport-lib
+cargo test -p ksp-job-backfill-lib
+```
+
+Les arbres Cargo n’ont pas besoin d’être rejoués pour ce fix : ni `Cargo.toml` de crate, ni dépendance, ni feature ne change.

deltas/0.3.10/pre.005-fix.002.md

@@ -0,0 +1,101 @@
+<!-- file: deltas/0.3.10/pre.005-fix.002.md -->
+<!-- version: 1 -->
+
+# Delta `0.3.10-pre.005-fix.002` — conformité Clippy du canari WS + inventaire dev exact
+
+## Base requise
+
+```text
+0.3.10-pre.005-fix.001
+```
+
+## Motif du fix
+
+Le second rejeu opérateur confirme `cargo check --workspace`, la common RAW et la suite Transport complète, mais révèle deux défauts test-only :
+
+```text
+25 clippy::question_mark_used dans crates/ksp-job-backfill-lib/tests/ws_raw_parity.rs
+1 canari hardening encore calibré sur dev-dependencies = {tokio}
+```
+
+Le manifest `pre.005` contient légitimement `tokio-tungstenite` en dev-only pour les serveurs WebSocket déterministes ; `tests/dependency_boundary.rs` verrouille déjà qu’il ne migre pas vers les dépendances de production.
+
+## Corrections
+
+`ws_raw_parity.rs` remplace tous les `?` par du contrôle de flux explicite :
+
+```text
+Option -> match + retour None
+Result -> match + retour Err/None
+appel async Result -> if let Err(error) + retour Err(error)
+```
+
+Aucun `#[allow(...)]`, aucun changement de golden et aucune modification du scénario positif `blockSubscribe` ou négatif Helius ne sont introduits.
+
+`hardening.rs` attend désormais exactement :
+
+```text
+dev-dependencies = {tokio, tokio-tungstenite}
+```
+
+L’inventaire des dépendances normales reste inchangé.
+
+## Invariants inchangés
+
+```text
+blockSubscribe standard confirmed/full/base64 legacy-v0 -> golden RAW-direct positif
+Helius transactionSubscribe full/base64 -> signal + hydration HTTP
+RAW v1 bytes/hash contracts
+TR-C2 Worker-owned
+tokio-tungstenite strictement dev-only
+aucun code de production modifié
+aucune dépendance ni feature modifiée par ce fix
+```
+
+## Version technique
+
+```text
+workspace.package.version = 0.3.10-pre.5.fix.2
+Cargo.toml header          = 498
+workspace members          = 20
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-job-backfill-lib/tests/hardening.rs
+crates/ksp-job-backfill-lib/tests/ws_raw_parity.rs
+docs/plans/031-V0_3_10_RAW_TRANSACTION_INGEST_PLAN.md
+docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md
+```
+
+## Fichier ajouté
+
+```text
+deltas/0.3.10/pre.005-fix.002.md
+```
+
+## Audits d’assemblage
+
+```text
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+KSP workspace Rust rule audit: clean
+Markdown table audit: clean (339 table(s), 761 file(s))
+```
+
+## Gate opérateur à rejouer
+
+```bash
+cargo fmt --all
+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 -p ksp-raw-transaction-lib
+cargo test -p ksp-onchain-transport-lib
+cargo test -p ksp-job-backfill-lib
+```
+
+Les arbres Cargo n’ont pas besoin d’être rejoués pour ce fix : aucun manifest de crate, aucune dépendance et aucune feature ne change.

deltas/0.3.10/pre.005.md

@@ -0,0 +1,232 @@
+<!-- file: deltas/0.3.10/pre.005.md -->
+<!-- version: 1 -->
+
+# Delta `0.3.10-pre.005` — qualification RAW WS standard et Helius
+
+## Base requise
+
+```text
+livraison : 0.3.10-pre.004-fix.001
+workspace.package.version = 0.3.10-pre.4.fix.1
+```
+
+Le rejeu opérateur communiqué le 2026-09-06 ferme intégralement le fix : audits statiques propres, `cargo check --workspace` PASS, Clippy strict PASS, tests common PASS, 387 tests Transport plus suites publiques/release/doctests PASS, et suite complète Backfill PASS. Les arbres Cargo n'ont pas été rejoués sur le fix car aucune dépendance ni feature n'y avait changé.
+
+## Objectif
+
+Qualifier les deux surfaces WebSocket déjà présentes sans ouvrir le Worker :
+
+```text
+Solana standard blockSubscribe full/base64
+    -> prouver ou refuser la production RAW directe
+
+Helius transactionSubscribe full/base64
+    -> prouver ou refuser la production RAW directe
+```
+
+Aucun adapter productif n'est placé dans Transport ou Backfill. `TR-C2` reste Worker-owned.
+
+## Version
+
+```text
+workspace.package.version = 0.3.10-pre.5
+```
+
+Le header du `Cargo.toml` racine passe de `495` à `496`. Le workspace reste à `20` membres.
+
+## Qualification positive — `blockSubscribe`
+
+Le canari cross-layer `crates/ksp-job-backfill-lib/tests/ws_raw_parity.rs` monte un serveur HTTP local et un serveur WebSocket standard local sur une fixture commune.
+
+Configuration qualifiée :
+
+```text
+commitment = confirmed
+encoding = base64
+transactionDetails = full
+maxSupportedTransactionVersion = 0
+showRewards = false
+```
+
+Le test compare :
+
+```text
+HTTP getBlock observed
+    vs
+WS blockSubscribe
+```
+
+puis exige :
+
+```text
+même SolanaConfirmedBlock
+même RawTransactionReference
+même slot
+même block_time
+mêmes bytes RAW v1
+même content_hash
+```
+
+La qualification directe est volontairement bornée au sous-ensemble legacy/v0 prouvé. Transaction V1 reste au gate `pre.006`.
+
+## Qualification négative — Helius `transactionSubscribe`
+
+Le même canari ouvre une session Helius locale et une hydration HTTP de référence pour la même transaction.
+
+L'enveloppe full/base64 qualifiée conserve :
+
+```text
+transaction wire
+meta
+signature
+slot
+transactionIndex
+```
+
+mais ne porte pas, dans le contrat typé actuel :
+
+```text
+blockTime
+version
+```
+
+Le test construit donc la meilleure projection RAW possible sans inventer ces champs et prouve :
+
+```text
+même identité que HTTP
+même slot que HTTP
+block_time différent
+bytes RAW v1 différents
+content_hash différent
+```
+
+Décision normative :
+
+```text
+Helius transactionSubscribe full/base64
+    -> signal live riche
+    -> HTTP hydration obligatoire
+    -> persistence RAW depuis le matériau HTTP complet
+```
+
+Aucun RAW v2 automatique et aucune normalisation ad hoc ne sont introduits.
+
+## Dependency firewall
+
+Pour les serveurs WebSocket locaux du canari, le manifest Backfill ajoute uniquement :
+
+```text
+[dev-dependencies]
+tokio-tungstenite = { workspace = true, features = ["handshake"] }
+```
+
+`tests/dependency_boundary.rs` vérifie explicitement que `tokio-tungstenite` n'apparaît pas dans `[dependencies]` et reste dans `[dev-dependencies]`.
+
+Il n'existe toujours aucun edge productif :
+
+```text
+ksp-onchain-transport-lib -> ksp-raw-transaction-lib
+ksp-raw-transaction-lib -> ksp-onchain-transport-lib
+```
+
+## Documentation
+
+`docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md` distingue désormais :
+
+```text
+blockSubscribe full/base64 legacy-v0 -> direct après parité prouvée
+Helius transactionSubscribe full/base64 -> signal + hydration HTTP
+```
+
+Le plan `031` et la validation `027` enregistrent la même qualification, la fermeture opérateur de `pre.004-fix.001` et le maintien de Transaction V1 dans `pre.006`.
+
+## Fraîcheur externe revalidée
+
+Les surfaces changeantes ont été revalidées le 2026-09-06 :
+
+```text
+Solana blockSubscribe : méthode unstable, confirmed/finalized, base64, full, maxSupportedTransactionVersion disponible
+Helius transactionSubscribe : full transaction streaming disponible ; enveloppe KSP qualifiée sans blockTime/version
+```
+
+Sources documentaires :
+
+```text
+https://solana.com/docs/rpc/websocket/blocksubscribe
+https://solana.com/docs/rpc/json-structures
+https://www.helius.dev/docs/rpc/websocket/transaction-subscribe
+https://www.helius.dev/blog/introducing-next-generation-enhanced-websockets
+```
+
+Ces faits d'accès/protocole restent documentaires et ne deviennent pas des constantes provider dans le Worker.
+
+## Fichiers ajoutés
+
+```text
+crates/ksp-job-backfill-lib/tests/ws_raw_parity.rs
+deltas/0.3.10/pre.005.md
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-job-backfill-lib/Cargo.toml
+crates/ksp-job-backfill-lib/tests/dependency_boundary.rs
+docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md
+docs/plans/031-V0_3_10_RAW_TRANSACTION_INGEST_PLAN.md
+docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md
+```
+
+## Fichiers supprimés
+
+Aucun.
+
+## Validations exécutées dans l'environnement d'assemblage
+
+```text
+python3 scripts/audit_rust_workspace_rules.py
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+KSP workspace Rust rule audit: clean
+
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas
+Markdown table audit: clean (339 table(s), 759 file(s))
+```
+
+L'environnement d'assemblage ne fournit ni `cargo`, ni `rustc`, ni `rustfmt` ; aucun gate Cargo de `pre.005` n'est déclaré PASS localement.
+
+## Gate opérateur demandé
+
+```bash
+cargo fmt --all
+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 -p ksp-raw-transaction-lib
+cargo test -p ksp-onchain-transport-lib
+cargo test -p ksp-job-backfill-lib
+cargo tree -p ksp-job-backfill-lib --edges normal
+cargo tree -p ksp-job-backfill-lib --edges dev
+cargo tree -p ksp-job-backfill-lib -e features
+```
+
+Les arbres sont requis cette fois-ci parce que `pre.005` ajoute une dev-dependency et doit prouver qu'elle ne contamine pas le graphe productif.
+
+## Décisions prises
+
+```text
+blockSubscribe full/base64 legacy-v0 est qualifié RAW-direct
+Helius transactionSubscribe full/base64 n'est pas qualifié RAW-direct
+Helius doit hydrater par HTTP avant persistence RAW
+aucun champ manquant n'est inventé
+aucun RAW v2 automatique
+TR-C2 reste Worker-owned
+aucun code de production ajouté dans cette tranche
+Transaction V1 reste à pre.006
+```
+
+## Questions ouvertes
+
+Aucune question ne bloque le gate déterministe de `pre.005`. `pre.006` reste dédiée aux adapters Yellowstone transactions/blocks et au gate Transaction V1 avant toute persistance directe de ces matériaux.

deltas/0.3.10/pre.006-fix.001.md

@@ -0,0 +1,166 @@
+<!-- file: deltas/0.3.10/pre.006-fix.001.md -->
+<!-- version: 1 -->
+
+# Delta `0.3.10-pre.006-fix.001` — corrections Rust du gate `pre.006` + recalibrage du sizing
+
+## Base requise
+
+```text
+0.3.10-pre.006
+```
+
+L'archive opérateur `khadhroony-solana-project- v0.3.10-pre.006.zip` est la base autoritaire de ce correctif.
+
+## Objectif
+
+Corriger strictement les défauts Rust révélés par le premier gate opérateur de `pre.006` sans modifier le contrat RAW V1, les goldens, la décision Yellowstone ni les dépendances de production, puis corriger le plan devenu surdimensionné avant toute implémentation lourde du Worker.
+
+Le gate opérateur a révélé trois familles de défauts dans la responsabilité `pre.006` :
+
+```text
+clippy::collapsible_if dans la validation V1 du heap size
+assert_eq! sur Result<&str, &Error> exigeant à tort PartialEq sur Error
+canari Yellowstone utilisant Error::new avec un &str et formatant ErrorCode via Display inexistant
+```
+
+## Version
+
+Le correctif modifie du Rust et synchronise donc la version technique Cargo conformément à `VER-ID-007` et `VER-ID-010` :
+
+```text
+workspace.package.version = 0.3.10-pre.6.fix.1
+```
+
+## Corrections Rust
+
+`ksp-raw-transaction-lib/src/wire.rs` applique la forme Clippy proposée pour la garde `heap_size` V1 sans modifier les bornes ni le résultat fonctionnel.
+
+`unit_tests/wire.rs` conserve exactement les quatre golden Base64 mais compare les succès par pattern matching, sans imposer `PartialEq` au type d'erreur KSP.
+
+`yellowstone_raw_parity.rs` construit désormais l'erreur de projection test-only avec un `ErrorCode` structuré et formate les codes d'erreur explicitement via `domain()` + `code()`. Aucun code d'erreur public de production n'est ajouté.
+
+## Recalibrage du sizing
+
+Le plan initial associait dans `0.3.10` deux moitiés devenues nettement séparables :
+
+```text
+common RAW + migration/parités            = déjà matérialisées en pre.002 à pre.006
+runtime Worker + sources + repair          = pas encore commencé
+```
+
+Les anciennes tranches `pre.007` à `pre.011` cumulaient plusieurs responsabilités chacune et ne respectaient plus le budget normatif d'environ 15 à 20 minutes. La clôture de toute la mission initiale dans une seule session devenait également incertaine.
+
+Le redécoupage durable retenu est donc :
+
+```text
+0.3.10 = common RAW + observed block + qualification HTTP/WS/Helius/Yellowstone
+0.3.11 = Worker foundation/runtime + persistence déterministe
+0.3.12 = Yellowstone + hydration HTTP + continuity
+0.3.13 = WS/Helius/HTTP live + convergence multi-source
+0.3.14 = gap repair/hardening + smokes provider accessibles
+0.3.15 = Desk d'ingestion
+0.3.16 = Backfill multi-source/multi-stratégie
+```
+
+La queue de fermeture de `0.3.10` devient :
+
+```text
+pre.007 = gate technique final, budget 15-20 min
+pre.008 = réconciliation documentaire, budget 10-15 min
+pre.009 = préparation de publication, budget 5-10 min
+rel.001 = publication stable mécanique
+```
+
+Chaque nouvelle release Worker recommencera par sa propre `pre.001` de sizing et devra scinder toute prerelease estimée au-delà du budget.
+
+## Vérification de l'archive
+
+Exécuté sur l'archive autoritaire avant modification :
+
+```text
+unzip -t                                  : PASS
+racine ZIP unique                         : PASS
+chemins absolus/traversal                 : 0
+symlinks                                  : 0
+workspace.package.version base            : 0.3.10-pre.6
+prompt 029 présent                        : PASS
+règles obligatoires présentes             : PASS
+```
+
+## Validations exécutées
+
+Après les corrections Rust et le recalibrage documentaire :
+
+```bash
+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.10
+```
+
+Résultats :
+
+```text
+General Rust rule audit                    : clean
+Rust export completeness audit             : 0 candidate(s)
+KSP workspace Rust rule audit              : clean
+Markdown table audit                       : clean
+```
+
+Les contrôles structurels ont également vérifié que le delta ne contient aucun chemin d'archive dangereux et que les références durables principales du nouveau découpage sont cohérentes.
+
+## Validations non exécutées dans l'environnement d'assemblage
+
+L'environnement d'assemblage ne fournit ni `cargo`, ni `rustc`, ni `rustfmt`. Les commandes suivantes ne sont donc **pas** déclarées PASS ici :
+
+```bash
+cargo fmt --all
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test -p ksp-raw-transaction-lib
+cargo test -p ksp-onchain-transport-lib
+cargo test -p ksp-job-backfill-lib
+cargo tree -p ksp-job-backfill-lib --edges normal
+cargo tree -p ksp-job-backfill-lib --edges dev
+cargo tree -p ksp-job-backfill-lib -e features
+```
+
+Elles constituent le rejeu opérateur requis pour fermer le fix.
+
+## Fichiers ajoutés
+
+```text
+deltas/0.3.10/pre.006-fix.001.md
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+ROADMAP.md
+crates/ksp-job-backfill-lib/tests/yellowstone_raw_parity.rs
+crates/ksp-raw-transaction-lib/src/wire.rs
+crates/ksp-raw-transaction-lib/unit_tests/wire.rs
+docs/architecture/004-COMPONENT_INVENTORY.md
+docs/architecture/005-DEPENDENCY_GRAPH.md
+docs/architecture/009-ACQUISITION_WORKERS_AND_JOBS.md
+docs/architecture/010-APPS_SERVICES_SCENARIOS_AND_CONTROL.md
+docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md
+docs/plans/031-V0_3_10_RAW_TRANSACTION_INGEST_PLAN.md
+docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md
+```
+
+## Fichiers supprimés
+
+Aucun.
+
+## Décisions prises
+
+- Les goldens Legacy/V0/V1 et le contrat RAW V1 de `pre.006` ne changent pas.
+- Le canari Yellowstone reste test-only et n'ajoute aucun nouvel edge productif.
+- `0.3.10` est réduit à la common RAW et aux qualifications cross-source déjà matérialisées avant ouverture du runtime Worker.
+- Le Worker concret est réparti sur `0.3.11` à `0.3.14` afin de respecter une release concrète par session et des prereleases bornées.
+- La Desk et le Backfill multi-source sont décalés respectivement à `0.3.15` et `0.3.16`.
+- Les anciens prompts/plans de releases déjà ouvertes restent des traces historiques et ne sont pas réécrits rétroactivement uniquement pour refléter ce recalibrage.
+
+## Questions ouvertes
+
+Aucune question fonctionnelle nouvelle pour ce fix. Le prochain gate est le rejeu Rust opérateur du correctif, puis `pre.007` si ce rejeu est vert.

deltas/0.3.10/pre.006-fix.002.md

@@ -0,0 +1,118 @@
+<!-- file: deltas/0.3.10/pre.006-fix.002.md -->
+<!-- version: 1 -->
+
+# Delta `0.3.10-pre.006-fix.002` — rustdoc Yellowstone + réconciliation architecture/prompt handoff
+
+## 1. Base requise
+
+```text
+0.3.10-pre.006-fix.001 appliquée
+workspace.package.version = 0.3.10-pre.6.fix.1
+```
+
+Le gate opérateur du 7 septembre 2026 confirme que les erreurs Rust corrigées par `fix.001` ont disparu. Le seul blocage restant sous Clippy strict est le lint crate-level `missing_docs` de `crates/ksp-job-backfill-lib/tests/yellowstone_raw_parity.rs`.
+
+## 2. Version technique
+
+Le correctif modifie un test Rust compilé. Conformément à `VER-ID-007` / `VER-ID-010` :
+
+```text
+workspace.package.version = 0.3.10-pre.6.fix.2
+commit attendu            = v0.3.10-pre.006-fix.002
+aucun tag prerelease
+```
+
+Aucune version npm/Tauri n'est modifiée : aucune application Desk n'est touchée.
+
+## 3. Correction Rust
+
+`tests/yellowstone_raw_parity.rs` reçoit la rustdoc crate-level manquante :
+
+```text
+//! Deterministic local Yellowstone gRPC parity canary for source-neutral RAW transaction v1 projection.
+```
+
+Aucun `#[allow(missing_docs)]` n'est ajouté. Le serveur fixture, la projection Yellowstone, les goldens, les assertions et les dépendances restent inchangés.
+
+## 4. Inventaire des composants
+
+`docs/architecture/004-COMPONENT_INVENTORY.md` :
+
+```text
++ ksp-raw-transaction-lib comme common RAW Transaction implémentée en 0.3.10
+CORE processor -> STRUCTURAL job
+CORE worker    -> STRUCTURAL worker
+```
+
+Le Job STRUCTURAL représente le traitement borné/rejouable RAW -> CORE ; le Worker STRUCTURAL représente le service continu backlog RAW -> CORE. Les références durables correspondantes dans `009-ACQUISITION_WORKERS_AND_JOBS.md`, `010-APPS_SERVICES_SCENARIOS_AND_CONTROL.md` et la séquence fonctionnelle active sont synchronisées. Les noms/packagings concrets restent à fixer lors de l'ouverture de la couche CORE.
+
+## 5. Graphe de dépendances
+
+`docs/architecture/005-DEPENDENCY_GRAPH.md` matérialise la lower layer réelle :
+
+```text
+ksp-raw-transaction-lib
+    -> ksp-store-api
+    -> ksp-core-lib
+    -> base64 / serde_json / sha2
+
+-X-> Transport
+-X-> ksp-store-lib
+-X-> Job / Worker
+-X-> Config / runtime async / backend Store
+```
+
+Le graphe Backfill ajoute son edge réel vers `ksp-raw-transaction-lib`, et le graphe du futur Worker réserve la même common crate avant la persistence par `ksp-store-lib`.
+
+## 6. Note de génération des prompts `0.3.12` à `0.3.15`
+
+Le plan `031` n'introduit pas quatre prompts prématurés. Il fixe un handoff séquentiel :
+
+```text
+0.3.11 ferme -> génère le prompt 0.3.12
+0.3.12 ferme -> génère le prompt 0.3.13
+0.3.13 ferme -> génère le prompt 0.3.14
+0.3.14 ferme -> génère le prompt 0.3.15
+```
+
+Chaque prompt doit partir de la base stable réellement obtenue, refaire son audit/sizing `pre.001`, rester sous le budget 15–20 min par tranche et rescinder sa release si la clôture dans une session devient incertaine. La note transfère les missions Yellowstone, WS/Helius/HTTP, gap repair/hardening puis Desk sans les figer comme vérité future.
+
+Le plan corrige aussi l'ancienne référence résiduelle de la Desk `0.3.11` vers sa cible recalibrée `0.3.15`.
+
+## 7. Validation opérateur requise
+
+```bash
+cargo fmt --all
+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 -p ksp-raw-transaction-lib
+cargo test -p ksp-onchain-transport-lib
+cargo test -p ksp-job-backfill-lib
+
+cargo tree -p ksp-job-backfill-lib --edges normal
+cargo tree -p ksp-job-backfill-lib --edges dev
+cargo tree -p ksp-job-backfill-lib -e features
+```
+
+Aucune commande ne doit être déclarée PASS avant exécution réelle. Si ce gate est vert, `pre.006-fix.002` ferme le défaut technique restant de `pre.006` et `pre.007` peut rester le gate technique final recalibré de `0.3.10`.
+
+## 8. Périmètre du delta
+
+```text
+Cargo.toml
+crates/ksp-job-backfill-lib/tests/yellowstone_raw_parity.rs
+docs/architecture/004-COMPONENT_INVENTORY.md
+docs/architecture/005-DEPENDENCY_GRAPH.md
+docs/architecture/009-ACQUISITION_WORKERS_AND_JOBS.md
+docs/architecture/010-APPS_SERVICES_SCENARIOS_AND_CONTROL.md
+docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md
+docs/plans/031-V0_3_10_RAW_TRANSACTION_INGEST_PLAN.md
+docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md
+deltas/0.3.10/pre.006-fix.002.md
+```
+
+Aucun code de production, manifest de crate, dépendance, feature, golden RAW, Config, Store schema, frontend ou application n'est modifié.

deltas/0.3.10/pre.006.md

@@ -0,0 +1,206 @@
+<!-- file: deltas/0.3.10/pre.006.md -->
+<!-- version: 1 -->
+
+# Delta `0.3.10-pre.006` — Transaction V1 + parité Yellowstone transaction/block
+
+## Base requise
+
+```text
+livraison : 0.3.10-pre.005-fix.002
+workspace.package.version = 0.3.10-pre.5.fix.2
+```
+
+Le gate opérateur communiqué le 2026-09-06 ferme cette baseline : audits statiques propres, `cargo check --workspace` PASS, Clippy strict PASS, common RAW PASS, 387 tests Transport avec suites publiques/release/doctests PASS, et suite Backfill complète PASS, y compris hardening et les deux canaris WS/Helius.
+
+## Objectif
+
+Fermer avant le Worker concret :
+
+```text
+Transaction V1 / SIMD-0385 dans la common source-neutral
+Yellowstone Transaction -> transaction wire exact
+Yellowstone Block       -> même transaction wire + block_time
+qualification RAW-direct vs hydration
+```
+
+Aucun adapter productif `Transport DTO -> common` n'est ajouté. `TR-C2` reste Worker-owned et `pre.007` reste le premier point où la crate Worker concrète peut apparaître.
+
+## Version
+
+```text
+workspace.package.version = 0.3.10-pre.6
+Cargo.toml header          = 499
+workspace members          = 20
+```
+
+## Common wire Legacy/V0/V1
+
+`ksp-raw-transaction-lib` ajoute un modèle source-neutral :
+
+```text
+RawSolanaMessageVersion
+RawSolanaMessageHeader
+RawSolanaCompiledInstruction
+RawSolanaAddressTableLookup
+RawSolanaTransactionConfig
+RawSolanaTransactionMessage
+RawSolanaTransactionWire
+```
+
+et deux serializers :
+
+```text
+serialize_solana_transaction_wire
+serialize_solana_transaction_wire_base64
+```
+
+Legacy et V0 conservent le layout signatures-first existant. V1 suit SIMD-0385 : `0x81`, header, config mask, lifetime, compteurs, adresses, valeurs config, headers/payloads d'instructions et signatures terminales.
+
+Les gardes V1 verrouillent notamment :
+
+```text
+transaction <= 4096 bytes
+1..=12 signatures
+<= 64 adresses
+<= 64 instructions
+num_readonly_signed < num_required_signatures
+indexes programme/comptes bornés
+aucune Address Lookup Table
+aucune adresse dupliquée
+config présente, y compris vide
+aucun trailing byte après les signatures
+```
+
+Les goldens couvrent Legacy, V0, V1 configuration complète et V1 configuration vide.
+
+## Extraction de signature V1
+
+`extract_raw_transaction_signature_from_binary_base64` distingue désormais :
+
+```text
+premier octet == 0x81 -> parser V1 et signatures terminales
+sinon                 -> parser short-vector signatures-first Legacy/V0
+```
+
+Le parser V1 parcourt structurellement mask/config, adresses, headers, payloads et signatures et exige la fin exacte du wire.
+
+## Parité Yellowstone
+
+`crates/ksp-job-backfill-lib/tests/yellowstone_raw_parity.rs` monte un serveur Geyser local déterministe, ouvre le vrai `YellowstoneGrpcChannel::open_standard_subscribe` puis reçoit :
+
+```text
+SubscribeUpdateTransaction V1
+SubscribeUpdateBlock V1 portant la même transaction
+```
+
+La projection vers `RawSolanaTransactionWire` est strictement test-only. Le canari exige le même wire V1 exact pour les deux updates et vérifie slot, transaction index et `block_time` côté Block.
+
+## Qualification RAW
+
+Le gate ferme volontairement une qualification partielle :
+
+```text
+Yellowstone transaction wire = direct/fiable
+Yellowstone Transaction RAW  = hydration HTTP obligatoire : block_time absent
+Yellowstone Block RAW complet= hydration HTTP obligatoire : meta JSON byte-identical non prouvée
+```
+
+Aucun champ manquant n'est inventé et aucune projection protobuf -> JSON ad hoc n'est introduite pour forcer un hash RAW identique.
+
+## Dependency firewall
+
+Le Backfill ajoute uniquement en dev :
+
+```text
+tonic = { workspace = true, features = ["codegen", "server"] }
+yellowstone-grpc-proto = { workspace = true, features = ["tonic"] }
+```
+
+`dependency_boundary.rs` verrouille leur absence des dépendances production et `hardening.rs` recalibre le set dev exact. Les dépendances normales restent inchangées.
+
+Il n'existe toujours aucun edge productif :
+
+```text
+ksp-onchain-transport-lib -> ksp-raw-transaction-lib
+ksp-raw-transaction-lib -> ksp-onchain-transport-lib
+```
+
+## Fraîcheur externe revalidée
+
+Revalidation le 2026-09-07 :
+
+```text
+SIMD-0385 : Transaction V1, status Review, version byte 129, signatures terminales, sans ALT
+Solana Transaction V1 examples : capacité Yellowstone avec Message.config ; activation cluster encore feature-gated/pre-release
+```
+
+Sources :
+
+```text
+https://github.com/solana-foundation/solana-improvement-documents/blob/main/proposals/0385-transaction-v1.md
+https://github.com/solana-foundation/transaction-v1-examples
+https://github.com/rpcpool/yellowstone-grpc/blob/master/yellowstone-grpc-proto/proto/solana-storage.proto
+```
+
+KSP implémente la capacité de lecture/canonicalisation V1 sans déclarer son activation sur Mainnet ou un autre cluster.
+
+## Fichiers ajoutés
+
+```text
+crates/ksp-job-backfill-lib/tests/yellowstone_raw_parity.rs
+crates/ksp-raw-transaction-lib/src/wire.rs
+crates/ksp-raw-transaction-lib/unit_tests/wire.rs
+deltas/0.3.10/pre.006.md
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-job-backfill-lib/Cargo.toml
+crates/ksp-job-backfill-lib/tests/dependency_boundary.rs
+crates/ksp-job-backfill-lib/tests/hardening.rs
+crates/ksp-raw-transaction-lib/src/lib.rs
+crates/ksp-raw-transaction-lib/src/signature.rs
+crates/ksp-raw-transaction-lib/tests/dependency_boundary.rs
+crates/ksp-raw-transaction-lib/tests/public_api.rs
+crates/ksp-raw-transaction-lib/tests/release_completeness.rs
+crates/ksp-raw-transaction-lib/unit_tests/signature.rs
+docs/architecture/011-RAW_TRANSACTION_ACQUISITION.md
+docs/plans/031-V0_3_10_RAW_TRANSACTION_INGEST_PLAN.md
+docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md
+```
+
+## Fichiers supprimés
+
+Aucun.
+
+## Gate opérateur demandé
+
+```bash
+cargo fmt --all
+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 -p ksp-raw-transaction-lib
+cargo test -p ksp-onchain-transport-lib
+cargo test -p ksp-job-backfill-lib
+cargo tree -p ksp-job-backfill-lib --edges normal
+cargo tree -p ksp-job-backfill-lib --edges dev
+cargo tree -p ksp-job-backfill-lib -e features
+```
+
+Les arbres Cargo sont requis car `pre.006` ajoute deux dev-dependencies test-only.
+
+## Décisions prises
+
+```text
+common sérialise Legacy/V0/V1 sans dépendre de Transport
+V1 est reconnu par 0x81 et possède des signatures terminales
+Yellowstone Transaction/Block conservent un transaction wire V1 exact sur canari
+Yellowstone RAW complet reste hydraté par HTTP tant que TR-C4 meta/block_time complet n'est pas prouvé
+aucun RAW v2 automatique
+aucun Worker concret avant pre.007
+TR-C2 reste Worker-owned
+```