0.7.52

2026-06-11 17:22:55 +02:00
parent bfdb2e69ae
commit 38f42da970
23 changed files with 2650 additions and 35 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -84,3 +84,4 @@
 0.7.50 - Raydium Launchpad event coverage bootstrap : normalisation locale canonique vers `raydium_launchpad`, ajout de `RAYDIUM_LAUNCHPAD_PROGRAM_ID`, synchronisation des entrées Carbon Launchpad dans le registre upstream, fallback audit/mapped decoder pour discriminants Launchpad, enrichissement audit Anchor self-CPI, maintien conservatoire en `decoded_events_only`, rapport Launchpad et SQL de validation dédiés.  
 0.7.50-pre-r2 - Clôture CPMM/CLMM post-Launchpad : ajout des entrées Carbon `cpi_event` pour `raydium_cpmm` et `raydium_clmm`, ajout de `raydium_clmm.update_dynamic_fee_config`, normalisation des Program-data events CLMM, ajout de la table `k_sol_token_account_events` et de la matérialisation `create_support_mint_associated`, reclassement des familles ambiguës (`cpi_transport`, `liquidity_calculation`, `liquidity_change`, `position_open`, `pool_create`, `admin_config`, `account_create`, `idl_management`), codage du discriminant CPMM `40f4bc78a7e9690a` comme `raydium_cpmm.anchor_idl_instruction` decoded-only après inspection Solscan, et contexte de secours pour matérialisation liquidity CLMM via événements frères quand possible.  
 0.7.51 - Raydium AMM v4 event coverage clôturé : decoder maximal local pour tous les discriminants officiels AMM v4 `00..11`, spécialisation des swaps `swap_base_in/out` et `swap_base_in/out_v2`, suppression durable du `raydium_amm_v4.swap` legacy, index AMM v4 en discriminant 1 octet, matérialisation validée des swaps, liquidity, lifecycle, fees, admin/config et side effects orderbook, `pre_initialize` conservé comme lifecycle audit deprecated/partial, `simulate_info` decoded-only, reset replay renforcé par `protocol_name`, validation des invariants failed/non-swap/single-target/unexplained gaps et maintien de `raydium_pool_v4` en audit conditionnel sans decoder autonome.  
 0.7.52 - Raydium Stable Swap event coverage clôturé : decoder legacy 1 octet pour la surface locale `00..0d`, matérialisation lifecycle/liquidity/admin/fee/orderbook selon contexte, swaps `swap_base_in/out` matérialisés uniquement depuis deltas de vaults exacts (`stable_swap_vault_balance_delta`), conservation des bornes d’instruction comme audit-only, failed transactions decoded-only avec skip reasons, validation locale 407 tests et clippy `-D warnings` OK.  
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,7 +8,7 @@ members = [
 ]
 [workspace.package]
-version = "0.7.51"
+version = "0.7.52"
 edition = "2024"
 license = "MIT"
 repository = "https://git.sasedev.com/Sasedev/khadhroony-bobobot"
--- a/README.md
+++ b/README.md
@@ -78,7 +78,7 @@ non-swap CLMM avec trade_count > 0 = 0
 Les 11 Anchor / `Program data` events CLMM restent listés en `upstream_git_unverified` car aucun corpus local ne les observe encore. Le code est préparé pour les accueillir en audit-only lorsqu’ils apparaîtront dans un corpus local, sans créer de trade/candle par défaut.
-La tranche `0.7.51 raydium_amm_v4` est maintenant validée côté `kb_lib`. La suite de roadmap reprend avec `0.7.52 raydium_stable`, tandis que `raydium_pool_v4` reste un audit conditionnel ultérieur et ne doit pas être promu sans confirmation de program id/rôle/corpus.
+Les tranches `0.7.51 raydium_amm_v4` et `0.7.52 raydium_stable_swap` sont maintenant validées côté `kb_lib`. La suite de roadmap reprend avec les rechecks conditionnels et les surfaces restantes, tandis que `raydium_pool_v4` reste un audit conditionnel ultérieur et ne doit pas être promu sans confirmation de program id/rôle/corpus.
 ## Organisation documentaire
@@ -320,7 +320,7 @@ Chaque DEX ou variante de DEX doit avoir sa propre étape de validation. Les fam
 À garder dans la matrice mais sans bloquer les versions immédiates :
- `raydium_stable_swap` tant que son usage réel n’est pas démontré par corpus local ;
+- `raydium_stable_swap` est désormais démontré par corpus local en `0.7.52` ; le garder comme DEX effectif supporté, avec surveillance des nouveaux discriminants ;
 - vieux programmes legacy uniquement utiles pour compatibilité ou replay historique ;
 - agrégateurs/routeurs comme `okx_dex` tant qu’ils ne correspondent pas à un DEX direct matérialisable ;
 - entrées ambiguës comme `zora` tant qu’aucun programme Solana pertinent n’est prouvé.
@@ -433,7 +433,7 @@ La priorité immédiate après le point de reprise `0.7.43-E5C` est :
 2. `0.7.49` : `raydium_clmm` — clôturé côté instructions observées, matérialisation non-trade prouvée et nettoyage fallback ;
 3. `0.7.50-pre-r2` : `raydium_launchpad` clos + re-vérification `raydium_cpmm` / `raydium_clmm` ;
 4. `0.7.51` : `raydium_amm_v4` ;
-5. `0.7.52` : `raydium_stable` ;
+5. `0.7.52` : `raydium_stable_swap` — clôturé ;
 6. `0.7.53` : `raydium_pool_v4` audit / program-id decision seulement si program id distinct et corpus exploitable ;
 7. `0.7.54` : `pump_swap` ;
 8. `0.7.55` : `pump_fun` ;
@@ -546,7 +546,7 @@ La suite fonctionnelle reprend par Raydium avant Meteora :
 2. `0.7.49` — `raydium_clmm` ;
 3. `0.7.50-pre-r2` — `raydium_launchpad` + clôture CPMM/CLMM ;
 4. `0.7.51` — `raydium_amm_v4` ;
-5. `0.7.52` — `raydium_stable` ;
+5. `0.7.52` — `raydium_stable_swap` — clôturé ;
 6. `0.7.53` — `raydium_pool_v4` audit conditionnel, sans promotion automatique ;
 7. `0.7.54+` — Pump, Meteora, Phoenix/OpenBook, Orca puis les autres DEX/surfaces.
@@ -632,3 +632,36 @@ Cette tranche complète la clôture Raydium en ajoutant `cpi_event` pour CPMM/CL
 Le discriminant CPMM `40f4bc78a7e9690a` est désormais codé comme `raydium_cpmm.anchor_idl_instruction` : les signatures inspectées correspondent aux instructions Anchor `IdlCreateAccount` / `IdlCloseAccount`, donc il reste `decoded_events_only` et ne matérialise aucune table métier.
 Rapport de clôture : `docs/reports/RAYDIUM_CPMM_CLMM_RECHECK_REPORT_0_7_50_PRE_R2.md`.
 ## Tranche clôturée — 0.7.52 raydium_stable_swap
 `0.7.52` clôture Raydium Stable Swap avec le code local canonique `raydium_stable_swap` et le program id `5quBtoiQqxF9Jv6KYKctB59NT3gtJD2Y65kdnB1Uev3h`.
 Décisions finales :
 - Stable Swap est décodé en layout legacy **1 octet**.
 - La surface locale observée `00..0d` est couverte : lifecycle, model setup, admin/config, liquidity, orderbook side effects, fees et swaps.
 - `swap_base_in` / `swap_base_out` produisent trades/candles uniquement avec des montants exacts dérivés des deltas de vaults (`amountSource=stable_swap_vault_balance_delta`).
 - Les arguments d’instruction `amountInRaw`, `minimumAmountOutRaw`, `maxAmountInRaw`, `amountOutRaw` sont conservés comme bornes d’instruction, mais ne sont pas utilisés comme prix/montants exacts.
 - Les transactions failed restent decoded-only avec `skipTradeReason=failed_transaction` et `skipCandleReason=failed_transaction`.
 Livrables de clôture :
 - `kb_lib/src/dex/raydium_stable_swap.rs`
 - `docs/reports/RAYDIUM_STABLE_SWAP_EVENT_COVERAGE_REPORT.md`
 - `validation_sql/SQL_VALIDATION_RAYDIUM_STABLE_SWAP_0_7_52.sql`
 Validation locale finale :
 ```text
 cargo test -p kb_lib -> 407 passed, 0 failed
 cargo clippy -p kb_lib --all-targets -- -D warnings -> ok
 ```
 Replay final observé :
 ```text
 replayed=298, trades=290, liquidity=16, lifecycle=4, candle_upserts=1160,
 instructionObservations=5317, catalog=40 tokens / 59 pools / 59 pairs
 ```
 Statut : **clôturé côté code et validation locale**.
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -36,7 +36,7 @@ Règles de planification :
 | `0.7.49` | `raydium_clmm` | Clôturé : 33 instructions observées/décodées, orderbook CLMM, liquidity/fee/reward/admin/lifecycle, fallbacks upstream nettoyés, 11 Program-data events préparés mais non observés. |
 | `0.7.50` | `raydium_launchpad` | Bootstrap ouvert : surface LaunchLab/Launchpad, discriminants Carbon/IDL, fallback audit, SQL de validation, aucune matérialisation métier sans corpus. |
 | `0.7.51` | `raydium_amm_v4` | Clôturé : decoder maximal `00..11`, swaps spécialisés, lifecycle/liquidity/fees/admin/orderbook, `pre_initialize` audit, `simulate_info` decoded-only, cleanup legacy/fallback. |
-| `0.7.52` | `raydium_stable` | Reprendre Raydium Stable : program ids/IDL, swaps stables, pool lifecycle, liquidity, fees/admin, invariants pricing/candles. |
+| `0.7.52` | `raydium_stable_swap` | Clôturé : surface legacy `00..0d`, swaps via deltas vault exacts, failed tx decoded-only, invariants trade/candle propres. |
 | `0.7.53` | `raydium_pool_v4` | Audit / program-id decision seulement : confirmer program id, rôle exact et corpus avant toute promotion métier. |
 | `0.7.54` | `pump_swap` | Couvrir `buy/sell` et tous les events auxiliaires disponibles : fees, cashback, volume accumulator, admin/config. |
 | `0.7.55` | `pump_fun` | Traiter launch/bonding/migration ; séparer création token, buy/sell bonding, migration vers DEX effectif. |
@@ -855,7 +855,7 @@ Matrice cible initiale :
 | `raydium_launchpad` | launch surface | planifié, program id local connu | ajouter decoder/materialization dédiée |
 | `raydium_amm_v4` | AMM legacy | partiel | corpus dédié après autres Raydium |
 | `raydium_router` | router | partiel | ne pas matérialiser en trade direct avant preuve |
-| `raydium_stable_swap` | AMM legacy | planifié | traiter seulement si corpus pertinent |
+| `raydium_stable_swap` | AMM legacy | supporté / 0.7.52 clos | swaps depuis deltas vault exacts ; failed tx decoded-only |
 | `meteora_dlmm` | DLMM | supporté | verrouiller corpus et non-régression |
 | `meteora_damm_v1` | AMM legacy | partiel | garder skip explicite sans payload montant/prix |
 | `meteora_damm_v2` | AMM | partiel | corpus et séparation events |
@@ -1006,7 +1006,7 @@ Réalisé :
 - maintien des launch surfaces comme surfaces reportées et non prioritaires ;
 - ajout du profil `0.7.39_dex_first_effective_swap_surfaces` ;
 - validation locale confirmée avec `validationPassed = true`, `blockingIssueCount = 0`, `actionableMissingTradeEventCount = 0` et `missingTradeEventCount = 0` ;
- confirmation par corpus local initial que Raydium CLMM est observé, tandis que Raydium AMM v4 et Stable Swap ne sont pas encore exploitables sans constitution de corpus dédiée.
+- confirmation par corpus local initial que Raydium CLMM est observé ; les tranches ultérieures ont ensuite clôturé Raydium AMM v4 en `0.7.51` et Stable Swap en `0.7.52`.
 Décision : `0.7.39` est clos. La suite immédiate ne doit pas commencer par un décodeur Raydium AMM v4 sans corpus. Il faut d’abord ajouter les outils de découverte on-chain et de backfill ciblé afin d’obtenir des signatures, pools/state accounts, token mints et instructions exploitables.
@@ -1310,10 +1310,10 @@ Objectif : hisser AMM v4 legacy au niveau de couverture CPMM/CLMM.
 Réalisé : decoder maximal AMM v4 pour tous les discriminants officiels `00..11`, spécialisation des swaps (`swap_base_in`, `swap_base_out`, `swap_base_in_v2`, `swap_base_out_v2`), suppression du legacy `raydium_amm_v4.swap`, observation locale de tous les discriminants, matérialisation validée des familles trade, liquidity, lifecycle, fee, admin/config et orderbook, `pre_initialize` conservé comme lifecycle audit deprecated/partial, `simulate_info` conservé en decoded-only, gaps successful non matérialisés expliqués, et validation des invariants failed/non-swap/single-target.
-### 6.084. Version `0.7.52` — `raydium_stable` event coverage
+### 6.084. Version `0.7.52` — `raydium_stable_swap` event coverage
-Objectif : reprendre Raydium Stable comme troisième tranche Raydium post-CLMM.
+Objectif : reprendre Raydium Stable comme tranche Raydium dédiée après AMM v4.
-À faire : vérifier program ids/IDL, swaps stables, liquidity, pool lifecycle, fees/admin/config, cohérence des montants/prix et absence de faux trades/candles.
+Réalisé : decoder legacy 1 octet, surface locale `00..0d`, matérialisation lifecycle/liquidity/admin/fee/orderbook selon contexte, swaps `swap_base_in/out` matérialisés uniquement depuis deltas vault exacts (`stable_swap_vault_balance_delta`), transactions failed decoded-only, invariants trade/candle propres.
 ### 6.085. Version `0.7.53` — `raydium_pool_v4` audit / program-id decision
 Objectif : auditer `raydium_pool_v4.json` comme source IDL annexe, sans promotion métier automatique.
@@ -1566,7 +1566,7 @@ Ordre de travail recommandé pour la suite :
 7. `0.7.49` : `raydium_clmm` — clos ;
 8. `0.7.50-pre-r2` : `raydium_launchpad` clos + re-vérification CPMM/CLMM ;
 9. `0.7.51` : `raydium_amm_v4` ;
-10. `0.7.52` : `raydium_stable` ;
+10. `0.7.52` : `raydium_stable_swap` — clôturé ;
 11. `0.7.53` : `raydium_pool_v4` audit conditionnel ;
 12. `0.7.54` : `pump_swap` ;
 13. `0.7.55` : `pump_fun` ;
@@ -1649,7 +1649,7 @@ La tranche CPMM reconnaît désormais tous les discriminants instruction-level l
 `0.7.48` est clôturable côté `raydium_cpmm`. Le decoder couvre les instructions/events CPMM listés par Carbon/fnzero/Raydium CP-Swap, avec matérialisation locale validée pour trades, liquidity, lifecycle, fees et admin/config. `swap_event` reste audit-only pour éviter les doublons avec `swap_base_input` / `swap_base_output`. Les side effects SPL Token / Token-2022 observés via Solscan (`burn`, `transfer`, `transferChecked`, `closeAccount`) restent hors decoder CPMM direct et alimenteront une réflexion transversale future.
-La suite après `0.7.49 raydium_clmm` reprend en `0.7.50-pre-r2` par la clôture Launchpad et la re-vérification CPMM/CLMM, puis `0.7.51 raydium_amm_v4`, `0.7.52 raydium_stable` et `0.7.53 raydium_pool_v4` uniquement comme audit conditionnel, en gardant la même discipline : sources Git/IDL + Solscan pour accélérer la découverte, mais corpus local obligatoire avant toute promotion métier.
+La suite après `0.7.49 raydium_clmm` reprend en `0.7.50-pre-r2` par la clôture Launchpad et la re-vérification CPMM/CLMM, puis `0.7.51 raydium_amm_v4`, `0.7.52 raydium_stable_swap` et `0.7.53 raydium_pool_v4` uniquement comme audit conditionnel, en gardant la même discipline : sources Git/IDL + Solscan pour accélérer la découverte, mais corpus local obligatoire avant toute promotion métier.
 ## Clôture `0.7.51` — Raydium AMM v4
@@ -1674,4 +1674,52 @@ Décision `raydium_pool_v4` : ne pas ouvrir de decoder autonome dans cette tranc
 Le rapport de décision est `docs/reports/RAYDIUM_POOL_V4_DECISION_NOTE.md`.
-La suite reprend `0.7.52 raydium_stable`, après rechecks CPMM/CLMM/Launchpad si la base de validation les contient.
+La tranche `0.7.52 raydium_stable_swap` est clôturée ; la suite reprend sur les surfaces restantes ou les audits conditionnels selon le corpus disponible.
 ### Addendum final — `0.7.52 raydium_stable_swap`
 Statut : **clôturé**.
 Décision finale : `raydium_stable_swap` est le code local canonique pour le program id `5quBtoiQqxF9Jv6KYKctB59NT3gtJD2Y65kdnB1Uev3h`. Le decoder utilise un layout legacy 1 octet et couvre la surface localement observée `00..0d`.
 Résultat de tranche :
 - `initialize` matérialise le lifecycle quand le contexte est complet ;
 - `init_model_data` reste decoded-only expliqué ;
 - `update_model_data` matérialise `k_sol_pool_admin_events` ;
 - `deposit` / `withdraw` matérialisent `k_sol_liquidity_events` ;
 - `monitor_step` / `admin_cancel_orders` matérialisent `k_sol_orderbook_events` quand le contexte est complet ;
 - `set_params` matérialise `k_sol_pool_admin_events` ;
 - `withdraw_pnl` / `withdraw_srm` matérialisent `k_sol_fee_events` quand le contexte est complet ;
 - `simulate_info` reste decoded-only ;
 - `swap_base_in` / `swap_base_out` matérialisent trades/candles uniquement depuis `amountSource=stable_swap_vault_balance_delta` ;
 - `stable_swap_instruction_bounds_only` reste decoded-only et ne matérialise pas de trade/candle ;
 - les transactions failed restent decoded-only avec `failed_transaction`.
 Validation finale :
 ```text
 cargo test -p kb_lib -> 407 passed, 0 failed
 cargo clippy -p kb_lib --all-targets -- -D warnings -> ok
 ```
 Replay final observé :
 ```text
 replayed=298, trades=290, liquidity=16, lifecycle=4, candle_upserts=1160,
 instructionObservations=5317, catalog=40 tokens / 59 pools / 59 pairs
 ```
 Clôture swap spécifique :
 ```text
 swap_base_in  stable_swap_vault_balance_delta     success 171 decoded / 171 trades
 swap_base_in  stable_swap_instruction_bounds_only  failed   27 decoded / 0 trades
 swap_base_out stable_swap_vault_balance_delta     success   4 decoded / 4 trades
 swap_base_out stable_swap_instruction_bounds_only  failed    2 decoded / 0 trades
 ```
 SQL de validation : `validation_sql/SQL_VALIDATION_RAYDIUM_STABLE_SWAP_0_7_52.sql`.
 Rapport : `docs/reports/RAYDIUM_STABLE_SWAP_EVENT_COVERAGE_REPORT.md`.
--- a/docs/DB_EVENT_MODEL_REVIEW.md
+++ b/docs/DB_EVENT_MODEL_REVIEW.md
@@ -369,3 +369,16 @@ Règles validées :
 - les side effects SPL Token / Token-2022 restent transversaux.
 Contrôle final AMM v4 : le SQL `materialized_target_count > 1` doit rester vide.
 ## 0.7.52 — Raydium Stable Swap DB model decision
 No schema migration is introduced for `raydium_stable_swap` at tranche opening.
 Stable Swap maps to existing DB targets:
 - `initialize` / `pre_initialize` → `k_sol_pool_lifecycle_events` when pool context is sufficient;
 - `deposit` / `withdraw` → `k_sol_liquidity_events` when pool/pair context is sufficient;
 - `swap_base_in` / `swap_base_out` → `k_sol_trade_events` and candles only when mints and amounts are reliable;
 - `swap_event` → `k_sol_dex_decoded_events` only until a corpus-backed materialization decision exists.
 Side effects from SPL Token, Token-2022, Serum/OpenBook-style accounts or router transport remain transverse evidence and are not promoted as direct `raydium_stable_swap.*` business events without an explicit later DB decision.
--- a/docs/DEX_DECODER_MATRIX.md
+++ b/docs/DEX_DECODER_MATRIX.md
@@ -31,8 +31,8 @@ Cette matrice complète `kb_lib/src/dex_support_matrix.rs`. Elle documente **ce
 | 1 | `raydium_cpmm` | `supported / 0.7.50-pre-r2 closure recheck` | Couverture CPMM clôturée : swaps, lifecycle, fees, admin/config, deposit/withdraw, `lp_change_event`, `swap_event` decoded-only, `cpi_event` transport Carbon et `anchor_idl_instruction` Solscan/manual pour `40f4bc78a7e9690a`. | Ne pas promouvoir `anchor_idl_instruction` : c'est de la gestion Anchor IDL, pas un événement AMM métier. |
 | 2 | `raydium_clmm` | `supported / 0.7.50-pre-r2 closure recheck` | Couverture CLMM complétée : `cpi_event`, `update_dynamic_fee_config`, Program-data events locaux, `create_support_mint_associated` vers `k_sol_token_account_events`, familles sans `unknown`, router/swap Program-data en decoded-only. | Rejouer la base CLMM et confirmer que les seuls résidus sont `decoded_events_only`, transactions failed ou absence prouvée de contexte pool/pair. |
 | 3 | `raydium_launchpad` | `bootstrap / 0.7.50` | Surface canonique normalisée, 1 entrée programme + 26 discriminants Carbon/IDL listés, fallback audit/mapped decoder, SQL dédié. | Créer DB neuve, backfill par discriminant, replay forcé, promouvoir seulement après corpus local. |
-| 4 | `raydium_amm_v4` | `supported / 0.7.51 closed` | Decoder maximal AMM v4 `00..11`, swaps spécialisés, lifecycle/liquidity/fees/admin/orderbook validés. | Rechecks CPMM/CLMM/Launchpad puis `raydium_stable`. |
+| 4 | `raydium_amm_v4` | `supported / 0.7.51 closed` | Decoder maximal AMM v4 `00..11`, swaps spécialisés, lifecycle/liquidity/fees/admin/orderbook validés. | Stable Swap clôturé ensuite en `0.7.52`; surveiller les surfaces restantes. |
-| 5 | `raydium_stable_swap` | `planned / 0.7.52` | Entrée conservée. | Reprendre Stable séparément : swaps stables, pool lifecycle, liquidity, fees/admin, montants/prix exploitables. |
+| 5 | `raydium_stable_swap` | `supported / 0.7.52 closed` | Decoder legacy 1 octet, surface `00..0d`, swaps matérialisés depuis deltas vault exacts. | Surveiller seulement de nouveaux discriminants ou `swap_event` observé. |
 | 6 | `raydium_pool_v4` | `to_verify / 0.7.53 conditional audit` | IDL annexe mentionnée par fnzero, non présente dans l'archive locale, pas de program id/rôle confirmé ici. | Ne pas promouvoir tant que program id distinct, rôle exact et corpus exploitable ne sont pas confirmés. |
 | 7 | `pump_swap` | `supported / 0.7.54 planned` | `buy`/`sell` décodés et matérialisés ; trade/candle OK. | Ajouter tous les events Carbon/Solana Streamer : cashback, fee, volume accumulator, admin/config ; conserver les non-trades hors candles. |
 | 8 | `pump_fun` | `partial / 0.7.55 launch_surface` | Création/token launch partiellement décodée ; intégrée au pipeline de listings. | Traiter tous les events Pump.fun disponibles : buy/sell/migrate/create/update ; séparer bonding/launch de DEX effectif ; valider migration vers PumpSwap. |
@@ -99,7 +99,7 @@ Un event peut devenir `materialized` uniquement si :
 | `raydium_launchpad` | `launch_surface` | `launch` | `known` | non | oui | non | `bootstrap` | decoded_events_only_until_local_corpus |
 | `raydium_liquidity_locking` | `to_verify` | `liquidity_locking` | `to_verify` | non | non | non | `to_verify` | upstream_git_program_id_requires_local_corpus_verification |
 | `raydium_router` | `aggregator_router` | `router` | `known` | non | non | non | `partial` | router_not_materialized_as_direct_trade_surface |
-| `raydium_stable_swap` | `dex_effective` | `AMM` | `known` | non | non | non | `planned` | deprecated_program_not_prioritized |
+| `raydium_stable_swap` | `dex_effective` | `AMM` | `known` | oui | oui | oui | `supported` | 0.7.52 closed; swaps via `stable_swap_vault_balance_delta` uniquement |
 | `meteora_dlmm` | `dex_effective` | `DLMM` | `known` | oui | oui | oui | `supported` |  |
 | `meteora_dlc` | `to_verify` | `unknown` | `to_verify` | non | non | non | `to_verify` | surface_and_program_id_to_verify |
 | `meteora_damm_v1` | `dex_effective` | `AMM` | `known` | oui | oui | non | `partial` | meteora_damm_v1_swap_without_amount_payload |
@@ -266,3 +266,10 @@ La clôture `0.7.50-pre-r2` complète les tranches `0.7.48` et `0.7.49` sans rou
 La tranche a été validée sur base SQLite dédiée : tous les discriminants `00..11` sont observés localement. Les gaps de matérialisation restants sont expliqués par decoded-only, transaction failed ou absence de catalogue/deltas exploitables.
 ## 0.7.52 — Raydium Stable Swap
 | decoder_code | program id | status | layout | notes |
 |---|---|---|---|---|
 | `raydium_stable_swap` | `5quBtoiQqxF9Jv6KYKctB59NT3gtJD2Y65kdnB1Uev3h` | supported / closed | legacy 1 octet | Surface locale `00..0d` couverte ; swaps `swap_base_in/out` matérialisés uniquement depuis deltas vault exacts ; instruction bounds et failed tx restent decoded-only. |
--- a/docs/DEX_EVENT_COVERAGE_MATRIX.md
+++ b/docs/DEX_EVENT_COVERAGE_MATRIX.md
@@ -189,3 +189,28 @@ Validation locale finale : tous les discriminants AMM v4 officiels `00..11` sont
 | `cpi/informational` | `simulate_info` | observed decoded-only | `k_sol_dex_decoded_events_only` | Audit technique uniquement. |
 | `token side effects` | SPL Token / Token-2022 inner instructions | transversal | decoded-only actuellement | Ne pas promouvoir comme AMM v4 direct. |
 | `unknown/unmapped audit` | residual `raydium_amm_v4.instruction_audit` | vide | decoded-only si futur inconnu | Tout residual doit être expliqué avant promotion. |
 ## 0.7.52 — `raydium_stable_swap`
 Status: **closed on local corpus**.
 | entry | discriminator | family | expected target | local event kind | status |
 |---|---:|---|---|---|---|
 | `initialize` | `00` | `pool_create` | `k_sol_pool_lifecycle_events` | `raydium_stable_swap.initialize` | observed/materialized when context complete |
 | `init_model_data` | `01` | `model_setup` | decoded-only | `raydium_stable_swap.init_model_data` | observed decoded-only / explained |
 | `update_model_data` | `02` | `admin_config` | `k_sol_pool_admin_events` | `raydium_stable_swap.update_model_data` | observed/materialized |
 | `deposit` | `03` | `liquidity_add` | `k_sol_liquidity_events` | `raydium_stable_swap.deposit` | observed/materialized |
 | `withdraw` | `04` | `liquidity_remove` | `k_sol_liquidity_events` | `raydium_stable_swap.withdraw` | observed/materialized |
 | `monitor_step` | `05` | `order_place` | `k_sol_orderbook_events` | `raydium_stable_swap.monitor_step` | observed/materialized |
 | `set_params` | `06` | `admin_config` | `k_sol_pool_admin_events` | `raydium_stable_swap.set_params` | observed/materialized |
 | `withdraw_pnl` | `07` | `fee` | `k_sol_fee_events` | `raydium_stable_swap.withdraw_pnl` | observed/materialized |
 | `withdraw_srm` | `08` | `fee` | `k_sol_fee_events` | `raydium_stable_swap.withdraw_srm` | observed/materialized when context complete |
 | `swap_base_in` | `09` | `swap` | `k_sol_trade_events` from vault deltas only | `raydium_stable_swap.swap_base_in` | success/vault-delta materialized; failed decoded-only |
 | `pre_initialize` | `0a` | `pool_create` | lifecycle or decoded-only | `raydium_stable_swap.pre_initialize` | observed decoded-only / explained in current corpus |
 | `swap_base_out` | `0b` | `swap` | `k_sol_trade_events` from vault deltas only | `raydium_stable_swap.swap_base_out` | success/vault-delta materialized; failed decoded-only |
 | `simulate_info` | `0c` | `cpi_transport` | decoded-only | `raydium_stable_swap.simulate_info` | observed decoded-only / explained |
 | `admin_cancel_orders` | `0d` | `orderbook_admin` | `k_sol_orderbook_events` | `raydium_stable_swap.admin_cancel_orders` | observed/materialized when context complete |
 | `swap_event` | `40c6cde8260871e2` | `cpi_transport` | decoded-only | `raydium_stable_swap.swap_event` | upstream mapped; not observed locally |
 Stable Swap swaps are not materialized from instruction min/max bounds. `swap_base_in/out` require `amountSource=stable_swap_vault_balance_delta`; `stable_swap_instruction_bounds_only` remains decoded-only and, in the final corpus, appears only on failed transactions.
--- a/docs/SOLSCAN_ACCOUNT_SOURCE_MATRIX.md
+++ b/docs/SOLSCAN_ACCOUNT_SOURCE_MATRIX.md
@@ -10,9 +10,6 @@ This file records the manual Solscan account inventory added during the `0.7.50`
 | `Aldrin AMM V2` | `CURVGoZn8zycx6FXwwevgBTB2gVvdbGTEpvMJDbgs2t4` | `no_idl` | https://solscan.io/account/CURVGoZn8zycx6FXwwevgBTB2gVvdbGTEpvMJDbgs2t4 |
 | `ApePro Smart Wallet Program` | `JSW99DKmxNyREQM14SQLDykeBvEUG63TeohrvmofEiw` | `solscan_program_idl` | https://solscan.io/account/JSW99DKmxNyREQM14SQLDykeBvEUG63TeohrvmofEiw#programIdl |
 | `Aquifer` | `AQU1FRd7papthgdrwPTTq5JacJh8YtwEXaBfKU3bTz45` | `no_idl` | https://solscan.io/account/AQU1FRd7papthgdrwPTTq5JacJh8YtwEXaBfKU3bTz45 |
 | `Arbitrage Bot (3s1rA)` | `3s1rAymURnacreXreMy718GfqW6kygQsLNka1xDyW8pC` | `no_idl` | https://solscan.io/account/3s1rAymURnacreXreMy718GfqW6kygQsLNka1xDyW8pC |
 | `Arbitrage Bot (6MWVT)` | `6MWVTis8rmmk6Vt9zmAJJbmb3VuLpzoQ1aHH4N6wQEGh` | `no_idl` | https://solscan.io/account/6MWVTis8rmmk6Vt9zmAJJbmb3VuLpzoQ1aHH4N6wQEGh |
 | `Arbitrage Bot (9Zzf9)` | `9Zzf9QqTy3TkyXysvJBsXyuRjda5aXCEJ9vXfL2HKSYv` | `no_idl` | https://solscan.io/account/9Zzf9QqTy3TkyXysvJBsXyuRjda5aXCEJ9vXfL2HKSYv |
 | `Axiom Trade` | `FLASHX8DrLbgeR8FcfNV1F5krxYcYMUdBkrP1EPBtxB9` | `no_idl` | https://solscan.io/account/FLASHX8DrLbgeR8FcfNV1F5krxYcYMUdBkrP1EPBtxB9 |
 | `Bags: Token Authority` | `BAGSB9TpGrZxQbEsrEznv5jXXdwyP6AXerN8aVRiAmcv` | `solscan_account` | https://solscan.io/account/BAGSB9TpGrZxQbEsrEznv5jXXdwyP6AXerN8aVRiAmcv |
 | `Believe : Token Authority` | `5qWya6UjwWnGVhdSBL3hyZ7B45jbk6Byt1hwd7ohEGXE` | `no_idl` | https://solscan.io/account/5qWya6UjwWnGVhdSBL3hyZ7B45jbk6Byt1hwd7ohEGXE |
--- a/docs/VALIDATION_STATUS_0_7_52_FINAL.md
+++ b/docs/VALIDATION_STATUS_0_7_52_FINAL.md
@@ -0,0 +1,67 @@
 # Validation status — 0.7.52 Raydium Stable Swap final
 ## Scope
 Decoder: `raydium_stable_swap`
 Program id:
 ```text
 5quBtoiQqxF9Jv6KYKctB59NT3gtJD2Y65kdnB1Uev3h
 ```
 ## Local commands
 ```text
 cargo test -p kb_lib
 407 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
 cargo clippy -p kb_lib --all-targets -- -D warnings
 ok
 ```
 ## Final replay snapshot
 ```text
 replayed=298
 decode_skipped=0
 ledger_upserts=298
 unsafe_ledger_rows=258
 trades=290
 liquidity=16
 lifecycle=4
 tokenAccount=0
 candle_upserts=1160
 instructionObservations=5317
 resetDeleted=1059
 catalog=40 tokens / 59 pools / 59 pairs
 ```
 ## Stable Swap swap closure
 ```text
 raydium_stable_swap.swap_base_in  stable_swap_instruction_bounds_only  failed   decoded=27  trades=0
 raydium_stable_swap.swap_base_in  stable_swap_vault_balance_delta      success  decoded=171 trades=171
 raydium_stable_swap.swap_base_out stable_swap_instruction_bounds_only  failed   decoded=2   trades=0
 raydium_stable_swap.swap_base_out stable_swap_vault_balance_delta      success  decoded=4   trades=4
 ```
 No successful Stable Swap swap remains without trade or skip reason.
 ## Invariants
 | invariant | status |
 |---|---|
 | residual local `instruction_audit` | empty |
 | residual `upstream_git.instruction_match` for covered entries | empty |
 | decoded without coverage | empty |
 | non-swap materialized as trade | empty |
 | failed tx materialized as trade | empty |
 | multi-target materialization | empty |
 | unexplained successful non-materialized event | empty |
 | successful swap via vault deltas | `trade_count = decoded_count` |
 | failed swap instruction bounds only | `trade_count = 0` |
 ## Decision
 `0.7.52 raydium_stable_swap` is closed for the current local corpus.
--- a/docs/reports/RAYDIUM_STABLE_SWAP_EVENT_COVERAGE_REPORT.md
+++ b/docs/reports/RAYDIUM_STABLE_SWAP_EVENT_COVERAGE_REPORT.md
@@ -0,0 +1,162 @@
 # Raydium Stable Swap event coverage report — 0.7.52 final
 ## Scope
 `0.7.52` closes the `raydium_stable_swap` tranche after `0.7.51 raydium_amm_v4`.
 Canonical local decoder code:
 ```text
 raydium_stable_swap
 ```
 Canonical program id validated by local corpus:
 ```text
 5quBtoiQqxF9Jv6KYKctB59NT3gtJD2Y65kdnB1Uev3h
 ```
 Stable Swap is handled as a Raydium legacy AMM-style program with a one-byte instruction discriminator layout. Anchor-like 8-byte discriminants remain upstream discovery evidence only and are not business proof.
 ## Final implementation status
 Implemented and locally validated:
 - `kb_lib/src/dex/raydium_stable_swap.rs`.
 - `RaydiumStableSwapDecoder` re-exported through `kb_lib/src/dex.rs` and `kb_lib/src/lib.rs`.
 - Stable Swap route in `DexDecodeService` before generic Raydium instruction-audit preservation.
 - One-byte Stable Swap instruction observation support.
 - Coverage entries for all locally observed Stable Swap discriminants `00..0d`.
 - Materialization into lifecycle/liquidity/fee/admin/orderbook/trade tables when the local corpus proves a safe target.
 - Swap materialization from exact vault balance deltas only.
 - Validation SQL in `validation_sql/SQL_VALIDATION_RAYDIUM_STABLE_SWAP_0_7_52.sql`.
 ## Instruction surface
 | entry | discriminator | family | final target | local event kind | final status |
 |---|---:|---|---|---|---|
 | `initialize` | `00` | `pool_create` | `k_sol_pool_lifecycle_events` | `raydium_stable_swap.initialize` | observed/materialized when context complete |
 | `init_model_data` | `01` | `model_setup` | decoded-only | `raydium_stable_swap.init_model_data` | observed decoded-only / explained |
 | `update_model_data` | `02` | `admin_config` | `k_sol_pool_admin_events` | `raydium_stable_swap.update_model_data` | observed/materialized |
 | `deposit` | `03` | `liquidity_add` | `k_sol_liquidity_events` | `raydium_stable_swap.deposit` | observed/materialized |
 | `withdraw` | `04` | `liquidity_remove` | `k_sol_liquidity_events` | `raydium_stable_swap.withdraw` | observed/materialized |
 | `monitor_step` | `05` | `order_place` | `k_sol_orderbook_events` | `raydium_stable_swap.monitor_step` | observed/materialized |
 | `set_params` | `06` | `admin_config` | `k_sol_pool_admin_events` | `raydium_stable_swap.set_params` | observed/materialized |
 | `withdraw_pnl` | `07` | `fee` | `k_sol_fee_events` | `raydium_stable_swap.withdraw_pnl` | observed/materialized |
 | `withdraw_srm` | `08` | `fee` | `k_sol_fee_events` | `raydium_stable_swap.withdraw_srm` | observed/materialized when context complete |
 | `swap_base_in` | `09` | `swap` | `k_sol_trade_events` only from vault deltas | `raydium_stable_swap.swap_base_in` | observed, materialized for successful swaps with exact deltas |
 | `pre_initialize` | `0a` | `pool_create` | decoded-only or lifecycle when complete | `raydium_stable_swap.pre_initialize` | observed decoded-only / explained in current corpus |
 | `swap_base_out` | `0b` | `swap` | `k_sol_trade_events` only from vault deltas | `raydium_stable_swap.swap_base_out` | observed, materialized for successful swaps with exact deltas |
 | `simulate_info` | `0c` | `cpi_transport` | decoded-only | `raydium_stable_swap.simulate_info` | observed decoded-only / explained |
 | `admin_cancel_orders` | `0d` | `orderbook_admin` | `k_sol_orderbook_events` | `raydium_stable_swap.admin_cancel_orders` | observed/materialized when context complete |
 | `swap_event` | `40c6cde8260871e2` | `cpi_transport` | decoded-only | `raydium_stable_swap.swap_event` | upstream mapped, not observed in local corpus |
 ## Swap amount policy
 Stable Swap instruction arguments are retained as instruction bounds, but they are not sufficient for trade/candle materialization:
 ```text
 swap_base_in:
  amountInRaw = exact input argument
  minimumAmountOutRaw = slippage lower bound, not exact output
 swap_base_out:
  amountOutRaw = requested output argument
  maxAmountInRaw = slippage upper bound, not exact input
 ```
 Therefore, `swap_base_in` and `swap_base_out` materialize as trades/candles only when exact base/quote amounts are inferred from vault balance deltas:
 ```text
 amountSource = stable_swap_vault_balance_delta
 ```
 Instruction-bound-only swaps remain decoded-only:
 ```text
 amountSource = stable_swap_instruction_bounds_only
 tradeCandidate = false
 candleCandidate = false
 ```
 For failed transactions the skip reasons are:
 ```text
 skipTradeReason = failed_transaction
 skipCandleReason = failed_transaction
 ```
 For successful transactions where exact vault deltas cannot be proven, the expected skip reason is:
 ```text
 stable_swap_exact_amounts_unresolved
 ```
 The final local corpus has no successful unresolved Stable Swap swap.
 ## Final local validation snapshot
 Latest confirmed local commands:
 ```text
 cargo test -p kb_lib
 407 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
 cargo clippy -p kb_lib --all-targets -- -D warnings
 ok
 ```
 Latest replay snapshot:
 ```text
 replayed=298
 decode_skipped=0
 ledger_upserts=298
 unsafe_ledger_rows=258
 trades=290
 liquidity=16
 lifecycle=4
 token_account=0
 candle_upserts=1160
 instructionObservations=5317
 resetDeleted=1059
 catalog=40 tokens / 59 pools / 59 pairs
 ```
 Stable Swap swap closure:
 | event kind | amount source | tx status | decoded | trades |
 |---|---|---|---:|---:|
 | `raydium_stable_swap.swap_base_in` | `stable_swap_instruction_bounds_only` | failed | 27 | 0 |
 | `raydium_stable_swap.swap_base_in` | `stable_swap_vault_balance_delta` | success | 171 | 171 |
 | `raydium_stable_swap.swap_base_out` | `stable_swap_instruction_bounds_only` | failed | 2 | 0 |
 | `raydium_stable_swap.swap_base_out` | `stable_swap_vault_balance_delta` | success | 4 | 4 |
 UI smoke evidence after the vault-delta correction:
 ```text
 pair 27, timeframe 60s -> 70 candles
 pair 30, timeframe 60s -> 44 candles
 ```
 ## Final invariant status
 Validated as clean on the local corpus:
 - residual `raydium_stable_swap.instruction_audit`: empty;
 - residual `upstream_git.instruction_match` for covered local entries: empty;
 - decoded-without-coverage: empty;
 - non-swap materialized as trade: empty;
 - failed transaction materialized as business trade: empty;
 - multi-target materialization: empty;
 - successful non-materialized swaps without skip reason: empty;
 - Stable Swap successful swaps with `stable_swap_vault_balance_delta`: `trade_count = decoded_count`;
 - Stable Swap instruction-bound-only swaps: failed only, `trade_count = 0`.
 ## Closure decision
 `0.7.52 raydium_stable_swap` is closed for the currently observed local corpus.
 The decoder has detected all locally observed Stable Swap instruction discriminants, materialized every event that can safely be materialized, and preserved non-materializable/failed events as decoded-only with explicit reasons.
 Future work is not a blocker for `0.7.52` and should be handled as a later tranche if a new local corpus reveals additional discriminants or a direct, reliable `swap_event` path.
--- a/kb_demo_app/package.json
+++ b/kb_demo_app/package.json
@@ -1,7 +1,7 @@
 {
    "name": "kb-demo-app",
    "private": true,
-    "version": "0.7.51",
+    "version": "0.7.52",
    "type": "module",
    "scripts": {
        "dev": "vite",
--- a/kb_demo_app/tauri.conf.json
+++ b/kb_demo_app/tauri.conf.json
@@ -1,7 +1,7 @@
 {
    "$schema": "https://schema.tauri.app/config/2",
    "productName": "kb-demo-app",
-    "version": "0.7.51",
+    "version": "0.7.52",
    "identifier": "com.sasedev.kb-demo-app",
    "build": {
        "beforeDevCommand": "npm run dev",
--- a/kb_lib/src/dex.rs
+++ b/kb_lib/src/dex.rs
@@ -17,6 +17,7 @@ mod raydium_amm_v4;
 mod raydium_clmm;
 mod raydium_cpmm;
 pub(crate) mod raydium_launchpad;
 mod raydium_stable_swap;
 pub use dexlab::DexlabCreatePoolDecoded;
 pub use dexlab::DexlabDecodedEvent;
@@ -90,3 +91,9 @@ pub use raydium_cpmm::RaydiumCpmmSwapMode;
 pub use raydium_cpmm::classify_raydium_cpmm_instruction_data;
 pub use raydium_cpmm::decode_raydium_cpmm_instruction;
 pub use raydium_cpmm::decode_raydium_cpmm_program_data_event;
 pub use raydium_stable_swap::RaydiumStableSwapDecodedEvent;
 pub use raydium_stable_swap::RaydiumStableSwapDecoder;
 pub use raydium_stable_swap::RaydiumStableSwapInstructionDecoded;
 pub use raydium_stable_swap::RaydiumStableSwapSwapEventDecoded;
 pub use raydium_stable_swap::classify_raydium_stable_swap_instruction_data;
 pub use raydium_stable_swap::decode_raydium_stable_swap_program_data_event;
--- a/kb_lib/src/dex/raydium_stable_swap.rs
+++ b/kb_lib/src/dex/raydium_stable_swap.rs
--- a/kb_lib/src/dex_decode.rs
+++ b/kb_lib/src/dex_decode.rs
@@ -11,6 +11,7 @@ pub struct DexDecodeService {
    persistence: crate::DetectionPersistenceService,
    raydium_amm_v4_decoder: crate::RaydiumAmmV4Decoder,
    raydium_clmm_decoder: crate::RaydiumClmmDecoder,
    raydium_stable_swap_decoder: crate::RaydiumStableSwapDecoder,
    pump_fun_decoder: crate::PumpFunDecoder,
    pump_swap_decoder: crate::PumpSwapDecoder,
    orca_whirlpools_decoder: crate::OrcaWhirlpoolsDecoder,
@@ -33,6 +34,7 @@ impl DexDecodeService {
            persistence,
            raydium_amm_v4_decoder: crate::RaydiumAmmV4Decoder::new(),
            raydium_clmm_decoder: crate::RaydiumClmmDecoder::new(),
            raydium_stable_swap_decoder: crate::RaydiumStableSwapDecoder::new(),
            pump_fun_decoder: crate::PumpFunDecoder::new(),
            pump_swap_decoder: crate::PumpSwapDecoder::new(),
            orca_whirlpools_decoder: crate::OrcaWhirlpoolsDecoder::new(),
@@ -78,6 +80,13 @@ impl DexDecodeService {
        if let Err(error) = append_result {
            return Err(error);
        }
        let append_result = append_persisted_events_result(
            &mut persisted,
            self.decode_and_persist_raydium_stable_swap_events(&transaction, &instructions).await,
        );
        if let Err(error) = append_result {
            return Err(error);
        }
        let append_result = append_persisted_events_result(
            &mut persisted,
            self.decode_and_persist_raydium_clmm_events(&transaction, &instructions).await,
@@ -1512,6 +1521,65 @@ impl DexDecodeService {
            .await;
    }
    async fn persist_raydium_stable_swap_event(
        &self,
        transaction: &crate::ChainTransactionDto,
        decoded_event: &crate::RaydiumStableSwapDecodedEvent,
    ) -> Result<crate::DexDecodedEventDto, crate::Error> {
        let transaction_id = match transaction.id {
            Some(transaction_id) => transaction_id,
            None => {
                return Err(crate::Error::InvalidState(format!(
                    "transaction '{}' has no internal id",
                    transaction.signature
                )));
            },
        };
        let instruction_id = match decoded_event.instruction_id() {
            Some(instruction_id) => instruction_id,
            None => {
                return Err(crate::Error::InvalidState(format!(
                    "raydium stable swap decoded event for transaction '{}' has no instruction id",
                    transaction.signature
                )));
            },
        };
        let event_kind = decoded_event.event_kind().to_string();
        let raw_payload_json = match decoded_event.to_payload_json() {
            Some(payload_json) => payload_json,
            None => {
                return Err(crate::Error::Json(
                    "cannot serialize decoded raydium stable swap payload".to_string(),
                ));
            },
        };
        let payload_value_result = enriched_raydium_payload_value(
            "raydium_stable_swap",
            event_kind.as_str(),
            raw_payload_json.as_str(),
        );
        let payload_value = match payload_value_result {
            Ok(payload_value) => payload_value,
            Err(error) => return Err(error),
        };
        return self
            .materialize_named_dex_event(
                transaction,
                transaction_id,
                instruction_id,
                "raydium_stable_swap",
                crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID.to_string(),
                event_kind.as_str(),
                decoded_event.pool_account().map(|value| return value.to_string()),
                decoded_event.market_account().map(|value| return value.to_string()),
                decoded_event.base_mint().map(|value| return value.to_string()),
                decoded_event.quote_mint().map(|value| return value.to_string()),
                decoded_event.lp_mint().map(|value| return value.to_string()),
                payload_value,
            )
            .await;
    }
    async fn persist_pump_fun_event(
        &self,
        transaction: &crate::ChainTransactionDto,
@@ -1708,6 +1776,32 @@ impl DexDecodeService {
        return Ok(persisted);
    }
    async fn decode_and_persist_raydium_stable_swap_events(
        &self,
        transaction: &crate::ChainTransactionDto,
        instructions: &[crate::ChainInstructionDto],
    ) -> Result<std::vec::Vec<crate::DexDecodedEventDto>, crate::Error> {
        let decoded_result = self
            .raydium_stable_swap_decoder
            .decode_transaction(transaction, instructions);
        let decoded_events = match decoded_result {
            Ok(decoded_events) => decoded_events,
            Err(error) => return Err(error),
        };
        let mut persisted = std::vec::Vec::new();
        for decoded_event in &decoded_events {
            let persist_result = self
                .persist_raydium_stable_swap_event(transaction, decoded_event)
                .await;
            let persisted_event = match persist_result {
                Ok(persisted_event) => persisted_event,
                Err(error) => return Err(error),
            };
            persisted.push(persisted_event);
        }
        return Ok(persisted);
    }
    async fn decode_and_persist_raydium_clmm_events(
        &self,
        transaction: &crate::ChainTransactionDto,
@@ -2509,6 +2603,13 @@ fn raydium_instruction_audit_spec(
            candidate_pool_account_index: 3,
        });
    }
    if program_id == crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID {
        return Some(RaydiumInstructionAuditSpec {
            protocol_name: "raydium_stable_swap",
            event_kind: "raydium_stable_swap.instruction_audit",
            candidate_pool_account_index: 1,
        });
    }
    if program_id == crate::RAYDIUM_LAUNCHPAD_PROGRAM_ID {
        return Some(RaydiumInstructionAuditSpec {
            protocol_name: "raydium_launchpad",
@@ -4234,6 +4335,7 @@ fn instruction_audit_event_kind_by_protocol(
        "raydium_amm_v4" => return Some("raydium_amm_v4.instruction_audit"),
        "raydium_clmm" => return Some("raydium_clmm.instruction_audit"),
        "raydium_cpmm" => return Some("raydium_cpmm.instruction_audit"),
        "raydium_stable_swap" => return Some("raydium_stable_swap.instruction_audit"),
        "raydium_launchpad" => return Some("raydium_launchpad.instruction_audit"),
        "meteora_dlmm" => return Some("meteora_dlmm.instruction_audit"),
        "meteora_damm_v1" => return Some("meteora_damm_v1.instruction_audit"),
@@ -4719,7 +4821,7 @@ fn raydium_instruction_discriminator_hex(
    bytes: std::option::Option<&[u8]>,
    offset: usize,
 ) -> std::option::Option<std::string::String> {
-    if protocol_name == "raydium_amm_v4" {
+    if protocol_name == "raydium_amm_v4" || protocol_name == "raydium_stable_swap" {
        return discriminator_hex_from_bytes_with_len(bytes, offset, 1);
    }
    return discriminator_hex_from_bytes(bytes, offset);
--- a/kb_lib/src/dex_detect.rs
+++ b/kb_lib/src/dex_detect.rs
@@ -108,6 +108,12 @@ impl DexDetectService {
                crate::dex_detection_route::DexDetectionRoute::RaydiumCpmmTrade => {
                    self.detect_raydium_cpmm_trade(&transaction, decoded_event).await
                },
                crate::dex_detection_route::DexDetectionRoute::RaydiumStableSwapTrade => {
                    self.detect_raydium_stable_swap_trade(&transaction, decoded_event).await
                },
                crate::dex_detection_route::DexDetectionRoute::RaydiumStableSwapPool => {
                    self.detect_raydium_stable_swap_pool(&transaction, decoded_event).await
                },
                crate::dex_detection_route::DexDetectionRoute::RaydiumClmmTrade => {
                    self.detect_raydium_clmm_trade(&transaction, decoded_event).await
                },
@@ -668,6 +674,78 @@ impl DexDetectService {
            .await;
    }
    async fn detect_raydium_stable_swap_pool(
        &self,
        transaction: &crate::ChainTransactionDto,
        decoded_event: &crate::DexDecodedEventDto,
    ) -> Result<crate::DexPoolDetectionResult, crate::Error> {
        return self
            .detect_materialized_pool_from_decoded_event(
                transaction,
                decoded_event,
                "raydium_stable_swap",
                crate::PoolKind::Amm,
                crate::PoolStatus::Active,
                "signal.dex.raydium_stable_swap",
            )
            .await;
    }
    async fn detect_raydium_stable_swap_trade(
        &self,
        transaction: &crate::ChainTransactionDto,
        decoded_event: &crate::DexDecodedEventDto,
    ) -> Result<crate::DexPoolDetectionResult, crate::Error> {
        let dex_id_result =
            crate::dex_catalog::ensure_known_dex(self.database.as_ref(), "raydium_stable_swap").await;
        let dex_id = match dex_id_result {
            Ok(dex_id) => dex_id,
            Err(error) => return Err(error),
        };
        let payload_value_result = parse_payload_json(decoded_event.payload_json.as_str());
        let payload_value = match payload_value_result {
            Ok(payload_value) => payload_value,
            Err(error) => return Err(error),
        };
        let base_vault_address = extract_payload_string_field(&payload_value, "baseVault");
        let quote_vault_address = extract_payload_string_field(&payload_value, "quoteVault");
        let input_result =
            crate::dex_pool_materialization::DexPoolMaterializationInput::from_decoded_event(
                decoded_event,
                dex_id,
                crate::PoolKind::Amm,
                crate::PoolStatus::Active,
                crate::dex_pool_materialization::DexPoolTokenOrder::AlreadyBaseQuote,
                base_vault_address,
                quote_vault_address,
                transaction.source_endpoint_name.clone(),
            );
        let input = match input_result {
            Ok(input) => input,
            Err(error) => return Err(error),
        };
        let detection_result =
            crate::dex_pool_materialization::materialize_dex_pool(self.database.as_ref(), &input)
                .await;
        let detection_result = match detection_result {
            Ok(detection_result) => detection_result,
            Err(error) => return Err(error),
        };
        let signal_result = self
            .record_pool_detection_signals(
                transaction,
                "signal.dex.raydium_stable_swap",
                &detection_result,
                payload_value,
            )
            .await;
        if let Err(error) = signal_result {
            return Err(error);
        }
        return Ok(detection_result);
    }
    async fn detect_raydium_cpmm_trade(
        &self,
        transaction: &crate::ChainTransactionDto,
--- a/kb_lib/src/dex_detection_route.rs
+++ b/kb_lib/src/dex_detection_route.rs
@@ -11,6 +11,10 @@ pub(crate) enum DexDetectionRoute {
    RaydiumAmmV4Trade,
    /// Raydium CPMM trade route.
    RaydiumCpmmTrade,
    /// Raydium Stable Swap trade route.
    RaydiumStableSwapTrade,
    /// Raydium Stable Swap pool lifecycle route.
    RaydiumStableSwapPool,
    /// Raydium CLMM trade route.
    RaydiumClmmTrade,
    /// Raydium Launchpad pool or bonding-curve creation route.
@@ -67,6 +71,18 @@ pub(crate) fn dex_detection_route(
        ("raydium_cpmm", "raydium_cpmm.swap_base_output") => {
            return Some(crate::dex_detection_route::DexDetectionRoute::RaydiumCpmmTrade);
        },
        ("raydium_stable_swap", "raydium_stable_swap.initialize") => {
            return Some(crate::dex_detection_route::DexDetectionRoute::RaydiumStableSwapPool);
        },
        ("raydium_stable_swap", "raydium_stable_swap.pre_initialize") => {
            return Some(crate::dex_detection_route::DexDetectionRoute::RaydiumStableSwapPool);
        },
        ("raydium_stable_swap", "raydium_stable_swap.swap_base_in") => {
            return Some(crate::dex_detection_route::DexDetectionRoute::RaydiumStableSwapTrade);
        },
        ("raydium_stable_swap", "raydium_stable_swap.swap_base_out") => {
            return Some(crate::dex_detection_route::DexDetectionRoute::RaydiumStableSwapTrade);
        },
        ("raydium_clmm", "raydium_clmm.swap") => {
            return Some(crate::dex_detection_route::DexDetectionRoute::RaydiumClmmTrade);
        },
--- a/kb_lib/src/dex_event_coverage.rs
+++ b/kb_lib/src/dex_event_coverage.rs
@@ -260,6 +260,39 @@ fn infer_expected_db_target_for_entry(
            );
        }
    }
    if decoder_code == "raydium_stable_swap" {
        if entry_name == "initialize" || entry_name == "pre_initialize" {
            return Some(
                crate::DexEventCoverageEntryDto::DB_TARGET_POOL_LIFECYCLE_EVENTS.to_string(),
            );
        }
        if entry_name == "deposit" || entry_name == "withdraw" {
            return Some(crate::DexEventCoverageEntryDto::DB_TARGET_LIQUIDITY_EVENTS.to_string());
        }
        if entry_name == "swap_base_in" || entry_name == "swap_base_out" {
            return Some(crate::DexEventCoverageEntryDto::DB_TARGET_TRADE_EVENTS.to_string());
        }
        if entry_name == "withdraw_pnl" || entry_name == "withdraw_srm" {
            return Some(crate::DexEventCoverageEntryDto::DB_TARGET_FEE_EVENTS.to_string());
        }
        if entry_name == "set_params" {
            return Some(crate::DexEventCoverageEntryDto::DB_TARGET_POOL_ADMIN_EVENTS.to_string());
        }
        if entry_name == "monitor_step" || entry_name == "admin_cancel_orders" {
            return Some(crate::DexEventCoverageEntryDto::DB_TARGET_ORDERBOOK_EVENTS.to_string());
        }
        if entry_name == "update_model_data" {
            return Some(crate::DexEventCoverageEntryDto::DB_TARGET_POOL_ADMIN_EVENTS.to_string());
        }
        if entry_name == "init_model_data"
            || entry_name == "simulate_info"
            || entry_name == "swap_event"
        {
            return Some(
                crate::DexEventCoverageEntryDto::DB_TARGET_DECODED_EVENTS_ONLY.to_string(),
            );
        }
    }
    if decoder_code == "raydium_clmm" {
        if entry_name == "initialize_reward" {
            return Some(crate::DexEventCoverageEntryDto::DB_TARGET_REWARD_EVENTS.to_string());
@@ -405,6 +438,9 @@ fn infer_event_family_for_entry(
    if decoder_code == "raydium_cpmm" {
        return infer_raydium_cpmm_event_family(entry_name, entry_kind);
    }
    if decoder_code == "raydium_stable_swap" {
        return infer_raydium_stable_swap_event_family(entry_name, entry_kind);
    }
    return infer_event_family(entry_name, entry_kind);
 }
@@ -452,6 +488,34 @@ fn infer_raydium_cpmm_event_family(
    }
 }
 fn infer_raydium_stable_swap_event_family(
    entry_name: &str,
    entry_kind: &str,
 ) -> std::option::Option<std::string::String> {
    if entry_kind == crate::ENTRY_KIND_PROGRAM {
        return None;
    }
    match entry_name {
        "initialize" => return Some("pool_create".to_string()),
        "pre_initialize" => return Some("pool_create".to_string()),
        "init_model_data" => return Some("model_setup".to_string()),
        "update_model_data" => return Some("admin_config".to_string()),
        "deposit" => return Some("liquidity_add".to_string()),
        "withdraw" => return Some("liquidity_remove".to_string()),
        "monitor_step" => return Some("order_place".to_string()),
        "set_params" => return Some("admin_config".to_string()),
        "withdraw_pnl" => return Some("fee".to_string()),
        "withdraw_srm" => return Some("fee".to_string()),
        "swap_base_in" => return Some("swap".to_string()),
        "swap_base_out" => return Some("swap".to_string()),
        "simulate_info" => return Some("cpi_transport".to_string()),
        "admin_cancel_orders" => return Some("orderbook_admin".to_string()),
        "swap_event" => return Some("cpi_transport".to_string()),
        _ => return infer_event_family(entry_name, entry_kind),
    }
 }
 fn infer_raydium_clmm_event_family(
    entry_name: &str,
    entry_kind: &str,
@@ -725,6 +789,32 @@ fn raydium_amm_v4_local_event_kind(entry_name: &str) -> std::option::Option<std:
    }
 }
 fn raydium_stable_swap_local_event_kind(
    entry_name: &str,
 ) -> std::option::Option<std::string::String> {
    match entry_name {
        "initialize" => return Some("raydium_stable_swap.initialize".to_string()),
        "init_model_data" => return Some("raydium_stable_swap.init_model_data".to_string()),
        "update_model_data" => return Some("raydium_stable_swap.update_model_data".to_string()),
        "pre_initialize" => return Some("raydium_stable_swap.pre_initialize".to_string()),
        "deposit" => return Some("raydium_stable_swap.deposit".to_string()),
        "withdraw" => return Some("raydium_stable_swap.withdraw".to_string()),
        "monitor_step" => return Some("raydium_stable_swap.monitor_step".to_string()),
        "set_params" => return Some("raydium_stable_swap.set_params".to_string()),
        "withdraw_pnl" => return Some("raydium_stable_swap.withdraw_pnl".to_string()),
        "withdraw_srm" => return Some("raydium_stable_swap.withdraw_srm".to_string()),
        "swap_base_in" => return Some("raydium_stable_swap.swap_base_in".to_string()),
        "swap_base_out" => return Some("raydium_stable_swap.swap_base_out".to_string()),
        "simulate_info" => return Some("raydium_stable_swap.simulate_info".to_string()),
        "admin_cancel_orders" => {
            return Some("raydium_stable_swap.admin_cancel_orders".to_string());
        },
        "swap_event" => return Some("raydium_stable_swap.swap_event".to_string()),
        _ => return None,
    }
 }
 pub(crate) fn known_local_event_kind(
    decoder_code: &str,
    entry_name: &str,
@@ -732,6 +822,9 @@ pub(crate) fn known_local_event_kind(
    if decoder_code == "raydium_amm_v4" {
        return raydium_amm_v4_local_event_kind(entry_name);
    }
    if decoder_code == "raydium_stable_swap" {
        return raydium_stable_swap_local_event_kind(entry_name);
    }
    if decoder_code == "raydium_launchpad" && raydium_launchpad_local_entry_is_known(entry_name) {
        return Some(format!("raydium_launchpad.{}", entry_name));
    }
--- a/kb_lib/src/instruction_observation_index.rs
+++ b/kb_lib/src/instruction_observation_index.rs
@@ -224,7 +224,29 @@ fn resolve_instruction_name(
        };
        return Some(name.to_string());
    }
-
+    if program_id == crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID
        || decoder_code == Some("raydium_stable_swap")
    {
        let name = match discriminator_hex {
            "00" => "raydium_stable_swap.initialize",
            "01" => "raydium_stable_swap.init_model_data",
            "02" => "raydium_stable_swap.update_model_data",
            "03" => "raydium_stable_swap.deposit",
            "04" => "raydium_stable_swap.withdraw",
            "05" => "raydium_stable_swap.monitor_step",
            "06" => "raydium_stable_swap.set_params",
            "07" => "raydium_stable_swap.withdraw_pnl",
            "08" => "raydium_stable_swap.withdraw_srm",
            "09" => "raydium_stable_swap.swap_base_in",
            "0a" => "raydium_stable_swap.pre_initialize",
            "0b" => "raydium_stable_swap.swap_base_out",
            "0c" => "raydium_stable_swap.simulate_info",
            "0d" => "raydium_stable_swap.admin_cancel_orders",
            "40c6cde8260871e2" => "raydium_stable_swap.swap_event",
            _ => return None,
        };
        return Some(name.to_string());
    }
    if program_id == crate::RAYDIUM_CPMM_PROGRAM_ID || decoder_code == Some("raydium_cpmm") {
        let name = match discriminator_hex {
            "9c5420764587467b" => "raydium_cpmm.close_permission_pda",
@@ -284,7 +306,6 @@ fn resolve_instruction_name(
        };
        return Some(name.to_string());
    }
    if program_id == crate::RAYDIUM_LAUNCHPAD_PROGRAM_ID
        || decoder_code == Some("raydium_launchpad")
    {
@@ -309,7 +330,9 @@ fn discriminator_hex_from_data_json(
        Some(decoded) => decoded,
        None => return None,
    };
-    let discriminator_len = if program_id == crate::RAYDIUM_AMM_V4_PROGRAM_ID {
+    let discriminator_len = if program_id == crate::RAYDIUM_AMM_V4_PROGRAM_ID
        || program_id == crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID
    {
        1_usize
    } else {
        8_usize
--- a/kb_lib/src/lib.rs
+++ b/kb_lib/src/lib.rs
@@ -505,6 +505,8 @@ pub use db::FeeEventEntity;
 pub use db::InstructionObservationDto;
 /// Persisted technical observation for one Solana instruction.
 pub use db::InstructionObservationEntity;
 /// Raw source row used to rebuild the technical instruction-observation index.
 pub use db::InstructionObservationSourceRow;
 /// Application-facing known HTTP endpoint DTO.
 pub use db::KnownHttpEndpointDto;
 /// Application-facing known WebSocket endpoint DTO.
@@ -517,6 +519,8 @@ pub use db::KnownWsEndpointEntity;
 pub use db::LaunchAttributionDto;
 /// Persisted launch attribution row.
 pub use db::LaunchAttributionEntity;
 /// Input used to upsert one launch event row.
 pub use db::LaunchEventUpsertInput;
 /// Application-facing launch surface DTO.
 pub use db::LaunchSurfaceDto;
 /// Persisted launch surface row.
@@ -762,12 +766,12 @@ pub use db::query_dex_decoded_events_delete_local_replay_scope_by_transaction_id
 pub use db::query_dex_decoded_events_delete_locally_covered_upstream_instruction_matches;
 /// Deletes Meteora DLMM Anchor self-CPI swap audit rows already covered by decoded swaps.
 pub use db::query_dex_decoded_events_delete_meteora_dlmm_anchor_swap_instruction_audits;
 /// Deletes decoded DEX instruction audit rows related to one decoded instruction.
 pub use db::query_dex_decoded_events_delete_related_instruction_audit;
 /// Deletes one Raydium CLMM instruction-audit row by discriminator.
 pub use db::query_dex_decoded_events_delete_raydium_clmm_instruction_audit_by_discriminator;
 /// Deletes one Raydium Launchpad self-CPI audit row by discriminator.
 pub use db::query_dex_decoded_events_delete_raydium_launchpad_anchor_self_cpi_audit;
 /// Deletes decoded DEX instruction audit rows related to one decoded instruction.
 pub use db::query_dex_decoded_events_delete_related_instruction_audit;
 /// Deletes Raydium CLMM instruction-audit rows for locally mapped CLMM instructions.
 pub use db::query_dex_decoded_events_delete_replaced_raydium_clmm_instruction_audits;
 /// Deletes Raydium CPMM instruction-audit rows already covered by local named rows.
@@ -778,10 +782,10 @@ pub use db::query_dex_decoded_events_get_by_key;
 pub use db::query_dex_decoded_events_get_latest_pump_fun_create_payload_by_mint;
 /// Lists decoded DEX events for one transaction.
 pub use db::query_dex_decoded_events_list_by_transaction_id;
 /// Inserts or updates one decoded DEX event row.
 pub use db::query_dex_decoded_events_upsert;
 /// Updates the persisted payload of one decoded DEX event row.
 pub use db::query_dex_decoded_events_update_payload_json_by_id;
 /// Inserts or updates one decoded DEX event row.
 pub use db::query_dex_decoded_events_upsert;
 /// Deletes DEX event coverage entries for one decoder.
 pub use db::query_dex_event_coverage_entries_delete_by_decoder;
 /// Lists DEX event coverage entries for one decoder.
@@ -819,8 +823,6 @@ pub use db::query_instruction_observations_delete_by_transaction_ids;
 pub use db::query_instruction_observations_list_by_filter;
 /// Upserts one instruction observation row.
 pub use db::query_instruction_observations_upsert;
 /// Raw source row used to rebuild the technical instruction-observation index.
 pub use db::InstructionObservationSourceRow;
 /// Reads one known HTTP endpoint by name.
 pub use db::query_known_http_endpoints_get;
 /// Lists all known HTTP endpoints.
@@ -841,8 +843,6 @@ pub use db::query_launch_attributions_list_by_pool_id;
 pub use db::query_launch_attributions_upsert;
 /// Inserts or updates one launch event row.
 pub use db::query_launch_events_upsert;
 /// Input used to upsert one launch event row.
 pub use db::LaunchEventUpsertInput;
 /// Returns one launch-surface matching key identified by its kind and value, if it exists.
 pub use db::query_launch_surface_keys_get_by_match;
 /// Lists all launch-surface matching keys attached to one launch surface id.
@@ -1221,8 +1221,18 @@ pub use dex::RaydiumCpmmSwapDecoded;
 pub use dex::RaydiumCpmmSwapEventDecoded;
 /// Raydium CPMM swap mode.
 pub use dex::RaydiumCpmmSwapMode;
 /// Raydium Stable Swap decoded event.
 pub use dex::RaydiumStableSwapDecodedEvent;
 /// Raydium Stable Swap decoder.
 pub use dex::RaydiumStableSwapDecoder;
 /// Decoded Raydium Stable Swap instruction.
 pub use dex::RaydiumStableSwapInstructionDecoded;
 /// Decoded Raydium Stable Swap program-data swap event.
 pub use dex::RaydiumStableSwapSwapEventDecoded;
 /// Decodes one Raydium CPMM instruction from projected instruction fields.
 pub use dex::classify_raydium_cpmm_instruction_data;
 /// Classifies one Raydium Stable Swap instruction data payload.
 pub use dex::classify_raydium_stable_swap_instruction_data;
 /// Decodes a Raydium CLMM instruction.
 pub use dex::decode_raydium_clmm_instruction;
 /// Decodes one Raydium CLMM Anchor Program data event.
@@ -1231,6 +1241,8 @@ pub use dex::decode_raydium_clmm_program_data_event;
 pub use dex::decode_raydium_cpmm_instruction;
 /// Decodes Raydium CPMM Anchor events emitted in `Program data:` logs.
 pub use dex::decode_raydium_cpmm_program_data_event;
 /// Decodes Raydium Stable Swap `Program data:` event payloads.
 pub use dex::decode_raydium_stable_swap_program_data_event;
 /// DEX decode service.
 pub use dex_decode::DexDecodeService;
 /// Business-level DEX detection service.
--- a/kb_lib/src/trade_amount_resolution.rs
+++ b/kb_lib/src/trade_amount_resolution.rs
@@ -98,6 +98,7 @@ pub(crate) async fn resolve_trade_amounts(
    }
    if (input.decoded_event.event_kind.starts_with("raydium_amm_v4.")
        || input.decoded_event.event_kind.starts_with("raydium_cpmm.")
        || input.decoded_event.event_kind.starts_with("raydium_stable_swap.")
        || input.decoded_event.event_kind.starts_with("raydium_clmm."))
        && (base_amount_raw.is_none()
            || quote_amount_raw.is_none()
@@ -183,6 +184,21 @@ pub(crate) async fn resolve_trade_amounts(
            return Err(error);
        }
    }
    if input.decoded_event.event_kind.starts_with("raydium_stable_swap.")
        && (base_amount_raw.is_none() || quote_amount_raw.is_none())
    {
        let resolution_result = crate::trade_amount_resolution::apply_vault_balance_delta_fallback(
            input,
            input.base_vault_address,
            input.quote_vault_address,
            &mut base_amount_raw,
            &mut quote_amount_raw,
            &mut price_quote_per_base,
        );
        if let Err(error) = resolution_result {
            return Err(error);
        }
    }
    if input.decoded_event.event_kind.starts_with("raydium_clmm.")
        && (base_amount_raw.is_none() || quote_amount_raw.is_none())
    {
--- a/kb_lib/src/upstream_registry_generated.rs
+++ b/kb_lib/src/upstream_registry_generated.rs
@@ -12836,6 +12836,28 @@ pub(crate) const UPSTREAM_REGISTRY_ENTRIES: &[crate::UpstreamRegistryEntry] = &[
        8,
        "decoders/raydium-liquidity-locking-decoder/src/instructions/settle_cp_fee_event.rs",
    ),
    manual_solscan_discriminator_entry(
        "raydium_stable_swap",
        Some(crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID),
        "raydium",
        "stable_swap",
        crate::ENTRY_KIND_INSTRUCTION,
        "init_model_data",
        "01",
        1,
        "docs.raydium.io/products/stable/instructions#initmodeldata-local-corpus-observed",
    ),
    manual_solscan_discriminator_entry(
        "raydium_stable_swap",
        Some(crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID),
        "raydium",
        "stable_swap",
        crate::ENTRY_KIND_INSTRUCTION,
        "update_model_data",
        "02",
        1,
        "docs.raydium.io/products/stable/instructions#updatemodeldata-local-corpus-observed",
    ),
    upstream_git_discriminator_entry(
        "raydium_stable_swap",
        Some(crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID),
@@ -12869,6 +12891,50 @@ pub(crate) const UPSTREAM_REGISTRY_ENTRIES: &[crate::UpstreamRegistryEntry] = &[
        1,
        "decoders/raydium-stable-swap-decoder/src/instructions/pre_initialize.rs",
    ),
    manual_solscan_discriminator_entry(
        "raydium_stable_swap",
        Some(crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID),
        "raydium",
        "stable_swap",
        crate::ENTRY_KIND_INSTRUCTION,
        "monitor_step",
        "05",
        1,
        "docs.raydium.io/products/stable/instructions#monitorstep-local-corpus-observed",
    ),
    manual_solscan_discriminator_entry(
        "raydium_stable_swap",
        Some(crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID),
        "raydium",
        "stable_swap",
        crate::ENTRY_KIND_INSTRUCTION,
        "set_params",
        "06",
        1,
        "docs.raydium.io/products/stable/instructions#setparams-local-corpus-observed",
    ),
    manual_solscan_discriminator_entry(
        "raydium_stable_swap",
        Some(crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID),
        "raydium",
        "stable_swap",
        crate::ENTRY_KIND_INSTRUCTION,
        "withdraw_pnl",
        "07",
        1,
        "docs.raydium.io/products/stable/instructions#withdrawpnl-local-corpus-observed",
    ),
    manual_solscan_discriminator_entry(
        "raydium_stable_swap",
        Some(crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID),
        "raydium",
        "stable_swap",
        crate::ENTRY_KIND_INSTRUCTION,
        "withdraw_srm",
        "08",
        1,
        "docs.raydium.io/products/stable/instructions#withdrawsrm-local-corpus-observed",
    ),
    upstream_git_discriminator_entry(
        "raydium_stable_swap",
        Some(crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID),
@@ -12902,6 +12968,39 @@ pub(crate) const UPSTREAM_REGISTRY_ENTRIES: &[crate::UpstreamRegistryEntry] = &[
        1,
        "decoders/raydium-stable-swap-decoder/src/instructions/withdraw.rs",
    ),
    manual_solscan_discriminator_entry(
        "raydium_stable_swap",
        Some(crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID),
        "raydium",
        "stable_swap",
        crate::ENTRY_KIND_INSTRUCTION,
        "simulate_info",
        "0c",
        1,
        "docs.raydium.io/products/stable/instructions#simulateinfo-local-corpus-observed",
    ),
    manual_solscan_discriminator_entry(
        "raydium_stable_swap",
        Some(crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID),
        "raydium",
        "stable_swap",
        crate::ENTRY_KIND_INSTRUCTION,
        "admin_cancel_orders",
        "0d",
        1,
        "raydium-amm/program/src/instruction.rs#admincancelorders-stable-local-corpus-observed",
    ),
    manual_solscan_discriminator_entry(
        "raydium_stable_swap",
        Some(crate::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID),
        "raydium",
        "stable_swap",
        crate::ENTRY_KIND_EVENT,
        "swap_event",
        "40c6cde8260871e2",
        8,
        "docs.raydium.io/products/stable/instructions#program-data-swap-event-decoded-only",
    ),
    upstream_git_discriminator_entry(
        "stabble_stable_swap",
        Some(crate::STABBLE_STABLE_SWAP_PROGRAM_ID),
--- a/validation_sql/SQL_VALIDATION_RAYDIUM_STABLE_SWAP_0_7_52.sql
+++ b/validation_sql/SQL_VALIDATION_RAYDIUM_STABLE_SWAP_0_7_52.sql
@@ -0,0 +1,292 @@
 -- file: validation_sql/SQL_VALIDATION_RAYDIUM_STABLE_SWAP_0_7_52.sql
 -- 0.7.52 raydium_stable_swap validation checklist.
 -- Run on a dedicated fresh SQLite database after corpus construction and replay with:
 -- skipDexDecode=no, forceDexDecode=yes, deferInstructionObservations=yes.
 -- 01. Coverage stable swap.
 SELECT
    entry_name,
    entry_kind,
    event_family,
    expected_db_target,
    proof_status,
    local_event_kind,
    discriminator_hex,
    observed_count,
    materialized_count,
    trade_count
 FROM k_sol_dex_event_coverage_entries
 WHERE decoder_code = 'raydium_stable_swap'
 ORDER BY entry_kind, entry_name, discriminator_hex;
 -- 02. Instruction observations.
 SELECT
    instruction_name,
    discriminator_hex,
    COUNT(*) AS observed_count,
    COUNT(DISTINCT signature) AS tx_count
 FROM k_sol_instruction_observations
 WHERE decoder_code = 'raydium_stable_swap'
 GROUP BY instruction_name, discriminator_hex
 ORDER BY observed_count DESC, instruction_name, discriminator_hex;
 -- 03. Residual local instruction audit.
 SELECT
    json_extract(payload_json, '$.discriminatorHex') AS discriminator_hex,
    COUNT(*) AS audit_count,
    COUNT(DISTINCT transaction_id) AS tx_count
 FROM k_sol_dex_decoded_events
 WHERE protocol_name = 'raydium_stable_swap'
  AND event_kind = 'raydium_stable_swap.instruction_audit'
 GROUP BY discriminator_hex
 ORDER BY audit_count DESC, discriminator_hex;
 -- 04. Residual upstream fallback for covered local entries.
 SELECT
    json_extract(ug.payload_json, '$.upstreamDecoderCode') AS upstream_decoder_code,
    json_extract(ug.payload_json, '$.upstreamEntryName') AS entry_name,
    json_extract(ug.payload_json, '$.upstreamDiscriminatorHex') AS discriminator_hex,
    json_extract(ug.payload_json, '$.upstreamSourceRepo') AS source_repo,
    COUNT(*) AS fallback_count,
    COUNT(DISTINCT ug.transaction_id) AS tx_count
 FROM k_sol_dex_decoded_events ug
 JOIN k_sol_dex_event_coverage_entries ce
    ON ce.decoder_code = json_extract(ug.payload_json, '$.upstreamDecoderCode')
   AND ce.entry_name = json_extract(ug.payload_json, '$.upstreamEntryName')
   AND ce.discriminator_hex = json_extract(ug.payload_json, '$.upstreamDiscriminatorHex')
   AND ce.local_event_kind IS NOT NULL
   AND ce.local_event_kind <> ''
 WHERE ug.protocol_name = 'upstream_git'
  AND ug.event_kind = 'upstream_git.instruction_match'
  AND json_extract(ug.payload_json, '$.upstreamDecoderCode') = 'raydium_stable_swap'
 GROUP BY upstream_decoder_code, entry_name, discriminator_hex, source_repo
 ORDER BY fallback_count DESC, entry_name;
 -- 05. Non-swap safety: non-swap event must not materialize as trade.
 SELECT
    de.event_kind,
    ce.event_family,
    COUNT(*) AS decoded_count,
    COUNT(te.id) AS trade_count
 FROM k_sol_dex_decoded_events de
 LEFT JOIN k_sol_dex_event_coverage_entries ce
    ON ce.decoder_code = 'raydium_stable_swap'
   AND ce.local_event_kind = de.event_kind
 LEFT JOIN k_sol_trade_events te
    ON te.decoded_event_id = de.id
 WHERE de.protocol_name = 'raydium_stable_swap'
 GROUP BY de.event_kind, ce.event_family
 HAVING ce.event_family <> 'swap'
   AND COUNT(te.id) > 0
 ORDER BY trade_count DESC, de.event_kind;
 -- 06. Failed transaction safety: failed tx must not materialize as business trade.
 SELECT
    de.event_kind,
    COUNT(*) AS decoded_failed_count,
    COUNT(te.id) AS trade_count
 FROM k_sol_dex_decoded_events de
 JOIN k_sol_chain_transactions tx
    ON tx.id = de.transaction_id
 LEFT JOIN k_sol_trade_events te
    ON te.decoded_event_id = de.id
 WHERE de.protocol_name = 'raydium_stable_swap'
  AND tx.err_json IS NOT NULL
  AND tx.err_json <> ''
  AND tx.err_json <> 'null'
 GROUP BY de.event_kind
 HAVING COUNT(te.id) > 0
 ORDER BY trade_count DESC, de.event_kind;
 -- 07. Decoded without coverage entry.
 SELECT
    de.event_kind,
    COUNT(*) AS decoded_count
 FROM k_sol_dex_decoded_events de
 LEFT JOIN k_sol_dex_event_coverage_entries ce
    ON ce.decoder_code = 'raydium_stable_swap'
   AND ce.local_event_kind = de.event_kind
 WHERE de.protocol_name = 'raydium_stable_swap'
  AND ce.id IS NULL
 GROUP BY de.event_kind
 ORDER BY decoded_count DESC, de.event_kind;
 -- 08. Multi-target materialization.
 SELECT
    de.event_kind,
    COUNT(DISTINCT de.id) AS decoded_count,
    COUNT(DISTINCT te.id) AS trade_count,
    COUNT(DISTINCT le.id) AS liquidity_count,
    COUNT(DISTINCT pe.id) AS lifecycle_count,
    COUNT(DISTINCT fe.id) AS fee_count,
    COUNT(DISTINCT ae.id) AS admin_count,
    COUNT(DISTINCT oe.id) AS orderbook_count,
    (
        CASE WHEN COUNT(DISTINCT te.id) > 0 THEN 1 ELSE 0 END
      + CASE WHEN COUNT(DISTINCT le.id) > 0 THEN 1 ELSE 0 END
      + CASE WHEN COUNT(DISTINCT pe.id) > 0 THEN 1 ELSE 0 END
      + CASE WHEN COUNT(DISTINCT fe.id) > 0 THEN 1 ELSE 0 END
      + CASE WHEN COUNT(DISTINCT ae.id) > 0 THEN 1 ELSE 0 END
      + CASE WHEN COUNT(DISTINCT oe.id) > 0 THEN 1 ELSE 0 END
    ) AS materialized_target_count
 FROM k_sol_dex_decoded_events de
 LEFT JOIN k_sol_trade_events te
    ON te.decoded_event_id = de.id
 LEFT JOIN k_sol_liquidity_events le
    ON le.decoded_event_id = de.id
 LEFT JOIN k_sol_pool_lifecycle_events pe
    ON pe.decoded_event_id = de.id
 LEFT JOIN k_sol_fee_events fe
    ON fe.decoded_event_id = de.id
 LEFT JOIN k_sol_pool_admin_events ae
    ON ae.decoded_event_id = de.id
 LEFT JOIN k_sol_orderbook_events oe
    ON oe.decoded_event_id = de.id
 WHERE de.protocol_name = 'raydium_stable_swap'
 GROUP BY de.event_kind
 HAVING materialized_target_count > 1
 ORDER BY materialized_target_count DESC, de.event_kind;
 -- 09. Unexplained successful non-materialized events.
 SELECT
    de.event_kind,
    COUNT(*) AS unexplained_count
 FROM k_sol_dex_decoded_events de
 JOIN k_sol_chain_transactions tx
    ON tx.id = de.transaction_id
 LEFT JOIN k_sol_trade_events te
    ON te.decoded_event_id = de.id
 LEFT JOIN k_sol_liquidity_events le
    ON le.decoded_event_id = de.id
 LEFT JOIN k_sol_pool_lifecycle_events pe
    ON pe.decoded_event_id = de.id
 LEFT JOIN k_sol_fee_events fe
    ON fe.decoded_event_id = de.id
 LEFT JOIN k_sol_pool_admin_events ae
    ON ae.decoded_event_id = de.id
 LEFT JOIN k_sol_orderbook_events oe
    ON oe.decoded_event_id = de.id
 LEFT JOIN k_sol_token_account_events tae
    ON tae.decoded_event_id = de.id
 WHERE de.protocol_name = 'raydium_stable_swap'
  AND (
      tx.err_json IS NULL
      OR tx.err_json = ''
      OR tx.err_json = 'null'
  )
  AND te.id IS NULL
  AND le.id IS NULL
  AND pe.id IS NULL
  AND fe.id IS NULL
  AND ae.id IS NULL
  AND oe.id IS NULL
  AND tae.id IS NULL
  AND COALESCE(TRIM(json_extract(de.payload_json, '$.skipTradeReason')), '') = ''
  AND COALESCE(TRIM(json_extract(de.payload_json, '$.skipLiquidityReason')), '') = ''
  AND COALESCE(TRIM(json_extract(de.payload_json, '$.skipLifecycleReason')), '') = ''
  AND COALESCE(TRIM(json_extract(de.payload_json, '$.skipCatalogReason')), '') = ''
 GROUP BY de.event_kind
 ORDER BY unexplained_count DESC, de.event_kind;
 -- 10. Materialization summary.
 SELECT
    de.event_kind,
    COUNT(DISTINCT de.id) AS decoded_count,
    COUNT(DISTINCT te.id) AS trade_count,
    COUNT(DISTINCT le.id) AS liquidity_count,
    COUNT(DISTINCT pe.id) AS lifecycle_count,
    COUNT(DISTINCT fe.id) AS fee_count,
    COUNT(DISTINCT ae.id) AS admin_count,
    COUNT(DISTINCT oe.id) AS orderbook_count
 FROM k_sol_dex_decoded_events de
 LEFT JOIN k_sol_trade_events te
    ON te.decoded_event_id = de.id
 LEFT JOIN k_sol_liquidity_events le
    ON le.decoded_event_id = de.id
 LEFT JOIN k_sol_pool_lifecycle_events pe
    ON pe.decoded_event_id = de.id
 LEFT JOIN k_sol_fee_events fe
    ON fe.decoded_event_id = de.id
 LEFT JOIN k_sol_pool_admin_events ae
    ON ae.decoded_event_id = de.id
 LEFT JOIN k_sol_orderbook_events oe
    ON oe.decoded_event_id = de.id
 WHERE de.protocol_name = 'raydium_stable_swap'
 GROUP BY de.event_kind
 ORDER BY de.event_kind;
 -- 11. Stable Swap swap amount-source closure.
 -- Successful swaps must materialize from exact vault deltas.
 -- Failed swaps may remain instruction-bounds-only and must not materialize as trades.
 SELECT
    de.event_kind,
    json_extract(de.payload_json, '$.amountSource') AS amount_source,
    CASE
        WHEN tx.err_json IS NOT NULL
         AND tx.err_json <> ''
         AND tx.err_json <> 'null'
        THEN 'failed'
        ELSE 'success'
    END AS tx_status,
    COUNT(*) AS decoded_count,
    COUNT(te.id) AS trade_count
 FROM k_sol_dex_decoded_events de
 JOIN k_sol_chain_transactions tx
    ON tx.id = de.transaction_id
 LEFT JOIN k_sol_trade_events te
    ON te.decoded_event_id = de.id
 WHERE de.protocol_name = 'raydium_stable_swap'
  AND de.event_kind IN (
      'raydium_stable_swap.swap_base_in',
      'raydium_stable_swap.swap_base_out'
  )
 GROUP BY de.event_kind, amount_source, tx_status
 ORDER BY de.event_kind, amount_source, tx_status;
 -- 12. Stable Swap successful swap without trade and without explanation.
 -- Expected result: empty.
 SELECT
    de.event_kind,
    COUNT(*) AS unexplained_success_count
 FROM k_sol_dex_decoded_events de
 JOIN k_sol_chain_transactions tx
    ON tx.id = de.transaction_id
 LEFT JOIN k_sol_trade_events te
    ON te.decoded_event_id = de.id
 WHERE de.protocol_name = 'raydium_stable_swap'
  AND de.event_kind IN (
      'raydium_stable_swap.swap_base_in',
      'raydium_stable_swap.swap_base_out'
  )
  AND (
      tx.err_json IS NULL
      OR tx.err_json = ''
      OR tx.err_json = 'null'
  )
  AND te.id IS NULL
  AND COALESCE(TRIM(json_extract(de.payload_json, '$.skipTradeReason')), '') = ''
 GROUP BY de.event_kind;
 -- 13. Stable Swap failed swap safety.
 -- Expected result: empty.
 SELECT
    de.event_kind,
    json_extract(de.payload_json, '$.amountSource') AS amount_source,
    COUNT(*) AS failed_trade_count
 FROM k_sol_dex_decoded_events de
 JOIN k_sol_chain_transactions tx
    ON tx.id = de.transaction_id
 JOIN k_sol_trade_events te
    ON te.decoded_event_id = de.id
 WHERE de.protocol_name = 'raydium_stable_swap'
  AND de.event_kind IN (
      'raydium_stable_swap.swap_base_in',
      'raydium_stable_swap.swap_base_out'
  )
  AND tx.err_json IS NOT NULL
  AND tx.err_json <> ''
  AND tx.err_json <> 'null'
 GROUP BY de.event_kind, amount_source
 ORDER BY de.event_kind, amount_source;