Passer au contenu principal

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.

Cette page est traduite automatiquement par IA. La version anglaise fait foi.Voir la version anglaise →

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 :
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 :
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)
  • txVersionV0 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 :
{
  "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 :
{
  "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 :
// 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éseauMainnetDevnet
Hôtetransaction-v1.raydium.iotransaction-v1-devnet.raydium.io
ProtocoleHTTPSHTTPS

Codes d’erreur

Messages d’erreur courants :
CodeSignification
REQ_SLIPPAGE_BPS_ERRORLe glissement est invalide ou hors plage
REQ_INPUT_MINT_ERRORL’adresse de mint d’entrée est invalide
REQ_OUTPUT_MINT_ERRORL’adresse de mint de sortie est invalide
REQ_AMOUNT_ERRORLe montant n’est pas un nombre valide
REQ_TX_VERSION_ERRORtxVersion doit être V0 ou LEGACY
REQ_WALLET_ERRORL’adresse du portefeuille est invalide
REQ_INPUT_ACCOUT_ERRORLe compte de token d’entrée est manquant ou invalide
REQ_OUTPUT_ACCOUT_ERRORLe compte de token de sortie est manquant ou invalide
UNKNOWN_ERRORErreur côté serveur ; vérifiez les paramètres de votre requête

Voir aussi