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

# Anchor IDL

> Where to find each Raydium program's IDL, how to regenerate TS / Rust / Python clients from it, and the protocol's IDL-change policy.

## What an IDL is

Anchor programs on Solana publish an **IDL** (Interface Definition Language) file describing their instructions, account layouts, error enum, and struct schemas. The IDL is the source of truth for client code generation — the TS SDK, Rust CPI crate, and third-party clients are all generated from (or hand-written against) it.

Raydium publishes IDLs for CPMM, CLMM, and LaunchLab. AMM v4, Stable AMM, and Farm (v3 / v5 / v6) predate Anchor or are otherwise not Anchor-distributed — their account structures are hand-maintained in the SDK.

## Where to find them

IDLs live in a dedicated repository:

```
https://github.com/raydium-io/raydium-idl
```

The exact files:

| Program    | IDL file                                                                                                                                                                                    |
| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| CPMM       | [`raydium_cpmm/raydium_cp_swap.json`](https://github.com/raydium-io/raydium-idl/blob/master/raydium_cpmm/raydium_cp_swap.json)                                                              |
| CLMM       | [`raydium_clmm/raydium_clmm.json`](https://github.com/raydium-io/raydium-idl/blob/master/raydium_clmm/raydium_clmm.json)                                                                    |
| LaunchLab  | [`raydium_launchpad/raydium_launchpad.json`](https://github.com/raydium-io/raydium-idl/blob/master/raydium_launchpad/raydium_launchpad.json)                                                |
| AMM v4     | no official IDL — see [`raydium-sdk-V2/src/raydium/liquidity/layout.ts`](https://github.com/raydium-io/raydium-sdk-V2/blob/master/src/raydium/liquidity/layout.ts) for hand-written layouts |
| Stable AMM | no official IDL — layouts in the SDK                                                                                                                                                        |
| Farm       | no official IDL — layouts in the SDK                                                                                                                                                        |

The IDL files are versioned in the repo's git history; pin to a specific commit if you need byte-for-byte reproducibility.

IDLs can also be pulled directly from the deployed programs via Anchor's **on-chain IDL** feature (if the program publisher opted in):

```bash theme={null}
anchor idl fetch <PROGRAM_ID> --provider.cluster mainnet
```

CPMM, CLMM, and LaunchLab all have on-chain IDLs. AMM v4, Stable AMM, and Farm do not (pre-Anchor programs).

## Regenerating a TypeScript client

Anchor's codegen produces a typed client from the IDL:

```bash theme={null}
# Using the anchor CLI
anchor build
anchor idl parse \
  --file target/idl/cpmm.json \
  --out target/types/cpmm.ts

# Or with the `@coral-xyz/anchor` TS helpers at runtime:
```

```ts theme={null}
import { Program, AnchorProvider } from "@coral-xyz/anchor";
// Pull the IDL directly from the raydium-idl repo (or vendor it into your project).
import cpmmIdl from "./idls/raydium_cp_swap.json";

const provider = new AnchorProvider(connection, wallet, {});
const program  = new Program(cpmmIdl as any, CPMM_PROGRAM_ID, provider);

// Typed method builders auto-generated:
await program.methods
  .swapBaseInput(new BN(amountIn), new BN(minAmountOut))
  .accounts({ ... })
  .rpc();
```

Most integrators do **not** do this — they use the higher-level `raydium.cpmm.swap(...)` helper which wraps the Anchor methods plus all the bookkeeping (ATA creation, transfer-fee adjustment, compute budget, Token-2022 program routing). Regenerate only when you need a layer below the SDK.

## Regenerating a Rust client (CPI crate)

Raydium publishes Anchor crates for the programs that have IDLs:

```toml theme={null}
# Cargo.toml
[dependencies]
raydium_cp_swap = { git = "https://github.com/raydium-io/raydium-cp-swap", branch = "master", features = ["cpi"] }
raydium_amm_v3 = { git = "https://github.com/raydium-io/raydium-clmm",    branch = "master", features = ["cpi"] }
```

The `cpi` feature exposes `cpi::accounts::<Ix>` account structs and `cpi::<ix>()` invokers — ready-to-use CPI wrappers. See [`sdk-api/rust-cpi`](/sdk-api/rust-cpi) for usage patterns.

If you prefer to generate fresh bindings:

```bash theme={null}
# From the IDL, using anchor-client
anchor idl parse \
  --file raydium_cpmm/raydium_cp_swap.json \
  --out src/generated/cpmm_bindings.rs
```

## Regenerating a Python client

There is no official Raydium Python SDK. Third-party generators include:

* **`anchorpy`** — Python port of `@coral-xyz/anchor`. Generates typed method builders from IDLs.
* **`solders`** — low-level Solana primitives (transactions, keypairs, pubkeys) in Rust bindings; used underneath `anchorpy`.

```bash theme={null}
pip install anchorpy solders solana
```

```python theme={null}
from anchorpy import Program, Provider
from solana.rpc.async_api import AsyncClient
from pathlib import Path
import json

idl = json.loads(Path("cpmm.json").read_text())
provider = Provider(AsyncClient("https://api.mainnet-beta.solana.com"), wallet)
program  = Program(idl, CPMM_PROGRAM_ID, provider)

await program.rpc["swap_base_input"](amount_in, min_amount_out, ctx=Context(accounts={...}))
```

See [`sdk-api/python-integration`](/sdk-api/python-integration) for a fuller walk-through.

## IDL change policy

Raydium follows these rules for IDL stability:

1. **Instruction discriminators never change.** Adding new instructions extends the enum at the end; existing discriminators remain stable.
2. **Account struct layouts evolve only additively.** New fields go at the end, preceded by a size bump in the on-chain schema. Existing fields keep their offsets.
3. **Error enum codes are append-only.** An existing error code always means the same thing.
4. **Breaking changes ship in new programs.** When a redesign is needed, the team deploys a new program ID (e.g. CPMM as a fresh program rather than upgrading AMM v4). Old pools continue to run on the old program; new pools go to the new one.

This policy makes regenerated clients backward-compatible: a client generated against a two-version-old IDL will still decode current state correctly (it sees extra trailing bytes as padding).

## What to do when the IDL changes

1. **Update the SDK.** `npm update @raydium-io/raydium-sdk-v2`.
2. **Regenerate your client code** if you use Anchor codegen directly.
3. **Diff the account layout.** The new layout's trailing fields are the only thing your code hasn't seen; confirm whether you need them.
4. **Don't assume old instruction discriminators are invalid.** Per rule 1, they still work.
5. **Re-run integration tests** against devnet before rolling to mainnet.

## IDL troubleshooting

### "Invalid discriminator" errors

Usually means a client built against version N of the IDL is trying to invoke an instruction that existed only in a pre-deploy version of the program. Re-pull the IDL from the live program:

```bash theme={null}
anchor idl fetch <PROGRAM_ID>
```

### Account decode failures

If `program.account.<Name>.fetch(pubkey)` throws with "Invalid account discriminator", the account was created by a previous program version and Anchor is rejecting its 8-byte discriminator. The fix is to use the raw layout parser from the SDK (`PoolInfoLayout.decode(accountData)`) which does not enforce Anchor discriminators.

### Missing instructions in the generated client

Anchor's TS codegen only generates methods for instructions whose IDL entry has a `name` that parses as a valid identifier. Raydium's instructions all satisfy this, but if you see a mismatch, check whether the IDL file is from the current SDK release.

## Pointers

* [`sdk-api/rust-cpi`](/sdk-api/rust-cpi) — using the Rust CPI crates.
* [`sdk-api/python-integration`](/sdk-api/python-integration) — Python via `anchorpy`.
* [`sdk-api/typescript-sdk`](/sdk-api/typescript-sdk) — the higher-level TS client.

Sources:

* [Raydium IDL repository](https://github.com/raydium-io/raydium-idl)
* [Anchor IDL spec](https://www.anchor-lang.com/docs/idl)