> ## Documentation Index
> Fetch the complete documentation index at: https://docs.raydium.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Matrice de support Token-2022
> Quels programmes Raydium supportent Token-2022, la liste blanche explicite d'extensions que chaque programme applique à la création de pool, et les chemins de contournement (liste blanche de mint statique, registre par mint, détection Superstate) qui admettent les mints autrement rejetés.
**Cette page est traduite automatiquement par IA. La version anglaise fait foi.**
[Voir la version anglaise →](/reference/token-2022-support)
Raydium **n'accepte pas** les mints Token-2022 arbitraires. CPMM et CLMM fonctionnent tous deux en **mode liste blanche stricte** : seul un petit ensemble d'extensions passe par défaut ; tout le reste est rejeté à la création du pool. Une poignée de mints de confiance sont admis par adresse codée en dur ; CLMM supporte en outre un registre par mint géré par un administrateur et une détection Superstate à l'exécution. Cette page est la référence unique pour ce qui est appliqué et où, avec des citations fichier-et-ligne dans le code source du programme.
## Support au niveau du programme
| Programme | Mints base/quote Token-2022 ? | Mode |
| --------------- | ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **CPMM** | Oui — contrôlé | Liste blanche stricte d'extensions + liste blanche statique de 4 mints. |
| **CLMM** | Oui — contrôlé | Liste blanche stricte d'extensions + liste blanche statique de 6 mints + registre par mint admin + détection Superstate. |
| **AMM v4** | Non | Le programme antécède Token-2022 ; les deux mints doivent être du Token SPL classique. |
| **Stable AMM** | Non | Mêmes contraintes que AMM v4. |
| **Farm v6** | Oui, partiel | Le mint de récompense peut être Token-2022 (soumis à la même liste blanche quand une farm enveloppe un LP CPMM/CLMM) ; les mints LP de stake des utilisateurs héritent du pool enveloppé. |
| **LaunchLab** | Oui, géré par programme | Le mint de base peut être Token-2022, mais seulement via l'instruction dédiée `initialize_with_token_2022` ; le programme crée lui-même le mint avec `MetadataPointer` (toujours) et optionnellement `TransferFeeConfig` (taux ≤ 5 %). Les mints Token-2022 pré-existants avec extensions arbitraires ne peuvent pas être utilisés comme base. |
| **Burn & Earn** | Miroir du programme de pool | Hérite du contrôle CPMM / CLMM. |
Les vérifications de liste blanche se trouvent dans :
* **CPMM** : `is_supported_mint` dans [`raydium-cp-swap/programs/cp-swap/src/utils/token.rs:178`](https://github.com/raydium-io/raydium-cp-swap), appelé depuis `Initialize`.
* **CLMM** : `is_supported_mint` dans [`raydium-clmm/programs/amm/src/util/token.rs:280`](https://github.com/raydium-io/raydium-clmm), appelé depuis `CreatePool`.
* **LaunchLab** : `initialize_with_token_2022` dans `raydium-launchpad/programs/launchpad/src/instructions/initialize_with_token_2022.rs` (source non publiquement disponible).
Il n'y a **pas** de vérification de mint au moment du swap sur CPMM ou CLMM — le portail se déclenche uniquement à la création du pool. Une fois qu'un pool existe, les swaps font simplement confiance au fait que les mints n'ont pas changé, ce qui est correct pour les parties immuables de l'état du mint Token-2022.
## Liste blanche d'extensions CPMM et CLMM
Après les courts-circuits de liste blanche statique (couverts ci-dessous), le programme itère les extensions du mint et rejette le mint s'il porte **une** extension autre que ces cinq :
| Extension | Raison pour laquelle c'est autorisé |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `TransferFeeConfig` | Les mathématiques du pool soustraient la commission entrante ; le programme Token-2022 traite la commission sortante. Voir [`algorithms/token-2022-transfer-fees`](/fr/algorithms/token-2022-transfer-fees). |
| `MetadataPointer` | Décorateur — pointe vers des métadonnées on-chain. |
| `TokenMetadata` | Décorateur — métadonnées en ligne. |
| `InterestBearingConfig` | Le pool voit le montant principal ; le multiplicateur UI est un décorateur et le solde sous-jacent est préservé. |
| `ScaledUiAmount` | Même forme que l'intérêt composé — le facteur d'échelle s'applique uniquement à l'affichage UI. |
Tout ce qui n'est pas dans cette liste — `TransferHook`, `NonTransferable`, `ConfidentialTransferMint`, `PermanentDelegate`, `MintCloseAuthority`, `DefaultAccountState`, `GroupPointer`, `GroupMemberPointer`, `MemberPointer`, `Pausable`, etc. — fait que `is_supported_mint` retourne `false` et la création du pool s'annule.
Les lignes pertinentes (CPMM, forme identique dans CLMM) :
```rust theme={null}
for e in extensions {
if e != ExtensionType::TransferFeeConfig
&& e != ExtensionType::MetadataPointer
&& e != ExtensionType::TokenMetadata
&& e != ExtensionType::InterestBearingConfig
&& e != ExtensionType::ScaledUiAmount
{
return Ok(false);
}
}
Ok(true)
```
— [`cp-swap/src/utils/token.rs:190–200`](https://github.com/raydium-io/raydium-cp-swap)
## Chemins de contournement
Un mint Token-2022 qui ne correspond pas à la liste blanche peut quand même être admis par l'un des trois contournements explicites. Ils sont tentés dans l'ordre, avant que l'itération d'extension ne s'exécute.
### 1. Liste blanche de mint statique
Un tableau constant `MINT_WHITELIST` de chaînes base58 est codé en dur dans chaque programme. Si l'adresse du mint correspond, la fonction retourne `true` immédiatement et aucune vérification d'extension n'est effectuée.
| Programme | Mints en liste blanche |
| --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| CPMM | `HVbpJAQGNpkgBaYBZQBR1t7yFdvaYVp2vCQQfKKEN4tM`, `Crn4x1Y2HUKko7ox2EZMT6N2t2ZyH7eKtwkBGVnhEq1g`, `FrBfWJ4qE5sCzKm3k3JaAtqZcXUh4LvJygDeketsrsH4`, `2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo` |
| CLMM | Les quatre mêmes, plus `DAUcJBg4jSpVoEzASxYzdqHMUN8vuTpQyG2TvDcCHfZg`, `AUSD1jCcCyPLybk1YnvPWsHQSrZ46dxwoMniN4N2UEB9` |
Ces adresses sont intégrées au programme ; la mise à jour de la liste nécessite une mise à niveau du programme via le multisig de mise à niveau 3/4.
### 2. Registre par mint — CLMM uniquement
CLMM consulte en outre un PDA `SupportMintAssociated` à la graine `[b"support_mint", mint]`. Si ce PDA existe pour le mint, il est admis indépendamment de son ensemble d'extensions.
Le PDA est créé par `CreateSupportMintAssociated` ([`admin/create_support_mint_associated.rs`](https://github.com/raydium-io/raydium-clmm)). L'instruction est contrôlée à deux signataires :
* `crate::admin::ID` — l'autorité admin Raydium standard.
* `crate::create_support_mint_associated_owner::ID` — une autorité dédiée à cet effet : `RayVyjyJQz9vAi126A4sGexKnSU1XeZaHTRcM1mZMPY` (mainnet), `rayf3nEbb3bnfN6RDGFpqPbjc5uUa3tRUzu6UVYrRx5` (devnet).
Effet : l'équipe CLMM peut inscrire un mint Token-2022 spécifique à la création de pool sans mise à niveau du programme. CPMM n'a pas d'équivalent — sa liste blanche est strictement codée dans la source.
### 3. Détection Superstate — CLMM uniquement
CLMM a un troisième chemin spécifiquement pour les actifs tokenisés de Superstate, qui utilisent l'extension `ScaledUiConfig` que la version de `spl-token-2022` liée au programme CLMM ne peut pas décompacter. Plutôt que de mettre à niveau la dépendance, CLMM détecte les tokens Superstate par la forme de leur autorité :
```rust theme={null}
superstate_allowlist::ID == freeze_authority
&& *mint_account_info.owner == spl_token_2022::ID
&& default_account_state_freeze
&& maybe_permanent_delegate
```
— [`raydium-clmm/programs/amm/src/util/token.rs:485`](https://github.com/raydium-io/raydium-clmm)
Un mint passe cette branche si **les quatre** tiennent :
* Son programme propriétaire est le programme Token-2022.
* Son autorité de gel égale `superstate_allowlist::ID`. Mainnet : `2Yq4T3mPNfjtEyTxSbRjRKqLf1pwbTasuCQrWe6QpM7x`. Devnet : `3TRuL3MFvzHaUfQAb6EsSAbQhWdhmYrKxEiViVkdQfXu`.
* Son extension `DefaultAccountState` est définie sur `Frozen`.
* Son délégué permanent est aussi `superstate_allowlist::ID`.
C'est une heuristique, pas un registre — tout mint futur que Superstate émettra avec la même forme d'autorité sera admis automatiquement.
## Ce que les contournements ne dispensent pas
Les contournements ignorent la liste blanche d'extensions, mais le programme applique toujours :
* Le mint est propriété de `Token` ou `Token-2022`. Un programme de token personnalisé est rejeté en amont.
* Les coffres du pool sont créés avec les bonnes extensions ATA pour les pools Token-2022 (`ImmutableOwner`, etc.).
* Tous les transferts passent par `transfer_checked` — les mints porteurs de frais landent le bon montant dans le coffre.
Un mint en liste blanche ou enregistré par PDA qui ajoute un `TransferHook` plus tard ne gagne pas une vérification au moment du swap ; le hook s'exécuterait simplement à chaque transfert et pourrait bloquer les swaps. La mise en liste blanche est donc une action de haute confiance.
## Sémantique « Bloqué »
Quand `is_supported_mint` retourne `false`, la création du pool s'annule avec `ErrorCode::NotSupportMint` (CPMM) / `ErrorCode::NotSupportMint` (CLMM). Voir [`reference/error-codes`](/fr/reference/error-codes) pour les codes numériques.
Les pools existants ne peuvent pas échouer rétroactivement cette vérification — le portail ne s'exécute qu'à la création. Les extensions de mint sont immuables pour les catégories que Raydium rejette (transfer hook, non-transférable, transfer confidentiel ne peut pas être ajouté post-création), donc la vérification statique est suffisante.
## Pourquoi chaque extension exclue est exclue
* **TransferHook** — invoque un programme personnalisé à chaque transfert, avec consommation CU arbitraire, conditions d'échec arbitraires, et la capacité à réentrer le programme appelant. Aucun sandbox sûr n'existe. Certains DEX maintiennent des listes blanches de hooks ; Raydium ne le fait pas.
* **NonTransferable** — `Transfer` échoue toujours. Un pool ne peut pas prendre la garde.
* **ConfidentialTransfer** — les montants de transfert sont chiffrés ; la courbe ne peut pas évaluer le swap.
* **PermanentDelegate** — un titulaire du délégué peut balayer n'importe quel compte de token, y compris le coffre du pool. Autorisé uniquement via la liste blanche statique pour les émetteurs de confiance (p. ex., stablecoins réglementés).
* **MintCloseAuthority** — le mint peut être fermé ; les pools existants deviennent inutilisables. Disallowed by default.
* **DefaultAccountState (Frozen)** — les ATA du pool se retrouveraient à l'état `Frozen` et nécessiteraient un dégel par compte. Autorisé uniquement via la détection Superstate, qui suppose que l'émetteur dégèle les comptes institutionnels lors de l'inscription.
* **Group/Member pointers** — pas activement nuisibles, mais non examinés. Disallowed by default to keep the surface narrow.
## Comptabilité des frais de transfert
Pour les mints portant `TransferFeeConfig`, chaque swap, dépôt et retrait déplace moins que le montant nominal. Le SDK expose les deux moitiés du calcul :
```ts theme={null}
const { amountIn, amountOut, feeAmount, token2022FeeIn, token2022FeeOut } =
await raydium.cpmm.computeSwapAmount({ ... });
```
Une UI correcte affiche :
* `amountIn + token2022FeeIn` comme « vous envoyez »
* `amountOut - token2022FeeOut` comme « vous recevez »
* `feeAmount` comme la commission du pool (LP + protocole), qui est séparée de la commission de transfert Token-2022
Une UI naïve qui affiche uniquement `amountIn → amountOut` sous-estime les coûts.
### Plafond `maximumFee`
Les frais de transfert Token-2022 sont plafonné par transfert. Pour un mint à 1 % avec un plafond de 10 000 tokens, un transfert de 100 000 000 tokens ne paie que 10 000 en frais. Le `computeSwapAmount` du SDK applique le plafond ; les appelants de programme directs doivent le reproduire.
### Transition d'époque
Une autorité de mint peut programmer un changement de taux de frais qui s'active à l'époque suivante. Pendant la fenêtre de transition, deux configs (`older`, `newer`) vivent sur le mint à la fois et `TransferChecked` sélectionne par époque actuelle. `SwapV2` de CPMM et `SwapV2` de CLMM passent tous deux le compte de mint complet dans `accounts`, donc le programme lit la bonne config sans recherche supplémentaire.
Si vous cotez plus d'une époque à l'avance via l'API Trade ou le SDK, les frais exécutés peuvent différer des frais cotés — délimité par `maximum_fee_basis_points` de la config la plus ancienne.
## Interest-bearing et ScaledUiAmount
Le pool détient le montant principal ; le « montant UI » est le principal multiplié par un facteur d'échelle dépendant du temps ou défini par un administrateur. Les mathématiques du swap opèrent sur le principal :
```
principal_in = ui_amount_in / ui_multiplier(now)
```
Le SDK convertit automatiquement. Les lecteurs RPC directs doivent traiter `pool.token0Vault.amount` comme principal.
## Définition de « pool Token-2022 »
Un pool est un pool Token-2022 si **l'un ou l'autre** mint a `programId == TokenzQdB...`. L'API expose ceci :
```
GET /pools/info/ids?ids=
```
```json theme={null}
{
"data": [{
"mintA": { "programId": "TokenzQdB...", "hasTransferFee": true, ... },
"mintB": { "programId": "Tokenkeg...", ... }
}]
}
```
Utilisez `programId` pour dispatcher, et `hasTransferFee` pour afficher un avertissement UI.
## Aides du SDK
```ts theme={null}
import { Raydium, TOKEN_2022_PROGRAM_ID } from "@raydium-io/raydium-sdk-v2";
import { ExtensionType, getExtensionTypes, unpackMint } from "@solana/spl-token";
const raydium = await Raydium.load({ owner, connection });
const acct = await connection.getAccountInfo(mintPubkey);
if (!acct) throw new Error("mint not found");
const mint = unpackMint(mintPubkey, acct, acct.owner);
if (acct.owner.equals(TOKEN_2022_PROGRAM_ID)) {
const extensions = getExtensionTypes(mint.tlvData);
const accepted = new Set([
ExtensionType.TransferFeeConfig,
ExtensionType.MetadataPointer,
ExtensionType.TokenMetadata,
ExtensionType.InterestBearingConfig,
ExtensionType.ScaledUiAmount,
]);
const rejecting = extensions.filter(e => !accepted.has(e));
if (rejecting.length) {
console.warn("Pool creation will revert unless this mint is whitelisted:", rejecting);
}
}
```
## Erreurs d'intégration courantes
* **Pré-validation seulement de l'ID du programme.** Un mint peut être Token-2022 *et* non supporté. Marchez la liste d'extension par rapport à la liste blanche (et la liste blanche statique) avant d'autoriser la création du pool.
* **Faire confiance à la cotation du SDK quand le mint n'est pas accepté du tout.** L'API de cotation ne refuse pas de coter — la création du pool est ce qui s'annule. Confirmez la sémantique `is_supported_mint` hors chaîne avant d'exposer la création du pool dans votre UI.
* **Coter sans la retenue de frais de transfert.** Un mint à frais de transfert de 1 % des deux côtés d'un pool CPMM à 0,25 % a une commission effective d'environ 2,25 %, pas 0,25 %. Utilisez la cotation du SDK ou la cotation de l'API Trade — ne calculez jamais les frais manuellement à partir du seul niveau de frais du pool.
* **Appeler l'instruction `Swap` héritée sur un pool Token-2022.** `Swap` antécède Token-2022. Utilisez `SwapV2` quand l'un ou l'autre mint est Token-2022.
* **Lister automatiquement les nouveaux mints Token-2022.** Les portefeuilles et agrégateurs doivent vérifier `TransferHook` et `NonTransferable` avant de surfacer un mint aux utilisateurs ; les deux sont hostiles à Raydium.
## Travaux futurs
Les éléments de feuille de route d'écosystème Solana et de protocole qui changeraient cette matrice :
* Programmes de transfer-hook en liste blanche au niveau Solana (convention d'écosystème en évolution).
* AMM compatibles avec confidential-transfer (stade de recherche).
* Registre par mint CPMM plus large (parité avec CLMM).
* Mise à niveau de dépendance afin que le décodage `ScaledUiConfig` de CLMM fonctionne sans l'heuristique Superstate.
Cette page sera mise à jour quand l'une d'elles aboutira.
## Pointeurs
* [`algorithms/token-2022-transfer-fees`](/fr/algorithms/token-2022-transfer-fees) — mathématiques des frais dans les swaps.
* [`products/cpmm/instructions`](/fr/products/cpmm/instructions) — `SwapV2`, `Initialize`.
* [`products/clmm/instructions`](/fr/products/clmm/instructions) — `SwapV2`, `CreatePool`, `CreateSupportMintAssociated`.
* [`reference/error-codes`](/fr/reference/error-codes) — codes numériques `NotSupportMint` par programme.
Sources :
* `raydium-cp-swap/programs/cp-swap/src/utils/token.rs` — `MINT_WHITELIST`, `is_supported_mint`.
* `raydium-clmm/programs/amm/src/util/token.rs` — `MINT_WHITELIST`, `superstate_allowlist`, `is_superstate_token`, `is_supported_mint`.
* `raydium-clmm/programs/amm/src/instructions/admin/create_support_mint_associated.rs` — instruction de registre par mint.
* `raydium-launchpad/programs/launchpad/src/instructions/initialize_with_token_2022.rs` — création de mint de base Token-2022 pour LaunchLab.