Toolchain

Minimum working setup for reading Raydium on-chain state, building transactions, and developing against the programs. Solana CLI, Anchor, SDKs in TypeScript and Python, and devnet/localnet tips.

Everything in this documentation assumes a working Solana development toolchain. This page lists the tools, the minimum versions known to work with Raydium as of April 2026, and the specific setup gotchas. Start here before running any of the code examples in later chapters.

Core tools

Solana CLI

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

Install:

sh -c "$(curl -sSfL https://release.solana.com/v1.18.22/install)"
# Or latest stable:
sh -c "$(curl -sSfL https://release.solana.com/stable/install)"

Verify:

solana --version   # → solana-cli 1.18.22 (or later)

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/coral-xyz/anchor avm --locked
avm install 0.30.1
avm use 0.30.1
anchor --version

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 \
  @coral-xyz/anchor \
  @raydium-io/raydium-sdk-v2 \
  bn.js \
  decimal.js

Versions known to work together as of April 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

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

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

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

Rust setup

For CPI integration and on-chain programs.

Toolchain

rustup install 1.76.0           # or whatever Anchor current requires
rustup component add rustfmt clippy
solana-install init 1.18.22     # BPF toolchain included

Program Cargo.toml for a Raydium CPI integration

[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"] }

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-py anchorpy
pip install raydium-py    # community Raydium SDK (not official)

Versions:

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

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 CPMMoo8L3F4NbTegBCKVNunggL7H1Zpdmwpwh8KMoZ0F \
  --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.42-alpha",
    "@solana/web3.js": "^1.95",
    "@solana/spl-token": "^0.4"
  },
  "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 0.30:

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 install docs.
• Anchor book: getting started.
• Raydium SDK v2 repo.