Blog

Comment Utiliser l'API Solana: Guide Complet pour Développeurs

Ashley Goolam

Ashley Goolam

6 February 2026

Comment Utiliser l'API Solana: Guide Complet pour Développeurs

Et si vous pouviez créer des applications blockchain capables de traiter 65 000 transactions par seconde avec une finalité de 400 millisecondes ? L'API de Solana rend cela possible, en offrant une interface JSON-RPC qui vous permet d'interroger des comptes, de soumettre des transactions et de vous abonner à des mises à jour en temps réel sans avoir à gérer vous-même l'infrastructure des validateurs.

Le développement traditionnel de la blockchain vous oblige à choisir entre vitesse et décentralisation. Les 15 TPS d'Ethereum créent des goulots d'étranglement lors de la congestion du réseau. Les solutions de couche 2 ajoutent de la complexité. Solana élimine ce compromis grâce à son consensus de preuve d'historique (Proof-of-History) combiné à la preuve d'enjeu (Proof-of-Stake), offrant des performances Web2 avec les garanties Web3. Vous construisez des applications qui semblent instantanées tout en conservant une résistance à la censure.

Table des matières :

💡
Lors de la création d'applications Solana, la gestion de plusieurs points d'accès RPC et le débogage des échecs de transaction deviennent complexes. Apidog offre des tests d'API visuels, une documentation automatisée et des fonctionnalités de collaboration en équipe, spécifiquement conçues pour le développement blockchain. Essayez Apidog gratuitement pour rationaliser votre flux de travail Solana – aucune carte de crédit requise.
bouton

Comprendre l'architecture de Solana

Solana utilise une architecture unique centrée sur la Solana Program Library (SPL) et un runtime à haut débit. Comprendre ces fondamentaux vous aide à écrire des appels API efficaces.

Preuve d'Historique (PoH)

La PoH crée un horodatage cryptographique pour chaque transaction avant le consensus. Cela élimine la nécessité pour les nœuds de s'accorder sur l'heure, réduisant considérablement la latence. Lorsque vous soumettez une transaction via l'API, elle est horodatée immédiatement et entre dans la file d'attente du leader pour traitement.

Comptes et Programmes

Contrairement au modèle basé sur les comptes d'Ethereum avec stockage de code, Solana sépare le code (programmes) des données (comptes). Les programmes sont sans état – ils ne contiennent que la logique exécutable. Les comptes stockent les données et spécifient quel programme les possède. Cette architecture permet le traitement parallèle des transactions puisque les comptes non superposés peuvent s'exécuter simultanément.

Chaque compte possède une adresse unique de 32 octets dérivée d'une clé publique Ed25519. Les comptes paient un loyer en lamports (1 SOL = 10^9 lamports) pour rester sur la chaîne. Les comptes exempts de loyer — ceux détenant au moins 2 ans de loyer — persistent indéfiniment sans dégradation.

Niveaux d'Engagement

Solana propose trois niveaux de confirmation :

Spécifiez les niveaux d'engagement dans les appels API pour équilibrer la vitesse et les garanties de finalité.

API Solana

Configurer votre environnement de développement

Vous avez besoin de trois composants : l'interface de ligne de commande (CLI) de Solana pour la gestion des clés et le déploiement, un point d'accès RPC pour l'accès à la blockchain, et le SDK JavaScript pour l'intégration d'applications.

Installer la CLI Solana

Installez l'outil CLI officiel :

sh -c "$(curl -sSfL https://release.solana.com/stable/install)"

Vérifiez l'installation :

solana --version

Configurez votre environnement pour Devnet (test) ou Mainnet (production) :

# Pour le développement
solana config set --url https://api.devnet.solana.com

# Pour la production
solana config set --url https://api.mainnet-beta.solana.com

Créer un Portefeuille

Générez une nouvelle paire de clés pour signer les transactions :

solana-keygen new --outfile ~/.config/solana/id.json

La CLI affiche votre adresse publique et une phrase mnémonique de 12 mots. Stockez la phrase mnémonique en toute sécurité — elle permet de récupérer votre portefeuille. Le fichier JSON contient votre clé privée ; protégez-le avec des permissions de fichier (chmod 600).

Vérifiez votre solde :

solana balance

Approvisionnez votre portefeuille Devnet avec du SOL gratuit :

solana airdrop 2

Les airdrops Devnet fournissent 2 SOL par demande, limités à une demande toutes les 10 secondes. Mainnet nécessite l'achat de SOL via des échanges.

Choisir un fournisseur RPC

Bien que Solana fournisse des points d'accès RPC publics, les applications de production nécessitent une infrastructure dédiée. Les options incluent :

Les niveaux gratuits autorisent généralement 100 000 requêtes par mois. Les plans payants offrent des limites plus élevées, des connexions "staked" pour l'atterrissage des transactions et des API de frais prioritaires.

Installer Web3.js

Le SDK JavaScript de Solana a deux versions majeures. La version 2.0 représente une réécriture complète avec des schémas de programmation fonctionnelle, une "tree-shakability" et zéro dépendances.

Installez la version 2.0 :

npm install @solana/web3.js@2 @solana-program/system @solana-program/compute-budget

Pour la compatibilité avec la version 1.x :

npm install @solana/web3.js
ConseilApidogSolana

Méthodes principales de l'API RPC Solana

L'API JSON-RPC de Solana fournit des points d'accès HTTP pour les requêtes et des points d'accès WebSocket pour les abonnements. Toutes les requêtes suivent la spécification JSON-RPC 2.0.

Méthodes principales de l'API RPC Solana

Opérations de compte

Obtenez les informations de compte et le solde :

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getAccountInfo",
    "params": [
      "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36zEGQp",
      {"encoding": "base58"}
    ]
  }'

Récupérez plusieurs comptes efficacement :

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getMultipleAccounts",
    "params": [
      [
        "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36zEGQp",
        "4fYNw3dojWGPgVMtUU7ziPwq1r2VMGrhCrKZC9EQTbkV"
      ],
      {"encoding": "base64"}
    ]
  }'

Requêtes de blocs et de transactions

Obtenez le dernier blockhash pour la construction des transactions :

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getLatestBlockhash",
    "params": [{"commitment": "confirmed"}]
  }'

Interrogez le statut de la transaction :

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getSignatureStatuses",
    "params": [
      [
        "5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpEz7CmGVZxhEHppBrGK"
      ],
      {"searchTransactionHistory": true}
    ]
  }'

Abonnements WebSocket

Surveillez les changements de compte en temps réel :

import { createSolanaRpcSubscriptions } from "@solana/web3.js";

const rpcSubscriptions = createSolanaRpcSubscriptions(
  "wss://api.devnet.solana.com"
);

const abortController = new AbortController();

await rpcSubscriptions.accountNotifications(
  "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36zEGQp",
  { commitment: "confirmed" },
  (notification) => {
    console.log("Account changed:", notification);
  },
  { abortSignal: abortController.signal }
);

// Arrêter l'écoute après 60 secondes
setTimeout(() => abortController.abort(), 60000);

Les connexions WebSocket nécessitent des pings périodiques toutes les 30 à 60 secondes pour rester actives. Implémentez une logique de reconnexion pour les applications de production.

Conseil de proApidogSolana

Construire des transactions avec Web3.js

Les transactions Solana se composent d'une ou plusieurs instructions ciblant des programmes spécifiques. Chaque instruction spécifie le programme, les comptes avec lesquels il interagit et les données sérialisées.

Créer une transaction de transfert

Transférez du SOL entre les comptes en utilisant le SDK version 2.0 :

import {
  airdropFactory,
  createKeyPairSignerFromBytes,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  generateKeyPairSigner,
  lamports,
  sendAndConfirmTransactionFactory,
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayer,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  signTransactionMessageWithSigners,
  getSignatureFromTransaction,
} from "@solana/web3.js";
import { getTransferSolInstruction } from "@solana-program/system";

const LAMPORTS_PER_SOL = BigInt(1_000_000_000);

// Configuration des connexions RPC
const rpc = createSolanaRpc("https://api.devnet.solana.com");
const rpcSubscriptions = createSolanaRpcSubscriptions("wss://api.devnet.solana.com");
const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });

// Générer l'expéditeur et le destinataire
const sender = await generateKeyPairSigner();
const recipient = await generateKeyPairSigner();

// Approvisionner l'expéditeur avec un airdrop
await airdropFactory({ rpc, rpcSubscriptions })({
  recipientAddress: sender.address,
  lamports: lamports(2n * LAMPORTS_PER_SOL),
  commitment: "confirmed",
});

// Obtenir le dernier blockhash
const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

// Construire la transaction en utilisant pipe
const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }),
  (msg) => setTransactionMessageFeePayer(sender.address, msg),
  (msg) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, msg),
  (msg) => appendTransactionMessageInstruction(
    getTransferSolInstruction({
      amount: lamports(LAMPORTS_PER_SOL / BigInt(2)),
      destination: recipient.address,
      source: sender,
    }),
    msg
  )
);

// Signer et envoyer
const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
console.log("Transaction signée");

await sendAndConfirmTransaction(signedTransaction, {
  commitment: "confirmed",
  maxRetries: 0n,
  skipPreflight: true,
});

console.log("Confirmée:", getSignatureFromTransaction(signedTransaction));

La fonction pipe crée une chaîne fonctionnelle où chaque étape transforme le message de transaction. Ce modèle élimine l'état mutable et rend la construction des transactions déclarative.

Optimiser avec des frais prioritaires

Lors de la congestion du réseau, les frais prioritaires garantissent l'inclusion des transactions. Récupérez les frais recommandés auprès de l'API Helius :

import { getBase64EncodedWireTransaction } from "@solana/web3.js";

const base64Transaction = getBase64EncodedWireTransaction(signedTransaction);

const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_KEY", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: "priority-fee-request",
    method: "getPriorityFeeEstimate",
    params: [{
      transaction: base64Transaction,
      options: { recommended: true }
    }]
  })
});

const { result } = await response.json();
const priorityFee = result.priorityFeeEstimate;

// Ajouter l'instruction de frais prioritaires
import { getSetComputeUnitPriceInstruction } from "@solana-program/compute-budget";

const optimizedMessage = pipe(
  transactionMessage,
  (msg) => appendTransactionMessageInstruction(
    getSetComputeUnitPriceInstruction({ microLamports: priorityFee }),
    msg
  )
);

Les frais prioritaires sont spécifiés en micro-lamports par unité de calcul. Des frais plus élevés augmentent la priorité de la transaction lors de la congestion.

Gérer les erreurs

Solana renvoie des codes d'erreur spécifiques pour les échecs courants :

import { isSolanaError, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE } from "@solana/web3.js";

try {
  await sendAndConfirmTransaction(signedTransaction);
} catch (error) {
  if (isSolanaError(error)) {
    switch (error.contextErrorCode) {
      case SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE:
        console.error("Pré-vérification échouée:", error.message);
        break;
      default:
        console.error("Erreur Solana:", error);
    }
  }
}

Les erreurs courantes incluent des fonds insuffisants (0x1), un blockhash invalide (expiré) et un compte en cours d'utilisation (conflits de transaction).

Meilleures pratiques de sécurité

Le débit élevé de Solana introduit des considérations de sécurité uniques. Mettez en œuvre ces mesures pour protéger votre application et vos utilisateurs.

Gestion des clés

Ne jamais soumettre de clés privées au contrôle de version. Utilisez des variables d'environnement :

# .env
SOLANA_PRIVATE_KEY="[1,2,3,...]"

Chargez les clés en toute sécurité dans votre application :

import { createKeyPairSignerFromBytes } from "@solana/web3.js";
import { getBase58Encoder } from "@solana/codecs";

const secretKey = JSON.parse(process.env.SOLANA_PRIVATE_KEY);
const signer = await createKeyPairSignerFromBytes(
  new Uint8Array(secretKey)
);

Pour les applications de navigateur, intégrez des adaptateurs de portefeuille (Phantom, Solflare) plutôt que de gérer directement les clés privées. Les utilisateurs signent les transactions via leur extension de portefeuille, garantissant la sécurité des clés.

Simulation de transaction

Simulez toujours les transactions avant de les soumettre pour détecter les erreurs précocement :

const simulationResult = await rpc.simulateTransaction(signedTransaction).send();

if (simulationResult.value.err) {
  console.error("Simulation échouée:", simulationResult.value.err);
  // Gérer l'erreur sans gaspiller de frais
}

La simulation exécute la transaction par rapport à l'état actuel sans valider les modifications. Elle révèle les erreurs logiques, les comptes insuffisants et les violations du budget de calcul.

Protection contre la relecture

Les transactions Solana incluent un blockhash récent qui expire après environ 90 secondes. Cela empêche les attaques par relecture – la soumission de la même transaction plusieurs fois. Pour les opérations idempotentes, générez des données d'instruction ou des comptes uniques par transaction.

Limitation de débit

Les points d'accès RPC publics implémentent une limitation de débit stricte (généralement 100 requêtes toutes les 10 secondes). Implémentez un recul exponentiel :

async function withRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.status === 429) {
        await new Promise(r => setTimeout(r, 1000 * Math.pow(2, i)));
        continue;
      }
      throw error;
    }
  }
}

Pour la production, utilisez des nœuds RPC dédiés ou des niveaux de fournisseur payants avec des limites plus élevées.

Vérification de Programme

Avant d'interagir avec des programmes tiers, vérifiez leur code source sur des explorateurs comme SolanaFM ou Solscan. Recherchez les badges de vérification indiquant que le bytecode déployé correspond aux dépôts open-source. Les programmes non vérifiés peuvent contenir une logique malveillante qui vide les fonds des utilisateurs.

Conclusion

L'API de Solana offre les performances que les applications modernes exigent — finalité en moins d'une seconde, débit élevé et frais prévisibles. Vous interrogez les états de compte via JSON-RPC, vous abonnez aux mises à jour en temps réel via WebSocket et construisez des transactions en utilisant le SDK fonctionnel Web3.js 2.0. L'architecture basée sur les comptes permet l'exécution parallèle tandis que les niveaux d'engagement vous permettent de choisir votre compromis sécurité-vitesse.

Commencez avec Devnet pour expérimenter sans risque financier. Utilisez les frais prioritaires pendant la congestion du Mainnet. Mettez en œuvre la simulation et une gestion appropriée des clés avant de déployer des applications destinées aux utilisateurs. L'écosystème de Solana fournit les outils ; la logique de votre application détermine la valeur.

Commencez dès aujourd'hui avec Apidog — importez vos points d'accès API Solana en quelques secondes et commencez à tester sans aucune configuration.

bouton

Pratiquez le Design-first d'API dans Apidog

Découvrez une manière plus simple de créer et utiliser des API

S'inscrire gratuitementTélécharger