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

# Instrucciones de CPMM

> Cada instrucción del programa CPMM, con sus argumentos, lista de cuentas, precondiciones/postcondiciones y errores que puede retornar.

<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 →](/products/cpmm/instructions)
</Info>

<Info>
  Esta página es la referencia de instrucciones autorizada. Para código que realmente compone estas instrucciones, consulta [`products/cpmm/code-demos`](/es/products/cpmm/code-demos). Para los significados de códigos de error, consulta [`reference/error-codes`](/es/reference/error-codes).
</Info>

## Resumen de instrucciones

| Nombre del discriminador   | Quién firma                               | Qué hace                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| -------------------------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Initialize`               | creador del pool                          | Crea un nuevo pool CPMM a partir de dos «mints» y un `AmmConfig`. Sin permisos; cualquiera puede llamarlo. Codifica `enable_creator_fee = false` en el nuevo pool. La cuenta `pool_state` puede ser la PDA canónica o un «keypair» aleatorio recién creado (ver cuentas de Initialize).                                                                                                                                                                                                                                                                                                                 |
| `InitializeWithPermission` | pagador + titular de una PDA `Permission` | Variante con permisos de `Initialize`. El llamador (`payer`) debe poseer una PDA `Permission` derivada de su propia clave pública. Se utiliza por plataformas que necesitan creación de pools controlada (p. ej., graduaciones de LaunchLab). Permite al llamador fijar `creator_fee_on` (`BothToken` / `OnlyToken0` / `OnlyToken1`) y fuerza `enable_creator_fee = true` en el nuevo pool. El campo `creator` en `pool_state` se establece en una cuenta `creator` pasada por separado, no en el pagador. Misma flexibilidad PDA-canónica-o-«keypair»-aleatorio para `pool_state` que en `Initialize`. |
| `Deposit`                  | LP                                        | Añade liquidez en ambos tokens; recibe tokens LP.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `Withdraw`                 | LP                                        | Quema tokens LP; recibe ambos tokens subyacentes en proporción.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `SwapBaseInput`            | intercambiador                            | Intercambio de entrada exacta (`amount_in` adentro, ≥ `minimum_amount_out` afuera).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `SwapBaseOutput`           | intercambiador                            | Intercambio de salida exacta (≤ `maximum_amount_in` adentro, `amount_out` afuera).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `CollectProtocolFee`       | `protocol_owner` (de `AmmConfig`)         | Recauda las comisiones de protocolo acumuladas de los almacenes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `CollectFundFee`           | `fund_owner` (de `AmmConfig`)             | Recauda las comisiones de fondo acumuladas de los almacenes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `CollectCreatorFee`        | `pool_creator`                            | Recauda las comisiones del creador acumuladas (si se habilitó).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `UpdatePoolStatus`         | `admin`                                   | Pausa/reanuda operaciones específicas en un pool mediante una máscara de bits.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `UpdateAmmConfig`          | `admin`                                   | Cambia las tasas de comisión o el propietario de protocolo/fondo en un `AmmConfig`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `CreateAmmConfig`          | `admin`                                   | Crea un nuevo nivel de tarifa (nueva cuenta `AmmConfig`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `CreatePermissionPda`      | `admin`                                   | Emite una PDA `Permission` que permite a una autoridad específica llamar a `InitializeWithPermission`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `ClosePermissionPda`       | `admin`                                   | Revoca una PDA `Permission` previamente emitida.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |

Máscara de estado: el `status` de cada pool es un `u8` donde el bit 0 = depósito deshabilitado, bit 1 = retiro deshabilitado, bit 2 = intercambio deshabilitado (`PoolStatusBitIndex { Deposit, Withdraw, Swap }` en el programa). Un bit claro significa que la operación está permitida; un bit establecido significa que está pausada. `UpdatePoolStatus` toma un `u8` sin procesar y sobrescribe el valor existente.

Las siguientes secciones detallen cada una. El orden de cuentas sigue el IDL de CPMM; el SDK y el cliente de Rust en `raydium-cp-swap/programs/cp-swap/src/instructions` coinciden con este orden.

## `Initialize`

Crea un nuevo pool CPMM.

**Argumentos**

```
init_amount_0: u64
init_amount_1: u64
open_time:     u64   // Unix timestamp; swaps rejected before this
```

**Cuentas** (W = escribible, S = firmante)

| #  | Nombre                     | W | S   | Notas                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| -- | -------------------------- | - | --- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1  | `creator`                  | W | S   | Paga renta; se registra como `pool_state.pool_creator`.                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 2  | `amm_config`               |   |     | El nivel de tarifa elegido.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 3  | `authority`                |   |     | PDA de autoridad global de CPMM.                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 4  | `pool_state`               | W | S\* | Se inicializa aquí. **O** la PDA canónica `["pool", amm_config, token_0_mint, token_1_mint]` **o** un «keypair» aleatorio recién creado — cuando no es la PDA canónica, el programa requiere que `pool_state` firme (`require_eq!(pool_account_info.is_signer, true)`). La ruta de «keypair» aleatorio permite que un creador evite intentos de adelantarse en la PDA canónica. Las PDA posteriores (`lp_mint`, `vaults`, `observation_state`) se derivan de `pool_state.key()` de cualquier forma. |
| 5  | `token_0_mint`             |   |     | Ordenado: `token_0_mint < token_1_mint`.                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 6  | `token_1_mint`             |   |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 7  | `lp_mint`                  | W |     | Se inicializa aquí. Autoridad establecida en `authority`.                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 8  | `creator_token_0`          | W |     | ATA de origen para `init_amount_0`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 9  | `creator_token_1`          | W |     | ATA de origen para `init_amount_1`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 10 | `creator_lp_token`         | W |     | Destino para LP (se crea si falta).                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 11 | `token_0_vault`            | W |     | Se inicializa aquí. Propiedad de `authority`.                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 12 | `token_1_vault`            | W |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 13 | `create_pool_fee`          | W |     | ATA de destino para el `create_pool_fee` pagado por el creador.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 14 | `observation_state`        | W |     | Se inicializa aquí.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 15 | `token_program`            |   |     | Token SPL (para LP mint).                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 16 | `token_0_program`          |   |     | Token SPL o Token-2022.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 17 | `token_1_program`          |   |     | Token SPL o Token-2022.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 18 | `associated_token_program` |   |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 19 | `system_program`           |   |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 20 | `rent`                     |   |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |

`*` `pool_state` firma solo en la ruta de «keypair» aleatorio; la ruta de PDA canónica se ejecuta sin que `pool_state` firme.

**Precondiciones**

* Los «mints» están ordenados (`token_0_mint < token_1_mint` por orden de bytes).
* Ningún «mint» utiliza una extensión fuera de la lista de permitidos de CPMM (`TransferFeeConfig`, `MetadataPointer`, `TokenMetadata`, `InterestBearingConfig`, `ScaledUiAmount`) — ver [`products/cpmm/accounts`](/es/products/cpmm/accounts#vaults-and-token-2022). Una pequeña lista de permitidos por «mint» dentro del programa omite la verificación para incorporación caso a caso.
* `creator` tiene al menos `init_amount_0` e `init_amount_1` en los respectivos ATA.
* `amm_config.disable_create_pool == false`.

**Postcondiciones**

* `pool_state` existe con `lp_supply = sqrt(init_amount_0 * init_amount_1) − LOCKED_LP`.
* El iniciador LP de `LOCKED_LP` (`100` lámparas de token LP) se bloquea permanentemente en el pool — `pool_state.lp_supply` registra `liquidity − 100` mientras que `100` unidades LP permanecen fuera de circulación, evitando que el pool se drene completamente y se divida por cero.
* `observation_state` se inicializa; `observation_index = 0` y `pool_id = pool_state.key()`.
* Las lámparas de `create_pool_fee` se transfieren del creador al receptor y se sincronizan como SOL nativo (es un ATA wSOL).
* La máscara de estado del pool es `0` (depósito / retiro / intercambio todos habilitados).
* `enable_creator_fee = false` y `creator_fee_on = BothToken`. `Initialize` **no** admite habilitar la comisión del creador — esa ruta es `InitializeWithPermission`.
* `open_time` se incrementa a `block_timestamp + 1` si el llamador pasó un valor `<= block_timestamp`. Los intercambios se rechazan antes de `open_time`; depósitos y retiros funcionan inmediatamente.

**Errores comunes** (lista completa en [`reference/error-codes`](/es/reference/error-codes))

* `InvalidInput` — «mints» sin ordenar o idénticos.
* `NotSupportMint` — extensión de Token-2022 bloqueada.
* `ExceededSlippage` — raramente; si `init_amount_0/1` resultan en cero LP debido a la falta de coincidencia de decimales.

## `Deposit`

Añade liquidez en ambos tokens proporcional al pool.

**Argumentos**

```
lp_token_amount:   u64   // how many LP tokens to mint to the LP
maximum_token_0:   u64
maximum_token_1:   u64
```

**Cuentas**

| #  | Nombre               | W | S |
| -- | -------------------- | - | - |
| 1  | `owner`              |   | S |
| 2  | `authority`          |   |   |
| 3  | `pool_state`         | W |   |
| 4  | `owner_lp_token`     | W |   |
| 5  | `token_0_account`    | W |   |
| 6  | `token_1_account`    | W |   |
| 7  | `token_0_vault`      | W |   |
| 8  | `token_1_vault`      | W |   |
| 9  | `token_program`      |   |   |
| 10 | `token_program_2022` |   |   |
| 11 | `vault_0_mint`       |   |   |
| 12 | `vault_1_mint`       |   |   |
| 13 | `lp_mint`            | W |   |

**Matemática**

```
needed_token_0 = ceil(lp_token_amount * vault_0 / lp_supply)
needed_token_1 = ceil(lp_token_amount * vault_1 / lp_supply)
require(needed_token_0 <= maximum_token_0, "ExceededSlippage")
require(needed_token_1 <= maximum_token_1, "ExceededSlippage")
```

Sin cambio en la proporcionalidad de `k` — ambos almacenes y `lp_supply` se escalan por el mismo factor.

**Postcondiciones**

* `lp_supply += lp_token_amount`.
* `vault_0 += needed_token_0` (neto de cualquier comisión de transferencia de Token-2022 en entrada).
* `vault_1 += needed_token_1` (neto de cualquier comisión de transferencia de Token-2022 en entrada).

**Errores comunes** — `ExceededSlippage`, `ZeroTradingTokens`, `InvalidStatus` si el depósito está pausado.

## `Withdraw`

Quema tokens LP y recibe ambos tokens subyacentes en proporción.

**Argumentos**

```
lp_token_amount:   u64
minimum_token_0:   u64
minimum_token_1:   u64
```

**Cuentas**

| #  | Nombre               | W | S |
| -- | -------------------- | - | - |
| 1  | `owner`              |   | S |
| 2  | `authority`          |   |   |
| 3  | `pool_state`         | W |   |
| 4  | `owner_lp_token`     | W |   |
| 5  | `token_0_account`    | W |   |
| 6  | `token_1_account`    | W |   |
| 7  | `token_0_vault`      | W |   |
| 8  | `token_1_vault`      | W |   |
| 9  | `token_program`      |   |   |
| 10 | `token_program_2022` |   |   |
| 11 | `vault_0_mint`       |   |   |
| 12 | `vault_1_mint`       |   |   |
| 13 | `lp_mint`            | W |   |

(Idéntico a `Deposit`; `lp_mint` es escribible porque los tokens LP se queman.)

**Matemática**

```
out_token_0 = floor(lp_token_amount * vault_0 / lp_supply)
out_token_1 = floor(lp_token_amount * vault_1 / lp_supply)
require(out_token_0 >= minimum_token_0, "ExceededSlippage")
require(out_token_1 >= minimum_token_1, "ExceededSlippage")
```

**Postcondiciones**

* `lp_supply -= lp_token_amount`.
* Los almacenes envían `out_token_0` / `out_token_1` (bruto; el usuario recibe neto de cualquier comisión de transferencia de Token-2022).

## `SwapBaseInput`

Intercambio de entrada exacta.

**Argumentos**

```
amount_in:            u64
minimum_amount_out:   u64
```

**Cuentas**

| #  | Nombre                 | W | S |
| -- | ---------------------- | - | - |
| 1  | `payer`                |   | S |
| 2  | `authority`            |   |   |
| 3  | `amm_config`           |   |   |
| 4  | `pool_state`           | W |   |
| 5  | `input_token_account`  | W |   |
| 6  | `output_token_account` | W |   |
| 7  | `input_vault`          | W |   |
| 8  | `output_vault`         | W |   |
| 9  | `input_token_program`  |   |   |
| 10 | `output_token_program` |   |   |
| 11 | `input_token_mint`     |   |   |
| 12 | `output_token_mint`    |   |   |
| 13 | `observation_state`    | W |   |

El orden **entrada → salida** es por la dirección del usuario, no por el `token_0 / token_1` canónico del pool. El programa determina qué almacén es cuál haciendo coincidir los «mints».

**Matemática** — ver [`products/cpmm/math`](/es/products/cpmm/math).

**Precondiciones**

* `open_time <= now`.
* `pool_status` permite intercambio.
* Ningún «mint» pausado o congelado para esta autoridad.
* `amount_in > 0`.

**Errores comunes**

* `ExceededSlippage` — `amount_out < minimum_amount_out`.
* `ZeroTradingTokens` — el comercio se redondea a cero.
* `NotApproved` — el pool está pausado para intercambios mediante `UpdatePoolStatus`.
* `InvalidInput` — los «mints» no coinciden con ninguno de los «mints» de almacén del pool.

## `SwapBaseOutput`

Intercambio de salida exacta.

**Argumentos**

```
max_amount_in:  u64
amount_out:     u64
```

**Cuentas** — igual que `SwapBaseInput`.

**Matemática** — curva inversa con límite máximo, ver [`products/cpmm/math`](/es/products/cpmm/math).

**Errores comunes** — `ExceededSlippage` (`gross_in > max_amount_in`), `ZeroTradingTokens`, `InvalidInput`, `NotApproved`.

## `CollectProtocolFee`

Recauda las comisiones de protocolo acumuladas de los almacenes al destino del protocolo.

**Argumentos** — ninguno.

**Cuentas**

| #  | Nombre                      | W | S |                                                 |
| -- | --------------------------- | - | - | ----------------------------------------------- |
| 1  | `owner`                     |   | S | Debe coincidir con `amm_config.protocol_owner`. |
| 2  | `authority`                 |   |   |                                                 |
| 3  | `pool_state`                | W |   |                                                 |
| 4  | `amm_config`                |   |   |                                                 |
| 5  | `token_0_vault`             | W |   |                                                 |
| 6  | `token_1_vault`             | W |   |                                                 |
| 7  | `vault_0_mint`              |   |   |                                                 |
| 8  | `vault_1_mint`              |   |   |                                                 |
| 9  | `recipient_token_0_account` | W |   |                                                 |
| 10 | `recipient_token_1_account` | W |   |                                                 |
| 11 | `token_program`             |   |   |                                                 |
| 12 | `token_program_2022`        |   |   |                                                 |

**Efecto**

```
transfer pool_state.protocol_fees_token0 from vault_0 to recipient_0
transfer pool_state.protocol_fees_token1 from vault_1 to recipient_1
pool_state.protocol_fees_token0 = 0
pool_state.protocol_fees_token1 = 0
```

Sin cambio en los saldos efectivos de la curva (las comisiones acumuladas ya estaban excluidas).

**Error común** — `NotApproved` si el firmante no es `protocol_owner`.

## `CollectFundFee`

Misma forma que `CollectProtocolFee` pero firmada por `fund_owner` e igualando los contadores `fund_fees_*` a cero.

## `CollectCreatorFee`

De nuevo misma forma, firmada por `pool_state.pool_creator`. Solo emite transferencias si el pool se inicializó con una tasa de comisión del creador distinta de cero.

## `UpdatePoolStatus`

Pausa o reanuda operaciones individuales en un pool. El campo `status` es una máscara de bits:

| Bit | Bandera             | Efecto cuando está establecida               |
| --- | ------------------- | -------------------------------------------- |
| 0   | `DEPOSIT_DISABLED`  | `Deposit` rechaza con `NotApproved`.         |
| 1   | `WITHDRAW_DISABLED` | `Withdraw` rechaza.                          |
| 2   | `SWAP_DISABLED`     | `SwapBaseInput` / `SwapBaseOutput` rechazan. |

**Argumentos**

```
status: u8      // new bitmask
```

**Cuentas**

| # | Nombre       | W | S |                                                                   |
| - | ------------ | - | - | ----------------------------------------------------------------- |
| 1 | `authority`  |   | S | Debe coincidir con la clave de administrador en el programa CPMM. |
| 2 | `pool_state` | W |   |                                                                   |

La clave de administrador es la autoridad de actualización del programa CPMM — en la práctica, el multisig de Raydium. Ver [`security/admin-and-multisig`](/es/security/admin-and-multisig).

## `CreateAmmConfig`

Crea un nuevo nivel de tarifa.

**Argumentos**

```
index:             u16
trade_fee_rate:    u64
protocol_fee_rate: u64
fund_fee_rate:     u64
create_pool_fee:   u64
```

**Cuentas**

| # | Nombre           | W | S |                     |
| - | ---------------- | - | - | ------------------- |
| 1 | `owner`          | W | S | Administrador.      |
| 2 | `amm_config`     | W |   | Se inicializa aquí. |
| 3 | `system_program` |   |   |                     |

**Precondiciones**

* No existe `AmmConfig` con el mismo `index`.
* `protocol_fee_rate + fund_fee_rate <= FEE_RATE_DENOMINATOR_VALUE`.

## `UpdateAmmConfig`

Cambia tasas de comisión u propiedad en un `AmmConfig` existente. Toma un `param: u8` (discriminador para qué campo actualizar) y un `value: u64`. La semántica de valor por parámetro está en el código fuente; comúnmente:

* `param = 0` → `trade_fee_rate`
* `param = 1` → `protocol_fee_rate`
* `param = 2` → `fund_fee_rate`
* `param = 3` → `new_protocol_owner` (pasa bytes de `Pubkey` como reinterpretación)
* `param = 4` → `new_fund_owner`
* `param = 5` → `create_pool_fee`
* `param = 6` → `disable_create_pool`

Los cambios se firman por el administrador y afectan **a cada pool vinculado a este `AmmConfig`** en el siguiente intercambio. Sin migración; los pools simplemente leen los nuevos valores.

## Matriz de cambio de estado

| Instrucción                | `lp_supply`  | Saldos de almacén              | Campos de comisión acumulada                                                  | `observation`                |
| -------------------------- | ------------ | ------------------------------ | ----------------------------------------------------------------------------- | ---------------------------- |
| `Initialize`               | + LP inicial | + `init_amount_{0,1}`          | 0                                                                             | init                         |
| `InitializeWithPermission` | + LP inicial | + `init_amount_{0,1}`          | 0                                                                             | init                         |
| `Deposit`                  | +            | + ambos                        | —                                                                             | —                            |
| `Withdraw`                 | −            | − ambos                        | —                                                                             | —                            |
| `SwapBaseInput`            | —            | + entrada, − salida            | + `trade_fee` dividido en protocolo/fondo; + `creator_fee` si está habilitado | + (si transcurrió intervalo) |
| `SwapBaseOutput`           | —            | + entrada, − salida            | + `trade_fee` dividido en protocolo/fondo; + `creator_fee` si está habilitado | + (si transcurrió intervalo) |
| `CollectProtocolFee`       | —            | − (por depósitos de protocolo) | `protocol_*` → 0                                                              | —                            |
| `CollectFundFee`           | —            | − (por depósitos de fondo)     | `fund_*` → 0                                                                  | —                            |
| `CollectCreatorFee`        | —            | − (por depósitos del creador)  | `creator_*` → 0                                                               | —                            |
| `UpdatePoolStatus`         | —            | —                              | —                                                                             | —                            |

## A dónde ir a continuación

* [`products/cpmm/code-demos`](/es/products/cpmm/code-demos) — ejemplos de TypeScript ejecutables para lo anterior.
* [`reference/error-codes`](/es/reference/error-codes) — la tabla completa de errores de Anchor.
* [`products/cpmm/fees`](/es/products/cpmm/fees) — el modelo de acumulación de comisiones que `CollectProtocolFee` / `CollectFundFee` / `CollectCreatorFee` vacían.

Fuentes:

* [`raydium-io/raydium-cp-swap` — instructions](https://github.com/raydium-io/raydium-cp-swap/tree/master/programs/cp-swap/src/instructions)
* [Raydium SDK v2 — `@raydium-io/raydium-sdk-v2`](https://github.com/raydium-io/raydium-sdk-V2)