> ## 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.

# Matriz de compatibilidad con Token-2022

> Qué programas de Raydium soportan Token-2022, la lista explícita de extensiones permitidas que cada programa aplica en la creación del pool, y las rutas de bypass (lista blanca estática de mints, registro por mint, detección Superstate) que admiten mints rechazados de otro modo.

<Info>
  **Esta página fue traducida automáticamente por IA. La versión en inglés es la fuente autorizada.**

  [Ver versión en inglés →](/reference/token-2022-support)
</Info>

Raydium **no** acepta mints arbitrarios de Token-2022. Tanto CPMM como CLMM funcionan en modo de **lista blanca estricta**: solo un pequeño conjunto de extensiones pasan por defecto; todo lo demás se rechaza en la creación del pool. Un puñado de mints de confianza se admiten por dirección codificada; CLMM además soporta un registro por mint administrado y detección de tokens Superstate en tiempo de ejecución. Esta página es la referencia única para lo que se aplica y dónde, con citas de archivo y línea en el código fuente del programa.

## Soporte a nivel de programa

| Programa        | ¿Mints base/quote de Token-2022? | Modo                                                                                                                                                                                                                                                                                                                    |
| --------------- | -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **CPMM**        | Sí — controlado                  | Lista blanca estricta de extensiones + lista blanca estática de 4 mints.                                                                                                                                                                                                                                                |
| **CLMM**        | Sí — controlado                  | Lista blanca estricta de extensiones + lista blanca estática de 6 mints + registro por mint del admin + detección Superstate.                                                                                                                                                                                           |
| **AMM v4**      | No                               | El programa es anterior a Token-2022; ambos mints deben ser Token SPL clásico.                                                                                                                                                                                                                                          |
| **Stable AMM**  | No                               | Las mismas restricciones que AMM v4.                                                                                                                                                                                                                                                                                    |
| **Farm v6**     | Sí, parcial                      | El mint de recompensa puede ser Token-2022 (sujeto a la misma lista blanca cuando una farm envuelve un LP de CPMM/CLMM); los mints de LP de stake del usuario heredan del pool envuelto.                                                                                                                                |
| **LaunchLab**   | Sí, administrado por programa    | El mint base puede ser Token-2022, pero solo mediante la instrucción dedicada `initialize_with_token_2022`; el programa mismo crea el mint con `MetadataPointer` (siempre) y opcionalmente `TransferFeeConfig` (tasa ≤ 5%). Los mints Token-2022 preexistentes con extensiones arbitrarias no se pueden usar como base. |
| **Burn & Earn** | Refleja el programa del pool     | Hereda el control de CPMM / CLMM.                                                                                                                                                                                                                                                                                       |

Las verificaciones de la lista blanca viven en:

* **CPMM**: `is_supported_mint` en [`raydium-cp-swap/programs/cp-swap/src/utils/token.rs:178`](https://github.com/raydium-io/raydium-cp-swap), llamado desde `Initialize`.
* **CLMM**: `is_supported_mint` en [`raydium-clmm/programs/amm/src/util/token.rs:280`](https://github.com/raydium-io/raydium-clmm), llamado desde `CreatePool`.
* **LaunchLab**: `initialize_with_token_2022` en `raydium-launchpad/programs/launchpad/src/instructions/initialize_with_token_2022.rs` (el código fuente no está disponible públicamente).

**No hay** verificación de mint en tiempo de swap en CPMM o CLMM — la puerta se activa solo en la creación del pool. Una vez que un pool existe, los swaps simplemente confían en que los mints no cambien, lo cual es correcto para las partes inmutables del estado del mint de Token-2022.

## Lista blanca de extensiones de CPMM y CLMM

Después de que los cortocircuitos de lista blanca estática (cubiertos más abajo), el programa itera las extensiones del mint y rechaza el mint si contiene **cualquier** extensión que no sea estas cinco:

| Extensión               | Razón por la que se permite                                                                                                                                                                    |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `TransferFeeConfig`     | Las matemáticas del pool restan la tarifa de entrada; el programa Token-2022 maneja la tarifa de salida. Ver [`algorithms/token-2022-transfer-fees`](/es/algorithms/token-2022-transfer-fees). |
| `MetadataPointer`       | Decorativa — apunta a metadatos en cadena.                                                                                                                                                     |
| `TokenMetadata`         | Decorativa — metadatos en línea.                                                                                                                                                               |
| `InterestBearingConfig` | El pool ve la cantidad principal; el multiplicador de UI es solo decorativo y el balance subyacente se preserva.                                                                               |
| `ScaledUiAmount`        | La misma forma que interest-bearing — el factor de escala se aplica solo a la pantalla de UI.                                                                                                  |

Cualquier cosa no en esta lista — `TransferHook`, `NonTransferable`, `ConfidentialTransferMint`, `PermanentDelegate`, `MintCloseAuthority`, `DefaultAccountState`, `GroupPointer`, `GroupMemberPointer`, `MemberPointer`, `Pausable`, etc. — hace que `is_supported_mint` devuelva `false` y la creación del pool se revierta.

Las líneas relevantes (CPMM, forma idéntica en 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)

## Rutas de bypass

Un mint de Token-2022 que no se ajusta a la lista blanca aún puede ser admitido a través de uno de tres bypasses explícitos. Se intentan en orden, antes de que se ejecute la iteración de extensiones.

### 1. Lista blanca estática de mints

Un array constante `MINT_WHITELIST` de strings en base58 se codifica en cada programa. Si la dirección del mint coincide, la función devuelve `true` inmediatamente y no se realiza ninguna verificación de extensión.

| Programa | Mints en la lista blanca                                                                                                                                                                       |
| -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| CPMM     | `HVbpJAQGNpkgBaYBZQBR1t7yFdvaYVp2vCQQfKKEN4tM`, `Crn4x1Y2HUKko7ox2EZMT6N2t2ZyH7eKtwkBGVnhEq1g`, `FrBfWJ4qE5sCzKm3k3JaAtqZcXUh4LvJygDeketsrsH4`, `2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo` |
| CLMM     | Los mismos cuatro, más `DAUcJBg4jSpVoEzASxYzdqHMUN8vuTpQyG2TvDcCHfZg`, `AUSD1jCcCyPLybk1YnvPWsHQSrZ46dxwoMniN4N2UEB9`                                                                          |

Estas direcciones se integran en el programa; actualizar la lista requiere una actualización del programa a través del multisig de actualización 3 de 4.

### 2. Registro por mint — solo CLMM

CLMM además consulta un PDA `SupportMintAssociated` con seed `[b"support_mint", mint]`. Si ese PDA existe para el mint, se admite independientemente de su conjunto de extensiones.

El PDA se crea por `CreateSupportMintAssociated` ([`admin/create_support_mint_associated.rs`](https://github.com/raydium-io/raydium-clmm)). La instrucción se controla a dos firmantes:

* `crate::admin::ID` — la autoridad estándar del admin de Raydium.
* `crate::create_support_mint_associated_owner::ID` — una autoridad dedicada para este propósito: `RayVyjyJQz9vAi126A4sGexKnSU1XeZaHTRcM1mZMPY` (mainnet), `rayf3nEbb3bnfN6RDGFpqPbjc5uUa3tRUzu6UVYrRx5` (devnet).

Efecto: el equipo de CLMM puede optar un mint específico de Token-2022 para la creación del pool sin una actualización del programa. CPMM no tiene equivalente — su lista blanca es estrictamente código fuente.

### 3. Detección Superstate — solo CLMM

CLMM tiene una tercera ruta específicamente para activos tokenizados de Superstate, que usan la extensión `ScaledUiConfig` que la versión de `spl-token-2022` vinculada al programa CLMM no puede desempaquetar. En lugar de actualizar la dependencia, CLMM detecta tokens Superstate por su forma de autoridad:

```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 pasa esta rama si **todos cuatro** se cumplen:

* Su programa propietario es el programa Token-2022.
* Su autoridad de congelación es igual a `superstate_allowlist::ID`. Mainnet: `2Yq4T3mPNfjtEyTxSbRjRKqLf1pwbTasuCQrWe6QpM7x`. Devnet: `3TRuL3MFvzHaUfQAb6EsSAbQhWdhmYrKxEiViVkdQfXu`.
* Su extensión `DefaultAccountState` está configurada en `Frozen`.
* Su delegado permanente es también `superstate_allowlist::ID`.

Esta es una heurística, no un registro — cualquier mint futuro que Superstate emita con la misma forma de autoridad será admitido automáticamente.

## Lo que los bypasses no eximen

Los bypasses omiten la lista blanca de extensiones, pero el programa aún aplica:

* El mint es propiedad de `Token` o `Token-2022`. Un programa de token personalizado se rechaza anteriormente.
* Los vaults del pool se crean con las extensiones ATA correctas para pools de Token-2022 (`ImmutableOwner`, etc.).
* Todas las transferencias pasan por `transfer_checked` — los mints con tarifa colocan la cantidad correcta en el vault.

Un mint en lista blanca o registrado en PDA que, p. ej., agrega un `TransferHook` más tarde no obtiene una verificación en tiempo de swap; el hook simplemente se ejecutaría en cada transferencia y podría bloquear los swaps. Por lo tanto, la inclusión en la lista blanca es una acción de alto nivel de confianza.

## Semántica de "bloqueado"

Cuando `is_supported_mint` devuelve `false`, la creación del pool se revierte con `ErrorCode::NotSupportMint` (CPMM) / `ErrorCode::NotSupportMint` (CLMM). Ver [`reference/error-codes`](/es/reference/error-codes) para los códigos numéricos.

Los pools existentes no pueden fallar retroactivamente en esta verificación — la puerta se ejecuta solo en la creación. Las extensiones de mint son inmutables para las categorías que Raydium rechaza (transfer hook, non-transferable, confidential transfer no se pueden agregar post-creación), por lo que la verificación estática es suficiente.

## Por qué se excluye cada extensión

* **TransferHook** — invoca un programa personalizado en cada transferencia, con consumo de CU arbitrario, condiciones de fallo arbitrarias, y la capacidad de reentrar al programa que llama. No existe sandbox seguro. Algunos DEXes mantienen listas blancas de hooks; Raydium no.
* **NonTransferable** — `Transfer` siempre falla. Un pool no puede tomar custodia.
* **ConfidentialTransfer** — los montos de transferencia están cifrados; la curva no puede fijar el precio del swap.
* **PermanentDelegate** — un titular del delegado puede barrer cualquier cuenta de token, incluido el vault del pool. Permitido solo mediante la lista blanca estática para emisores de confianza (p. ej., monedas estables reguladas).
* **MintCloseAuthority** — el mint puede cerrarse; los pools existentes se vuelven inutilizables. Desallowado por defecto.
* **DefaultAccountState (Frozen)** — los ATAs del pool aterrizarían en estado `Frozen` y requerirían descongelar por cuenta. Permitido solo mediante detección Superstate, que asume que el emisor descongela cuentas institucionales en la inscripción.
* **Punteros Group/Member** — no son activamente dañinos, pero no revisados. Desallowado por defecto para mantener la superficie estrecha.

## Contabilidad de tarifa de transferencia

Para mints que llevan `TransferFeeConfig`, cada swap, depósito y retiro mueve menos que la cantidad nominal. El SDK muestra ambas mitades del cálculo:

```ts theme={null}
const { amountIn, amountOut, feeAmount, token2022FeeIn, token2022FeeOut } =
  await raydium.cpmm.computeSwapAmount({ ... });
```

Una UI correcta muestra:

* `amountIn + token2022FeeIn` como "envías"
* `amountOut - token2022FeeOut` como "recibes"
* `feeAmount` como la tarifa del pool (LP + protocolo), que es separada de la tarifa de transferencia de Token-2022

Una UI ingenua que muestra solo `amountIn → amountOut` subestima los costos.

### Tope `maximumFee`

Las tarifas de transferencia de Token-2022 se capping por transferencia. Para un mint del 1% con un tope de 10,000 tokens, una transferencia de 100,000,000 tokens paga solo 10,000 en tarifa. El `computeSwapAmount` del SDK aplica el tope; los llamadores diretos del programa deben replicarlo.

### Transición de epoch

Una autoridad de mint puede programar un cambio de tasa de tarifa que se activa en el siguiente epoch. Durante la ventana de transición, dos configs (`older`, `newer`) viven en el mint a la vez y `TransferChecked` selecciona por epoch actual. Tanto CPMM `SwapV2` como CLMM `SwapV2` pasan la cuenta de mint completa en `accounts`, por lo que el programa lee la config correcta sin una búsqueda adicional.

Si cotizas más de un epoch en avance a través de la Trade API o SDK, la tarifa ejecutada puede diferir de la tarifa cotizada — limitada por `maximum_fee_basis_points` de la config anterior.

## Interest-bearing y ScaledUiAmount

El pool tiene la cantidad principal; el "monto de UI" es la cantidad principal multiplicada por un factor de escala dependiente del tiempo o configurado por admin. Las matemáticas del swap operan sobre la cantidad principal:

```
principal_in = ui_amount_in / ui_multiplier(now)
```

El SDK convierte automáticamente. Los lectores de RPC directo deben tratar `pool.token0Vault.amount` como principal.

## Definición de "pool de Token-2022"

Un pool es un pool de Token-2022 si **cualquiera** mint tiene `programId == TokenzQdB...`. La API muestra esto:

```
GET /pools/info/ids?ids=<POOL_ID>
```

```json theme={null}
{
  "data": [{
    "mintA": { "programId": "TokenzQdB...", "hasTransferFee": true, ... },
    "mintB": { "programId": "Tokenkeg...", ... }
  }]
}
```

Usa `programId` para despachar, y `hasTransferFee` para mostrar una advertencia de UI.

## Helpers de 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);
  }
}
```

## Errores comunes de integración

* **Pre-flighting solo el ID del programa.** Un mint puede ser Token-2022 *y* no soportado. Camina la lista de extensiones contra la lista blanca (y la lista blanca estática) antes de permitir la creación del pool.
* **Confiar en la cotización del SDK cuando el mint no se acepta en absoluto.** La API de cotización no se niega a cotizar — la creación del pool es lo que se revierte. Confirma la semántica de `is_supported_mint` fuera de cadena antes de exponer la creación del pool en tu UI.
* **Cotizar sin el corte de tarifa de transferencia.** Un mint con tarifa de transferencia del 1% en ambos lados de un pool CPMM del 0.25% tiene una tarifa efectiva alrededor del 2.25%, no del 0.25%. Usa la cotización del SDK o la cotización de Trade API — nunca calcules la tarifa manualmente solo desde el tier de tarifa del pool.
* **Llamar la instrucción `Swap` heredada en un pool de Token-2022.** `Swap` es anterior a Token-2022. Usa `SwapV2` siempre que cualquiera de los mints sea Token-2022.
* **Listar automáticamente nuevos mints de Token-2022.** Las billeteras y agregadores deben verificar `TransferHook` y `NonTransferable` antes de mostrar un mint a los usuarios; ambos son hostiles a Raydium.

## Trabajo futuro

Elementos de hoja de ruta del protocolo y ecosistema de Solana que cambiarían esta matriz:

* Programas de transfer-hook en lista blanca a nivel de Solana (convención del ecosistema evolucionando).
* AMMs compatibles con confidential-transfer (etapa de investigación).
* Registro por mint de CPMM más amplio (paridad con CLMM).
* Actualización de dependencia para que la decodificación de `ScaledUiConfig` de CLMM funcione sin la heurística de Superstate.

Esta página se actualizará cuando alguno aterrice.

## Enlaces

* [`algorithms/token-2022-transfer-fees`](/es/algorithms/token-2022-transfer-fees) — matemáticas de tarifa en swaps.
* [`products/cpmm/instructions`](/es/products/cpmm/instructions) — `SwapV2`, `Initialize`.
* [`products/clmm/instructions`](/es/products/clmm/instructions) — `SwapV2`, `CreatePool`, `CreateSupportMintAssociated`.
* [`reference/error-codes`](/es/reference/error-codes) — códigos numéricos de `NotSupportMint` por programa.

Fuentes:

* `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` — instrucción de registro por mint.
* `raydium-launchpad/programs/launchpad/src/instructions/initialize_with_token_2022.rs` — creación de mint base Token-2022 de LaunchLab.