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

# Aperçu de l'API de transaction

> Constructeur de transactions de swap côté serveur pour Solana.

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

  [Voir la version anglaise →](/api-reference/route-api-v2/overview)
</Info>

## Qu'est-ce que l'API de transaction ?

L'API de transaction Raydium (Route V2) est un service côté serveur qui construit des transactions de swap Solana sérialisées sans obliger les clients à maintenir une connexion RPC ou à intégrer l'ensemble du SDK Raydium. Cela simplifie considérablement l'intégration pour :

* Les interfaces web qui ne peuvent pas exécuter un client RPC local
* Les applications mobiles aux ressources limitées
* Les bots de trading sans interface
* Les agrégateurs et fournisseurs de portefeuille

Au lieu d'effectuer un routage complexe des pools et une construction de transaction côté client, vous demandez des devis de swap et la construction de transaction à notre API, puis vous signez et diffusez le résultat via n'importe quel RPC Solana.

## Vue d'ensemble du flux de travail

L'API de transaction sépare les préoccupations en deux phases :

### 1. Phase de calcul : Obtenir un devis

Appelez `/compute/swap-base-in` ou `/compute/swap-base-out` pour recevoir la sortie de swap attendue (ou l'entrée requise) en fonction des états actuels des pools. Ce point de terminaison est **en lecture seule** et ne nécessite aucune signature :

```bash theme={null}
GET /compute/swap-base-in?inputMint=EPjF...&outputMint=So111...&amount=1000000&slippageBps=50&txVersion=V0
```

La réponse inclut :

* Le montant de sortie attendu
* La décomposition de la route (quels pools et sources de liquidité sont utilisés)
* L'impact sur le prix

### 2. Phase de transaction : Construire et signer

Une fois que vous avez la réponse de calcul, passez-la (ainsi que le portefeuille et la configuration) à `/transaction/swap-base-in` ou `/transaction/swap-base-out` :

```bash theme={null}
POST /transaction/swap-base-in
Content-Type: application/json

{
  "wallet": "YourWalletAddress",
  "swapResponse": { ...response from /compute/swap-base-in },
  "txVersion": "V0",
  "computeUnitPriceMicroLamports": "1000",
  "wrapSol": false,
  "unwrapSol": false,
  "inputAccount": "TokenAccount1...",
  "outputAccount": "TokenAccount2..."
}
```

La réponse contient :

* Une transaction versionnée encodée en base64 prête à être signée
* Les adresses des tables de recherche d'adresses (si txVersion=V0)

Votre client effectue alors :

1. Décode la transaction
2. La signe avec la paire de clés de l'utilisateur
3. La diffuse via n'importe quel RPC Solana
4. Attend la confirmation

## Points de terminaison de calcul

### `GET /compute/swap-base-in`

**Cas d'utilisation** : L'utilisateur spécifie le montant d'entrée, nous calculons la sortie.

**Paramètres de requête obligatoires** :

* `inputMint` – Adresse de mint du token que vous envoyez
* `outputMint` – Adresse de mint du token que vous voulez
* `amount` – Montant d'entrée en lamports (unité la plus petite)
* `slippageBps` – Glissement maximal acceptable en points de base (0–10000)
* `txVersion` – `V0` ou `LEGACY`

**Optionnel** :

* `referrerBps` – Si vous avez une autorité de parrain, points de base de la sortie à collecter en tant que frais de parrain

### `GET /compute/swap-base-out`

**Cas d'utilisation** : L'utilisateur spécifie la sortie désirée, nous calculons l'entrée requise.

**Paramètres de requête obligatoires** :

* `inputMint`, `outputMint`, `amount` (sortie désirée), `slippageBps`, `txVersion`

**Remarque** : Pas de points de base de parrain pour base-out (pas encore implémenté).

## Points de terminaison de transaction

### `POST /transaction/swap-base-in`

Construit une transaction pour un montant d'entrée fixe.

**Corps obligatoire** :

* `wallet` – Votre adresse de portefeuille de signature
* `swapResponse` – L'objet de réponse de calcul complet
* `txVersion` – Version de la transaction
* `computeUnitPriceMicroLamports` – Frais de priorité en micro-lamports

**Optionnel** :

* `wrapSol` – Si true, enveloppe le SOL natif pour l'entrée
* `unwrapSol` – Si true, déverrouille le WSOL en SOL en sortie
* `inputAccount` – Compte de token pour l'entrée (requis si vous ne n'enveloppez pas le SOL)
* `outputAccount` – Compte de token pour la sortie
* `nonceInfo` – Nonce durable pour la signature hors ligne
* `jitoInfo` – Paramètres du bundle de protection MEV Jito
* `referrerWallet` – Portefeuille du parrain pour la collecte de frais

### `POST /transaction/swap-base-out`

Construit une transaction pour un montant de sortie fixe.

**Mêmes paramètres que base-in**, sauf :

* Le champ `referrerInfo` est actuellement commenté (pas encore implémenté)

## Enveloppe de réponse

Tous les points de terminaison renvoient une enveloppe standard :

```json theme={null}
{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "success": true,
  "version": "V1",
  "data": { ... }
}
```

En cas d'erreur, `success` est `false` et `msg` contient le code d'erreur (par exemple, `REQ_WALLET_ERROR`, `REQ_SLIPPAGE_BPS_ERROR`).

## Forme de réponse de transaction

Une réponse de transaction réussie ressemble à ceci :

```json theme={null}
{
  "id": "...",
  "success": true,
  "version": "V1",
  "data": {
    "transaction": "AgABB...",  // Base64-encoded transaction
    "addressLookupTableAddresses": ["Address1...", "Address2..."]  // For V0 only
  }
}
```

## Exemple d'intégration

Voici un flux typique en pseudocode :

```typescript theme={null}
// 1. Get quote
const quote = await fetch(
  'https://transaction-v1.raydium.io/compute/swap-base-in?' +
  'inputMint=EPjF...&outputMint=So111...&amount=1000000&slippageBps=50&txVersion=V0'
).then(r => r.json());

// 2. Validate quote
if (!quote.success) {
  throw new Error(quote.msg);
}

// 3. Build transaction
const tx = await fetch(
  'https://transaction-v1.raydium.io/transaction/swap-base-in',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      wallet: userWalletAddress,
      swapResponse: quote,
      txVersion: 'V0',
      computeUnitPriceMicroLamports: '1000',
      inputAccount: userInputTokenAccount,
      outputAccount: userOutputTokenAccount,
    }),
  }
).then(r => r.json());

// 4. Decode and sign
const transaction = VersionedTransaction.deserialize(
  Buffer.from(tx.data.transaction, 'base64')
);
transaction.sign([userKeypair]);

// 5. Send via RPC
const rpc = new Connection('https://api.mainnet-beta.solana.com');
const sig = await rpc.sendTransaction(transaction);
await rpc.confirmTransaction(sig);
```

## Paramètres clés expliqués

### `txVersion`

* **V0** : Transaction Solana moderne avec tables de recherche d'adresses (ALT). Taille de sérialisation plus petite, frais plus bas.
* **LEGACY** : Format de transaction antérieur aux ALT. Plus grand, mais fonctionne avec tous les points de terminaison RPC.

Choisissez **V0** si possible ; revenez à **LEGACY** si votre RPC ou portefeuille ne supporte pas les ALT.

### `computeUnitPriceMicroLamports`

Frais de priorité pour une inclusion plus rapide dans le bloc. Défini à `0` pour aucun frais de priorité, ou des valeurs plus élevées (par exemple, `1000`) pour rivaliser dans les réseaux congestionnés. Les unités sont des micro-lamports par unité de calcul.

### `slippageBps`

Tolérance de glissement maximal en points de base. `100` = 1%, `50` = 0,5%.

* Utilisez des valeurs plus basses (par exemple, 25–50 bps) pour la plupart des swaps stables
* Augmentez pour les paires volatiles ou faiblement liquides

### `wrapSol` et `unwrapSol`

* **wrapSol** : Si `true`, l'API enveloppe votre SOL natif en WSOL. Aucun `inputAccount` n'est nécessaire.
* **unwrapSol** : Si `true`, l'API déverrouille le WSOL de sortie en SOL natif. Aucun `outputAccount` n'est nécessaire.

Si les deux sont `false`, vous devez fournir des comptes de token explicites.

## Points de terminaison réseau

| Réseau    | Mainnet                     | Devnet                             |
| --------- | --------------------------- | ---------------------------------- |
| Hôte      | `transaction-v1.raydium.io` | `transaction-v1-devnet.raydium.io` |
| Protocole | HTTPS                       | HTTPS                              |

## Codes d'erreur

Messages d'erreur courants :

| Code                      | Signification                                                  |
| ------------------------- | -------------------------------------------------------------- |
| `REQ_SLIPPAGE_BPS_ERROR`  | Le glissement est invalide ou hors plage                       |
| `REQ_INPUT_MINT_ERROR`    | L'adresse de mint d'entrée est invalide                        |
| `REQ_OUTPUT_MINT_ERROR`   | L'adresse de mint de sortie est invalide                       |
| `REQ_AMOUNT_ERROR`        | Le montant n'est pas un nombre valide                          |
| `REQ_TX_VERSION_ERROR`    | txVersion doit être V0 ou LEGACY                               |
| `REQ_WALLET_ERROR`        | L'adresse du portefeuille est invalide                         |
| `REQ_INPUT_ACCOUT_ERROR`  | Le compte de token d'entrée est manquant ou invalide           |
| `REQ_OUTPUT_ACCOUT_ERROR` | Le compte de token de sortie est manquant ou invalide          |
| `UNKNOWN_ERROR`           | Erreur côté serveur ; vérifiez les paramètres de votre requête |

## Voir aussi

* [Spécification OpenAPI](/fr/api-reference/openapi/route-api-v2.yaml)
* [Guide d'intégration d'agrégateur](/fr/integration-guides/aggregator)