<!-- file: docs/validation/027-V0_3_10_RAW_TRANSACTION_INGEST.md -->
<!-- version: 14 -->

# Validation v0.3.10 — RAW Transaction commune + qualification cross-source

## 1. Rôle du document

Ce document suit les preuves de la release `0.3.10` : extraction de la canonicalisation RAW v1 vers `ksp-raw-transaction-lib`, migration Backfill, matériau/wire source-neutral et qualification cross-source HTTP/WS/Helius/Yellowstone. Après le recalibrage de `pre.006-fix.001`, la matérialisation du Worker continu est transférée vers `0.3.11` à `0.3.14` avant toute implémentation lourde.

Il distingue toujours :

```text
preuve exécutée
preuve seulement planifiée
preuve live accessible
preuve live bloquée par secret/tier
non-claim explicite
```

## 2. Gate `pre.001` — audit/sizing/plan

État : **fermé pour la planification**, sans claim Cargo local.

### 2.1 Base contrôlée

```text
archive : khadhroony-solana-project-v0.3.9.zip
SHA-256 : 41ef2589a11410aabfb329d387f0008e116006da60ada0802e5f72bc30d3466f
bytes : 7859118
entries : 1855
unzip -t : PASS
workspace members : 19
workspace.package.version base : 0.3.9
stable delta : deltas/0.3.9/rel.001.md
```

Sécurité archive :

```text
absolute/traversal entries : 0
symlinks : 0
.git/ : 0
target/ : 0
node_modules/ : 0
Cargo.lock : 0
.env : 0
private-key-like files checked : 0
```

Le ZIP ne contient pas `.git`; le tag n’est donc pas directement inspectable dans cet environnement.

### 2.2 Baseline statique 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))
```

### 2.3 Cargo local

```text
cargo : indisponible dans l’environnement d’assemblage
```

Par conséquent :

```text
cargo fmt   : NON EXÉCUTÉ ici
cargo check : NON EXÉCUTÉ ici
cargo clippy: NON EXÉCUTÉ ici
cargo test  : NON EXÉCUTÉ ici
cargo tree  : NON EXÉCUTÉ ici
Tauri build : NON EXÉCUTÉ ici
```

Aucun de ces gates n’est déclaré PASS par cette session. Le journal opérateur fourni pour la stable `0.3.9` montre un gate complet antérieur ; il reste une preuve externe de la base stable, pas une exécution `pre.001` locale.

### 2.4 Gate opérateur après livraison de `pre.001`

Le 6 septembre 2026, l’opérateur a exécuté sur `workspace.package.version = 0.3.10-pre.1` :

```text
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
```

Résultats communiqués :

```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), 753 file(s))
cargo check --workspace : terminé sans erreur
cargo clippy --workspace --all-targets --all-features -- -D warnings : terminé sans erreur
```

Ce gate opérateur ferme les contrôles demandés pour passer à `pre.002`. Aucun `cargo test` de `pre.001` n’a été fourni dans ce message et il n’est pas inventé.

## 3. Preuves de conception fermées en `pre.001`

### 3.1 Common RAW

Décisions prouvées par inspection du code courant :

```text
format_id courant = ksp.solana.raw_transaction
format_version courant = 1
RawObservationKey est explicitement producer-owned dans Store
RawTransaction identity = network + signature
RawTransactionObservation est séparée de l’entité
`DEP-PIPE-006` impose les modèles `ksp-store-api` à la lower-layer RAW réutilisable ; la décision `ksp-store-lib` de `pre.001` est corrigée en `pre.002`
Backfill conversion mélange actuellement canonicalisation commune et metadata Job-owned
```

Canari RAW v1 recalculé :

```text
bytes = {"transaction":["AQID","base64"],"meta":{"a":{"x":null,"y":true},"z":1},"version":"legacy","transactionIndex":7}
len = 112
sha256 = 220792d2b15d262fda242cb220774ee9ddeffebf04dcfadabcf8ef76a9b1a7c3
```

Le plan interdit tout déplacement de `job_id`, `scope_fingerprint`, lifecycle, checkpoint ou observation-key algorithm dans common.

### 3.2 Transport

Inventaire confirmé dans `ksp-onchain-transport-lib` :

```text
HttpObservedValue<T>
get_transaction_observed
get_block / get_blocks / get_blocks_with_limit
logsSubscribe
signatureSubscribe
blockSubscribe
Helius transactionSubscribe
Yellowstone transactions
Yellowstone transactions_status
Yellowstone blocks
Yellowstone blocks_meta
Yellowstone slots
Yellowstone from_slot
SubscribeReplayInfo / reconnect snapshot
```

Gaps requalifiés :

```text
TR-B confirmé : get_block_observed
TR-C confirmé/scindé : common material + adapters Worker + Transport seulement si DTO insuffisant
TR-D confirmé : provenance durable full-material + runtime source projection
TR-E confirmé : réutiliser from_slot/replay existant, aucun second moteur
TR-F réservé : aucun EARLY sans protocole+accès+rôle RAW prouvés
```

### 3.3 Config

Constats :

```text
std.transport format_version = 3
mainnet logique déjà canonique
profils OrbitFlare Devnet et PublicNode Mainnet/Testnet déjà présents
gRPC metadata publique/secrète déjà typée et redacted
HTTP roles/priorities/limits déjà supportés
WS protocol/session déjà supportés
```

Décision de handoff : pas d’edge Worker -> Config et pas de nouveau document métier Worker imposé par la common RAW. Une adaptation Config future n’est admise que pour un manque Transport concret découvert dans les releases Worker concernées.

## 4. Fraîcheur externe `pre.001`

### 4.1 Yellowstone

Vérifié le 5 septembre 2026 :

```text
yellowstone-grpc-proto latest = 12.7.0
publication = 2026-08-29
workspace KSP = ^12.7
```

Décision : aucun bump en ouverture.

Canaris imposés par changements upstream récents :

```text
Transaction V1/config doit survivre à la projection
block replay from_slot doit avoir un smoke dédié
```

### 4.2 Providers

| Source           | Fait revalidé                                                                        | Type de preuve `0.3.10`                |
|:-----------------|:-------------------------------------------------------------------------------------|:---------------------------------------|
| Solana public    | HTTP/WS standard accessibles ; blockSubscribe unstable                               | live opt-in + fixtures                 |
| PublicNode       | Yellowstone Mainnet/Testnet affiché ; archive access proposé                         | live opt-in si token/config disponible |
| OrbitFlare       | Devnet gRPC Free/Developer ; Yellowstone full-fidelity                               | live opt-in avec x-token opérateur     |
| Helius           | transactionSubscribe courant ; blockSubscribe non supporté ; LaserStream replay 24 h | fixture + live si tier/key             |
| QuickNode        | gRPC Scale+ ; port 443/x-token ; 10000 sunset 2026-10-01                             | tier-bloqué                            |
| Alchemy          | PAYG/Enterprise ; docs replay 6000 vs 432000 slots contradictoires                   | tier-bloqué, aucune constante          |
| Jito ShredStream | shutdown annoncé 2026-09-05                                                          | exclu TR-F                             |

## 5. Gates de parité RAW obligatoires

Une source dite full n’obtient le statut `direct canonical producer` qu’après :

```text
same fixture identity
same canonical bytes
same SHA-256
same slot
same block_time semantics
same version/index semantics
```

Familles à prouver séparément :

```text
HTTP getTransaction
HTTP getBlock transaction
WS blockSubscribe transaction legacy/v0 full/base64
Helius transactionSubscribe full/base64 -> negative parity / hydration
Yellowstone transaction
Yellowstone block transaction
Transaction V1
```

En cas d’échec de parité :

```text
pas de RAW v2 automatique
pas de first-provider-wins
pas de content normalization ad hoc non documentée
source utilisée comme discovery + hydration HTTP jusqu’à résolution
```

## 6. Gates Worker transférés aux releases `0.3.11`–`0.3.14`

Ces gates faisaient partie du plan `pre.001` initial. Ils restent des exigences de handoff, mais **ne sont plus des critères de sortie de `0.3.10`** depuis le redécoupage de `pre.006-fix.001`. Leur conservation ici évite de perdre le threat model et les preuves prévues ; leur exécution appartient aux nouveaux documents de validation Worker.

### 6.1 Lifecycle/runtime

```text
Created -> Starting -> Running -> Stopping -> Stopped
Faulted terminal
stop idempotent
caller-owned Tokio runtime
Worker-owned spawned tasks
aucun JoinHandle public
shutdown borné
aucune tâche source survivante
```

### 6.2 Sources et backpressure

```text
N sources simultanées
bounded channels seulement
slow source isolation
queue saturation observable
aucun drop silencieux
degraded/unhealthy/fault policy explicite
```

### 6.3 Persistence

```text
new entity + new observation
idempotent entity + new source observation
idempotent observation
content conflict terminal
aucun backend physique dans Worker
```

### 6.4 Continuité

```text
run frontier borné
reconnect != replay
transaction replay from_slot
block replay from_slot
redundant-source repair
HTTP block repair
hydration repair
unresolved gap reste visible
aucun historical caller parameter
```

### 6.5 Observabilité

```text
WorkerSnapshot commun
RawTransactionIngestSnapshot concret
latest-value indépendamment des lecteurs
source health/counters/gaps/frontiers sûrs
aucun payload/signature/URL/secret
```

## 7. Matrice de types de preuve

| Preuve                        | Déterministe | Réseau externe |   Secret/tier   | Gate release                                      |
|:------------------------------|:------------:|:--------------:|:---------------:|:--------------------------------------------------|
| common golden RAW v1          |     oui      |      non       |       non       | obligatoire                                       |
| cross-source parity fixtures  |     oui      |      non       |       non       | obligatoire                                       |
| Worker fake multi-source      |     oui      |      non       |       non       | obligatoire                                       |
| Store façade fake             |     oui      |      non       |       non       | obligatoire                                       |
| HTTP/WS Solana public smoke   |     non      |      oui       |       non       | opt-in, pertinent                                 |
| PublicNode Yellowstone        |     non      |      oui       |    possible     | opt-in si accès                                   |
| OrbitFlare Devnet Yellowstone |     non      |      oui       |     x-token     | opt-in si accès                                   |
| Helius transactionSubscribe   |     non      |      oui       |    key/tier     | opt-in, non bloquant si tier absent               |
| QuickNode Yellowstone         |     non      |      oui       |      tier       | bloqué, fixture suffit                            |
| Alchemy Yellowstone           |     non      |      oui       | PAYG/Enterprise | bloqué, fixture suffit                            |
| PostgreSQL Store proof        |     non      | local/externe  |   URI dédiée    | opt-in gate technique si environnement disponible |

## 8. Commands de gate cible

À exécuter dès que Rust est modifié puis au gate technique final :

```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 --workspace --all-targets --all-features
cargo tree -p ksp-raw-transaction-lib --edges normal
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
cargo tree --duplicates
```

Ne jamais remplacer un gate non exécuté par un ancien log stable.

## 9. Non-claims `pre.001`

À ce stade il n’est **pas** affirmé que :

```text
Yellowstone full produit déjà des bytes RAW v1 identiques à HTTP
Helius full produit déjà des bytes RAW v1 identiques à HTTP
PublicNode/OrbitFlare replay est disponible à une profondeur donnée
Alchemy a une profondeur replay stable
une source WS reconnectée est lossless
une source EARLY est implémentée
le Worker concret existe déjà
la common crate existe déjà
un test Cargo de pre.001 a été exécuté localement
```

Ces points deviennent des gates ou restent explicitement bloqués.

## 10. Trajectoire de validation

```text
pre.002 common golden + dependency firewall
pre.003 Backfill migration parity
pre.004 observed block
pre.005 WS/Helius parity
pre.006 Yellowstone parity
pre.006-fix.001 corrections Rust + recalibrage du sizing
pre.007 final technical gate 0.3.10
pre.008 final docs reconciliation 0.3.10
pre.009 publication preparation 0.3.10
rel.001 stable publication
0.3.11 Worker foundation/runtime
0.3.12 Yellowstone live + hydration + continuity
0.3.13 WS/Helius/HTTP live + convergence multi-source
0.3.14 gap repair/hardening + smokes
0.3.15 Desk d'ingestion
0.3.16 Backfill multi-source
```

## 11. Gate `pre.002` — common RAW foundation

État : **matérialisé ; `pre.002-fix.001` requis après gate Clippy opérateur**.

### 11.1 Crate et frontière

```text
crate = ksp-raw-transaction-lib
workspace.package.version = 0.3.10-pre.2
runtime async = aucun
Transport / Config / Job / Worker = absents
backend Store = absent
```

La dépendance exacte retenue après contrôle normatif est :

```text
ksp-raw-transaction-lib
    -> ksp-core-lib
    -> ksp-store-api
    -> serde_json
    -> sha2
```

Cette correction remplace la proposition `ksp-store-lib(default-features=false)` de `pre.001` car `DEP-PIPE-006` est plus spécifique : le pipeline RAW partagé peut dépendre de `ksp-store-api`, pas de `ksp-store-lib`.

### 11.2 Surface matérialisée

```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
```

`RawObservationKey` reste fournie par le producteur. La common crate ne contient aucun domaine de clé Backfill/Worker.

### 11.3 Preuves déterministes ajoutées

```text
signature Base58 : bornes texte + alphabet + overflow + exactement 64 octets
RAW v1 golden : 112 bytes exacts
RAW v1 SHA-256 : 220792d2b15d262fda242cb220774ee9ddeffebf04dcfadabcf8ef76a9b1a7c3
meta/version/index : omitted != null != value
JSON : clés objet triées récursivement, arrays conservés, strings échappées, nombres conservés
block_time : négatif/overflow/max Store
payload : borne MAX_RAW_PAYLOAD_BYTES
Debug/error : aucune signature, transaction body ou meta hostile recopiée
acquisition : observation key producer-owned et référence exactement égale à la transaction
public API : consommation par crate-root
firewall : absence Store runtime/Transport/Config/Job/Worker/backend
```

### 11.4 Validation locale d’assemblage

Exécuté 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))

manifest TOML : 20 membres workspace, ksp-raw-transaction-lib présent
manifest common : 4 dépendances exactes, aucune feature/dev/build dependency
```

`cargo`, `rustc` et `rustfmt` ne sont pas présents dans cet environnement. Les gates Cargo de la nouvelle crate restent donc **NON EXÉCUTÉS LOCALEMENT**.

### 11.5 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
```

`pre.003` ne doit migrer le Backfill qu’après ce gate vert.

### 11.6 Résultat opérateur du 2026-09-06 et `pre.002-fix.001`

Le gate communiqué exécute bien la séquence demandée. Résultats observés :

```text
cargo fmt --all : exécuté
audits Rust : clean ; export completeness = 0 ; workspace rules = clean
audit Markdown : clean (339 tables, 754 fichiers)
cargo check --workspace : PASS
cargo clippy --workspace --all-targets --all-features -- -D warnings : FAIL
cargo test -p ksp-raw-transaction-lib : PASS, 9 unit + 8 intégration, 0 échec
cargo tree --edges normal : graphe attendu core/store-api/serde_json/sha2
cargo tree -e features : aucun feature KSP/runtime inattendu
```

L’échec Clippy est limité à cinq diagnostics dans les nouveaux tests d’intégration :

```text
missing_docs : tests/dependency_boundary.rs
missing_docs : tests/public_api.rs
missing_docs : tests/release_completeness.rs
missing_docs : tests/security_hardening.rs
clippy::collapsible_if : tests/release_completeness.rs
```

`pre.002-fix.001` applique la convention déjà utilisée dans le workspace : une rustdoc de crate `//! ...` dans chaque test d’intégration. Le `if` imbriqué d’inventaire est réécrit sans suppression de lint ni `#[allow(...)]`. Aucun type public, golden, dépendance, feature ou comportement RAW n’est modifié.

Version technique du fix :

```text
workspace.package.version = 0.3.10-pre.2.fix.1
```

Le gate Clippy complet doit être rejoué après application du fix avant ouverture de `pre.003`.

## 12. `pre.002-fix.001` fermé et `pre.003` — migration Backfill vers common

### 12.1 Fermeture opérateur de `pre.002-fix.001`

Le rejeu communiqué le 2026-09-06 ferme le fix précédent :

```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), 755 file(s))
cargo check --workspace : PASS
cargo clippy --workspace --all-targets --all-features -- -D warnings : PASS
cargo test -p ksp-raw-transaction-lib : PASS
```

Détail des tests common communiqué :

```text
9 unitaires : PASS
8 intégration : PASS
0 échec
0 doctest
```

L’arbre normal confirme uniquement `ksp-core-lib`, `ksp-store-api`, `serde_json` et `sha2` côté common. L’arbre de features ne révèle aucune feature KSP/runtime inattendue. `pre.003` peut donc être ouverte.

### 12.2 Migration réalisée dans `pre.003`

`ksp-job-backfill-lib` dépend désormais explicitement de `ksp-raw-transaction-lib`. La conversion Backfill ne possède plus :

```text
algorithme Base58 64-byte
canonical JSON récursif
construction RawPayload
SHA-256 du payload RAW
conversion block_time RAW
assemblage direct RawTransaction + RawTransactionObservation
```

Le chemin productif devient :

```text
BackfillSignature
    -> ksp-raw-transaction-lib::parse_raw_transaction_signature

SolanaConfirmedTransaction
    -> adapter Transport local
    -> RawTransactionMaterial::binary_base64
    -> ksp-raw-transaction-lib::canonicalize_raw_transaction

Backfill provenance + Backfill observation key
    -> ksp-raw-transaction-lib::assemble_raw_transaction_acquisition
    -> Store facade
```

Le Backfill conserve volontairement :

```text
getTransaction observed + rôle HTTP
commitment/campagne/job_id/scope_fingerprint
provider + endpoint réel gagnant
RawAcquisitionOrigin::Backfill
capture_session = JobId
algorithme de RawObservationKey Backfill v1
remapping des erreurs common vers ERROR_CODE_BACKFILL_RAW_CONVERSION_INVALID
persistence Store et sémantique Missing
```

### 12.3 Parité gelée

Les canaris Backfill continuent d’exiger :

```text
RAW_TRANSACTION_FORMAT_ID = ksp.solana.raw_transaction
RAW_TRANSACTION_FORMAT_VERSION = 1
byte_len golden = 112
sha256 golden = 220792d2b15d262fda242cb220774ee9ddeffebf04dcfadabcf8ef76a9b1a7c3
block_time golden = 1700000000000 ms
network = devnet
signature = 64 octets zéro pour le vecteur de référence
provider = publicnode
protocol = solana.http.json_rpc
method = getTransaction
endpoint = devnet-primary
commitment = finalized
capture_session = backfill:pre006
```

L’observation key Backfill du vecteur `provider` / `endpoint-a` est désormais verrouillée byte-for-byte :

```text
b8550f0f2165f370de918bd4fb0ec782391afdddb88c57f010743e000b136702
```

Ce canari prouve que la migration common ne déplace pas l’idempotence producer-owned vers la lower layer.

### 12.4 Frontières de dépendances

Le graphe Backfill attendu devient :

```text
ksp-job-backfill-lib
    -> 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
    -> sha2
    -> tokio macros+sync
```

`serde_json` reste un type direct de l’adapter Transport (`SolanaWireField<serde_json::Value>`), mais aucune canonicalisation JSON Backfill n’existe plus. `sha2` reste Job-owned pour scope fingerprint et observation key ; le hash du payload RAW appartient désormais uniquement à common.

### 12.5 Validation locale d’assemblage `pre.003`

Exécuté 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 toujours ni `cargo`, ni `rustc`, ni `rustfmt`. Les gates Cargo de `pre.003` restent donc à rejouer côté opérateur.

### 12.6 Gate opérateur demandé pour `pre.003`

```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
```

## 13. Fermeture opérateur `pre.003` et gate `pre.004` — HTTP observed block

### 13.1 Fermeture opérateur de `pre.003`

Le rejeu communiqué le 2026-09-06 ferme la migration Backfill :

```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), 756 file(s))
cargo check --workspace : PASS
cargo clippy --workspace --all-targets --all-features -- -D warnings : PASS
cargo test -p ksp-raw-transaction-lib : PASS, 9 unit + 8 intégration
cargo test -p ksp-job-backfill-lib : PASS, 51 unit + 20 intégration
cargo tree -p ksp-job-backfill-lib --edges normal : edge common présent, graphe attendu
cargo tree -p ksp-job-backfill-lib -e features : aucune feature KSP inattendue
```

`pre.004` peut donc être ouverte sur une base entièrement validée.

### 13.2 Surface Transport `pre.004`

`HttpTransportPool::get_block_observed(...)` :

```text
réutilise exactement la validation/config moderne de get_block
utilise le même routing/admission/retry standard
retourne Option<SolanaConfirmedBlock>
conserve endpoint_name + provider du winner réel
préserve result = null comme None
n’expose ni URL, ni headers, ni raw HTTP body
Debug de HttpObservedValue ne rend pas le block payload
```

Les fixtures déterministes couvrent le retry/reroute depuis un premier endpoint `429` vers un second winner et vérifient que la provenance retournée appartient au second endpoint.

### 13.3 Matériau common depuis un bloc Base64

`ksp-raw-transaction-lib` ajoute :

```text
extract_raw_transaction_signature_from_binary_base64(...)
RawTransactionMaterial::binary_base64_with_embedded_signature(...)
```

L’extracteur :

```text
borne l’entrée avant décodage
exige un Base64 STANDARD canonique
lit le short_vec Solana de signatures sans dépendance Solana transaction runtime
refuse count = 0
refuse short_vec tronqué/non canonique
refuse tableau de signatures tronqué
exige des bytes message après le tableau déclaré
copie uniquement la première signature exacte de 64 octets
ne copie jamais le transaction wire dans erreur/Debug
```

Les fixtures de référence utilisent deux transactions minimales de `66` octets : prefix `1`, signatures respectives `[0; 64]` et `[1; 64]`, puis un byte de message. Les signatures extraites sont donc exactement distinctes et restent associées aux index 0 et 1 du bloc.

### 13.4 Preuve cross-layer sans mauvais edge

Le canari d’intégration `ksp-job-backfill-lib/tests/http_block_material.rs` utilise les deux dépendances déjà autorisées de cette crate pour prouver :

```text
get_block_observed
    -> SolanaConfirmedBlock
    -> 2 SolanaBlockTransaction distinctes
    -> full Base64 transaction + meta + version + index 0/1
    -> RawTransactionMaterial::binary_base64_with_embedded_signature
    -> canonicalize_raw_transaction
    -> signatures [0;64] / [1;64] préservées
```

Cette preuve est volontairement test-only. `TR-C2` reste inchangé : l’adapter productif Transport DTO -> common sera Worker-owned. Il n’existe toujours aucun edge de production `ksp-onchain-transport-lib -> ksp-raw-transaction-lib` ni l’inverse.

### 13.5 Audits d’assemblage

Exécuté dans l’environnement d’assemblage après fermeture du delta :

```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))
```

Les gates Cargo restent à rejouer côté opérateur dans l’environnement Rust complet :

```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 --test http_block_material
cargo tree -p ksp-raw-transaction-lib --edges normal
cargo tree -p ksp-onchain-transport-lib --edges normal
```

### 13.6 Résultat opérateur de `pre.004` et `pre.004-fix.001`

Le rejeu communiqué le 2026-09-06 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, 12 unit + 9 intégration, 0 échec
cargo test -p ksp-onchain-transport-lib : PASS, 387 unit + 51 public API + 43 release completeness + 4 doctests, 0 échec ; smokes live ignorés comme prévu
cargo test -p ksp-job-backfill-lib --test http_block_material : PASS, 1 test
cargo tree -p ksp-raw-transaction-lib --edges normal : graphe attendu avec base64/core/store-api/serde_json/sha2
cargo tree -p ksp-onchain-transport-lib --edges normal : aucun edge vers ksp-raw-transaction-lib
```

L’échec Clippy est strictement limité à sept `clippy::expect_used` dans les helpers privés de fixture de `crates/ksp-job-backfill-lib/tests/http_block_material.rs` : construction de l’URL/pool, bind/adresse/accept/read/write du serveur local. Les `expect()` situés directement dans la fonction `#[tokio::test]` restent conformes à `allow-expect-in-tests = true`.

`pre.004-fix.001` remplace uniquement ces sept usages hors-test par des retours `Result` et un contrôle de flux explicite. Aucun `#[allow(...)]` n’est ajouté et aucun code de production n’est modifié.

Version technique du fix :

```text
workspace.package.version = 0.3.10-pre.4.fix.1
```

Le rejeu du fix communiqué le 2026-09-06 est intégralement vert :

```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), 758 file(s))
cargo check --workspace : PASS
cargo clippy --workspace --all-targets --all-features -- -D warnings : PASS
cargo test -p ksp-raw-transaction-lib : PASS, 12 unit + 9 intégration, 0 échec
cargo test -p ksp-onchain-transport-lib : PASS, 387 unit + 51 public API + 43 release completeness + 4 doctests, 0 échec ; smokes live ignorés comme prévu
cargo test -p ksp-job-backfill-lib : PASS, 51 unit + 21 intégration, 0 échec
```

Les arbres Cargo n’ont pas été rejoués sur ce fix car aucune dépendance ni feature n’a changé. `pre.004-fix.001` est donc fermé et `pre.005` peut s’ouvrir.

### 13.7 Qualification WS/Helius de `pre.005`

Le canari `ksp-job-backfill-lib/tests/ws_raw_parity.rs` utilise uniquement des serveurs HTTP/WS locaux déterministes. Aucun smoke réseau ni secret provider n’est requis.

Cas positif standard :

```text
HTTP getBlock observed
WS blockSubscribe confirmed/full/base64/maxSupportedTransactionVersion=0
    -> même SolanaConfirmedBlock
    -> même RawTransactionReference
    -> même slot
    -> même block_time
    -> mêmes bytes RAW v1
    -> même content_hash
```

Ce gate qualifie uniquement le sous-ensemble legacy/v0. Transaction V1 reste au gate `pre.006`.

Cas négatif Helius :

```text
Helius transactionSubscribe full/base64
    -> même signature/identité que HTTP
    -> même slot
    -> transaction wire + meta + transactionIndex présents
    -> blockTime absent
    -> version absente

meilleure projection Helius
    != hydration HTTP complète sur block_time
    != bytes RAW v1
    != content_hash
```

Le résultat est normatif pour le Worker : Helius `transactionSubscribe` est un signal live riche qui doit être hydraté par HTTP avant persistence RAW. Aucun champ absent n’est inventé et aucun RAW v2 n’est introduit.

La dépendance `tokio-tungstenite` nécessaire aux fixtures WS est strictement `dev-dependencies`; `tests/dependency_boundary.rs` verrouille cette frontière. Aucun edge de production Transport -> common n’est ajouté.

### 13.8 Premier rejeu opérateur de `pre.005` et fix de typage

Le rejeu communiqué le 2026-09-06 obtient :

```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), 759 file(s))
cargo check --workspace : PASS
cargo clippy --workspace --all-targets --all-features -- -D warnings : FAIL sur une unique erreur E0308 du canari ws_raw_parity
cargo test -p ksp-raw-transaction-lib : PASS, 12 unit + 9 intégration, 0 échec
cargo test -p ksp-onchain-transport-lib : PASS, 387 unit + 51 public API + 43 release completeness + 4 doctests, 0 échec ; smokes live ignorés comme prévu
cargo test -p ksp-job-backfill-lib : FAIL à la compilation du même canari ws_raw_parity
cargo tree -p ksp-job-backfill-lib --edges normal : PASS, surface normale attendue
cargo tree -p ksp-job-backfill-lib --edges dev : PASS, tokio + tokio-tungstenite uniquement
cargo tree -p ksp-job-backfill-lib -e features : PASS
```

L’erreur est strictement locale à l’assertion de preuve Helius :

```text
http_raw.block_time().map(...unix_millis()) -> Option<u64>
Some(FIXTURE_BLOCK_TIME * 1_000)          -> Option<i64>
```

`pre.005-fix.001` remplace la constante de comparaison par `FIXTURE_BLOCK_TIME_MILLIS: u64 = 1_787_072_400_000` et compare directement `Option<u64>` à `Option<u64>`. Aucun cast, `unwrap`, `expect`, code de production ou changement de dépendance n’est introduit. Les goldens de qualification standard/Helius et la frontière `tokio-tungstenite` dev-only restent inchangés.

L’assemblage local du fix obtient :

```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))
```

### 13.9 Second rejeu opérateur de `pre.005-fix.001` et fix Clippy/hardening

Le rejeu communiqué le 2026-09-06 confirme d’abord :

```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), 760 file(s))
cargo check --workspace : PASS
cargo test -p ksp-raw-transaction-lib : PASS, 12 unit + 9 intégration, 0 échec
cargo test -p ksp-onchain-transport-lib : PASS, 387 unit + 51 public API + 43 release completeness + 4 doctests, 0 échec ; smokes live ignorés comme prévu
```

Deux défauts restent strictement confinés aux nouveaux canaris de `pre.005` :

```text
cargo clippy --workspace --all-targets --all-features -- -D warnings
    -> FAIL : 25 clippy::question_mark_used dans tests/ws_raw_parity.rs

cargo test -p ksp-job-backfill-lib
    -> 51 unit PASS
    -> dependency_boundary 3/3 PASS
    -> hardening 8/9 PASS
    -> FAIL : inventaire dev attendu {tokio} alors que le manifest réel contient {tokio, tokio-tungstenite}
```

`pre.005-fix.002` corrige uniquement ces gardes :

```text
ws_raw_parity.rs
    ? sur Option/Result -> match explicite ou if let Err(...)
    aucun #[allow(...)]
    aucun changement de scénario/golden

hardening.rs
    dev attendu -> {tokio, tokio-tungstenite}
    inventaire normal inchangé
```

Le fix ne modifie ni `crates/ksp-job-backfill-lib/Cargo.toml`, ni aucune dépendance/feature, ni le code de production. Les arbres Cargo déjà validés pour `pre.005` restent donc applicables et n’ont pas besoin d’être rejoués pour ce fix.

L’assemblage local de `pre.005-fix.002` obtient :

```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))
```

### 13.10 Gate d'assemblage `pre.006` — Transaction V1 et Yellowstone

Le rejeu opérateur de `pre.005-fix.002` communiqué le 6 septembre 2026 est intégralement vert : audits statiques, `cargo check --workspace`, Clippy strict, common RAW, 387 tests Transport avec suites publiques/release/doctests, et suite Backfill complète incluant hardening et parité WS/Helius. `pre.006` part donc de cette baseline fermée.

La tranche ajoute dans `ksp-raw-transaction-lib` :

```text
RawSolanaMessageVersion Legacy/V0/V1
RawSolanaMessageHeader
RawSolanaCompiledInstruction
RawSolanaAddressTableLookup
RawSolanaTransactionConfig
RawSolanaTransactionMessage
RawSolanaTransactionWire
serialize_solana_transaction_wire
serialize_solana_transaction_wire_base64
```

Les tests common imposent des goldens Base64 exacts Legacy/V0/V1, la configuration V1 vide significative, les limites structurelles V1, l'interdiction des ALT et l'extraction de signature depuis les signatures terminales.

Le canari Backfill `tests/yellowstone_raw_parity.rs` utilise un serveur Geyser local et le vrai canal public Yellowstone Transport. Il exige :

```text
Transaction V1 : slot = 42, index = 3, wire = golden common
Block V1       : slot = 42, index = 3, block_time présent, wire identique
meta           : conservée comme DTO Yellowstone, sans prétendre à l'identité JSON HTTP
```

Décision de qualification :

```text
Yellowstone transaction wire  = QUALIFIÉ
Yellowstone Transaction RAW   = HYDRATION HTTP (block_time absent)
Yellowstone Block RAW complet = HYDRATION HTTP (meta JSON byte-identical non prouvée)
TR-C2 adapter productif       = différé au Worker 0.3.11
```

Le manifest Backfill ajoute uniquement en dev :

```text
tonic = { workspace = true, features = ["codegen", "server"] }
yellowstone-grpc-proto = { workspace = true, features = ["tonic"] }
```

`tests/dependency_boundary.rs` vérifie qu'elles ne figurent pas avant `[dev-dependencies]`, et le canari hardening attend exactement `{tokio, tokio-tungstenite, tonic, yellowstone-grpc-proto}` en dev tout en gardant l'inventaire normal inchangé.

L'environnement d'assemblage ne fournit ni `cargo`, ni `rustc`, ni `rustfmt`. Le gate Cargo/Clippy/tests reste donc opérateur. Les audits Python KSP et Markdown sont exécutés après fermeture du delta et leurs résultats sont enregistrés dans `deltas/0.3.10/pre.006.md`.

### 13.11 Rejeu opérateur de `pre.006-fix.001` et `pre.006-fix.002`

Le rejeu opérateur communiqué le 7 septembre 2026 confirme la correction des trois familles d'erreurs initiales de `pre.006-fix.001` :

```text
cargo check --workspace                                      PASS
ksp-raw-transaction-lib                                      16 unit + 10 integration/public/security PASS
ksp-onchain-transport-lib                                    387 unit + 51 public + 43 release + doctests PASS
ksp-job-backfill-lib                                         51 unit + suites integration PASS hors lint strict
```

Le seul échec de `cargo clippy --workspace --all-targets --all-features -- -D warnings` restant est :

```text
crates/ksp-job-backfill-lib/tests/yellowstone_raw_parity.rs
missing documentation for the crate
```

Le fichier d'intégration Yellowstone était le seul test de la crate sans rustdoc de crate `//! ...`. `pre.006-fix.002` ajoute uniquement cette documentation crate-level et incrémente la version technique à `0.3.10-pre.6.fix.2`; aucune logique de fixture, aucun golden, aucune dépendance et aucun comportement de production ne changent.

Le même correctif réconcilie aussi l'architecture durable avec l'extraction common déjà effective :

```text
ksp-raw-transaction-lib est inventoriée explicitement ;
son graphe lower-layer est documenté ;
les anciens libellés `CORE processor` / `CORE worker` sont requalifiés en `STRUCTURAL job` / `STRUCTURAL worker` ;
le plan conserve une note de génération séquentielle des prompts 0.3.12 -> 0.3.15.
```

Le rejeu opérateur du 8 septembre 2026 sur `0.3.10-pre.6.fix.2` ferme ce correctif sans warning ni test rouge :

```text
Rust audits                                                    PASS
Markdown audit                                                 PASS (340 tables / 764 files)
cargo check --workspace                                       PASS
cargo clippy --workspace --all-targets --all-features -D warnings PASS
ksp-raw-transaction-lib                                       PASS
ksp-onchain-transport-lib                                     PASS
ksp-job-backfill-lib                                          PASS
```

Les smokes réseau opt-in de Transport restent `ignored` conformément à leur politique et ne sont pas transformés en succès live. Cette preuve autorise l'ouverture de `pre.007`, mais ne remplace pas le gate final exigé sur l'identifiant `0.3.10-pre.7`.

### 13.12 Ouverture du gate technique final `pre.007`

`pre.007` ne porte aucun nouveau scope fonctionnel. Il fige la version workspace à `0.3.10-pre.7` et exige le gate complet de la section 8 sur cette version exacte. Les références au Worker concret sont retirées du gate puisque `ksp-worker-raw-transaction-ingest-lib` appartient désormais à `0.3.11`.

Tout défaut découvert ouvre `pre.007-fix.NNN`. Tant que le gate `pre.007` n'est pas entièrement vert, `pre.008` de réconciliation documentaire ne doit pas commencer.

### 13.13 Gate opérateur `pre.007` et ouverture de `pre.008`

Le rejeu opérateur communiqué le 8 septembre 2026 sur `0.3.10-pre.7` ferme le gate technique final : audits Rust/Markdown, `cargo check --workspace`, Clippy workspace strict, `cargo test --workspace --all-targets --all-features`, suites ciblées common/Transport/Backfill et graphes Cargo demandés sont exécutés sans échec. Les smokes live opt-in restent `ignored` par conception et ne sont pas requalifiés en preuves réseau.

`pre.008` est exclusivement documentaire. La nomenclature durable des couches de données Store est réconciliée avec la décision prise lors de l'ouverture Store :

```text
D1 = RAW
D2 = STRUCTURAL
D3 = DECODED
D4 = DOMAIN
```

Les plans Store historiques qui parlent de N1–N4 data sont interprétés selon cette correspondance, mais la documentation durable réserve désormais `D1–D4` aux couches de données afin de ne pas entrer en collision avec les niveaux architecturaux N1–N4 de `002-LAYERS_AND_DEPENDENCIES.md`.

Le terme historique `CORE` n'est plus un nom de couche D2 Store. Il reste valide lorsqu'il désigne `ksp-core-lib`, le domaine Core fondamental ou un nom propre comme « Solana Core Programs ». Les anciens plans/deltas clôturés restent des traces historiques et ne sont pas réécrits en masse.

La réconciliation vérifie également la documentation durable de `ksp-raw-transaction-lib` : la crate étant désormais une lower-layer complétée de `0.3.10`, elle doit posséder son `README.md` descriptif et son `USAGE.md` version-neutre conformément aux règles de clôture des bibliothèques KSP.