> ## 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 de routage

> Référence pour les instructions de routage AMM activées sur mainnet — six variantes couvrant les swaps avec montant fixe en entrée / sortie et les utilitaires wSOL.

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

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

## Résumé des instructions

| Tag | Discriminateur               | Exact  | Variante   |
| --- | ---------------------------- | ------ | ---------- |
| 0   | `SwapBaseInWithUserAccount`  | Input  | Legacy     |
| 1   | `SwapBaseOutWithUserAccount` | Output | Legacy     |
| 5   | `CreateSyncNative`           | —      | Utilitaire |
| 6   | `CloseTokenAccount`          | —      | Utilitaire |
| 8   | `SwapBaseIn`                 | Input  | Courant    |
| 9   | `SwapBaseOut`                | Output | Courant    |

**Légende :**

* **Exact :** quel montant est fixé par l'appelant (Input = montant fixe en entrée `amount_in` ; Output = montant fixe en sortie `amount_out`).
* **Variante :** Les instructions Legacy nécessitent une deque `limit_prices` non vide même s'il n'y a pas de saut CLMM dans la route. Les instructions courantes (8 / 9) traitent une `limit_prices` vide comme « pas de vérifications », ce qui est le chemin recommandé pour le nouveau code.

Toutes les variantes de swap routent les tokens intermédiaires via des **ATAs contrôlées par l'utilisateur** — l'utilisateur possède l'ATA d'entrée, tous les ATAs intermédiaires et l'ATA de sortie. Pour les nouvelles intégrations, utilisez **tag 8 (`SwapBaseIn`)** ou **tag 9 (`SwapBaseOut`)** sauf si vous avez une raison précise d'appeler une variante Legacy.

## Instructions de swap courants (recommandées)

Ce sont les points d'entrée que le nouveau code devrait utiliser. La structure des arguments est la même que pour les variantes Legacy mais `limit_prices` peut être vide.

### `SwapBaseIn` (tag 8)

Swap multi-saut avec montant fixe en entrée. L'appelant fixe `amount_in` ; le routeur exécute saut par saut et affirme que le montant final atteint ou dépasse `minimum_amount_out`.

**Arguments**

```
amount_in:            u64
minimum_amount_out:   u64
limit_prices:         VecDeque<u128>  // optionnel ; une deque vide signifie pas de vérification de prix CLMM par saut
```

**Comptes**

```
[
  <user_input_ata> W S,         // signataire ; solde >= amount_in
  <user_intermediate_ata_1> W,  // un par saut intermédiaire
  ... <user_intermediate_ata_N> W,
  <user_output_ata> W,
  <token_program>,

  <pool_program_hop_1>,         // identifie quelle famille AMM utilise le saut 1
  <pool_state_hop_1> W,
  ... <autres comptes requis par le programme du saut 1>,

  <pool_program_hop_2>,
  <pool_state_hop_2> W,
  ... <comptes du saut 2>,

  ... [répéter par saut]
]
```

La liste exacte des comptes par saut dépend du programme AMM sous-jacent (AMM v4 / CPMM / CLMM / Stable). Le routeur fait un CPI dans chacun à tour de rôle et valide que l'ID du programme correspond à l'un des quatre programmes supportés.

**Pré-conditions**

* L'appelant signe avec `user_input_ata`.
* `user_input_ata.amount >= amount_in`.
* Chaque ATA intermédiaire utilisateur existe et est possédé par l'appelant.
* Si un saut est CLMM et que vous voulez appliquer un contrôle de prix, fournissez une entrée `limit_prices` par saut CLMM.

**Post-conditions**

* Le solde de `user_input_ata` diminue de `amount_in`.
* Le solde de `user_output_ata` augmente de ≥ `minimum_amount_out`.
* Chaque ATA intermédiaire est laissé avec zéro changement net (la route consomme ce qu'elle a produit un saut plus tôt).

**Erreurs courantes**

* `ExceededSlippage` — sortie finale \< `minimum_amount_out`.
* `InvalidInput` — route vide, comptes malformés ou `pool_program` non supporté.
* `SqrtPriceX64` — le prix d'un saut CLMM s'est déplacé en dehors de la limite `limit_prices` fournie (seulement quand `limit_prices` est non vide).

***

### `SwapBaseOut` (tag 9)

Swap multi-saut avec montant fixe en sortie. L'appelant fixe `amount_out` ; le routeur affirme que l'entrée réelle ne dépasse pas `maximum_amount_in`.

**Arguments**

```
maximum_amount_in:   u64
amount_out:          u64
limit_prices:        VecDeque<u128>  // optionnel ; une deque vide signifie pas de vérification de prix CLMM par saut
```

**Comptes** — même structure que tag 8.

**Pré-conditions**

* L'appelant signe avec `user_input_ata` ; solde `>= maximum_amount_in` (cas limite).
* Chaque ATA intermédiaire et de sortie existent.

**Post-conditions**

* `user_input_ata` diminue du montant réel nécessaire (≤ `maximum_amount_in`).
* `user_output_ata` augmente d'exactement `amount_out`.

**Erreurs courantes**

* `ExceededSlippage` — entrée requise dépasse `maximum_amount_in`.
* `InvalidInput`, `SqrtPriceX64` — comme pour tag 8.

***

## Instructions de swap Legacy

Ces variantes plus anciennes sont toujours appelables sur le programme en direct et sont documentées ici pour exhaustivité. Préférez tag 8 / tag 9 pour le nouveau code ; les deux variantes Legacy ci-dessous nécessitent une deque `limit_prices` non vide même quand aucun saut CLMM n'est impliqué, ce qui les rend maladroites à utiliser.

### `SwapBaseInWithUserAccount` (tag 0)

Swap multi-saut avec montant fixe en entrée, identique en structure à tag 8 mais avec l'exigence `limit_prices` plus stricte.

**Arguments**

```
amount_in:           u64
minimum_amount_out:  u64
limit_prices:        VecDeque<u128>  // requis, non vide
```

**Comptes** — même structure que `SwapBaseIn` (tag 8). Tous les emplacements intermédiaires doivent être des ATAs possédés par l'appelant.

**Pré-conditions**

* L'appelant signe avec `user_input_ata`.
* `user_input_ata.amount >= amount_in`.
* Tous les ATAs intermédiaires utilisateur existent et sont possédés par l'appelant.
* `limit_prices` est non vide (une entrée par saut CLMM ; remplissez avec des valeurs d'espace réservé s'il n'y a pas de saut CLMM).

**Post-conditions**

* Le solde de `user_input_ata` diminue de `amount_in`.
* Le solde de `user_output_ata` augmente de ≥ `minimum_amount_out`.

**Erreurs courantes**

* `ExceededSlippage`.
* `InvalidInput` — une `limit_prices` vide est rejetée pour cette variante Legacy.
* `SqrtPriceX64`.

***

### `SwapBaseOutWithUserAccount` (tag 1)

Swap avec montant fixe en sortie, l'équivalent Legacy de `SwapBaseOut` (tag 9).

**Arguments**

```
maximum_amount_in:   u64
amount_out:          u64
limit_prices:        VecDeque<u128>  // requis, non vide
```

**Comptes** — même structure que tag 0 / tag 9.

**Pré-conditions**

* L'appelant signe avec `user_input_ata`.
* `user_input_ata.amount >= maximum_amount_in`.
* Tous les ATAs intermédiaires utilisateur existent et sont possédés par l'appelant.
* `limit_prices` est non vide.

**Post-conditions**

* `user_input_ata` diminue du montant réel nécessaire (≤ `maximum_amount_in`).
* `user_output_ata` augmente d'exactement `amount_out`.

**Erreurs courantes**

* `ExceededSlippage`.
* `InvalidInput`.
* `SqrtPriceX64`.

***

## Instructions utilitaires

### `CreateSyncNative` (tag 5)

Créez (si absent) et synchronisez un ATA wSOL en une seule étape. Pratique quand vous enveloppez SOL en ligne avec un swap.

**Arguments**

```
amount: u64    // SOL à envelopper (lamports)
```

**Comptes**

```
[
  <user_wsol_ata> W,            // ATA pour wSOL ; créé s'absent
  <user_native_account> W S,    // signataire ; SOL est débité d'ici
  <wsol_mint>,
  <system_program>,
  <token_program>,
  <associated_token_program>,
]
```

**Effet**

* Crée `user_wsol_ata` s'il n'existe pas encore.
* Transfère `amount` lamports du solde SOL natif du signataire vers l'ATA.
* Appelle `SyncNative` sur l'ATA afin que son solde de tokens reflète les nouveaux lamports.

**Erreurs courantes**

* `InvalidOwner` — le propriétaire de `user_wsol_ata` n'est pas le signataire.

***

### `CloseTokenAccount` (tag 6)

Fermez un compte de token et retournez son loyer au portefeuille de destination. Fonctionne avec `CreateSyncNative` : après un swap avec branche wSOL, appelez `CloseTokenAccount` pour récupérer le loyer qui soutenait l'ATA wSOL.

**Arguments** — aucun.

**Comptes**

```
[
  <token_account_to_close> W,
  <destination_for_rent> W,
  <owner> S,
  <token_program>,
]
```

**Effet**

* Ferme `token_account_to_close`.
* Transfère le solde en lamports exempt de loyer (\~0.00203928 SOL sur mainnet pour un compte SPL Token vanilla) vers `destination_for_rent`.
* Le compte de token doit avoir un solde de token nul.

**Erreurs courantes**

* `InvalidOwner` — l'appelant n'est pas le propriétaire de l'ATA.
* Le solde du compte de token est non nul.

***

## Prochaines étapes

* [`products/routing/code-demos`](/fr/products/routing/code-demos) — construisez chacune de ces instructions en TypeScript.
* [`products/routing/accounts`](/fr/products/routing/accounts) — clés de dispatch par AMM et mise en page des comptes par saut.
* [`reference/error-codes`](/fr/reference/error-codes) — liste complète de `RouteError`.