CPMM-Code-Demos

End-to-End-TypeScript-Beispiele für jeden CPMM-Vorgang — Pool erstellen, Swap, Einzahlung, Auszahlung, Gebühren einziehen — plus ein minimales Rust-CPI-Skelett.

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

Englische Version ansehen →

Versionsbanner. Alle TypeScript-Demos zielen auf @raydium-io/raydium-sdk-v2@0.2.64-alpha ab; sie wurden zuletzt gegen 0.2.42-alpha (2026-04) ausgeführt und ihre Aufrufsignaturen wurden am 09.09.2026 gegen die 0.2.64-alpha-Quelle überprüft, gegen Solana mainnet-beta. Das Rust-CPI-Skelett zielt auf raydium-cp-swap auf master, Anchor 1.0.2. Programm-IDs werden über Konstanten aus reference/program-addresses abgerufen.

​

Voraussetzungen

npm install @raydium-io/raydium-sdk-v2 @solana/web3.js @solana/spl-token bn.js decimal.js

Jedes Demo auf dieser Seite spiegelt eine Datei in raydium-sdk-V2-demo/src/cpmm; der GitHub-Link befindet sich neben jedem Abschnitt. Das Bootstrap folgt der config.ts.template des Demo-Repos (Quelle):

import { Connection, Keypair, clusterApiUrl } from "@solana/web3.js";
import { Raydium, TxVersion } from "@raydium-io/raydium-sdk-v2";
import fs from "node:fs";

const connection = new Connection(process.env.RPC_URL ?? clusterApiUrl("mainnet-beta"));
const owner = Keypair.fromSecretKey(
  new Uint8Array(JSON.parse(fs.readFileSync(process.env.KEYPAIR!, "utf8"))),
);

const raydium = await Raydium.load({
  owner,
  connection,
  cluster: "mainnet",
  disableFeatureCheck: true,
  blockhashCommitment: "finalized",
});

Die Raydium-Instanz ist die Fassade des SDK — jedes Demo unten nutzt sie. Raydium.load ist asynchron, da es standardmäßig die Token-Liste lädt; übergeben Sie disableLoadToken: true, um diesen Abruf zu überspringen. Die Verfügbarkeitsprüfung ist bereits übersprungen, es sei denn, Sie übergeben disableFeatureCheck: false. Fee-Konfigurationen werden beim ersten Gebrauch über raydium.api.getCpmmConfigs() lazy geladen.

​

CPMM-Pool erstellen

Quelle: src/cpmm/createCpmmPool.ts

import { PublicKey } from "@solana/web3.js";
import BN from "bn.js";
import { CREATE_CPMM_POOL_PROGRAM, CREATE_CPMM_POOL_FEE_ACC }
  from "@raydium-io/raydium-sdk-v2";
// (Wenn Sie alle Pool-PDAs auf einmal benötigen, ist der exportierte Helper `getCreatePoolKeys`.
//  Es gibt kein `getCpmmPdas`.)

const mintA = new PublicKey("So11111111111111111111111111111111111111112"); // wSOL
const mintB = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"); // USDC

// 1. Wählen Sie eine Fee-Konfiguration. index=0 ist die 0,25%-Stufe.
const feeConfigs = await raydium.api.getCpmmConfigs();
const feeConfig  = feeConfigs.find((c) => c.index === 0)!;

// 2. Rufen Sie Mint-Metadaten ab, damit das SDK Token-2022-Erweiterungen verarbeiten kann.
const mintAInfo = await raydium.token.getTokenInfo(mintA);
const mintBInfo = await raydium.token.getTokenInfo(mintB);

// 3. Erstellen Sie die Transaktion.
const { execute, extInfo } = await raydium.cpmm.createPool({
  programId:       CREATE_CPMM_POOL_PROGRAM,
  poolFeeAccount:  CREATE_CPMM_POOL_FEE_ACC,
  mintA:           mintAInfo,
  mintB:           mintBInfo,
  mintAAmount:     new BN(1_000_000_000),   // 1 SOL (angenommen 9 Dezimalstellen)
  mintBAmount:     new BN(   160_000_000),  // 160 USDC (bei 160/SOL)
  startTime:       new BN(0),               // sofort öffnen
  feeConfig,
  associatedOnly:  false,
  ownerInfo:       { useSOLBalance: true },
  txVersion:       TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool erstellt bei", extInfo.address.poolId.toBase58());
console.log("Tx:", txId);

Ein paar Dinge, die das SDK stillschweigend übernimmt:

• Sortieren der Mints in token0/token1-Reihenfolge vor der PDA-Ableitung.
• Zahlen der einmaligen create_pool_fee an poolFeeAccount.
• Erstellen der zugehörigen Token-Konten des Aufrufers, falls fehlend.
• Auswahl des richtigen Token-Programms (SPL Token vs. Token-2022) pro Seite.

Nach der Bestätigung können Sie den Live-Pool-Status abrufen mit:

// getPoolInfoFromRpc nimmt einen positionalen base58-String, keine PublicKey und kein Objekt.
const { poolKeys, poolInfo, rpcData } = await raydium.cpmm.getPoolInfoFromRpc(
  extInfo.address.poolId.toBase58(),
);

​

Swap (Basis-Input)

Quelle: src/cpmm/swap.ts

import { CurveCalculator, FeeOn } from "@raydium-io/raydium-sdk-v2";

const POOL_ID = "<POOL_ID>";   // base58-String

// 1. Laden Sie den aktuellen Pool-Status direkt von einem RPC (nicht von der API).
const { poolInfo, poolKeys, rpcData } = await raydium.cpmm.getPoolInfoFromRpc(POOL_ID);

const inputMint  = poolInfo.mintA.address;                // Swap A → B
const amountIn   = new BN(100_000_000);                   // 0,1 SOL
const slippage   = 0.005;                                 // 0,5%

// 2. Zitieren Sie lokal. CurveCalculator spiegelt die On-Chain-Mathematik wider, einschließlich
//    Token-2022-Transfergebühren auf beiden Seiten. Alle acht Argumente sind erforderlich.
const baseIn = inputMint === poolInfo.mintA.address;
const swapResult = CurveCalculator.swapBaseInput(
  amountIn,
  baseIn ? rpcData.baseReserve : rpcData.quoteReserve,
  baseIn ? rpcData.quoteReserve : rpcData.baseReserve,
  rpcData.configInfo!.tradeFeeRate,
  rpcData.configInfo!.creatorFeeRate,
  rpcData.configInfo!.protocolFeeRate,
  rpcData.configInfo!.fundFeeRate,
  rpcData.feeOn === FeeOn.BothToken || rpcData.feeOn === FeeOn.OnlyTokenB,
);
// swapResult-Felder sind inputAmount / outputAmount / tradeFee / protocolFee /
// fundFee / creatorFee / newInputVaultAmount / newOutputVaultAmount.
// Es gibt kein destinationAmountSwapped oder sourceAmountSwapped.

// 3. Erstellen und senden. Das Übergeben von `slippage` hier ist das, was die Grenze anwendet —
//    keine manuelle Minimum-Out-Arithmetik ist erforderlich.
const { execute } = await raydium.cpmm.swap({
  poolInfo,
  poolKeys,
  inputAmount: amountIn,
  swapResult,
  slippage,
  baseIn,
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Swap-Tx:", txId);

Hinweis: Das SDK ruft den Pool-Status immer von einem RPC innerhalb von getPoolInfoFromRpc ab. Zitieren Sie nicht von api-v3.raydium.io für eine Transaktion, die Sie gerade signieren werden — ein Zitat, das einen Block alt ist, kann beim Landen in ExceededSlippage rutschen.

​

Swap (Basis-Output)

Quelle: src/cpmm/swapBaseOut.ts

const amountOutWanted = new BN(15_000_000);        // 15 USDC
const slippage        = 0.005;

const baseIn = false; // false → mintB ist die Input-Seite
const swapResult = CurveCalculator.swapBaseOutput(
  amountOutWanted,
  baseIn ? rpcData.baseReserve : rpcData.quoteReserve,
  baseIn ? rpcData.quoteReserve : rpcData.baseReserve,
  rpcData.configInfo!.tradeFeeRate,
  rpcData.configInfo!.creatorFeeRate,
  rpcData.configInfo!.protocolFeeRate,
  rpcData.configInfo!.fundFeeRate,
  rpcData.feeOn === FeeOn.BothToken || rpcData.feeOn === FeeOn.OnlyTokenB,
);
// swapResult.inputAmount ist die erforderliche Eingabe; es gibt kein sourceAmountSwapped.

const { execute } = await raydium.cpmm.swap({
  poolInfo,
  poolKeys,
  inputAmount: new BN(0),   // ungenutzt bei fixedOut — der Betrag kommt von swapResult
  fixedOut:    true,
  swapResult,               // erforderlich, und es trägt den Zielausgabebetrag
  baseIn,
  slippage,
  txVersion:   TxVersion.V0,
});

await execute({ sendAndConfirm: true });

​

Liquidität einzahlen

Quelle: src/cpmm/deposit.ts

import { Percent } from "@raydium-io/raydium-sdk-v2";
import Decimal from "decimal.js";

// addLiquidity wird durch einen INPUT-Betrag angetrieben, nicht durch einen LP-Betrag.
const uiInputAmount = "0.0001";
const inputAmount = new BN(
  new Decimal(uiInputAmount).mul(10 ** poolInfo.mintA.decimals).toFixed(0),
);
const slippage = new Percent(1, 100);   // ein Percent, keine Zahl

const { execute } = await raydium.cpmm.addLiquidity({
  poolInfo,
  poolKeys,
  inputAmount,
  baseIn: true,           // inputAmount ist in mintA denominiert
  slippage,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Das SDK leitet den gepaarten Betrag aus den aktuellen Reserven des Pools ab, erhöht jede Seite um den Slippage für die maximum_*-Argumente der Anweisung und erstellt die ATA-Erstellungen bei Bedarf. raydium.cpmm.computePairAmount({ ... }) gibt die gleichen Zahlen zurück, wenn Sie diese für eine UI-Vorschau möchten.

​

Liquidität abheben

Quelle: src/cpmm/withdraw.ts

import { Percent } from "@raydium-io/raydium-sdk-v2";

const lpAmount = new BN(100_000);           // LP zum Verbrennen
const slippage = new Percent(1, 100);       // ein Percent, keine Zahl

const { execute } = await raydium.cpmm.withdrawLiquidity({
  poolInfo,
  poolKeys,
  lpAmount,
  slippage,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

​

Protokoll-/Fonds-/Creator-Gebühren einziehen

Quelle: src/cpmm/collectCreatorFee.ts, src/cpmm/collectAllCreatorFee.ts

Protokoll- und Fondseinzug bleiben an Autorisierung gebunden. Creator-Gebühren haben zwei Pfade: das von der Creator signierte CollectCreatorFee und das additive CollectCreatorFeePermissionless, das jeder Zahler aufrufen kann, aber nur an die kanonischen ATAs des Creators überweisen kann. 0.2.64-alpha liefert Builder auf Modulebene für beide Creator-Pfade:

// creator-signed
const { execute } = await raydium.cpmm.collectCreatorFees({
  poolInfo,
  poolKeys,
  txVersion: TxVersion.V0,
});

// permissionless — jeder Zahler; Erlöse gehen an die kanonischen ATAs des Creators
const { execute } = await raydium.cpmm.collectCreatorFeesPermissionless({
  poolInfo,
  poolKeys,
  txVersion: TxVersion.V0,
});

// mehrere Pools auf einmal, creator-signed
await raydium.cpmm.collectMultiCreatorFees({ poolInfoList, txVersion: TxVersion.V0 });

Beide Creator-Instruktionen haben ihre Kontolisten im Programm-Upgrade vom 2026-09-19 geändert. Jede nimmt nun eine creator_fee_share PDA unter ["creator_fee_share", creator, ammConfig] auf, und die permissionless-Variante nimmt auch amm_config — beide nach system_program angehängt statt eingefügt, sodass die bereits vorhandenen Konten ihre Positionen behalten. Ein Builder, der an eine SDK-Version vor dem Upgrade gebunden ist, gibt die kürzere Liste aus und die Transaktion wird wegen fehlender Konten abgelehnt. Überprüfen Sie, dass die installierte Version die neuen Konten enthält, bevor Sie diese Helfer gegen das aktualisierte Programm verwenden, und aktualisieren Sie die IDL, wenn Sie Clients daraus generieren.

Das Übergeben der PDA ist obligatorisch, auch wenn sie noch nie erstellt wurde — leiten Sie sie ab und übergeben Sie sie; das Programm fällt auf AmmConfig.creator_fee_share_rate zurück, wenn das Konto leer ist.

Die beiden Creator-Instruktionen haben unterschiedliche Diskriminatoren und Kontolayouts — die permissionless-Variante ersetzt den Creator-Signer durch einen separaten payer und einen nicht signierenden creator. Verwenden Sie den passenden Builder, statt Konten der anderen Instruktion manuell auszutauschen.

Es gibt keinen Protokoll- oder Fonds-Gebühren-Builder im SDK (makeCollectProtocolFeeInstruction und makeCollectFundFeeInstruction existieren unter keinem Namen) — das sind Admin-Pfade, ebenso wie CreateCreatorFeeShare / CloseCreatorFeeShare, die auch keinen Builder haben. Die Low-Level-Instruktions-Builder, die es gibt, sind collectCpFeeInstruction, makeCollectCreatorFeeInstruction und collectCreatorFeePermissionlessInInstruction.

Off-Chain können Sie aufgelaufene Gebühren direkt aus PoolState auslesen:

const pool = await raydium.cpmm.getRpcPoolInfo(POOL_ID);   // base58 string
console.log("Accrued protocol fee mintA:", pool.protocolFeesMintA.toString());
console.log("Accrued protocol fee mintB:", pool.protocolFeesMintB.toString());
// Die CpmmPoolInfoLayout-Felder sind protocolFeesMintA/B, fundFeesMintA/B und
// creatorFeesMintA/B — es gibt keine ...Token0/...Token1 Felder.
//
// creatorFeesMintA/B ist die *Brutto*-Abgrenzung. Der Creator erhält sie abzüglich des
// Protokoll-Anteils, der zum Zeitpunkt der Einziehung aufgelöst wird; protocolFeesMintA/B erhält diesen
// Anteil, wächst also auch bei Creator-Gebühren-Einziehungen, nicht nur bei Swaps.
// Siehe products/cpmm/fees#protocol-share-of-the-creator-fee.

​

Rust-CPI-Skelett

Wenn Sie CPMM aus Ihrem eigenen Anchor-Programm aufrufen möchten — beispielsweise ein Vault, das im Namen seiner Einzahler swapped — sieht der CPI-Kontext so aus. Die Kontoordnung folgt products/cpmm/instructions.

// Cargo.toml — `master` pinnt anchor-lang =1.0.2.
// raydium-cp-swap = { git = "https://github.com/raydium-io/raydium-cp-swap",
//                     branch = "master", features = ["cpi"] }
// anchor-lang      = "=1.0.2"   // muss mit dem von raydium-cp-swap gepinnten übereinstimmen
// anchor-spl       = "=1.0.2"
//
// Das `cpi` Feature ist erforderlich — das `raydium_cp_swap::cpi` Modul existiert nur
// unter ihm. Das CLMM-Beispiel in products/clmm/code-demos pinnt das gleiche
// =1.0.2 auf seinem eigenen `master`, sodass die beiden ein Programm teilen können.

use anchor_lang::prelude::*;
use anchor_spl::token_interface::{TokenAccount, TokenInterface, Mint};
use raydium_cp_swap::cpi::accounts::Swap;
use raydium_cp_swap::cpi;
use raydium_cp_swap::program::RaydiumCpSwap;

#[derive(Accounts)]
pub struct ProxySwap<'info> {
    #[account(mut)]
    pub payer: Signer<'info>,

    /// CHECK: validated by the CPMM program
    pub authority:     UncheckedAccount<'info>,
    /// CHECK:
    pub amm_config:    UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub pool_state:    UncheckedAccount<'info>,

    #[account(mut)]
    pub input_token_account:  InterfaceAccount<'info, TokenAccount>,
    #[account(mut)]
    pub output_token_account: InterfaceAccount<'info, TokenAccount>,

    #[account(mut)]
    pub input_vault:  InterfaceAccount<'info, TokenAccount>,
    #[account(mut)]
    pub output_vault: InterfaceAccount<'info, TokenAccount>,

    pub input_token_program:  Interface<'info, TokenInterface>,
    pub output_token_program: Interface<'info, TokenInterface>,

    pub input_token_mint:  InterfaceAccount<'info, Mint>,
    pub output_token_mint: InterfaceAccount<'info, Mint>,

    #[account(mut)]
    /// CHECK: ring buffer
    pub observation_state: UncheckedAccount<'info>,

    pub cpmm_program: Program<'info, RaydiumCpSwap>,
}

pub fn proxy_swap_base_input(
    ctx: Context<ProxySwap>,
    amount_in: u64,
    minimum_amount_out: u64,
) -> Result<()> {
    let cpi_accounts = Swap {
        payer:                ctx.accounts.payer.to_account_info(),
        authority:            ctx.accounts.authority.to_account_info(),
        amm_config:           ctx.accounts.amm_config.to_account_info(),
        pool_state:           ctx.accounts.pool_state.to_account_info(),
        input_token_account:  ctx.accounts.input_token_account.to_account_info(),
        output_token_account: ctx.accounts.output_token_account.to_account_info(),
        input_vault:          ctx.accounts.input_vault.to_account_info(),
        output_vault:         ctx.accounts.output_vault.to_account_info(),
        input_token_program:  ctx.accounts.input_token_program.to_account_info(),
        output_token_program: ctx.accounts.output_token_program.to_account_info(),
        input_token_mint:     ctx.accounts.input_token_mint.to_account_info(),
        output_token_mint:    ctx.accounts.output_token_mint.to_account_info(),
        observation_state:    ctx.accounts.observation_state.to_account_info(),
    };
    // Anchor 1.0 nimmt hier den Pubkey des Programms, nicht sein AccountInfo.
    let cpi_ctx = CpiContext::new(
        *ctx.accounts.cpmm_program.key,
        cpi_accounts,
    );
    cpi::swap_base_input(cpi_ctx, amount_in, minimum_amount_out)
}

Wenn Ihr CPI als PDA signiert (z. B. verwalten Sie einen Vault im Namen von Einzahlern), ersetzen Sie CpiContext::new durch CpiContext::new_with_signer und übergeben Sie Ihre Seeds.

​

Häufige Fallstricke

Eine kurze Checkliste, bevor Sie ein Support-Ticket öffnen:

• Sortierte Mints. Wenn Ihre abgeleitete poolState PDA nicht mit dem On-Chain-Pool übereinstimmt, haben Sie wahrscheinlich vergessen, die Mints zu sortieren.
• Veraltetes API-Angebot. Übergeben Sie niemals einen Reserve-Wert von api-v3.raydium.io an CurveCalculator.swap. Rufen Sie von einem RPC ab.
• Falsches Token-Programm. Der Vault eines Token-2022-Mints wird vom Token-2022-Programm verwaltet, nicht vom SPL Token. Verwenden Sie immer die Felder token_0_program / token_1_program des Pools.
• Slippage unter-denominiert für Transfer-Fee-Mints. Wenn eine Seite des Pools ein Token-2022-Transfer-Fee-Mint ist, muss Ihr minimum_amount_out in dem denominiert sein, was der Benutzer tatsächlich erhält, nicht in dem, was der Vault sendet.
• NotApproved bei einem Swap. Überprüfen Sie PoolState.status — der Admin hat möglicherweise Swaps auf diesem Pool pausiert. Siehe products/cpmm/instructions für die Status-Bitmaske.

​

Nächste Schritte

• sdk-api/typescript-sdk — vollständige SDK-Referenz.
• sdk-api/rest-api — Quote- und Pool-Metadaten-Endpunkte.
• user-flows/create-cpmm-pool — die Code-freie Anleitung zum gleichen Ablauf.
• integration-guides/aggregator — wenn Sie CPMM als Teil eines Multi-Hop-Pfads routen.

Quellen:

• Raydium SDK v2 — @raydium-io/raydium-sdk-v2
• Raydium SDK v2 Demos — raydium-sdk-v2-demo
• raydium-io/raydium-cp-swap