CLMM-Code-Demos

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

Versionsbanner. Alle Demos zielen auf @raydium-io/raydium-sdk-v2@0.2.42-alpha gegen Solana mainnet-beta ab, verifiziert 2026-04. Program IDs stammen aus reference/program-addresses über das SDK.

Setup

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/clmm; der GitHub-Link befindet sich neben jedem Abschnitt. Das Bootstrap folgt der config.ts.template des Demo-Repos (Quelle) — disableFeatureCheck: true ist die empfohlene Einstellung für jede nicht-triviale Integration:

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",
});
export const txVersion = TxVersion.V0;

Erstellen Sie einen CLMM-Pool

Quelle: src/clmm/createPool.ts

import { PublicKey } from "@solana/web3.js";
import { CLMM_PROGRAM_ID } from "@raydium-io/raydium-sdk-v2";
import BN from "bn.js";
import Decimal from "decimal.js";

const mintA = await raydium.token.getTokenInfo(
  new PublicKey("So11111111111111111111111111111111111111112"));   // wSOL
const mintB = await raydium.token.getTokenInfo(
  new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"));   // USDC

const ammConfigs = await raydium.api.getClmmConfigs();
const ammConfig  = ammConfigs.find((c) => c.index === 1)!;        // 0.05% tier

const initialPrice = new Decimal(160);        // 160 USDC per SOL
const { execute, extInfo } = await raydium.clmm.createPool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  startTime: new BN(0),
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool:", extInfo.address.id.toBase58(), "tx:", txId);

Das SDK:

Sortiert mint1/mint2 nach Byte-Reihenfolge vor der Ableitung.
Berechnet sqrt_price_x64 = floor(sqrt(initialPrice × 10^(dB−dA)) × 2^64).
Erstellt die observation- und tick_array_bitmap_extension-Konten.
Zahlt die von ammConfig definierte Pool-Erstellungsgebühr.

Öffnen Sie eine Position in einem gewählten Bereich

Quelle: src/clmm/createPosition.ts

import { PoolUtils, TickUtils } from "@raydium-io/raydium-sdk-v2";

const poolId = new PublicKey("<POOL_ID>");
const { poolInfo, poolKeys, rpcData } = await raydium.clmm.getPoolInfoFromRpc(poolId);

// Choose a price range. Here: ±10% of current.
const currentPrice = new Decimal(poolInfo.price);
const lowerPrice   = currentPrice.mul(0.9);
const upperPrice   = currentPrice.mul(1.1);

// Snap to valid ticks for this pool's tick_spacing.
const { tick: tickLower } = TickUtils.getPriceAndTick({
  poolInfo, price: lowerPrice, baseIn: true,
});
const { tick: tickUpper } = TickUtils.getPriceAndTick({
  poolInfo, price: upperPrice, baseIn: true,
});

// How much of each token to deposit.
const inputAmount = new BN(10_000_000);  // 0.01 SOL
const inputMint   = poolInfo.mintA.address;

const res = PoolUtils.getLiquidityAmountOutFromAmountIn({
  poolInfo,
  slippage: 0.01,
  inputA: true,
  tickUpper,
  tickLower,
  amount: inputAmount,
  add: true,
  amountHasFee: true,
  epochInfo: await raydium.fetchEpochInfo(),
});

const { execute } = await raydium.clmm.openPositionFromBase({
  poolInfo,
  poolKeys,
  tickUpper,
  tickLower,
  base: "MintA",
  ownerInfo: { useSOLBalance: true },
  baseAmount: inputAmount,
  otherAmountMax: res.amountSlippageB.amount,
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Position opened, tx:", txId);

Das SDK berechnet automatisch, welche Tick-Arrays der Bereich berührt, und bündelt InitTickArray-Anweisungen, falls welche nicht initialisiert sind.

Erhöhen Sie die Liquidität einer bestehenden Position

Quelle: src/clmm/increaseLiquidity.ts

const positionNftMint = new PublicKey("<POSITION_NFT_MINT>");

const positionAccount = await raydium.clmm.getPositionInfo({
  nftMint: positionNftMint,
});

const { execute } = await raydium.clmm.increasePositionFromBase({
  poolInfo,
  poolKeys,
  ownerPosition: positionAccount,
  base: "MintA",
  baseAmount: new BN(5_000_000),
  otherAmountMax: new BN(1_000_000_000),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Verringern Sie die Liquidität (und sammeln Sie gleichzeitig Gebühren)

Quelle: src/clmm/decreaseLiquidity.ts und src/clmm/closePosition.ts

const { execute } = await raydium.clmm.decreaseLiquidity({
  poolInfo,
  poolKeys,
  ownerPosition: positionAccount,
  liquidity: positionAccount.liquidity.divn(2),   // halve
  amountMinA: new BN(0),
  amountMinB: new BN(0),
  closePosition: false,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Um nur Gebühren zu sammeln, rufen Sie decreaseLiquidity mit liquidity = new BN(0) auf. Die Nebenfolge der Anweisung ist die Abrechnung von tokens_fees_owed_{0,1} und deren Übertragung. Um die Position vollständig zu schließen, nachdem Sie die Liquidität und Gebühren auf Null gesetzt haben, übergeben Sie closePosition: true beim letzten decreaseLiquidity-Aufruf. Das SDK hängt ClosePosition an und verbrennt das NFT.

Positionen mit eingeschränktem Emittenten erfordern einen kompatiblen Close-Builder. Diese Positionen haben ein eingefrorenes NFT-Token-Konto. ClosePosition muss die Pool-ID der Position als erstes verbleibendes Konto anhängen, damit CLMM das Konto auftauen kann, bevor es das NFT verbrennt. Der Program-Source-Branch enthält keine SDK-Änderung. Bestätigen Sie, dass Ihre SDK-Version den eingefrorenen Close-Pfad explizit unterstützt, bevor Sie die Erstellung von Positionen mit eingeschränktem Emittenten aktivieren.

Für einen direkten Anchor-Client behalten Sie die deklarierten Konten unverändert und hängen den Pool an:

// CLMM program: see reference/program-addresses; source ecb1577;
// Solana mainnet-beta; last verified 2026-08-13.
await program.methods
  .closePosition()
  .accounts({
    nftOwner,
    positionNftMint,
    positionNftAccount,
    personalPosition,
    systemProgram: SystemProgram.programId,
    tokenProgram: positionNftTokenProgram,
  })
  .remainingAccounts([
    { pubkey: poolId, isWritable: false, isSigner: false },
  ])
  .rpc();

Sie können poolId bei jedem Close übergeben. CLMM liest es nur, wenn positionNftAccount eingefroren ist, was einen Client-Pfad kompatibel mit alten und neuen Positionen hält.

Sammeln Sie Reward(s)

Quelle: src/clmm/harvestAllRewards.ts

const { execute } = await raydium.clmm.harvestAllRewards({
  ownerInfo: { useSOLBalance: true },
  allPoolInfo: { [poolInfo.id]: poolInfo },
  allPositions: { [poolInfo.id]: [positionAccount] },
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

harvestAllRewards durchläuft jede Position in jedem übergebenen Pool, bündelt CollectReward-Anweisungen (und alle UpdateRewardInfos-Anweisungen) und teilt sie bei Bedarf auf mehrere Transaktionen auf.

Swap

Quelle: src/clmm/swap.ts

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

const amountIn = new BN(10_000_000);
const baseIn   = true;               // swap A (SOL) → B (USDC)
const slippage = 0.005;

const { minAmountOut, remainingAccounts, priceImpact } =
  PoolUtils.computeAmountOutFormat({
    poolInfo,
    tickArrayCache: await raydium.clmm.fetchTickArrays({ poolInfo }),
    amountIn,
    tokenOut: poolInfo.mintB,
    slippage,
    epochInfo: await raydium.fetchEpochInfo(),
  });

const { execute } = await raydium.clmm.swap({
  poolInfo,
  poolKeys,
  inputMint: new PublicKey(poolInfo.mintA.address),
  amountIn,
  amountOutMin: minAmountOut.amount,
  observationId: poolKeys.observationId,
  remainingAccounts,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

computeAmountOutFormat durchläuft die Tick-Map offline mit der gleichen Logik wie das On-Chain-Programm und gibt zurück:

die erwartete Ausgabemenge,
die Mindestausgabemenge nach Slippage,
die Liste der Tick-Array-Konten, die der tatsächliche Swap berührt (remainingAccounts).

Übergeben Sie immer die von der Simulation zurückgegebenen remainingAccounts: Wenn Sie zu wenige übergeben, wird der Swap mit TickArrayNotFound mitten im Durchlauf rückgängig gemacht; wenn Sie veraltete übergeben, verschwenden Sie Compute.

Erstellen Sie einen anpassbaren CLMM-Pool

createCustomizablePool ist der neue Einstiegspunkt, der die dynamischen Gebühren- und Single-Sided-Fee-Schalter zum Zeitpunkt der Pool-Erstellung verfügbar macht. Es hat die gleiche Form wie createPool plus drei Ergänzungen:

import { CLMM_PROGRAM_ID, CollectFeeOn } from "@raydium-io/raydium-sdk-v2";

const dynamicFeeConfigs = await raydium.api.getClmmDynamicConfigs();    // GET /main/clmm-dynamic-config
const dynamicFeeConfig  = dynamicFeeConfigs.find((c) => c.index === 0); // pick a calibration tier

const { execute, extInfo } = await raydium.clmm.createCustomizablePool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  startTime: new BN(0),
  // New fields:
  collectFeeOn:        CollectFeeOn.Token1Only,   // 0 = FromInput, 1 = Token0Only, 2 = Token1Only
  enableDynamicFee:    true,
  dynamicFeeConfigId:  dynamicFeeConfig?.id,      // omit when enableDynamicFee is false
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });
console.log("Customizable pool:", extInfo.address.id.toBase58());

createPool funktioniert weiterhin für den Standard-Gebühren-, No-Limit-Order-, No-Dynamic-Fee-Pfad. Verwenden Sie createCustomizablePool, wenn Sie einen der drei neuen Schalter benötigen. Siehe products/clmm/instructions für die On-Chain-Kontoliste.

Limit Orders

Eine Limit Order parkt Benutzereingaben bei einem einzelnen Tick und wird FIFO gefüllt, wenn ein Swap diesen Tick kreuzt. Ausgaben werden zum Zeitpunkt der Abrechnung an das ATA des Eigentümers gepusht; der Eigentümer muss nicht online sein, um gefüllt zu werden.

Öffnen Sie eine Limit Order

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

const limitConfigs = await raydium.api.getClmmLimitOrderConfigs(); // GET /main/clmm-limit-order-config
const limitConfig  = limitConfigs.find((c) => c.poolId === poolInfo.id);

// Limit price MUST be quantized to tick_spacing.
const targetPrice = new Decimal(180);                              // sell SOL at 180 USDC
const { tick: limitTick } = TickUtils.getPriceAndTick({
  poolInfo, price: targetPrice, baseIn: true,
});

const { execute } = await raydium.clmm.openLimitOrder({
  poolInfo,
  poolKeys,
  limitOrderConfig: limitConfig,
  inputMint: poolInfo.mintA.address,         // selling SOL
  inputAmount: new BN(50_000_000),           // 0.05 SOL
  tick: limitTick,
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Limit order opened, tx:", txId);

Das SDK leitet die LimitOrderState PDA von (pool, owner, tick, nonce) ab, erhöht die Pro-(Pool, Eigentümer) LimitOrderNonce und fügt die Order in die FIFO-Kohorte bei diesem Tick ein.

Erhöhen / verringern Sie eine offene Order

await raydium.clmm.increaseLimitOrder({
  poolInfo,
  poolKeys,
  limitOrderId: <LIMIT_ORDER_PUBKEY>,
  addAmount: new BN(20_000_000),
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

await raydium.clmm.decreaseLimitOrder({
  poolInfo,
  poolKeys,
  limitOrderId: <LIMIT_ORDER_PUBKEY>,
  removeAmount: new BN(10_000_000),
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

decreaseLimitOrder kann nur vom ungefüllten Teil der Order entfernen; der gefüllte Teil ist bis zur Abrechnung gesperrt. Beide Anweisungen werden mit InvalidOrderPhase rückgängig gemacht, wenn die Order bereits vollständig gefüllt wurde.

Begleichen Sie eine gefüllte Order

await raydium.clmm.settleLimitOrder({
  poolInfo,
  poolKeys,
  limitOrderId: <LIMIT_ORDER_PUBKEY>,
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

settleLimitOrder liest das unfilled_ratio_x64 der Order gegen den Kohorten-Tracker, berechnet die gefüllte Ausgabe und überträgt sie an das ATA des Eigentümers. Der Eigentümer kann dies selbst aufrufen; limit_order_admin (ein Off-Chain-Betriebskeeper) kann es auch im Namen des Eigentümers aufrufen — die Ausgabe geht immer noch an den Eigentümer. Um vollständig abgerechnete Orders zu schließen und Miete zurückzugewinnen, verwenden Sie closeLimitOrder (einzeln) oder closeAllLimitOrder (Batch). Um viele auf einmal abzurechnen, packt settleAllLimitOrder so viele SettleLimitOrder-Aufrufe wie möglich in eine v0-Tx.

Listen Sie die geparkten Orders einer Wallet auf (Off-Chain)

// API helper. See api-reference/temp-api-v1.
const active = await fetch(
  `https://temp-api-v1.raydium.io/limit-order/order/list?wallet=<your-wallet-pubkey>`,
).then((r) => r.json());

Der Endpunkt für aktive Orders gibt sowohl ungefüllte als auch teilweise gefüllte Orders in einer Payload zurück (totalAmount / filledAmount / pendingSettle unterscheiden die Phasen). Für die Closed-Order-Historie verwenden Sie /limit-order/history/order/list-by-user?wallet=… (pro Wallet, paginiert nach nextPageId); für das vollständige Ereignisprotokoll einer bestimmten Order verwenden Sie /limit-order/history/event/list-by-pda?pda=….

Rust CPI-Skelett

use anchor_lang::prelude::*;
use raydium_amm_v3::cpi;
use raydium_amm_v3::program::AmmV3;
use raydium_amm_v3::cpi::accounts::SwapV2;

#[derive(Accounts)]
pub struct ProxyClmmSwap<'info> {
    #[account(mut)]
    pub payer: Signer<'info>,
    /// CHECK:
    pub amm_config: UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub pool_state: UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub input_token_account: UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub output_token_account: UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub input_vault: UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub output_vault: UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub observation_state: UncheckedAccount<'info>,
    /// CHECK:
    pub token_program: UncheckedAccount<'info>,
    /// CHECK:
    pub token_program_2022: UncheckedAccount<'info>,
    /// CHECK:
    pub memo_program: UncheckedAccount<'info>,
    /// CHECK:
    pub input_vault_mint: UncheckedAccount<'info>,
    /// CHECK:
    pub output_vault_mint: UncheckedAccount<'info>,
    pub clmm_program: Program<'info, AmmV3>,
    // `remaining_accounts` carries the tick_array and bitmap_extension accounts.
}

pub fn proxy_swap(
    ctx: Context<ProxyClmmSwap>,
    amount: u64,
    other_amount_threshold: u64,
    sqrt_price_limit_x64: u128,
    is_base_input: bool,
) -> Result<()> {
    let cpi_accounts = SwapV2 {
        payer:                 ctx.accounts.payer.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(),
        observation_state:     ctx.accounts.observation_state.to_account_info(),
        token_program:         ctx.accounts.token_program.to_account_info(),
        token_program_2022:    ctx.accounts.token_program_2022.to_account_info(),
        memo_program:          ctx.accounts.memo_program.to_account_info(),
        input_vault_mint:      ctx.accounts.input_vault_mint.to_account_info(),
        output_vault_mint:     ctx.accounts.output_vault_mint.to_account_info(),
    };
    let cpi_ctx = CpiContext::new(ctx.accounts.clmm_program.to_account_info(), cpi_accounts)
        .with_remaining_accounts(ctx.remaining_accounts.to_vec());
    cpi::swap_v2(cpi_ctx, amount, other_amount_threshold, sqrt_price_limit_x64, is_base_input)
}

Reihenfolge der verbleibenden Konten für SwapV2:

[tick_array_bitmap_extension?, tick_array_0, tick_array_1, …]

Wenn der Swap die Erweiterung nie benötigt, lassen Sie sie weg; andernfalls ist sie das erste verbleibende Konto.

Häufige Fallstricke

Off-Spacing-Tick-Endpunkte → InvalidTickIndex. Snappen Sie immer über TickUtils.getPriceAndTick.
Nicht genug Tick-Arrays in SwapV2 bereitgestellt → TickArrayNotFound. Verwenden Sie computeAmountOutFormat, um die vollständige Liste zu erhalten.
Full-Range-Position ohne Bitmap-Erweiterung → die Erweiterungs-PDA muss beschreibbar sein; das SDK handhabt dies automatisch.
sqrt_price_x64 mit price verwechseln → eine Faktor-2-Verwirrung hier ist besonders schmerzhaft. Im Zweifelsfall lassen Sie das SDK es aus einem lesbaren Preis berechnen.
Rewards zu eifrig sammeln → jede Sammlung kostet eine Transaktion. Bündeln Sie über harvestAllRewards über viele Positionen.
NFT-Konten selbst schließen → ClosePosition verbrennt das NFT und schließt sein ATA. Es schließt auch eine Token-2022-NFT-Mint; eine klassische SPL-Token-Mint bleibt bei Angebot Null, da dieses Programm Mints nicht schließen kann. Schließen Sie unterstützte Konten nicht separat, oder die Anweisung wird rückgängig gemacht.
Öffnen einer Limit Order bei einem nicht-gespaced Tick → InvalidTickIndex. Quantisieren Sie immer über TickUtils.getPriceAndTick.
decreaseLimitOrder auf einer vollständig gefüllten Order aufrufen → InvalidOrderPhase. Verwenden Sie stattdessen settleLimitOrder dann closeLimitOrder.
dynamicFeeConfigId vergessen, während enableDynamicFee: true übergeben wird → der CreateCustomizablePool-Revert ist InvalidDynamicFeeConfigParams. Schalten Sie entweder die dynamische Gebühr aus oder wählen Sie eine Konfiguration aus /main/clmm-dynamic-config.

Wo geht es weiter

sdk-api/typescript-sdk — vollständige SDK-Oberfläche.
sdk-api/rest-api — Quote- und Pool-Metadaten-Endpunkte.
user-flows/create-clmm-pool — Nicht-Code-Anleitung.
integration-guides/aggregator — Routing CLMM als Teil eines Pfads.

Quellen:

Produkte

Algorithmen

Setup

Erstellen Sie einen CLMM-Pool

Öffnen Sie eine Position in einem gewählten Bereich

Erhöhen Sie die Liquidität einer bestehenden Position

Verringern Sie die Liquidität (und sammeln Sie gleichzeitig Gebühren)

Sammeln Sie Reward(s)

Swap

Erstellen Sie einen anpassbaren CLMM-Pool

Limit Orders

Öffnen Sie eine Limit Order

Erhöhen / verringern Sie eine offene Order

Begleichen Sie eine gefüllte Order

Listen Sie die geparkten Orders einer Wallet auf (Off-Chain)

Rust CPI-Skelett

Häufige Fallstricke

Wo geht es weiter

​Setup

​Erstellen Sie einen CLMM-Pool

​Öffnen Sie eine Position in einem gewählten Bereich

​Erhöhen Sie die Liquidität einer bestehenden Position

​Verringern Sie die Liquidität (und sammeln Sie gleichzeitig Gebühren)

​Sammeln Sie Reward(s)

​Swap

​Erstellen Sie einen anpassbaren CLMM-Pool

​Limit Orders

​Öffnen Sie eine Limit Order

​Erhöhen / verringern Sie eine offene Order

​Begleichen Sie eine gefüllte Order

​Listen Sie die geparkten Orders einer Wallet auf (Off-Chain)

​Rust CPI-Skelett

​Häufige Fallstricke

​Wo geht es weiter

Setup

Erstellen Sie einen CLMM-Pool

Öffnen Sie eine Position in einem gewählten Bereich

Erhöhen Sie die Liquidität einer bestehenden Position

Verringern Sie die Liquidität (und sammeln Sie gleichzeitig Gebühren)

Sammeln Sie Reward(s)

Swap

Erstellen Sie einen anpassbaren CLMM-Pool

Limit Orders

Öffnen Sie eine Limit Order

Erhöhen / verringern Sie eine offene Order

Begleichen Sie eine gefüllte Order

Listen Sie die geparkten Orders einer Wallet auf (Off-Chain)

Rust CPI-Skelett

Häufige Fallstricke

Wo geht es weiter