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

# Instructions CPMM

> Chaque instruction du programme CPMM, avec ses arguments, sa liste de comptes, ses conditions préalables/postérieures et les erreurs qu'elle peut renvoyer.

<Info>
  **Cette page est traduite automatiquement par IA. La version anglaise fait foi.**

  [Voir la version anglaise →](/products/cpmm/instructions)
</Info>

## Résumé des instructions

| Nom du discriminateur      | Qui signe                                | Ce qu'elle fait                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| -------------------------- | ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Initialize`               | créateur du pool                         | Crée un nouveau pool CPMM à partir de deux mints et d'une `AmmConfig`. Sans permission ; n'importe qui peut l'appeler. Fixe `enable_creator_fee = false` sur le nouveau pool. Le compte `pool_state` peut être soit le PDA canonique, soit une nouvelle paire de clés aléatoire (voir les comptes Initialize).                                                                                                                                                                                                                                                                                     |
| `InitializeWithPermission` | payeur + détenteur d'un PDA `Permission` | Variante avec permission de `Initialize`. L'appelant (`payer`) doit posséder un PDA `Permission` dérivé de sa propre clé publique. Utilisée par les plateformes qui ont besoin d'une création de pool contrôlée (par ex. LaunchLab graduations). Permet à l'appelant de fixer `creator_fee_on` (`BothToken` / `OnlyToken0` / `OnlyToken1`) et force `enable_creator_fee = true` sur le nouveau pool. Le champ `creator` sur `pool_state` est défini sur un compte `creator` passé séparément, pas le payeur. Même flexibilité PDA-canonique-ou-paire-aléatoire pour `pool_state` que `Initialize`. |
| `Deposit`                  | LP                                       | Ajoute de la liquidité dans les deux tokens ; reçoit des tokens LP.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `Withdraw`                 | LP                                       | Brûle les tokens LP ; reçoit les deux tokens sous-jacents au prorata.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `SwapBaseInput`            | swapper                                  | Swap à entrée exacte (`amount_in` en, ≥ `minimum_amount_out` sortie).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `SwapBaseOutput`           | swapper                                  | Swap à sortie exacte (≤ `maximum_amount_in` en, `amount_out` sortie).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `CollectProtocolFee`       | `protocol_owner` (de `AmmConfig`)        | Récupère les frais de protocole accumulés des coffres.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `CollectFundFee`           | `fund_owner` (de `AmmConfig`)            | Récupère les frais de fonds accumulés des coffres.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `CollectCreatorFee`        | `pool_creator`                           | Récupère les frais de créateur accumulés (si les frais de créateur ont été activés).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `UpdatePoolStatus`         | `admin`                                  | Met en pause / reprend les opérations spécifiques sur un pool via un masque de bits.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `UpdateAmmConfig`          | `admin`                                  | Change les taux de frais ou le propriétaire protocole/fonds sur une `AmmConfig`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `CreateAmmConfig`          | `admin`                                  | Crée une nouvelle tranche de frais (nouveau compte `AmmConfig`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `CreatePermissionPda`      | `admin`                                  | Crée un PDA `Permission` qui permet à une autorité spécifique d'appeler `InitializeWithPermission`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `ClosePermissionPda`       | `admin`                                  | Révoque un PDA `Permission` précédemment émis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |

Masque de statut : le `status` de chaque pool est un `u8` où le bit 0 = dépôt désactivé, le bit 1 = retrait désactivé, le bit 2 = swap désactivé (`PoolStatusBitIndex { Deposit, Withdraw, Swap }` dans le programme). Un bit à zéro signifie que l'opération est autorisée ; un bit à un signifie qu'elle est en pause. `UpdatePoolStatus` prend un `u8` brut et remplace la valeur existante.

Les sections suivantes détaillent chacune d'elles. L'ordre des comptes suit l'IDL CPMM ; le SDK et le client Rust dans `raydium-cp-swap/programs/cp-swap/src/instructions` suivent cet ordre.

## `Initialize`

Crée un nouveau pool CPMM.

**Arguments**

```
init_amount_0: u64
init_amount_1: u64
open_time:     u64   // Timestamp Unix ; les swaps sont rejetés avant
```

**Comptes** (W = inscriptible, S = signataire)

| #  | Nom                        | W | S   | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| -- | -------------------------- | - | --- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1  | `creator`                  | W | S   | Paie le loyer ; enregistré comme `pool_state.pool_creator`.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 2  | `amm_config`               |   |     | La tranche de frais choisie.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 3  | `authority`                |   |     | PDA d'autorité globale CPMM.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 4  | `pool_state`               | W | S\* | `init`ialisé ici. **Soit** le PDA canonique `["pool", amm_config, token_0_mint, token_1_mint]` **soit** une nouvelle paire de clés aléatoire — lorsqu'il ne s'agit pas du PDA canonique, le programme exige que `pool_state` signe (`require_eq!(pool_account_info.is_signer, true)`). Le chemin à paire aléatoire permet à un créateur d'éviter les tentatives de front-running sur le PDA canonique. Les PDA en aval (`lp_mint`, `vaults`, `observation_state`) sont dérivés de `pool_state.key()` de toute façon. |
| 5  | `token_0_mint`             |   |     | Triés : `token_0_mint < token_1_mint`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 6  | `token_1_mint`             |   |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 7  | `lp_mint`                  | W |     | `init`ialisé ici. Autorité définie à `authority`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 8  | `creator_token_0`          | W |     | ATA source pour `init_amount_0`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 9  | `creator_token_1`          | W |     | ATA source pour `init_amount_1`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 10 | `creator_lp_token`         | W |     | Destination pour LP (créée si manquante).                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 11 | `token_0_vault`            | W |     | `init`ialisé ici. Propriété de `authority`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 12 | `token_1_vault`            | W |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 13 | `create_pool_fee`          | W |     | ATA de destination pour le `create_pool_fee` payé par le créateur.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 14 | `observation_state`        | W |     | `init`ialisé ici.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 15 | `token_program`            |   |     | SPL Token (pour le mint LP).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 16 | `token_0_program`          |   |     | SPL Token ou Token-2022.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 17 | `token_1_program`          |   |     | SPL Token ou Token-2022.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 18 | `associated_token_program` |   |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 19 | `system_program`           |   |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 20 | `rent`                     |   |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |

`*` `pool_state` signe uniquement sur le chemin à paire aléatoire ; le chemin PDA canonique s'exécute sans que `pool_state` signe.

**Conditions préalables**

* Les mints sont triés (`token_0_mint < token_1_mint` par ordre d'octets).
* Aucun mint n'utilise d'extension en dehors de la liste d'autorisation CPMM (`TransferFeeConfig`, `MetadataPointer`, `TokenMetadata`, `InterestBearingConfig`, `ScaledUiAmount`) — voir [`products/cpmm/accounts`](/fr/products/cpmm/accounts#vaults-and-token-2022). Une petite liste d'autorisation par mint à l'intérieur du programme contourne la vérification pour l'intégration cas par cas.
* `creator` a au moins `init_amount_0` et `init_amount_1` dans les ATA respectifs.
* `amm_config.disable_create_pool == false`.

**Conditions postérieures**

* `pool_state` existe avec `lp_supply = sqrt(init_amount_0 * init_amount_1) − LOCKED_LP`.
* Le démarrage LP de `LOCKED_LP` (`100` lamports de token LP) est verrouillé de façon permanente dans le pool — `pool_state.lp_supply` enregistre `liquidity − 100` tandis que `100` unités LP restent hors circulation, empêchant le pool d'être complètement vidé et une division par zéro.
* `observation_state` est initialisé ; `observation_index = 0` et `pool_id = pool_state.key()`.
* Les lamports `create_pool_fee` sont transférés du créateur au destinataire et synchronisés en SOL natif (c'est un ATA wSOL).
* Le masque de statut du pool est `0` (dépôt / retrait / swap tous activés).
* `enable_creator_fee = false` et `creator_fee_on = BothToken`. `Initialize` **ne** supporte **pas** l'activation des frais de créateur — ce chemin est `InitializeWithPermission`.
* `open_time` est augmenté à `block_timestamp + 1` si l'appelant a passé une valeur `<= block_timestamp`. Les swaps sont rejetés avant `open_time` ; les dépôts et retraits fonctionnent immédiatement.

**Erreurs courantes** (liste complète dans [`reference/error-codes`](/fr/reference/error-codes))

* `InvalidInput` — mints non triés, ou mints identiques.
* `NotSupportMint` — extension Token-2022 bloquée.
* `ExceededSlippage` — rarement ; si `init_amount_0/1` entraînent zéro LP en raison d'une différence de décimales.

## `Deposit`

Ajoute de la liquidité dans les deux tokens proportionnelle au pool.

**Arguments**

```
lp_token_amount:   u64   // combien de tokens LP à créer pour le LP
maximum_token_0:   u64
maximum_token_1:   u64
```

**Comptes**

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

**Mathématiques**

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

Pas de changement à la proportionnalité de `k` — les deux coffres et `lp_supply` se mettent à l'échelle du même facteur.

**Conditions postérieures**

* `lp_supply += lp_token_amount`.
* `vault_0 += needed_token_0` (net de tout frais de transfert Token-2022 à l'entrée).
* `vault_1 += needed_token_1` (net de tout frais de transfert Token-2022 à l'entrée).

**Erreurs courantes** — `ExceededSlippage`, `ZeroTradingTokens`, `InvalidStatus` si le dépôt est en pause.

## `Withdraw`

Brûle les tokens LP et reçoit les deux tokens sous-jacents au prorata.

**Arguments**

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

**Comptes**

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

(Identique à `Deposit` ; `lp_mint` est inscriptible car les tokens LP sont brûlés.)

**Mathématiques**

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

**Conditions postérieures**

* `lp_supply -= lp_token_amount`.
* Les coffres envoient `out_token_0` / `out_token_1` (brut ; l'utilisateur reçoit net de tout frais de transfert Token-2022).

## `SwapBaseInput`

Swap à entrée exacte.

**Arguments**

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

**Comptes**

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

L'ordre **entrée → sortie** suit la direction de l'utilisateur, pas le `token_0 / token_1` canonique du pool. Le programme détermine quel coffre correspond à quel en comparant les mints.

**Mathématiques** — voir [`products/cpmm/math`](/fr/products/cpmm/math).

**Conditions préalables**

* `open_time <= now`.
* `pool_status` autorise le swap.
* Aucun mint en pause ou gelé pour cette autorité.
* `amount_in > 0`.

**Erreurs courantes**

* `ExceededSlippage` — `amount_out < minimum_amount_out`.
* `ZeroTradingTokens` — le commerce s'arrondit à zéro.
* `NotApproved` — le pool est en pause pour les swaps via `UpdatePoolStatus`.
* `InvalidInput` — les mints ne correspondent à aucun des mints des coffres du pool.

## `SwapBaseOutput`

Swap à sortie exacte.

**Arguments**

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

**Comptes** — identique à `SwapBaseInput`.

**Mathématiques** — courbe inverse avec plafond, voir [`products/cpmm/math`](/fr/products/cpmm/math).

**Erreurs courantes** — `ExceededSlippage` (`gross_in > max_amount_in`), `ZeroTradingTokens`, `InvalidInput`, `NotApproved`.

## `CollectProtocolFee`

Récupère les frais de protocole accumulés des coffres vers la destination du protocole.

**Arguments** — aucun.

**Comptes**

| #  | Nom                         | W | S |                                                  |
| -- | --------------------------- | - | - | ------------------------------------------------ |
| 1  | `owner`                     |   | S | Doit correspondre à `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`        |   |   |                                                  |

**Effet**

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

Pas de changement aux balances effectives de la courbe (les frais accumulés étaient déjà exclus).

**Erreur courante** — `NotApproved` si le signataire n'est pas `protocol_owner`.

## `CollectFundFee`

Même structure que `CollectProtocolFee` mais signée par `fund_owner` et mettant à zéro les compteurs `fund_fees_*`.

## `CollectCreatorFee`

Même structure à nouveau, signée par `pool_state.pool_creator`. Émet des transferts uniquement si le pool a été initialisé avec un taux de frais de créateur non nul.

## `UpdatePoolStatus`

Met en pause ou reprend les opérations individuelles sur un pool. Le champ `status` est un masque de bits :

| Bit | Drapeau             | Effet lorsqu'il est défini                    |
| --- | ------------------- | --------------------------------------------- |
| 0   | `DEPOSIT_DISABLED`  | `Deposit` rejette avec `NotApproved`.         |
| 1   | `WITHDRAW_DISABLED` | `Withdraw` rejette.                           |
| 2   | `SWAP_DISABLED`     | `SwapBaseInput` / `SwapBaseOutput` rejettent. |

**Arguments**

```
status: u8      // nouveau masque de bits
```

**Comptes**

| # | Nom          | W | S |                                                                |
| - | ------------ | - | - | -------------------------------------------------------------- |
| 1 | `authority`  |   | S | Doit correspondre à la clé d'administrateur du programme CPMM. |
| 2 | `pool_state` | W |   |                                                                |

La clé d'administrateur est l'autorité de mise à niveau du programme CPMM — en pratique, le multisig Raydium. Voir [`security/admin-and-multisig`](/fr/security/admin-and-multisig).

## `CreateAmmConfig`

Crée une nouvelle tranche de frais.

**Arguments**

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

**Comptes**

| # | Nom              | W | S |                   |
| - | ---------------- | - | - | ----------------- |
| 1 | `owner`          | W | S | Administrateur.   |
| 2 | `amm_config`     | W |   | `init`ialisé ici. |
| 3 | `system_program` |   |   |                   |

**Conditions préalables**

* Aucune `AmmConfig` existante avec le même `index`.
* `protocol_fee_rate + fund_fee_rate <= FEE_RATE_DENOMINATOR_VALUE`.

## `UpdateAmmConfig`

Change les taux de frais ou la propriété sur une `AmmConfig` existante. Prend un `param: u8` (discriminateur pour le champ à mettre à jour) et une `value: u64`. La sémantique des valeurs par paramètre se trouve dans le code source ; couramment :

* `param = 0` → `trade_fee_rate`
* `param = 1` → `protocol_fee_rate`
* `param = 2` → `fund_fee_rate`
* `param = 3` → `new_protocol_owner` (passe les octets `Pubkey` comme une réinterprétation)
* `param = 4` → `new_fund_owner`
* `param = 5` → `create_pool_fee`
* `param = 6` → `disable_create_pool`

Les modifications sont signées par l'administrateur et affectent **tous les pools liés à cette `AmmConfig`** lors du prochain swap. Pas de migration ; les pools lisent simplement les nouvelles valeurs.

## Matrice de changements d'état

| Instruction                | `lp_supply`  | Balances des coffres      | Champs de frais accumulés                                           | `observation`            |
| -------------------------- | ------------ | ------------------------- | ------------------------------------------------------------------- | ------------------------ |
| `Initialize`               | + LP initial | + `init_amount_{0,1}`     | 0                                                                   | init                     |
| `InitializeWithPermission` | + LP initial | + `init_amount_{0,1}`     | 0                                                                   | init                     |
| `Deposit`                  | +            | + les deux                | —                                                                   | —                        |
| `Withdraw`                 | −            | − les deux                | —                                                                   | —                        |
| `SwapBaseInput`            | —            | + entrée, − sortie        | + `trade_fee` divisé en protocole/fonds ; + `creator_fee` si activé | + (si intervalle écoulé) |
| `SwapBaseOutput`           | —            | + entrée, − sortie        | + `trade_fee` divisé en protocole/fonds ; + `creator_fee` si activé | + (si intervalle écoulé) |
| `CollectProtocolFee`       | —            | − (par buckets protocole) | `protocol_*` → 0                                                    | —                        |
| `CollectFundFee`           | —            | − (par buckets fonds)     | `fund_*` → 0                                                        | —                        |
| `CollectCreatorFee`        | —            | − (par buckets créateur)  | `creator_*` → 0                                                     | —                        |
| `UpdatePoolStatus`         | —            | —                         | —                                                                   | —                        |

## Où aller ensuite

* [`products/cpmm/code-demos`](/fr/products/cpmm/code-demos) — exemples TypeScript exécutables pour ce qui précède.
* [`reference/error-codes`](/fr/reference/error-codes) — la table d'erreurs Anchor complète.
* [`products/cpmm/fees`](/fr/products/cpmm/fees) — le modèle d'accumulation de frais que `CollectProtocolFee` / `CollectFundFee` / `CollectCreatorFee` drainent.

Sources :

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