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

# Programme und Anchor

> Wie Solana-Programme bereitgestellt und aktualisiert werden, welche Funktionen das Anchor-Framework bietet und wie Sie Raydium's IDL lesen, um eigene Clients zu generieren.

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

  [Englische Version ansehen →](/solana-fundamentals/programs-and-anchor)
</Info>

<Info>
  Raydium's neuere Programme (CPMM, CLMM, Farm v6, LaunchLab) sind in **Anchor** geschrieben — ein Rust-Framework, das auf Solana's nativen Programmmodell aufbaut und Kontenvalidierung, Fehlerbehandlung und ein IDL (Interface-Beschreibung) bietet. AMM v4 und ältere Farms entstanden vor Anchor. Das Verständnis beider Paradigmen hilft Ihnen, den Code zu lesen, Clients aus der IDL zu generieren und unerwartete Fehler zu debuggen.
</Info>

## Bereitstellungsmodell für Programme

Jedes Solana-Programm existiert unter einer `Pubkey`. Der Bytecode des Programmes wird in einem **ausführbaren** Konto gespeichert, das vom **BPF Upgradeable Loader** (`BPFLoaderUpgradeab1e11111111111111111111111`) gehört.

Eine Programmbereitstellung besteht aus drei Konten:

1. **Programmkonto**: kleines Metadatenkonto unter der Programm-ID. Besitzer: BPF Upgradeable Loader.
2. **ProgramData-Konto**: enthält den eigentlichen Bytecode. Abgeleitet als `[program_id, "programdata"]`.
3. **Buffer-Konto** (transient): enthält neuen Bytecode während eines Upgrades. Nach dem Upgrade verworfen.

Das ProgramData-Konto hat eine **Upgrade-Berechtigung** — einen Schlüssel, der den Bytecode durch eine neue Version ersetzen kann. Raydium's Upgrade-Berechtigung ist ein Multisig hinter einer 24-Stunden-Zeitsperre; siehe [`security/admin-and-multisig`](/de/security/admin-and-multisig).

### Überprüfung eines bereitgestellten Programmes

Um zu bestätigen, dass das On-Chain-Programm dem audit-genehmigten Source entspricht:

```bash theme={null}
# Programm von Mainnet exportieren
solana program dump CPMMoo8L3F4NbTegBCKVNunggL7H1Zpdmwpwh8KMoZ0F cpmm-onchain.so

# Aus bekanntem Source bauen
cargo build-bpf --manifest-path raydium-cp-swap/programs/cp-amm/Cargo.toml
cp target/deploy/raydium_cp_swap.so cpmm-source.so

# Vergleichen
sha256sum cpmm-onchain.so cpmm-source.so
```

Übereinstimmende Hashes beweisen, dass Sie mit dem erwarteten Source interagieren. Raydium veröffentlicht Verified-Build-Anweisungen in den Release Notes.

## Anchor: ein Framework auf Solana

Raw-Solana-Programme sind Rust-Funktionen mit dieser Signatur:

```rust theme={null}
pub fn process_instruction(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    instruction_data: &[u8],
) -> ProgramResult {
    // Manuelles Parsen von instruction_data
    // Manuelle Kontenvalidierung
    // Manuelle Deserialisierung von Kontodaten
    // Manuelle Überprüfung von Signer/Writable-Flags
    // ... dann die eigentliche Arbeit
}
```

Anchor verpackt den ganzen Boilerplate und lässt Sie schreiben:

```rust theme={null}
#[program]
pub mod cpmm {
    use super::*;

    pub fn swap_base_input(
        ctx: Context<Swap>,
        amount_in: u64,
        min_out: u64,
    ) -> Result<()> {
        // Nur die Business-Logik — ctx ist bereits validiert
    }
}

#[derive(Accounts)]
pub struct Swap<'info> {
    pub payer: Signer<'info>,
    #[account(mut, seeds = [b"pool", config.key().as_ref(), ...], bump)]
    pub pool_state: AccountLoader<'info, PoolState>,
    #[account(mut)]
    pub input_vault: Box<Account<'info, TokenAccount>>,
    // ... weitere Konten
}
```

Anchor:

* Generiert automatisch einen deterministischen 8-Byte-**Diskriminator** für jede Instruktion und jeden Kontotyp.
* Validiert Kontobeschränkungen (Besitzer, Seeds, Writable, Signer, Mint-Übereinstimmung, Token-Programm-Übereinstimmung), bevor Ihr Code ausgeführt wird.
* Generiert ein **IDL** — eine Interface-Beschreibungsdatei, die Clients verwenden, um das Programm aufzurufen.
* Wird mit Rust-, TypeScript- und Python-Bibliotheken für die Client-Seite ausgeliefert.

### Der 8-Byte-Diskriminator

Jedes Anchor-Konto und jede Anchor-Instruktion beginnt mit einem 8-Byte-Diskriminator — den ersten 8 Bytes des SHA-256-Hashs eines festen Strings:

```
Kontodiskriminator:       sha256("account:PoolState")[0..8]
Instruktionsdiskriminator: sha256("global:swap_base_input")[0..8]
```

Wenn Sie eine Anchor-Instruktion aufrufen, sind die ersten 8 Bytes der Instruktionsdaten dieser Diskriminator; Anchor leitet zur richtigen Behandlung weiter, indem die Bytes nachgeschlagen werden.

Wenn Sie ein Anchor-Konto lesen, teilen die ersten 8 Bytes seinen Typ mit — entscheidend für Tools wie `getProgramAccounts`, die alle Konten eines Typs aufzählen.

### Fehler

Anchor-Programme definieren Fehler über `#[error_code]`:

```rust theme={null}
#[error_code]
pub enum ErrorCode {
    #[msg("Slippage tolerance exceeded")]
    SlippageExceeded,
    #[msg("Pool is disabled")]
    PoolDisabled,
    // ...
}
```

Anchor weist diesen numerischen Codes automatisch ab 6000 (0x1770) zu. Raydium's vollständige Fehlercodes-Tabelle befindet sich in [`reference/error-codes`](/de/reference/error-codes).

## Die IDL

Eine Anchor-**IDL** (Interface Description Language) Datei ist eine JSON-Beschreibung eines Programmes: seine Instruktionen, Konten, Typen, Fehler und Events. Sie ist das Äquivalent eines Ethereum ABI.

Raydium veröffentlicht IDLs für alle Anchor-Programme. Abrufen live von On-Chain:

```bash theme={null}
anchor idl fetch CPMMoo8L3F4NbTegBCKVNunggL7H1Zpdmwpwh8KMoZ0F -o cpmm.idl.json
```

Oder aus dem SDK-Source: `src/raydium/*/idl/*.json`.

### IDL-Struktur

```json theme={null}
{
  "version":      "0.1.0",
  "name":         "raydium_cp_swap",
  "instructions": [ { "name": "swap_base_input", "accounts": [ ... ], "args": [ ... ] }, ... ],
  "accounts":     [ { "name": "PoolState", "type": { ... } }, ... ],
  "types":        [ { "name": "AmmConfig", "type": { ... } }, ... ],
  "errors":       [ { "code": 6000, "name": "SlippageExceeded", "msg": "..." }, ... ],
  "events":       [ { "name": "SwapEvent", "fields": [ ... ] }, ... ]
}
```

### Generieren eines Clients aus der IDL

Die Anchor `anchor` CLI generiert TypeScript- und Rust-Typen:

```bash theme={null}
anchor idl build -o target/idl/cpmm.json
# TypeScript-Typen automatisch von Anchor's ts-client generiert
# Raydium SDK enthält diese bereits
```

Tools von Drittanbietern wie [Kinobi](https://github.com/metaplex-foundation/kinobi) können Clients in Rust, Python, C oder Go aus einer IDL generieren.

### Wenn die IDL Ihr Freund ist

Wenn Sie eine benutzerdefinierte Integration erstellen möchten, die nicht durch Raydium SDK läuft:

1. Rufen Sie die IDL ab (live von On-Chain oder aus dem SDK-Source).
2. Suchen Sie die Instruktion auf, die Sie möchten (z. B. `swap_base_input`).
3. Konstruieren Sie die Instruktionsdaten: 8-Byte-Diskriminator + kodierte Argumente.
4. Übergeben Sie Konten in der Reihenfolge, die die IDL angibt.

Siehe [`sdk-api/anchor-idl`](/de/sdk-api/anchor-idl) für durchgearbeitete Beispiele.

## Pre-Anchor-Programme: AMM v4 und Farm v3/v5

Diese Programme entstanden vor Anchor. Sie verwenden:

* **Manuelle Instruktionsverteilung**: ein `u8`-Tag in `instruction_data` mit einer `match`-Anweisung.
* **Manuelle Kontenvalidierung**: `if accounts[0].owner != &expected_program { ... }`.
* **Borsh-serialisierte Instruktionsargumente**: kein Diskriminator, nur `instruction_data[1..]`.
* **Layout über `#[repr(C, packed)]`**: C-Struktur-Binärlayout.

Raydium SDK v2 wird mit TypeScript-Layouts für die Non-Anchor-AMM-v4-Instruktionen ausgeliefert, damit Clients ohne Anchor kodieren/dekodieren können:

```ts theme={null}
import { liquidityStateV4Layout, swapInstructionData }
  from "@raydium-io/raydium-sdk-v2";

const data = swapInstructionData.encode({
  instruction: 9,   // swap
  amountIn:    1_000_000n,
  minAmountOut: 950_000n,
});
```

Das Integrationsmuster ist dasselbe — Sie erhalten einfach nicht Anchor's IDL-gesteuerte Auto-Generierung.

## Programmaktualisierungsmechanik

Nur die `upgrade_authority` des ProgramData kann aktualisiert werden. Schritte:

1. Kompilieren Sie den neuen Bytecode.
2. Schreiben Sie ihn in ein Buffer-Konto (`solana program write-buffer`).
3. Reichen Sie eine Upgrade-Instruktion ein: `BpfLoaderUpgradeable::Upgrade { buffer, program, authority }`.
4. Die Runtime ersetzt den Bytecode des Programmes atomar durch den Inhalt des Buffers.

Raydium schränkt dies mit einer **24-Stunden-Zeitsperre** ein, die in den Einstellungen des Squads-Multisigs implementiert ist. Eine Upgrade-Transaktion muss 24 Stunden nach der Multisig-Genehmigung warten, bevor sie ausgeführt werden kann. Dies schützt vor übereilten/erzwungenen Upgrades.

Siehe [`security/admin-and-multisig`](/de/security/admin-and-multisig).

### Ein Programm unveränderbar machen

Eine Upgrade-Berechtigung kann auf `None` gesetzt werden. Danach wird das Programm permanent unveränderbar. Raydium hat dies für kein Produkt getan — das Team behält die Fähigkeit, Sicherheitspatches bereitzustellen. Kompromiss: Benutzer müssen dem Multisig + Zeitsperre-Prozess vertrauen.

## Programme und Miete

Die Bereitstellung eines Programmes verbraucht mietfreie Lamports:

* Ein 50-KB-Programm: \~0,35 SOL Miete.
* Ein 200-KB-Programm: \~1,4 SOL Miete.

Das Schließen eines Programmes (über `solana program close`) gibt die Lamports zurück. Raydium-Programme bleiben aktiv und sind nicht zum Schließen geplant.

## Debugging von Anchor-Programmen

### Log-Ausgabe

Das `msg!` Makro von Anchor schreibt in das Transaktionslog. Simulieren Sie eine Transaktion, um Logs zu sehen:

```ts theme={null}
const sim = await connection.simulateTransaction(tx);
console.log(sim.value.logs);
```

Logs beinhalten:

* Programmaufruf (`Program CPMMoo8... invoke [1]`).
* `msg!`-Aufrufe aus Programmcode.
* Compute-Unit-Verbrauch (`consumed 137842 of 400000 compute units`).
* Programmerfolg oder Fehler.

### Fehlercodes

Wenn ein Anchor-Programm fehlschlägt, zeigt das Log:

```
Program CPMMoo8... failed: custom program error: 0x1770
```

0x1770 = 6000 dezimal = der erste Anchor-Fehler (z. B. `SlippageExceeded`). Kreuzen Sie mit dem Array `errors` der IDL ab.

Siehe [`reference/error-codes`](/de/reference/error-codes) für Raydium's vollständige Fehlertabelle.

### Konto-Layout-Mismatch

Wenn Sie das falsche Konto in den falschen Slot übergeben, geben Anchor's Kontenvalidierungs-Makros Fehler wie folgt zurück:

```
AnchorError: AccountNotInitialized. Error Number: 3012
```

Fehlernummern unter 6000 sind Anchor's integrierte Fehler (siehe Anchor's `ErrorCode`-Enum); Fehler ≥6000 sind die benutzerdefinierten Codes des Programmes.

## Zeiger

* [`solana-fundamentals/account-model`](/de/solana-fundamentals/account-model) — wie Programme Konten besitzen.
* [`solana-fundamentals/pdas-and-cpis`](/de/solana-fundamentals/pdas-and-cpis) — PDAs wie Anchor sie deklariert.
* [`sdk-api/anchor-idl`](/de/sdk-api/anchor-idl) — Abrufen und Verwenden von Raydium's IDLs.
* [`reference/program-addresses`](/de/reference/program-addresses) — Programm-IDs.
* [`reference/error-codes`](/de/reference/error-codes) — Fehlercode-Referenz.
* [`security/admin-and-multisig`](/de/security/admin-and-multisig) — Upgrade-Berechtigungskontrollen.

Quellen:

* [Anchor book](https://book.anchor-lang.com).
* [Solana program deployment](https://docs.solana.com/cli/deploy-a-program).
* Raydium IDLs (veröffentlicht in SDK `src/raydium/*/idl/*.json`).