Toolchain

Everything in this documentation assumes a working Solana development toolchain. This page lists the tools, the versions known to work with Raydium as of September 2026, and the specific setup gotchas. Start here before running any of the code examples in later chapters.Two sets of versions matter, and they are not the same. To build or fork the Raydium programs you need the exact toolchain they pin — Rust 1.91.0, Agave 3.1.10, Anchor 1.0.2 as of the 2026-09-09 upgrade. To integrate against the deployed programs from TypeScript or Python you only need a client library recent enough to talk to them, and the pins are advisory. Each section below says which case it covers.

Core tools

Solana CLI

The canonical command-line interface for interacting with Solana clusters — wallet management, RPC calls, program deployment. Install:

# The version the Raydium programs are built and tested against
sh -c "$(curl -sSfL https://release.anza.xyz/v3.1.10/install)"

# Or track a channel instead of a tag
sh -c "$(curl -sSfL https://release.anza.xyz/stable/install)"

Verify:

solana --version   # → solana-cli 3.1.10 (... client:Agave)

The install host moved. release.solana.com belonged to Solana Labs; the client is now maintained by Anza as Agave, and releases are served from release.anza.xyz. The self-update binary is agave-install (solana-install is kept as a legacy alias), so agave-install update and agave-install init <version> are the current spellings. Solana’s own docs also offer a one-command installer that pulls the CLI, Rust and Anchor together:

curl --proto '=https' --tlsv1.2 -sSfL https://solana-install.solana.workers.dev | bash

That installer tracks its own idea of current and may hand you a different Anchor than the one Raydium’s programs pin — check anchor --version afterwards.

Configure for mainnet:

solana config set --url https://api.mainnet-beta.solana.com
solana config set --keypair ~/.config/solana/id.json
solana-keygen new                           # create a wallet if you don't have one
solana address                              # your public key

For Raydium testing, you’ll almost always want a funded devnet wallet:

solana config set --url https://api.devnet.solana.com
solana airdrop 2                            # 2 SOL for testing

SPL Token CLI

The official CLI for SPL Token / Token-2022 operations — creating mints, minting tokens, transferring. Install (included with Solana CLI):

spl-token --version

Common ops:

spl-token create-token                                  # create an SPL Token mint
spl-token create-token --program-id TOKEN_2022 ...      # create a Token-2022 mint
spl-token create-account <MINT>                         # create an ATA
spl-token mint <MINT> 1000                              # mint 1000 tokens to your ATA
spl-token transfer <MINT> 100 <RECIPIENT>               # transfer 100
spl-token display <ACCOUNT_OR_MINT>                     # inspect

Anchor CLI

Needed for fetching Raydium IDLs, building clients, and verifying programs. Install:

cargo install --git https://github.com/solana-foundation/anchor avm --locked --force
avm install 1.0.2
avm use 1.0.2
anchor --version   # → anchor-cli 1.0.2

Anchor moved repository and major version. The canonical repo is now github.com/solana-foundation/anchor (it was coral-xyz/anchor), and Anchor 1.0 is the first release line the Raydium programs use — CPMM and LaunchLab both pin anchor-lang/anchor-spl =1.0.2 as of the 2026-09-09 upgrade, up from 0.32.1. avm can hold several versions; avm use 1.0.2 is what makes anchor build reproduce Raydium’s artifacts. Anchor 1.1 and 1.2 exist and build fine for your own programs, but a CPI crate compiled against a different anchor-lang minor than the one the target program pins will not link — see sdk-api/rust-cpi.

Common ops:

anchor idl fetch <PROGRAM_ID> -o program.idl.json       # fetch the on-chain IDL
anchor idl init -f idl.json <PROGRAM_ID>                # upload an IDL
anchor build                                             # build a program from source

TypeScript setup

The primary integration path for Raydium.

Packages

npm install \
  @solana/web3.js \
  @solana/spl-token \
  @anchor-lang/core \
  @raydium-io/raydium-sdk-v2 \
  bn.js \
  decimal.js

Versions known to work together as of September 2026:

Package	Version	Note
`@solana/web3.js`	`^1.95`	The 1.x API. `2.x` / `3.x` are a different, incompatible API surface; the Raydium SDK targets 1.x.
`@solana/spl-token`	`^0.4.15`	0.4.15 is what exposes `createUnwrapLamportsInstruction` — see reclaimable rent.
`@anchor-lang/core`	`^1.0` (currently resolves to `1.2.0`)	The Anchor 1.x TypeScript client. Raydium’s own repos pin exactly `1.0.2`; for client-side use any 1.x works, but pin `1.0.2` if you want to match their test suites.
`@raydium-io/raydium-sdk-v2`	`0.2.64-alpha`	The pin every code demo in these docs uses.

@coral-xyz/anchor is frozen; the package is now @anchor-lang/core. @coral-xyz/anchor stopped at 0.32.1 when Anchor moved out of Coral. Anchor 1.x publishes as @anchor-lang/core, and Raydium’s own program repositories switched their test suites to it in the 2026-09-09 upgrade. The imports you actually use are unchanged — import { Program, BN, AnchorProvider } from "@anchor-lang/core" — so migrating is a package rename plus a lockfile update.Two behavioural notes if you are moving off 0.3x: .accounts({...}) now only accepts accounts Anchor cannot resolve itself, so a builder that passes the full set should call .accountsPartial({...}) instead; and @anchor-lang/core/dist/cjs/utils/token is where helpers such as ASSOCIATED_PROGRAM_ID moved.

Minimal script

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,
});

// `ids` is a comma-separated list, and the call returns an array
const [poolInfo] = await raydium.api.fetchPoolById({ ids: "..." });
console.log(poolInfo);

See sdk-api/typescript-sdk for the full SDK reference.

Rust setup

For CPI integration and on-chain programs.

rustup install 1.91.0           # what the Raydium programs pin
rustup default 1.91.0
rustup component add rustfmt clippy
agave-install init 3.1.10       # SBF toolchain included

Build the programs with cargo build-sbf (the old cargo build-bpf spelling is gone).

Program Cargo.toml for a Raydium CPI integration

# CPMM integration (Anchor 1.0)
[dependencies]
anchor-lang     = "=1.0.2"
anchor-spl      = "=1.0.2"
raydium-cp-swap = { git = "https://github.com/raydium-io/raydium-cp-swap", branch = "chore/upgrade-anchor", features = ["cpi"] }

# CLMM integration — still Anchor 0.32, so it needs its own crate
[dependencies]
anchor-lang  = "=0.32.1"
anchor-spl   = "=0.32.1"
raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm", branch = "master", features = ["cpi"] }

Pin anchor-lang and anchor-spl with = to the version the target program pins. As of 2026-09 CPMM pins =1.0.2 and CLMM still pins =0.32.1, so a single crate cannot CPI into both — see sdk-api/rust-cpi. The "cpi" feature imports the cpi module with CPI helpers (so you can raydium_cp_swap::cpi::swap_base_input(...)). See sdk-api/rust-cpi.

Python setup

Secondary integration path — common for bot developers.

Packages

pip install solders solana anchorpy

Versions:

Package	PyPI name	Version
`solders`	`solders`	≥0.29
solana-py	`solana`	≥0.40
`anchorpy`	`anchorpy`	≥0.21

Two naming traps. The RPC client is imported as solana but the project is called solana-py — pip install solana-py installs nothing useful. And there is no raydium-py package on PyPI: the community Raydium helper is a repository you clone, AL-THE-BOT-FATHER/raydium_py, not a published distribution. Earlier revisions of this page listed a pip install raydium-py line that never worked.

Minimal script

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)

    # Load IDL and program
    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)

See sdk-api/python-integration.

RPC endpoints

Public mainnet RPC (api.mainnet-beta.solana.com) is heavily rate-limited and throttles under any load. For non-trivial usage, get a private endpoint:

Provider	Notes
Helius	Most popular; generous free tier.
Triton	Enterprise; premium pricing, stable.
QuickNode	Solid; sub-per-second latency.
Your own RPC node	Costs ~$500/mo in hardware; full control.

Configure:

const connection = new Connection("https://mainnet.helius-rpc.com/?api-key=...");

Some RPC operations need extended capabilities:

getProgramAccounts — unrestricted scans are expensive; some providers gate or charge per scan.
getPriorityFeeEstimate — Helius-specific endpoint; others have equivalents.
geyser / WebSocket streaming — needed for low-latency bots; not all providers expose it.

Devnet and localnet

Devnet

Solana’s public test cluster. Raydium has a partial devnet deployment:

Some CPMM pools exist for testing.
AMM v4 has historical devnet pools.
CLMM has a few demo pools.
Farm v6 is deployed.

solana config set --url https://api.devnet.solana.com
solana airdrop 2

The SDK supports devnet via cluster: "devnet":

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

Caveat: devnet pools have thin liquidity and may have stale state. Don’t rely on devnet for price discovery; use it for building-and-testing-instruction flows only.

Localnet with a forked mainnet state

For realistic testing, fork mainnet state into a local validator:

solana-test-validator \
  --url https://api.mainnet-beta.solana.com \
  --clone CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C \
  --clone CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK \
  --clone <SOME_POOL_ID> \
  --clone <SOME_MINT_ID>

This clones specific program/account state to localhost, where you can transact freely. Ideal for:

Unit-testing your CPI integration against a real Raydium program.
Replaying a transaction with a modified parameter to debug.
Stress-testing with large synthetic volumes.

Raydium’s team uses forked localnet extensively for regression testing prior to mainnet deployment.

Project templates

TypeScript integration starter

my-raydium-app/
├── package.json
├── tsconfig.json
├── src/
│   ├── swap.ts           # swap example
│   ├── add-liquidity.ts
│   └── read-pool.ts
└── .env                  # RPC URL, wallet path

Minimal package.json:

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

Anchor CPI program starter

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

With Anchor 1.0:

anchor init my-raydium-cpi
cd my-raydium-cpi
# add raydium-cp-swap to Cargo.toml with features = ["cpi"]
anchor build
anchor test

Useful CLI utilities

`solana-keygen`

solana-keygen new --outfile ./wallet.json          # generate a key
solana-keygen pubkey ./wallet.json                 # show public key

Reading any account

solana account <ADDRESS> --output json-compact

Useful for eyeballing pool state without a decoder.

Program logs

solana logs | grep CPMMoo8                         # tail CPMM-related tx logs

Transaction inspection

solana confirm <TX_SIGNATURE> -v                   # pretty-prints logs

Or via explorer — paste the signature and look at the “Program Logs” tab.

Environment hygiene

Separate wallets per purpose

Development wallet: holds testnet SOL, used for building.
Production wallet: holds real SOL, used only for deploys / multisig submissions.
Hot wallet for bots: small balance, narrow permissions.

Keys should never be hardcoded. Use environment variables or secret managers.

`.env` pattern

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

import { config } from "dotenv";
config();

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

Version pinning

Lock all Solana-ecosystem dependencies. The ecosystem moves fast; a minor version bump of @solana/web3.js has previously introduced breaking changes. Use package-lock.json / Cargo.lock religiously.

Pointers

sdk-api/typescript-sdk — TypeScript SDK reference.
sdk-api/rust-cpi — Rust CPI usage.
sdk-api/python-integration — Python setup.
solana-fundamentals/programs-and-anchor — Anchor background.

Sources:

Solana fundamentals

Quick start

SDK & API

Integration guides

Toolchain

Core tools

Solana CLI

SPL Token CLI

Anchor CLI

TypeScript setup

Packages

Minimal script

Rust setup

Toolchain

Program Cargo.toml for a Raydium CPI integration

Python setup

Packages

Minimal script

RPC endpoints

Devnet and localnet

Devnet

Localnet with a forked mainnet state

Project templates

TypeScript integration starter

Anchor CPI program starter

Useful CLI utilities

`solana-keygen`

Reading any account

Program logs

Transaction inspection

Environment hygiene

Separate wallets per purpose

`.env` pattern

Version pinning

Pointers

​Core tools

​Solana CLI

​SPL Token CLI

​Anchor CLI

​TypeScript setup

​Packages

​Minimal script

​Rust setup

​Toolchain

​Program Cargo.toml for a Raydium CPI integration

​Python setup

​Packages

​Minimal script

​RPC endpoints

​Devnet and localnet

​Devnet

​Localnet with a forked mainnet state

​Project templates

​TypeScript integration starter

​Anchor CPI program starter

​Useful CLI utilities

​solana-keygen

​Reading any account

​Program logs

​Transaction inspection

​Environment hygiene

​Separate wallets per purpose

​.env pattern

​Version pinning

​Pointers

Core tools

Solana CLI

SPL Token CLI

Anchor CLI

TypeScript setup

Packages

Minimal script

Rust setup

Toolchain

Program Cargo.toml for a Raydium CPI integration

Python setup

Packages

Minimal script

RPC endpoints

Devnet and localnet

Devnet

Localnet with a forked mainnet state

Project templates

TypeScript integration starter

Anchor CPI program starter

Useful CLI utilities

`solana-keygen`

Reading any account

Program logs

Transaction inspection

Environment hygiene

Separate wallets per purpose

`.env` pattern

Version pinning

Pointers