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

# CPMM-Anweisungen

> Jede Anweisung im CPMM-Programm mit ihren Argumenten, Kontoliste, Vor-/Nachbedingungen und möglichen Fehlern.

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

  [Englische Version ansehen →](/products/cpmm/instructions)
</Info>

## Zusammenfassung der Anweisungen

| Discriminator-Name         | Unterzeichner                           | Funktion                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| -------------------------- | --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Initialize`               | Pool-Ersteller                          | Erstellt einen neuen CPMM-Pool aus zwei Mints und einer `AmmConfig`. Keine Genehmigung erforderlich; jeder kann aufrufen. Setzt `enable_creator_fee = false` hardcodiert auf dem neuen Pool. Das `pool_state`-Konto kann entweder die kanonische PDA oder ein frischer zufälliger Keypair sein (siehe Initialize-Konten).                                                                                                                                                                                                                                                                                                                          |
| `InitializeWithPermission` | Zahler + Inhaber einer `Permission`-PDA | Berechtigte Variante von `Initialize`. Der Aufrufer (`payer`) muss eine `Permission`-PDA besitzen, die von seinem eigenen Public Key abgeleitet ist. Wird von Plattformen verwendet, die kontrollierte Pool-Erstellung benötigen (z. B. LaunchLab-Absolventinnen). Ermöglicht dem Aufrufer, `creator_fee_on` (`BothToken` / `OnlyToken0` / `OnlyToken1`) zu setzen und erzwingt `enable_creator_fee = true` auf dem neuen Pool. Das `creator`-Feld auf `pool_state` wird auf ein separat übergebenes `creator`-Konto gesetzt, nicht auf den Zahler. Gleiche kanonische-PDA-oder-zufälliger-Keypair-Flexibilität für `pool_state` wie `Initialize`. |
| `Deposit`                  | LP                                      | Fügt Liquidität in beiden Token hinzu; erhält LP-Token.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `Withdraw`                 | LP                                      | Brennt LP-Token; erhält beide zugrunde liegenden Token anteilig.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `SwapBaseInput`            | Swapper                                 | Swap mit exaktem Input (`amount_in` rein, ≥ `minimum_amount_out` raus).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `SwapBaseOutput`           | Swapper                                 | Swap mit exaktem Output (≤ `maximum_amount_in` rein, `amount_out` raus).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `CollectProtocolFee`       | `protocol_owner` (aus `AmmConfig`)      | Sammelt aufgelaufene Protokollgebühren aus Vaults.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `CollectFundFee`           | `fund_owner` (aus `AmmConfig`)          | Sammelt aufgelaufene Fondsgebühren aus Vaults.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `CollectCreatorFee`        | `pool_creator`                          | Sammelt aufgelaufene Ersteller-Gebühren (falls aktiviert).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `UpdatePoolStatus`         | `admin`                                 | Pausiert / setzt bestimmte Pool-Operationen über eine Bitmaske fort.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `UpdateAmmConfig`          | `admin`                                 | Ändert Gebührensätze oder Protokoll-/Fondsbesitzer auf einer `AmmConfig`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `CreateAmmConfig`          | `admin`                                 | Erstellt eine neue Gebührenklasse (neues `AmmConfig`-Konto).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `CreatePermissionPda`      | `admin`                                 | Prägt eine `Permission`-PDA, die einer bestimmten Autorität ermöglicht, `InitializeWithPermission` aufzurufen.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `ClosePermissionPda`       | `admin`                                 | Widerruft eine zuvor ausgestellte `Permission`-PDA.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |

Status-Bitmaske: Der `status` jedes Pools ist ein `u8`, wobei Bit 0 = Einzahlung deaktiviert, Bit 1 = Abhebung deaktiviert, Bit 2 = Swap deaktiviert (`PoolStatusBitIndex { Deposit, Withdraw, Swap }` im Programm). Ein gelöschtes Bit bedeutet, die Operation ist erlaubt; ein gesetztes Bit bedeutet, sie ist pausiert. `UpdatePoolStatus` nimmt einen rohen `u8` und überschreibt den vorhandenen Wert.

Die nächsten Abschnitte gehen auf jede im Detail ein. Die Kontoreihenfolge folgt der CPMM-IDL; das SDK und der Rust-Client in `raydium-cp-swap/programs/cp-swap/src/instructions` entsprechen dieser Reihenfolge.

## `Initialize`

Erstellt einen neuen CPMM-Pool.

**Argumente**

```
init_amount_0: u64
init_amount_1: u64
open_time:     u64   // Unix-Zeitstempel; Swaps vor diesem abgelehnt
```

**Konten** (W = schreibbar, S = Unterzeichner)

| #  | Name                       | W | S   | Hinweise                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| -- | -------------------------- | - | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 1  | `creator`                  | W | S   | Zahlt Miete; erfasst als `pool_state.pool_creator`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 2  | `amm_config`               |   |     | Die gewählte Gebührenklasse.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 3  | `authority`                |   |     | Globale CPMM-Autoritäts-PDA.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 4  | `pool_state`               | W | S\* | Wird hier initialisiert. **Entweder** die kanonische PDA `["pool", amm_config, token_0_mint, token_1_mint]` **oder** ein frischer zufälliger Keypair — wenn nicht die kanonische PDA, verlangt das Programm, dass `pool_state` unterzeichnet (`require_eq!(pool_account_info.is_signer, true)`). Der zufällige-Keypair-Pfad ermöglicht einem Ersteller, Front-Running-Versuchen auf der kanonischen PDA auszuweichen. Die nachgelagerten PDAs (`lp_mint`, `vaults`, `observation_state`) werden in jedem Fall von `pool_state.key()` abgeleitet. |
| 5  | `token_0_mint`             |   |     | Sortiert: `token_0_mint < token_1_mint`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 6  | `token_1_mint`             |   |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 7  | `lp_mint`                  | W |     | Wird hier initialisiert. Autorität auf `authority` gesetzt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 8  | `creator_token_0`          | W |     | Quell-ATA für `init_amount_0`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 9  | `creator_token_1`          | W |     | Quell-ATA für `init_amount_1`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 10 | `creator_lp_token`         | W |     | Ziel für LP (wird erstellt, falls fehlend).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 11 | `token_0_vault`            | W |     | Wird hier initialisiert. Im Besitz von `authority`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 12 | `token_1_vault`            | W |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 13 | `create_pool_fee`          | W |     | Ziel-ATA für die `create_pool_fee`, die vom Ersteller gezahlt wird.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 14 | `observation_state`        | W |     | Wird hier initialisiert.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 15 | `token_program`            |   |     | SPL Token (für LP-Mint).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 16 | `token_0_program`          |   |     | SPL Token oder Token-2022.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 17 | `token_1_program`          |   |     | SPL Token oder Token-2022.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 18 | `associated_token_program` |   |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 19 | `system_program`           |   |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 20 | `rent`                     |   |     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |

`*` `pool_state` unterzeichnet nur auf dem zufälligen-Keypair-Pfad; der kanonische-PDA-Pfad läuft ohne `pool_state`-Unterzeichnung.

**Vorbedingungen**

* Mints sind sortiert (`token_0_mint < token_1_mint` nach Byte-Reihenfolge).
* Kein Mint verwendet eine Erweiterung außerhalb der CPMM-Zulassungsliste (`TransferFeeConfig`, `MetadataPointer`, `TokenMetadata`, `InterestBearingConfig`, `ScaledUiAmount`) — siehe [`products/cpmm/accounts`](/de/products/cpmm/accounts#vaults-and-token-2022). Eine kleine Pro-Mint-Zulassungsliste im Programm umgeht die Prüfung für Fall-für-Fall-Onboarding.
* `creator` hat mindestens `init_amount_0` und `init_amount_1` in den jeweiligen ATAs.
* `amm_config.disable_create_pool == false`.

**Nachbedingungen**

* `pool_state` existiert mit `lp_supply = sqrt(init_amount_0 * init_amount_1) − LOCKED_LP`.
* Der LP-Starter von `LOCKED_LP` (`100` Lamports LP-Token) ist dauerhaft im Pool gesperrt — `pool_state.lp_supply` erfasst `liquidity − 100`, während `100` LP-Einheiten außerhalb des Umlaufs verbleiben und verhindern, dass der Pool vollständig geleert wird und durch Null dividiert.
* `observation_state` wird initialisiert; `observation_index = 0` und `pool_id = pool_state.key()`.
* `create_pool_fee` Lamports werden vom Ersteller zum Empfänger übertragen und als natives SOL synchronisiert (es ist eine wSOL-ATA).
* Die Status-Bitmaske des Pools ist `0` (Einzahlung / Abhebung / Swap alle aktiviert).
* `enable_creator_fee = false` und `creator_fee_on = BothToken`. `Initialize` unterstützt **nicht** die Aktivierung der Ersteller-Gebühr — dieser Pfad ist `InitializeWithPermission`.
* `open_time` wird auf `block_timestamp + 1` erhöht, wenn der Aufrufer einen Wert `<= block_timestamp` weitergegeben hat. Swaps werden vor `open_time` abgelehnt; Einzahlungen und Abhebungen funktionieren sofort.

**Häufige Fehler** (vollständige Liste in [`reference/error-codes`](/de/reference/error-codes))

* `InvalidInput` — Mints unsortiert oder identisch.
* `NotSupportMint` — blockierte Token-2022-Erweiterung.
* `ExceededSlippage` — selten; wenn `init_amount_0/1` aufgrund von Dezimalstellen-Abweichung zu null LP führt.

## `Deposit`

Fügt Liquidität in beiden Token anteilig zum Pool hinzu.

**Argumente**

```
lp_token_amount:   u64   // wie viele LP-Token für die LP geprägt werden sollen
maximum_token_0:   u64
maximum_token_1:   u64
```

**Konten**

| #  | Name                 | W | S |
| -- | -------------------- | - | - |
| 1  | `owner`              |   | S |
| 2  | `authority`          |   |   |
| 3  | `pool_state`         | W |   |
| 4  | `owner_lp_token`     | W |   |
| 5  | `token_0_account`    | W |   |
| 6  | `token_1_account`    | W |   |
| 7  | `token_0_vault`      | W |   |
| 8  | `token_1_vault`      | W |   |
| 9  | `token_program`      |   |   |
| 10 | `token_program_2022` |   |   |
| 11 | `vault_0_mint`       |   |   |
| 12 | `vault_1_mint`       |   |   |
| 13 | `lp_mint`            | W |   |

**Mathematik**

```
needed_token_0 = ceil(lp_token_amount * vault_0 / lp_supply)
needed_token_1 = ceil(lp_token_amount * vault_1 / lp_supply)
require(needed_token_0 <= maximum_token_0, "ExceededSlippage")
require(needed_token_1 <= maximum_token_1, "ExceededSlippage")
```

Keine Änderung an der Proportionalität von `k` — sowohl Vaults als auch `lp_supply` skalieren um denselben Faktor.

**Nachbedingungen**

* `lp_supply += lp_token_amount`.
* `vault_0 += needed_token_0` (netto der Token-2022-Transfergebühr für Input, falls vorhanden).
* `vault_1 += needed_token_1` (netto der Token-2022-Transfergebühr für Input, falls vorhanden).

**Häufige Fehler** — `ExceededSlippage`, `ZeroTradingTokens`, `InvalidStatus`, falls Einzahlung pausiert ist.

## `Withdraw`

Brennt LP-Token und empfängt beide zugrunde liegenden Token anteilig.

**Argumente**

```
lp_token_amount:   u64
minimum_token_0:   u64
minimum_token_1:   u64
```

**Konten**

| #  | Name                 | W | S |
| -- | -------------------- | - | - |
| 1  | `owner`              |   | S |
| 2  | `authority`          |   |   |
| 3  | `pool_state`         | W |   |
| 4  | `owner_lp_token`     | W |   |
| 5  | `token_0_account`    | W |   |
| 6  | `token_1_account`    | W |   |
| 7  | `token_0_vault`      | W |   |
| 8  | `token_1_vault`      | W |   |
| 9  | `token_program`      |   |   |
| 10 | `token_program_2022` |   |   |
| 11 | `vault_0_mint`       |   |   |
| 12 | `vault_1_mint`       |   |   |
| 13 | `lp_mint`            | W |   |

(Identisch mit `Deposit`; `lp_mint` ist schreibbar, da die LP-Token gebrannt werden.)

**Mathematik**

```
out_token_0 = floor(lp_token_amount * vault_0 / lp_supply)
out_token_1 = floor(lp_token_amount * vault_1 / lp_supply)
require(out_token_0 >= minimum_token_0, "ExceededSlippage")
require(out_token_1 >= minimum_token_1, "ExceededSlippage")
```

**Nachbedingungen**

* `lp_supply -= lp_token_amount`.
* Vaults senden `out_token_0` / `out_token_1` (brutto; der Benutzer erhält netto der Token-2022-Transfergebühr, falls vorhanden).

## `SwapBaseInput`

Swap mit exaktem Input.

**Argumente**

```
amount_in:            u64
minimum_amount_out:   u64
```

**Konten**

| #  | Name                   | W | S |
| -- | ---------------------- | - | - |
| 1  | `payer`                |   | S |
| 2  | `authority`            |   |   |
| 3  | `amm_config`           |   |   |
| 4  | `pool_state`           | W |   |
| 5  | `input_token_account`  | W |   |
| 6  | `output_token_account` | W |   |
| 7  | `input_vault`          | W |   |
| 8  | `output_vault`         | W |   |
| 9  | `input_token_program`  |   |   |
| 10 | `output_token_program` |   |   |
| 11 | `input_token_mint`     |   |   |
| 12 | `output_token_mint`    |   |   |
| 13 | `observation_state`    | W |   |

Die Reihenfolge **Input → Output** folgt der Richtung des Benutzers, nicht der kanonischen `token_0 / token_1` des Pools. Das Programm bestimmt, welcher Vault welcher ist, durch Abgleich der Mints.

**Mathematik** — siehe [`products/cpmm/math`](/de/products/cpmm/math).

**Vorbedingungen**

* `open_time <= now`.
* `pool_status` erlaubt Swap.
* Kein Mint pausiert oder eingefroren für diese Autorität.
* `amount_in > 0`.

**Häufige Fehler**

* `ExceededSlippage` — `amount_out < minimum_amount_out`.
* `ZeroTradingTokens` — der Handel rundet auf Null.
* `NotApproved` — Pool ist pausiert für Swaps via `UpdatePoolStatus`.
* `InvalidInput` — Mints stimmen mit keinem der Pool-Vault-Mints überein.

## `SwapBaseOutput`

Swap mit exaktem Output.

**Argumente**

```
max_amount_in:  u64
amount_out:     u64
```

**Konten** — gleich wie `SwapBaseInput`.

**Mathematik** — umgekehrte Kurve mit Obergrenze, siehe [`products/cpmm/math`](/de/products/cpmm/math).

**Häufige Fehler** — `ExceededSlippage` (`gross_in > max_amount_in`), `ZeroTradingTokens`, `InvalidInput`, `NotApproved`.

## `CollectProtocolFee`

Sammelt aufgelaufene Protokollgebühren aus den Vaults zum Protokoll-Ziel.

**Argumente** — keine.

**Konten**

| #  | Name                        | W | S |                                               |
| -- | --------------------------- | - | - | --------------------------------------------- |
| 1  | `owner`                     |   | S | Muss `amm_config.protocol_owner` entsprechen. |
| 2  | `authority`                 |   |   |                                               |
| 3  | `pool_state`                | W |   |                                               |
| 4  | `amm_config`                |   |   |                                               |
| 5  | `token_0_vault`             | W |   |                                               |
| 6  | `token_1_vault`             | W |   |                                               |
| 7  | `vault_0_mint`              |   |   |                                               |
| 8  | `vault_1_mint`              |   |   |                                               |
| 9  | `recipient_token_0_account` | W |   |                                               |
| 10 | `recipient_token_1_account` | W |   |                                               |
| 11 | `token_program`             |   |   |                                               |
| 12 | `token_program_2022`        |   |   |                                               |

**Effekt**

```
transfer pool_state.protocol_fees_token0 from vault_0 to recipient_0
transfer pool_state.protocol_fees_token1 from vault_1 to recipient_1
pool_state.protocol_fees_token0 = 0
pool_state.protocol_fees_token1 = 0
```

Keine Änderung an den effektiven Bilanzen der Kurve (aufgelaufene Gebühren waren bereits ausgeschlossen).

**Häufiger Fehler** — `NotApproved`, falls Unterzeichner nicht `protocol_owner` ist.

## `CollectFundFee`

Gleiche Form wie `CollectProtocolFee`, aber unterzeichnet von `fund_owner` und setzt die `fund_fees_*`-Zähler auf Null.

## `CollectCreatorFee`

Gleiche Form nochmals, unterzeichnet von `pool_state.pool_creator`. Emittiert Transfers nur, wenn der Pool mit einem Ersteller-Gebührensatz ungleich Null initialisiert wurde.

## `UpdatePoolStatus`

Pausiert oder setzt einzelne Operationen auf einem Pool fort. Das `status`-Feld ist eine Bitmaske:

| Bit | Flag                | Effekt, wenn gesetzt                          |
| --- | ------------------- | --------------------------------------------- |
| 0   | `DEPOSIT_DISABLED`  | `Deposit` lehnt mit `NotApproved` ab.         |
| 1   | `WITHDRAW_DISABLED` | `Withdraw` lehnt ab.                          |
| 2   | `SWAP_DISABLED`     | `SwapBaseInput` / `SwapBaseOutput` lehnen ab. |

**Argumente**

```
status: u8      // neue Bitmaske
```

**Konten**

| # | Name         | W | S |                                                        |
| - | ------------ | - | - | ------------------------------------------------------ |
| 1 | `authority`  |   | S | Muss dem Admin-Schlüssel im CPMM-Programm entsprechen. |
| 2 | `pool_state` | W |   |                                                        |

Der Admin-Schlüssel ist die Upgrade-Autorität im CPMM-Programm — in der Praxis das Raydium-Multisig. Siehe [`security/admin-and-multisig`](/de/security/admin-and-multisig).

## `CreateAmmConfig`

Erstellt eine neue Gebührenklasse.

**Argumente**

```
index:             u16
trade_fee_rate:    u64
protocol_fee_rate: u64
fund_fee_rate:     u64
create_pool_fee:   u64
```

**Konten**

| # | Name             | W | S |                          |
| - | ---------------- | - | - | ------------------------ |
| 1 | `owner`          | W | S | Admin.                   |
| 2 | `amm_config`     | W |   | Wird hier initialisiert. |
| 3 | `system_program` |   |   |                          |

**Vorbedingungen**

* Keine existierende `AmmConfig` mit demselben `index`.
* `protocol_fee_rate + fund_fee_rate <= FEE_RATE_DENOMINATOR_VALUE`.

## `UpdateAmmConfig`

Ändert Gebührensätze oder Eigentümerschaft auf einer existierenden `AmmConfig`. Nimmt einen `param: u8` (Diskriminator für das zu aktualisierende Feld) und einen `value: u64`. Die Wert-Semantik pro Param sind in der Quelle; häufig:

* `param = 0` → `trade_fee_rate`
* `param = 1` → `protocol_fee_rate`
* `param = 2` → `fund_fee_rate`
* `param = 3` → `new_protocol_owner` (übergeben Sie `Pubkey`-Bytes als Reinterpretation)
* `param = 4` → `new_fund_owner`
* `param = 5` → `create_pool_fee`
* `param = 6` → `disable_create_pool`

Änderungen werden vom Admin unterzeichnet und beeinflussen **jeden Pool, der an diese `AmmConfig` gebunden ist,** beim nächsten Swap. Keine Migration; Pools lesen einfach die neuen Werte.

## Zustandsänderungs-Matrix

| Anweisung                  | `lp_supply` | Vault-Bilanzen             | Aufgelaufene-Gebühren-Felder                                                  | `observation`                   |
| -------------------------- | ----------- | -------------------------- | ----------------------------------------------------------------------------- | ------------------------------- |
| `Initialize`               | + init LP   | + `init_amount_{0,1}`      | 0                                                                             | init                            |
| `InitializeWithPermission` | + init LP   | + `init_amount_{0,1}`      | 0                                                                             | init                            |
| `Deposit`                  | +           | + beide                    | —                                                                             | —                               |
| `Withdraw`                 | −           | − beide                    | —                                                                             | —                               |
| `SwapBaseInput`            | —           | + in, − out                | + `trade_fee` aufgeteilt in Protokoll/Fonds; + `creator_fee`, falls aktiviert | + (falls Intervall verstrichen) |
| `SwapBaseOutput`           | —           | + in, − out                | + `trade_fee` aufgeteilt in Protokoll/Fonds; + `creator_fee`, falls aktiviert | + (falls Intervall verstrichen) |
| `CollectProtocolFee`       | —           | − (nach Protokoll-Buckets) | `protocol_*` → 0                                                              | —                               |
| `CollectFundFee`           | —           | − (nach Fonds-Buckets)     | `fund_*` → 0                                                                  | —                               |
| `CollectCreatorFee`        | —           | − (nach Ersteller-Buckets) | `creator_*` → 0                                                               | —                               |
| `UpdatePoolStatus`         | —           | —                          | —                                                                             | —                               |

## Weitere Ressourcen

* [`products/cpmm/code-demos`](/de/products/cpmm/code-demos) — ausführbare TypeScript-Beispiele für das Obige.
* [`reference/error-codes`](/de/reference/error-codes) — die vollständige Anchor-Fehler-Tabelle.
* [`products/cpmm/fees`](/de/products/cpmm/fees) — das Gebühren-Auflösungs-Modell, das `CollectProtocolFee` / `CollectFundFee` / `CollectCreatorFee` leert.

Quellen:

* [`raydium-io/raydium-cp-swap` — instructions](https://github.com/raydium-io/raydium-cp-swap/tree/master/programs/cp-swap/src/instructions)
* [Raydium SDK v2 — `@raydium-io/raydium-sdk-v2`](https://github.com/raydium-io/raydium-sdk-V2)