Infrastructure Solana Quicknode

Construisez des applications Solana haute performance avec Quicknode — fournisseur d'infrastructure blockchain supportant 80+ chaînes avec des endpoints RPC à faible latence, API DAS, streaming gRPC Yellowstone, pipelines de données en temps réel et des API orientées développeurs.

Vue d'ensemble

Quicknode fournit :

• Endpoints RPC : Accès Solana à faible latence avec authentification intégrée dans l'URL
• API DAS : Requêtes unifiées d'NFT et de tokens — NFT standard, NFT compressés (cNFT), tokens fongibles, MPL Core Assets, Token 2022
• Yellowstone gRPC : Streaming de données Solana en temps réel via plugin Geyser
• API Priority Fee : Estimation des frais pour l'arrivée des transactions
• Streams : Pipelines de données en temps réel et historiques avec filtrage JavaScript
• Webhooks : Notifications blockchain événementielles
• Metis : Intégration de l'API Jupiter Swap
• IPFS : Stockage de fichiers décentralisé
• Key-Value Store : Persistance d'état serverless pour Streams
• Admin API : Gestion programmatique des endpoints
• x402 : RPC pay-per-request via micropaiements USDC (pas de clé API requise)
• Multi-Chain : 80+ réseaux incluant Ethereum, Polygon, Arbitrum, Base, BSC, Avalanche, Bitcoin, et plus

Démarrage rapide

Obtenir votre endpoint

1. Visitez quicknode.com/endpoints
2. Sélectionnez Solana et votre réseau (Mainnet / Devnet)
3. Créez un endpoint
4. Copiez les URLs HTTP et WSS

Configuration de l'environnement

# .env file
QUICKNODE_RPC_URL=https://your-endpoint.solana-mainnet.quiknode.pro/your-token/
QUICKNODE_WSS_URL=wss://your-endpoint.solana-mainnet.quiknode.pro/your-token/
QUICKNODE_API_KEY=your_console_api_key  # Optional: for Admin API

Configuration de base avec @solana/kit

import { createSolanaRpc, createSolanaRpcSubscriptions } from "@solana/kit";

const rpc = createSolanaRpc(process.env.QUICKNODE_RPC_URL!);
const rpcSubscriptions = createSolanaRpcSubscriptions(process.env.QUICKNODE_WSS_URL!);

// Effectuer des appels RPC
const slot = await rpc.getSlot().send();
const balance = await rpc.getBalance(address).send();

Authentification

Les endpoints Quicknode incluent l'authentification dans l'URL :

https://{ENDPOINT_NAME}.solana-mainnet.quiknode.pro/{TOKEN}/

Activez l'authentification JWT ou la liste blanche d'IP dans le tableau de bord Quicknode pour une sécurité supplémentaire.

Endpoints RPC

Endpoints Solana

Utilisation avec @solana/kit

import {
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  address,
  lamports,
} from "@solana/kit";

const rpc = createSolanaRpc(process.env.QUICKNODE_RPC_URL!);
const rpcSubscriptions = createSolanaRpcSubscriptions(process.env.QUICKNODE_WSS_URL!);

// Solde du compte
const balance = await rpc.getBalance(address("E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk")).send();

// Informations du compte
const accountInfo = await rpc.getAccountInfo(address("E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk"), {
  encoding: "base64",
}).send();

// Blockhash récent
const { value: blockhash } = await rpc.getLatestBlockhash().send();

// Comptes de tokens
const tokenAccounts = await rpc.getTokenAccountsByOwner(
  address("E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk"),
  { programId: address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA") },
  { encoding: "jsonParsed" },
).send();

Utilisation avec web3.js hérité

import { Connection, PublicKey } from "@solana/web3.js";

const connection = new Connection(process.env.QUICKNODE_RPC_URL!);
const balance = await connection.getBalance(new PublicKey("E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk"));

Limites de taux et plans

API DAS (Digital Asset Standard)

API complète pour interroger les actifs numériques Solana — NFT standard, NFT compressés (cNFT), tokens fongibles, MPL Core Assets et Token 2022 Assets. Disponible en tant que module complémentaire Marketplace (API DAS Metaplex).

Obtenir les actifs par propriétaire

const response = await fetch(process.env.QUICKNODE_RPC_URL!, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "getAssetsByOwner",
    params: {
      ownerAddress: "E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk",
      limit: 10,
      options: { showFungible: true, showCollectionMetadata: true },
    },
  }),
});

const { result } = await response.json();
// result.total — total des actifs
// result.items — tableau des métadonnées d'actifs
// result.cursor — pour la pagination

Rechercher des actifs

const response = await fetch(process.env.QUICKNODE_RPC_URL!, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "searchAssets",
    params: {
      ownerAddress: "E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk",
      tokenType: "fungible",
      limit: 50,
    },
  }),
});

Obtenir la preuve d'actif (NFT compressés)

const response = await fetch(process.env.QUICKNODE_RPC_URL!, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "getAssetProof",
    params: { id: "compressed_nft_id" },
  }),
});

Référence des méthodes DAS

Yellowstone gRPC (Solana Geyser)

Plugin Geyser Solana haute performance pour le streaming de données blockchain en temps réel via gRPC. Disponible en tant que module complémentaire Marketplace.

Configuration

import Client, { CommitmentLevel } from "@triton-one/yellowstone-grpc";

// Dérivez l'URL gRPC à partir de l'endpoint HTTP :
// HTTP:  https://example.solana-mainnet.quiknode.pro/TOKEN/
// gRPC:  https://example.solana-mainnet.quiknode.pro:10000
const client = new Client(
  "https://example.solana-mainnet.quiknode.pro:10000",
  "TOKEN",
  {}
);

const stream = await client.subscribe();

stream.on("data", (data) => {
  if (data.transaction) {
    console.log("Transaction:", data.transaction);
  }
  if (data.account) {
    console.log("Mise à jour du compte:", data.account);
  }
});

// S'abonner aux transactions d'un programme spécifique
stream.write({
  transactions: {
    txn_filter: {
      vote: false,
      failed: false,
      accountInclude: ["PROGRAM_PUBKEY"],
      accountExclude: [],
      accountRequired: [],
    },
  },
  accounts: {},
  slots: {},
  blocks: {},
  blocksMeta: {},
  transactionsStatus: {},
  entry: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.CONFIRMED,
});

Types de filtres

Bonnes pratiques gRPC

• Utilisez le port 10000 pour les connexions gRPC
• Définissez l'engagement sur CONFIRMED pour la plupart des cas, FINALIZED pour l'irréversibilité
• Activez la compression zstd pour réduire la bande passante
• Envoyez des pings keepalive toutes les 10 secondes pour maintenir les connexions
• Implémentez une logique de reconnexion avec backoff exponentiel
• Utilisez des filtres étroits (comptes ou programmes spécifiques) pour minimiser le volume de données

API Priority Fee

Estimez les frais de priorité pour un arrivage optimal des transactions.

// Obtenir les frais de priorité recommandés
const response = await fetch(process.env.QUICKNODE_RPC_URL!, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    method: "qn_estimatePriorityFees",
    params: {
      last_n_blocks: 100,
      account: "YOUR_ACCOUNT_PUBKEY",
    },
  }),
});

Utilisation des frais de priorité dans les transactions

import {
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayer,
  setTransactionMessageLifetimeUsingBlockhash,
  prependTransactionMessageInstructions,
  appendTransactionMessageInstruction,
} from "@solana/kit";
import {
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
} from "@solana-program/compute-budget";

// 1. Obtenir l'estimation des frais
const feeResponse = await fetch(process.env.QUICKNODE_RPC_URL!, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    method: "qn_estimatePriorityFees",
    params: { last_n_blocks: 100, account: payer.address },
  }),
});
const feeData = await feeResponse.json();
const priorityFee = feeData.result.per_compute_unit.high;

// 2. Construire la transaction avec budget de calcul
const tx = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayer(payer.address, tx),
  (tx) => setTransactionMessageLifetimeUsingBlockhash(blockhash, tx),
  (tx) => prependTransactionMessageInstructions([
    getSetComputeUnitLimitInstruction({ units: 200_000 }),
    getSetComputeUnitPriceInstruction({ microLamports: BigInt(priorityFee) }),
  ], tx),
  (tx) => appendTransactionMessageInstruction(mainInstruction, tx),
);

Metis — API Jupiter Swap

API Jupiter Swap hébergée par Quicknode pour l'agrégation DEX. Disponible en tant que module complémentaire Marketplace.

import { createJupiterApiClient } from "@jup-ag/api";

const jupiterApi = createJupiterApiClient({
  basePath: process.env.QUICKNODE_METIS_URL!,
});

// Obtenir un devis de swap
const quote = await jupiterApi.quoteGet({
  inputMint: "So11111111111111111111111111111111111111112",   // SOL
  outputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
  amount: 1_000_000_000, // 1 SOL
  slippageBps: 50,
});

// Obtenir la transaction de swap
const swapResult = await jupiterApi.swapPost({
  swapRequest: {
    quoteResponse: quote,
    userPublicKey: "YourPubkey...",
  },
});

Streams

Pipelines de données blockchain en temps réel et historiques qui filtrent, transforment et livrent les données vers des destinations.

Types de streams

Configuration

1. Créez un stream dans le tableau de bord Quicknode
2. Sélectionnez Solana et le type de données
3. Ajoutez une fonction de filtre (JavaScript)
4. Configurez la destination (webhook, S3, PostgreSQL, Azure)

Exemple de fonction de filtre

function main(data) {
  // Filtrer les transactions impliquant un programme spécifique
  const PROGRAM_ID = "YOUR_PROGRAM_ID";
  const hasProgram = data.transaction?.message?.accountKeys?.some(
    (key) => key === PROGRAM_ID
  );
  if (!hasProgram) return null;
  return data;
}

Streams vs Webhooks

Webhooks

Notifications événementielles pour l'activité blockchain Solana.

Configuration des webhooks

Créez des webhooks via le tableau de bord Quicknode ou l'Admin API pour recevoir des notifications lorsque des événements spécifiques on-chain se produisent.

Consultez resources/webhooks-reference.md pour les exemples d'API et la configuration.

Stockage IPFS

Stockage de fichiers décentralisé via la passerelle IPFS de Quicknode.

// Télécharger un fichier vers IPFS
const formData = new FormData();
formData.append("file", fileBuffer);

const response = await fetch("https://api.quicknode.com/ipfs/rest/v1/s3/put-object", {
  method: "POST",
  headers: { "x-api-key": process.env.QUICKNODE_API_KEY! },
  body: formData,
});

const { pin } = await response.json();
// Accédez via : https://quicknode.quicknode-ipfs.com/ipfs/{pin.cid}

Cas d'usage courants

• Stockage de métadonnées NFT
• Hébergement d'actifs pour les collections
• Persistance de contenu décentralisé

Key-Value Store

Stockage serverless pour les listes et les ensembles clé-valeur, accessible à partir des fonctions de filtre Streams via la bibliothèque d'assistance qnLib.

Intégration Streams (qnLib)

// Dans une fonction de filtre Streams :

// Opérations sur les listes — gérer les listes de surveillance d'adresses
await qnLib.qnAddListItem("my-watchlist", "E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk");
const isWatched = await qnLib.qnContainsListItems("my-watchlist", [data.from]);

// Opérations sur les ensembles — stocker des paires clé-valeur
await qnLib.qnAddSet("token-prices", { key: "SOL", value: "150.25" });
const price = await qnLib.qnGetSet("token-prices", "SOL");

Opérations sur les listes

• qnLib.qnUpsertList — créer ou mettre à jour une liste
• qnLib.qnAddListItem — ajouter un élément à une liste
• qnLib.qnRemoveListItem — supprimer un élément d'une liste
• qnLib.qnContainsListItems — vérification d'appartenance en lot
• qnLib.qnDeleteList — supprimer une liste

Opérations sur les ensembles

• qnLib.qnAddSet — créer un ensemble clé-valeur
• qnLib.qnGetSet — récupérer la valeur par clé
• qnLib.qnBulkSets — créer/supprimer des ensembles en lot
• qnLib.qnDeleteSet — supprimer un ensemble

SDK Quicknode

SDK JavaScript/TypeScript officiel pour les services Quicknode.

npm install @quicknode/sdk

import { Core } from "@quicknode/sdk";

const core = new Core({
  endpointUrl: process.env.QUICKNODE_RPC_URL!,
});

// Token API
const balances = await core.client.qn_getWalletTokenBalance({
  wallet: "E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk",
});

// NFT API
const nfts = await core.client.qn_fetchNFTs({
  wallet: "E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk",
  page: 1,
  perPage: 10,
});

Admin API

API REST pour la gestion programmatique des endpoints Quicknode, utilisation, limites de taux, sécurité et facturation.

Authentification

Toutes les requêtes Admin API utilisent l'en-tête x-api-key contre https://api.quicknode.com/v0/.

const QN_API_KEY = process.env.QUICKNODE_API_KEY!;

// Lister tous les endpoints
const res = await fetch("https://api.quicknode.com/v0/endpoints", {
  headers: { "x-api-key": QN_API_KEY },
});
const endpoints = await res.json();

// Obtenir les métriques d'utilisation
const usage = await fetch("https://api.quicknode.com/v0/usage/rpc", {
  headers: { "x-api-key": QN_API_KEY },
});

Référence rapide

x402 (RPC Pay-Per-Request)

Accès RPC pay-per-request via micropaiements USDC sur Base. Aucune clé API requise.

import { wrapFetch } from "@x402/fetch";
import { createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const walletClient = createWalletClient({
  account,
  chain: base,
  transport: http(),
});

// Envelopper fetch pour gérer automatiquement les paiements 402
const x402Fetch = wrapFetch(fetch, walletClient);

// Utiliser comme un fetch normal — les paiements sont gérés automatiquement
const response = await x402Fetch("https://x402.quicknode.com/solana-mainnet", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    method: "getSlot",
    params: [],
    id: 1,
  }),
});

Support multi-chaînes

Quicknode prend en charge 80+ réseaux de blockchain au-delà de Solana :

Liste complète : quicknode.com/chains

Configuration multi-chaînes

import { Core } from "@quicknode/sdk";

const chains = {
  solana: new Core({ endpointUrl: process.env.QUICKNODE_SOL_RPC! }),
  ethereum: new Core({ endpointUrl: process.env.QUICKNODE_ETH_RPC! }),
  polygon: new Core({ endpointUrl: process.env.QUICKNODE_POLYGON_RPC! }),
};

Valeurs par défaut de sécurité

• Préférez devnet quand un réseau n'est pas spécifié
• Préférez les opérations en lecture seule et les simulations avant de créer des ressources
• Ne demandez jamais et n'acceptez jamais les clés privées ou clés secrètes
• Exigez une confirmation explicite avant de créer des Streams, Webhooks ou uploads IPFS

Gestion des erreurs

try {
  const response = await fetch(process.env.QUICKNODE_RPC_URL!, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "getSlot", params: [] }),
  });
  if (!response.ok) {
    if (response.status === 401) console.error("URL d'endpoint ou token invalide");
    if (response.status === 429) console.error("Limité en taux — mettre à niveau le plan ou réduire les requêtes");
    if (response.status >= 500) console.error("Erreur serveur — relancer avec backoff");
  }
} catch (error) {
  console.error("Erreur réseau:", error);
}

Codes d'erreur courants

Bonnes pratiques

Sécurité des clés API

• Ne validez jamais les URLs d'endpoint ou les clés API dans git
• Utilisez les variables d'environnement
• Activez la liste blanche d'IP pour la production
• Utilisez l'authentification JWT pour les opérations sensibles
• Renouvelez les identifiants périodiquement

Performance

• Utilisez les abonnements WebSocket pour les données en temps réel
• Regroupez les requêtes RPC pour réduire les appels API
• Mettez en cache les réponses quand les données ne changent pas fréquemment
• Utilisez Yellowstone gRPC pour le streaming à plus faible latence
• Définissez les niveaux d'engagement appropriés (confirmed pour la plupart, finalized pour l'irréversibilité)

Fiabilité

• Implémentez une logique de relance avec backoff exponentiel
• Gérez gracieusement les limites de taux avec backoff
• Utilisez Streams pour un traitement d'événement fiable (nouvelles tentatives automatiques)
• Surveillez l'intégrité de l'endpoint via les métriques de l'Admin API

Ressources

• Documentation Quicknode
• Docs spécifiques à Solana
• Référence API DAS
• Yellowstone gRPC
• Docs Streams
• SDK Quicknode
• Admin API
• Key-Value Store
• x402
• Docs optimisées pour LLM (llms.txt)
• Guides
• Marketplace
• Exemples d'applications
• Repo des exemples de guides

Structure de skill

quicknode/
├── SKILL.md                       # Ce fichier
├── resources/
│   ├── rpc-reference.md           # Méthodes RPC et patterns WebSocket
│   ├── das-api-reference.md       # Méthodes et paramètres de l'API DAS
│   ├── yellowstone-grpc-reference.md  # Référence streaming gRPC
│   ├── streams-reference.md       # Fonctions de filtre Streams et destinations
│   ├── webhooks-reference.md      # Configuration des webhooks
│   └── marketplace-addons.md      # Token API, NFT API, Metis, Priority Fees
├── examples/
│   ├── basic-rpc/                 # Appels RPC de base
│   ├── das-api/                   # Requêtes API DAS
│   ├── streaming/                 # Exemples Yellowstone gRPC
│   └── streams-webhooks/          # Configuration Streams et webhooks
├── templates/
│   └── quicknode-setup.ts         # Modèle de démarrage
└── docs/
    └── troubleshooting.md         # Problèmes courants et solutions

Vérifier

• Un appel RPC/SDK réel a été émis (mainnet, devnet ou validateur local) et la charge de réponse est capturée dans la transcription, et non simplement paraphrasée
• Chaque transaction a été simulée (simulateTransaction ou équivalent) avant toute étape de signature/envoi ; les journaux de simulation sont joints
• Pour toute transaction signée/envoyée, la signature résultante est enregistrée et confirmée on-chain (statut renvoyé par getSignatureStatuses ou une URL d'explorateur)
• Le slippage, les frais de priorité et les limites d'unités de calcul ont été définis explicitement avec des valeurs numériques concrètes, et non laissés aux valeurs par défaut de la bibliothèque
• Les adresses de comptes, les mints et les ID de programme utilisés dans l'exécution correspondent aux adresses quicknode-infra documentées pour le cluster ciblé (pas de mélange mainnet/devnet)
• Le chemin d'échec a été exercé au moins une fois (solde insuffisant, oracle obsolète, blockhash expiré, etc.) et la gestion d'erreur de l'agent a produit un message lisible pour les humains