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

> Wo Sie die IDL jedes Raydium-Programms finden, wie Sie daraus TS / Rust / Python-Clients regenerieren und die IDL-Änderungsrichtlinie des Protokolls.

<Info>
  **Diese Seite wurde mit KI automatisch übersetzt. Maßgeblich ist stets die englische Version.**

  [Englische Version ansehen →](/sdk-api/anchor-idl)
</Info>

## Was eine IDL ist

Anchor-Programme auf Solana veröffentlichen eine **IDL**-Datei (Interface Definition Language), die ihre Anweisungen, Account-Layouts, Error-Enums und Struct-Schemas beschreibt. Die IDL ist die Quelle der Wahrheit für die Client-Code-Generierung — das TS SDK, die Rust-CPI-Crate und Clients von Drittanbietern werden alle aus ihr generiert (oder von Hand geschrieben).

Raydium veröffentlicht IDLs für CPMM, CLMM und LaunchLab. AMM v4, Stable AMM und Farm entstanden vor Anchor oder werden anderweitig nicht über Anchor verteilt — ihre Account-Strukturen werden manuell im SDK gepflegt.

## Wo Sie sie finden

IDLs befinden sich in einem dedizierten Repository:

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

Die genauen Dateien:

| Programm   | IDL-Datei                                                                                                                                                                                               |
| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 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     | keine offizielle IDL — siehe [`raydium-sdk-V2/src/raydium/liquidity/layout.ts`](https://github.com/raydium-io/raydium-sdk-V2/blob/master/src/raydium/liquidity/layout.ts) für manuell gepflegte Layouts |
| Stable AMM | keine offizielle IDL — Layouts sind im SDK                                                                                                                                                              |
| Farm       | keine offizielle IDL — Layouts sind im SDK                                                                                                                                                              |

Die IDL-Dateien sind in der Git-Historie des Repos versioniert; fixieren Sie auf einen bestimmten Commit, wenn Sie Byte-für-Byte-Reproduzierbarkeit benötigen.

IDLs können auch direkt von den bereitgestellten Programmen über Anchors **On-Chain-IDL**-Funktion abgerufen werden (falls der Programmveröffentlicher sich dafür entschieden hat):

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

CPMM, CLMM und LaunchLab verfügen alle über On-Chain-IDLs. AMM v4, Stable AMM und Farm nicht (Programme vor Anchor).

## TypeScript-Client regenerieren

Anchors Codegen erstellt einen typisierten Client aus der IDL:

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

# Oder mit den `@coral-xyz/anchor` TS-Helfern zur Laufzeit:
```

```ts theme={null}
import { Program, AnchorProvider } from "@coral-xyz/anchor";
// Ziehen Sie die IDL direkt aus dem raydium-idl Repo (oder integrieren Sie sie in Ihr Projekt).
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);

// Typisierte Methodenbauer werden automatisch generiert:
await program.methods
  .swapBaseInput(new BN(amountIn), new BN(minAmountOut))
  .accounts({ ... })
  .rpc();
```

Die meisten Integrator machen das **nicht** — sie verwenden stattdessen den höherstufigen `raydium.cpmm.swap(...)`-Helfer, der die Anchor-Methoden plus alle administrativen Aufgaben (ATA-Erstellung, Transfergebührenanpassung, Compute-Budget, Token-2022-Programm-Routing) kapselt. Regenerieren Sie nur, wenn Sie eine Schicht unterhalb des SDK benötigen.

## Rust-Client regenerieren (CPI-Crate)

Raydium veröffentlicht Anchor-Crates für die Programme, die IDLs haben:

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

Das `cpi`-Feature stellt `cpi::accounts::<Ix>`-Account-Structs und `cpi::<ix>()`-Aufrufer bereit — einsatzbereite CPI-Wrapper. Siehe [`sdk-api/rust-cpi`](/de/sdk-api/rust-cpi) für Verwendungsmuster.

Wenn Sie lieber neue Bindungen generieren möchten:

```bash theme={null}
# Aus der IDL mit anchor-client
anchor idl parse \
  --file raydium_cpmm/raydium_cp_swap.json \
  --out src/generated/cpmm_bindings.rs
```

## Python-Client regenerieren

Es gibt kein offizielles Raydium Python SDK. Generatoren von Drittanbietern sind:

* **`anchorpy`** — Python-Port von `@coral-xyz/anchor`. Generiert typisierte Methodenbauer aus IDLs.
* **`solders`** — Low-Level-Solana-Primitive (Transaktionen, Keypairs, Pubkeys) in Rust-Bindungen; wird unter `anchorpy` verwendet.

```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={...}))
```

Siehe [`sdk-api/python-integration`](/de/sdk-api/python-integration) für eine ausführlichere Anleitung.

## IDL-Änderungsrichtlinie

Raydium befolgt diese Regeln für IDL-Stabilität:

1. **Anweisungs-Diskriminatoren ändern sich nie.** Das Hinzufügen neuer Anweisungen erweitert das Enum am Ende; bestehende Diskriminatoren bleiben stabil.
2. **Account-Struct-Layouts entwickeln sich nur additiv.** Neue Felder kommen am Ende hin, vorher kommt eine Größenerhöhung im On-Chain-Schema. Bestehende Felder behalten ihre Offsets.
3. **Error-Enum-Codes sind nur anhängbar.** Ein bestehender Error-Code bedeutet immer dasselbe.
4. **Breaking Changes werden in neuen Programmen ausgerollt.** Wenn ein Redesign erforderlich ist, setzt das Team eine neue Programm-ID ein (z. B. CPMM als frisches Programm statt AMM v4 zu aktualisieren). Alte Pools laufen weiterhin auf dem alten Programm; neue Pools gehen zum neuen.

Diese Richtlinie macht regenerierte Clients rückwärtskompatibel: Ein Client, der gegen eine zwei Versionen alte IDL generiert wurde, kann den aktuellen Zustand immer noch korrekt dekodieren (er sieht zusätzliche nachfolgende Bytes als Padding).

## Was zu tun ist, wenn sich die IDL ändert

1. **Das SDK aktualisieren.** `npm update @raydium-io/raydium-sdk-v2`.
2. **Ihren Client-Code regenerieren**, wenn Sie Anchor Codegen direkt verwenden.
3. **Das Account-Layout vergleichen.** Die nachfolgenden Felder des neuen Layouts sind das Einzige, das Ihr Code nicht gesehen hat; überprüfen Sie, ob Sie sie benötigen.
4. **Gehen Sie nicht davon aus, dass alte Anweisungs-Diskriminatoren ungültig sind.** Gemäß Regel 1 funktionieren sie immer noch.
5. **Führen Sie Integrationstests erneut durch** auf Devnet, bevor Sie zu Mainnet wechseln.

## IDL-Fehlerbehebung

### „Invalid discriminator"-Fehler

Dies bedeutet normalerweise, dass ein Client, der gegen Version N der IDL erstellt wurde, versucht, eine Anweisung aufzurufen, die es nur in einer Version des Programms vor der Bereitstellung gab. Ziehen Sie die IDL erneut vom Live-Programm:

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

### Account-Dekodierungsfehler

Wenn `program.account.<Name>.fetch(pubkey)` mit „Invalid account discriminator" fehlschlägt, wurde das Account von einer vorherigen Programmversion erstellt und Anchor lehnt seinen 8-Byte-Diskriminator ab. Die Lösung besteht darin, den Raw-Layout-Parser aus dem SDK (`PoolInfoLayout.decode(accountData)`) zu verwenden, der keine Anchor-Diskriminatoren durchsetzt.

### Fehlende Anweisungen im generierten Client

Anchors TS Codegen generiert nur Methoden für Anweisungen, deren IDL-Eintrag einen `name` hat, der als gültiger Identifier analysiert wird. Raydiums Anweisungen erfüllen alle diese Anforderung, aber wenn Sie einen Unterschied feststellen, überprüfen Sie, ob die IDL-Datei aus der aktuellen SDK-Version stammt.

## Zeiger

* [`sdk-api/rust-cpi`](/de/sdk-api/rust-cpi) — Verwendung der Rust-CPI-Crates.
* [`sdk-api/python-integration`](/de/sdk-api/python-integration) — Python via `anchorpy`.
* [`sdk-api/typescript-sdk`](/de/sdk-api/typescript-sdk) — der höherstufige TS-Client.

Quellen:

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