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

# Chaîne d'outils

> Configuration minimale pour lire l'état on-chain de Raydium, construire des transactions et développer face aux programmes. Solana CLI, Anchor, SDKs en TypeScript et Python, et conseils devnet/localnet.

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

  [Voir la version anglaise →](/solana-fundamentals/toolchain)
</Info>

<Info>
  Toute la documentation suppose une chaîne d'outils de développement Solana fonctionnelle. Cette page énumère les outils, les versions minimales connues pour fonctionner avec Raydium en avril 2026, et les pièges spécifiques à la configuration. Commencez ici avant d'exécuter tout exemple de code dans les chapitres suivants.
</Info>

## Outils principaux

### Solana CLI

L'interface de ligne de commande canonique pour interagir avec les clusters Solana — gestion des portefeuilles, appels RPC, déploiement de programmes.

Installation :

```bash theme={null}
sh -c "$(curl -sSfL https://release.solana.com/v1.18.22/install)"
# Ou la dernière version stable :
sh -c "$(curl -sSfL https://release.solana.com/stable/install)"
```

Vérification :

```bash theme={null}
solana --version   # → solana-cli 1.18.22 (ou plus récent)
```

Configuration pour mainnet :

```bash theme={null}
solana config set --url https://api.mainnet-beta.solana.com
solana config set --keypair ~/.config/solana/id.json
solana-keygen new                           # créer un portefeuille si vous n'en avez pas
solana address                              # votre clé publique
```

Pour les tests Raydium, vous voudrez presque toujours un portefeuille devnet financé :

```bash theme={null}
solana config set --url https://api.devnet.solana.com
solana airdrop 2                            # 2 SOL pour les tests
```

### CLI SPL Token

L'interface de ligne de commande officielle pour les opérations SPL Token / Token-2022 — création de mints, minage de tokens, transferts.

Installation (incluse avec Solana CLI) :

```bash theme={null}
spl-token --version
```

Opérations courantes :

```bash theme={null}
spl-token create-token                                  # créer un mint SPL Token
spl-token create-token --program-id TOKEN_2022 ...      # créer un mint Token-2022
spl-token create-account <MINT>                         # créer une ATA
spl-token mint <MINT> 1000                              # miner 1000 tokens vers votre ATA
spl-token transfer <MINT> 100 <RECIPIENT>               # transférer 100
spl-token display <ACCOUNT_OR_MINT>                     # inspecter
```

### CLI Anchor

Nécessaire pour récupérer les IDLs Raydium, construire des clients et vérifier les programmes.

Installation :

```bash theme={null}
cargo install --git https://github.com/coral-xyz/anchor avm --locked
avm install 0.30.1
avm use 0.30.1
anchor --version
```

Opérations courantes :

```bash theme={null}
anchor idl fetch <PROGRAM_ID> -o program.idl.json       # récupérer l'IDL on-chain
anchor idl init -f idl.json <PROGRAM_ID>                # télécharger un IDL
anchor build                                             # construire un programme à partir de la source
```

## Configuration TypeScript

Le chemin d'intégration principal pour Raydium.

### Packages

```bash theme={null}
npm install \
  @solana/web3.js \
  @solana/spl-token \
  @coral-xyz/anchor \
  @raydium-io/raydium-sdk-v2 \
  bn.js \
  decimal.js
```

Versions connues pour fonctionner ensemble en avril 2026 :

| Package                      | Version       |
| ---------------------------- | ------------- |
| `@solana/web3.js`            | ≥1.95         |
| `@solana/spl-token`          | ≥0.4          |
| `@coral-xyz/anchor`          | ≥0.30         |
| `@raydium-io/raydium-sdk-v2` | ≥0.2.42-alpha |

### Script minimal

```ts theme={null}
import { Connection, Keypair } from "@solana/web3.js";
import { Raydium } from "@raydium-io/raydium-sdk-v2";

const connection = new Connection("https://api.mainnet-beta.solana.com", "confirmed");
const owner      = Keypair.fromSecretKey(/* your key */);

const raydium = await Raydium.load({
  connection,
  owner,
  cluster:      "mainnet",
  disableFeatureCheck: true,
});

const poolInfo = await raydium.api.fetchPoolById({ id: "..." });
console.log(poolInfo);
```

Voir [`sdk-api/typescript-sdk`](/fr/sdk-api/typescript-sdk) pour la référence complète du SDK.

## Configuration Rust

Pour l'intégration CPI et les programmes on-chain.

### Chaîne d'outils

```bash theme={null}
rustup install 1.76.0           # ou ce qu'Anchor nécessite actuellement
rustup component add rustfmt clippy
solana-install init 1.18.22     # chaîne d'outils BPF incluse
```

### Cargo.toml de programme pour une intégration CPI Raydium

```toml theme={null}
[dependencies]
anchor-lang        = "0.30.1"
anchor-spl         = "0.30.1"
raydium-cp-swap    = { version = "0.2", features = ["cpi"] }
raydium-clmm       = { version = "0.1", features = ["cpi"] }
```

La fonctionnalité `"cpi"` importe le module `cpi` avec des assistants CPI (afin que vous puissiez faire `raydium_cp_swap::cpi::swap_base_input(...)`). Voir [`sdk-api/rust-cpi`](/fr/sdk-api/rust-cpi).

## Configuration Python

Chemin d'intégration secondaire — courant pour les développeurs de bots.

### Packages

```bash theme={null}
pip install solders solana-py anchorpy
pip install raydium-py    # SDK Raydium communautaire (non officiel)
```

Versions :

| Package      | Version |
| ------------ | ------- |
| `solders`    | ≥0.21   |
| `solana-py`  | ≥0.34   |
| `anchorpy`   | ≥0.21   |
| `raydium-py` | ≥0.2.1  |

### Script minimal

```python theme={null}
from solana.rpc.async_api import AsyncClient
from solders.keypair import Keypair
from anchorpy import Provider, Wallet, Program

async def main():
    conn = AsyncClient("https://api.mainnet-beta.solana.com")
    owner = Keypair()
    wallet = Wallet(owner)
    provider = Provider(conn, wallet)

    # Charger l'IDL et le programme
    with open("cpmm.idl.json") as f:
        idl = json.load(f)
    program = Program(idl, CPMM_PROGRAM_ID, provider)

    pool = await program.account["PoolState"].fetch(pool_id)
    print(pool)
```

Voir [`sdk-api/python-integration`](/fr/sdk-api/python-integration).

## Points de terminaison RPC

Le RPC mainnet public (`api.mainnet-beta.solana.com`) est fortement limité en débit et ralentit sous toute charge. Pour une utilisation non triviale, obtenez un point de terminaison privé :

| Fournisseur           | Notes                                             |
| --------------------- | ------------------------------------------------- |
| Helius                | Le plus populaire ; couche gratuite généreuse.    |
| Triton                | Entreprise ; prix premium, stable.                |
| QuickNode             | Solide ; latence inférieure à la seconde.         |
| Votre propre nœud RPC | Coûte \~500 \$/mois en matériel ; contrôle total. |

Configuration :

```ts theme={null}
const connection = new Connection("https://mainnet.helius-rpc.com/?api-key=...");
```

Certaines opérations RPC nécessitent des capacités étendues :

* `getProgramAccounts` — les scans non restreints sont coûteux ; certains fournisseurs les limitent ou facturent par scan.
* `getPriorityFeeEstimate` — point de terminaison spécifique à Helius ; d'autres ont des équivalents.
* `geyser` / streaming WebSocket — nécessaire pour les bots à faible latence ; pas tous les fournisseurs l'exposent.

## Devnet et localnet

### Devnet

Le cluster de test public de Solana. Raydium dispose d'un déploiement partiel sur devnet :

* Certains pools CPMM existent pour les tests.
* AMM v4 a des pools devnet historiques.
* CLMM dispose de quelques pools de démonstration.
* Farm v6 est déployé.

```bash theme={null}
solana config set --url https://api.devnet.solana.com
solana airdrop 2
```

Le SDK supporte devnet via `cluster: "devnet"` :

```ts theme={null}
const raydium = await Raydium.load({ connection, owner, cluster: "devnet" });
```

**Mise en garde** : les pools devnet ont une liquidité mince et peuvent avoir un état obsolète. Ne vous fiez pas à devnet pour la découverte des prix ; utilisez-le uniquement pour construire et tester les flux d'instructions.

### Localnet avec un état mainnet forké

Pour des tests réalistes, forcez l'état mainnet dans un validateur local :

```bash theme={null}
solana-test-validator \
  --url https://api.mainnet-beta.solana.com \
  --clone CPMMoo8L3F4NbTegBCKVNunggL7H1Zpdmwpwh8KMoZ0F \
  --clone CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK \
  --clone <SOME_POOL_ID> \
  --clone <SOME_MINT_ID>
```

Cela clone l'état spécifique du programme/compte vers localhost, où vous pouvez transactionner librement. Idéal pour :

* Tester unitairement votre intégration CPI face à un vrai programme Raydium.
* Rejouer une transaction avec un paramètre modifié pour déboguer.
* Tester la charge avec de grands volumes synthétiques.

L'équipe Raydium utilise le localnet forké de manière extensive pour les tests de régression avant le déploiement sur mainnet.

## Modèles de projet

### Démarrage intégration TypeScript

```
my-raydium-app/
├── package.json
├── tsconfig.json
├── src/
│   ├── swap.ts           # exemple swap
│   ├── add-liquidity.ts
│   └── read-pool.ts
└── .env                  # URL RPC, chemin portefeuille
```

`package.json` minimal :

```json theme={null}
{
  "name": "my-raydium-app",
  "type": "module",
  "scripts": { "swap": "tsx src/swap.ts" },
  "dependencies": {
    "@raydium-io/raydium-sdk-v2": "^0.2.42-alpha",
    "@solana/web3.js": "^1.95",
    "@solana/spl-token": "^0.4"
  },
  "devDependencies": {
    "@types/node": "^20",
    "tsx": "^4",
    "typescript": "^5"
  }
}
```

### Démarrage programme Anchor CPI

```
my-raydium-cpi/
├── Anchor.toml
├── Cargo.toml
├── programs/
│   └── my-cpi/
│       ├── Cargo.toml
│       └── src/lib.rs
└── tests/
    └── my-cpi.ts
```

Avec Anchor 0.30 :

```bash theme={null}
anchor init my-raydium-cpi
cd my-raydium-cpi
# ajouter raydium-cp-swap à Cargo.toml avec features = ["cpi"]
anchor build
anchor test
```

## Utilitaires CLI utiles

### `solana-keygen`

```bash theme={null}
solana-keygen new --outfile ./wallet.json          # générer une clé
solana-keygen pubkey ./wallet.json                 # afficher la clé publique
```

### Lire n'importe quel compte

```bash theme={null}
solana account <ADDRESS> --output json-compact
```

Utile pour examiner l'état du pool sans décodeur.

### Journaux du programme

```bash theme={null}
solana logs | grep CPMMoo8                         # suivi des journaux de transactions liées au CPMM
```

### Inspection de transaction

```bash theme={null}
solana confirm <TX_SIGNATURE> -v                   # affiche les journaux avec formatage
```

Ou via [explorer](https://explorer.solana.com) — collez la signature et regardez l'onglet « Program Logs ».

## Hygiène environnementale

### Portefeuilles séparés par finalité

* **Portefeuille de développement** : détient SOL testnet, utilisé pour la construction.
* **Portefeuille de production** : détient le vrai SOL, utilisé uniquement pour les déploiements / soumissions multisig.
* **Portefeuille actif pour les bots** : petit solde, permissions étroites.

Les clés ne doivent jamais être codées en dur. Utilisez les variables d'environnement ou les gestionnaires de secrets.

### Modèle `.env`

```
# .env (non engagé)
SOLANA_RPC_URL=https://mainnet.helius-rpc.com/?api-key=...
WALLET_PATH=/Users/you/.config/solana/id.json
```

```ts theme={null}
import { config } from "dotenv";
config();

const connection = new Connection(process.env.SOLANA_RPC_URL!);
```

### Épinglage des versions

Verrouillez toutes les dépendances de l'écosystème Solana. L'écosystème évolue rapidement ; une augmentation de version mineure de `@solana/web3.js` a précédemment introduit des changements incompatibles. Utilisez `package-lock.json` / `Cargo.lock` religieusement.

## Pointeurs

* [`sdk-api/typescript-sdk`](/fr/sdk-api/typescript-sdk) — Référence SDK TypeScript.
* [`sdk-api/rust-cpi`](/fr/sdk-api/rust-cpi) — Utilisation Rust CPI.
* [`sdk-api/python-integration`](/fr/sdk-api/python-integration) — Configuration Python.
* [`solana-fundamentals/programs-and-anchor`](/fr/solana-fundamentals/programs-and-anchor) — Contexte Anchor.

Sources :

* [Documentation installation Solana](https://docs.solana.com/cli/install-solana-cli-tools).
* [Livre Anchor : démarrage](https://book.anchor-lang.com/getting_started/installation.html).
* [Dépôt Raydium SDK v2](https://github.com/raydium-io/raydium-sdk-V2).