CLMM-Code-Demos

Durchgängige TypeScript-Beispiele: einen CLMM-Pool erstellen, eine Position in einer gewählten Preisspanne eröffnen, Liquidität anpassen, tauschen sowie Gebühren und Belohnungen einsammeln.

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

Englische Version ansehen →

​

Einrichtung

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

Jede Demo auf dieser Seite spiegelt eine Datei in raydium-sdk-V2-demo/src/clmm; der GitHub-Link steht neben jedem Abschnitt. Die Initialisierung folgt der Vorlage config.ts.template des Demo-Repositorys (Quelle). disableFeatureCheck: true wird für jede nicht triviale Integration empfohlen:

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;

​

Einen CLMM-Pool erstellen

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

// getClmmConfigs() returns ApiClmmConfigInfo (id is a string). createPool wants
// ClmmConfigInfo, which needs a PublicKey id plus fundOwner/description — convert:
const clmmConfigs = await raydium.api.getClmmConfigs();
const picked = clmmConfigs.find((c) => c.index === 1)!;        // 0.05% tier
const ammConfig = { ...picked, id: new PublicKey(picked.id), fundOwner: "", description: "" };

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,
  txVersion: TxVersion.V0,   // no `startTime` — CreateConcentratedPool has no such field
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool:", extInfo.address.id, "tx:", txId);   // already a base58 string

Das SDK:

• Sortiert mint1/mint2 vor der Ableitung nach Byte-Reihenfolge.
• Berechnet sqrt_price_x64 = floor(sqrt(initialPrice × 10^(dB−dA)) × 2^64).
• Legt die Konten observation und tick_array_bitmap_extension an.
• Bezahlt die Gebühr für die Poolerstellung, die durch ammConfig festgelegt ist.

​

Eine Position in einer gewählten Preisspanne eröffnen

Quelle: src/clmm/createPosition.ts

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

const POOL_ID = "<POOL_ID>";   // base58 string
// note: CLMM's getPoolInfoFromRpc returns `rpcPoolInfo`, not `rpcData` (CPMM's does)
const { poolInfo, poolKeys, rpcPoolInfo } = await raydium.clmm.getPoolInfoFromRpc(POOL_ID);

// 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.
// The class is TickUtil (singular), and it takes decimals + tickSpacing, not poolInfo.
const { tick: tickLower } = TickUtil.getPriceAndTick({
  price: lowerPrice,
  mintADecimals: poolInfo.mintA.decimals,
  mintBDecimals: poolInfo.mintB.decimals,
  zeroForOne: true,
  tickSpacing: poolInfo.config.tickSpacing,
});
const { tick: tickUpper } = TickUtil.getPriceAndTick({
  price: upperPrice,
  mintADecimals: poolInfo.mintA.decimals,
  mintBDecimals: poolInfo.mintB.decimals,
  zeroForOne: true,
  tickSpacing: poolInfo.config.tickSpacing,
});

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

// getLiquidityAmountOutFromAmountIn is async — await it.
const res = await 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, welche Tick-Arrays die Spanne berührt, und übergibt sie als Konten. Eine Init-Instruktion muss es nicht bündeln: Es gibt keine init-tick-array-Instruktion. OpenPosition* legt ein fehlendes Tick-Array selbst an, auf Kosten des Zahlers.

​

Liquidität auf einer bestehenden Position erhöhen

Quelle: src/clmm/increaseLiquidity.ts

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

// There is no getPositionInfo — enumerate the wallet's positions and pick one.
const allPositions = await raydium.clmm.getOwnerPositionInfo({
  programId: poolInfo.programId,
});
const positionAccount = allPositions.find((p) => p.nftMint.equals(positionNftMint));
if (!positionAccount) throw new Error("position not found for this wallet");

const { execute } = await raydium.clmm.increasePositionFromBase({
  poolInfo,
  ownerPosition: positionAccount,
  ownerInfo: { useSOLBalance: true },   // required
  base: "MintA",
  baseAmount: new BN(5_000_000),
  otherAmountMax: new BN(1_000_000_000),
  txVersion: TxVersion.V0,              // no poolKeys member on this call
});

await execute({ sendAndConfirm: true });

​

Liquidität verringern (und gleichzeitig Gebühren einsammeln)

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

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

await execute({ sendAndConfirm: true });

Um nur Gebühren und Belohnungen einzusammeln, rufen Sie decreaseLiquidity mit liquidity = new BN(0) auf. Die Nebenwirkung der Instruktion besteht darin, token_fees_owed_{0,1} und reward_amount_owed abzurechnen und auszuzahlen. Das ist der einzige Weg, beides einzusammeln.

Um die Position vollständig zu schließen, nachdem Liquidität und Gebühren auf null gesetzt wurden, übergeben Sie ownerInfo: { closePosition: true } beim letzten decreaseLiquidity-Aufruf. Das SDK hängt ClosePosition an und verbrennt den NFT.

Positionen mit eingeschränktem Emittenten benötigen einen kompatiblen Schließ-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 vor dem Verbrennen auftauen kann. Der Programmquellcode-Zweig enthält keine SDK-Änderung. Prüfen Sie, ob Ihre SDK-Version den Schließpfad für eingefrorene Konten ausdrücklich unterstützt, bevor Sie die Erstellung von Positionen mit eingeschränktem Emittenten aktivieren.

Für einen direkten Anchor-Client lassen 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 Schließen übergeben. CLMM liest sie nur, wenn positionNftAccount eingefroren ist. So bleibt ein Client-Pfad mit alten und neuen Positionen kompatibel.

​

Belohnung(en) einsammeln

Quelle: src/clmm/harvestAllRewards.ts

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

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

// harvestAllRewards is a MULTI-transaction builder: `sequentially` is required
// and the result is `txIds`, not `txId`.
const { txIds } = await execute({ sequentially: true });

harvestAllRewards durchläuft jede Position in jedem übergebenen Pool. Dabei bündelt es die DecreaseLiquidity-Aufrufe mit null Liquidität, die Gebühren und Belohnungen abrechnen (zusammen mit etwaigen UpdateRewardInfos), und verteilt sie bei Bedarf auf mehrere Transaktionen.

​

Swap

Quelle: src/clmm/swap.ts

Dieses Beispiel entspricht src/clmm/swap.ts. Dort wird die Simulation mit swapInternal durchgeführt und nicht mit PoolUtils.computeAmountOutFormat.

import {
  swapInternal,
  getPdaExBitmapAccount,
  TickArrayBitmapExtensionLayout,
  CLMM_PROGRAM_ID,
} from "@raydium-io/raydium-sdk-v2";

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

const poolIdPub = new PublicKey(poolInfo.id);
const { rpcData, tickArrays, configInfo } =
  await raydium.clmm.getSwapPoolInfo(poolInfo.id, zeroForOne);

const exBitmap = getPdaExBitmapAccount(CLMM_PROGRAM_ID, poolIdPub).publicKey;
const exBitmapInfo = await raydium.connection.getAccountInfo(exBitmap);

const simulation = swapInternal({
  programId: CLMM_PROGRAM_ID,
  poolId: poolIdPub,
  poolInfo: rpcData,
  tickArrays,
  configInfo,
  tickarrayBitmapExtension: TickArrayBitmapExtensionLayout.decode(exBitmapInfo!.data),
  amountSpecified: amountIn,
  sqrtPriceLimitX64: new BN(0),
  zeroForOne,
  isBaseInput: true,               // false for exact-output
  blockTimestamp: Math.floor(Date.now() / 1000),
  includeExtraTickArrays: true,
});

const { execute } = await raydium.clmm.swap({
  poolInfo,
  poolKeys,
  inputMint: poolInfo.mintA.address,
  amountIn,
  amountOutMin: simulation.amountCalculated,
  observationId: rpcData.observationId,
  ownerInfo: { useSOLBalance: true },   // required
  remainingAccounts: simulation.accounts,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Die Simulation durchläuft die Tick-Map außerhalb der Chain mit derselben Logik wie das On-Chain-Programm. Sie liefert den Ausgabebetrag (amountCalculated) sowie die genaue Kontoliste, die der Swap berühren wird (accounts).

Übergeben Sie immer die remainingAccounts, die die Simulation zurückgibt. Sind es zu wenige, bricht der Swap mitten in der Durchquerung mit NotEnoughTickArrayAccount ab. Veraltete Konten verbrauchen lediglich unnötiges Compute-Budget.

PoolUtils.computeAmountOutFormat gibt es weiterhin. Es benötigt jedoch eine ComputeClmmPoolInfo (das computePoolInfo aus getPoolInfoFromRpc, kein API-Pool-Objekt) sowie zwei weitere Pflichtargumente, tickarrayBitmapExtension und blockTimestamp. Außerdem existiert keine Methode raydium.clmm.fetchTickArrays. fetchTickArrays ist eine freie Funktion. Die modulweiten Hilfsfunktionen sind PoolUtils.fetchMultiplePoolTickArrays sowie die tickData und tickArrays, die getPoolInfoFromRpc zurückgibt.

​

Einen anpassbaren CLMM-Pool erstellen

createCustomizablePool ist der Einstiegspunkt, der beim Erstellen des Pools die Schalter für dynamische Gebühren und einseitige Gebühren bereitstellt. Er übernimmt die Struktur von createPool und ergänzt zwei Parameter:

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,
  // The two additions:
  collectFeeOn:      CollectFeeOn.TokenOnlyB,   // FromInput | TokenOnlyA | TokenOnlyB
  dynamicFeeConfig:  new PublicKey(dynamicFeeConfig!.id),
  txVersion: TxVersion.V0,
});

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

Es gibt weder einen Parameter enableDynamicFee noch dynamicFeeConfigId oder startTime. Die Angabe von dynamicFeeConfig aktiviert dynamische Gebühren. Lassen Sie den Parameter weg, erhalten Sie einen Pool mit statischen Gebühren, und zwar ohne Fehlermeldung. Beachten Sie außerdem, dass die Enum-Member im SDK TokenOnlyA / TokenOnlyB heißen, während das Rust-Enum on-chain Token0Only / Token1Only benennt. Die numerischen Werte stimmen überein (FromInput = 0).

createPool funktioniert weiterhin für den Pfad mit Standardgebühren ohne dynamische Gebühren. Verwenden Sie createCustomizablePool, sobald Sie eine der beiden Optionen benötigen. Die On-Chain-Kontoliste finden Sie unter products/clmm/instructions.

​

Limit-Orders

Eine Limit-Order hinterlegt die Eingabe des Nutzers bei genau einem Tick. Sie wird im FIFO-Verfahren ausgeführt, sobald ein Swap diesen Tick durchquert. Die Ausgaben werden beim Settlement an die ATA des Inhabers gesendet. Der Inhaber muss zum Zeitpunkt der Ausführung nicht online sein.

​

Limit-Order eröffnen

Es gibt weder ein Konfigurationskonto pro Pool für Limit-Orders noch einen Helfer getClmmLimitOrderConfigs(). Orders werden über ihren Tick identifiziert.

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

const { poolInfo, rpcData } = await raydium.clmm.getSimplePoolInfo(POOL_ID);

// Limit price MUST be quantized to tick_spacing — getOrderTick does that.
const targetPrice = new Decimal(180);                              // sell SOL at 180 USDC
const orderData = getOrderTick({
  baseIn: true,                                                    // selling mintA
  mintADecimal: poolInfo.mintA.decimals,
  mintBDecimal: poolInfo.mintB.decimals,
  tickSpacing: poolInfo.config.tickSpacing,
  price: targetPrice,
});

// A sell order must sit above the current tick; a buy order below it.
if (orderData.tick < rpcData.tickCurrent) throw new Error("sell price must be > current price");

const { execute, extInfo } = await raydium.clmm.openLimitOrder({
  poolInfo,
  baseIn: true,
  orderTick: orderData.tick,
  amount: new BN(50_000_000),                // 0.05 SOL
  tickArrayBitmap: getPdaExBitmapAccount(
    CLMM_PROGRAM_ID,
    new PublicKey(poolInfo.id),
  ).publicKey,
  // noneIndex: 0,                           // optional, defaults to 0
  txVersion: TxVersion.V0,
});

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

Der SDK leitet die PDA von LimitOrderState aus (owner, nonce PDA, order nonce) ab, erhöht die LimitOrderNonce pro Wallet und fügt die Order am jeweiligen Tick in die FIFO-Kohorte ein.

​

Offene Order erhöhen oder verringern

const limitOrder = new PublicKey("<LIMIT_ORDER_PDA>");

await raydium.clmm.increaseLimitOrder({
  poolInfo,
  limitOrder,
  amount: new BN(20_000_000),
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

await raydium.clmm.decreaseLimitOrder({
  poolInfo,
  limitOrder,
  amount: new BN(10_000_000),
  slippage: 100,                 // optional; DecreaseLimitOrder adds this over Increase
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

decreaseLimitOrder kann nur aus dem nicht ausgeführten Teil der Order entnehmen. Der ausgeführte Teil bleibt bis zum Settlement gesperrt. Beide Instruktionen brechen mit InvalidOrderPhase ab, wenn die Order bereits vollständig ausgeführt wurde.

​

Ausgeführte Order abrechnen

// settleLimitOrder takes ONLY the order PDA — no poolInfo, no poolKeys.
await raydium.clmm.settleLimitOrder({
  limitOrder,
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

settleLimitOrder liest das unfilled_ratio_x64 der Order gegen den Kohorten-Tracker aus, berechnet den ausgeführten Ertrag und überweist ihn an die ATA des Inhabers. Der Inhaber kann dies selbst aufrufen. Auch limit_order_admin (ein Off-Chain-Operations-Keeper) kann es im Namen des Inhabers tun. Die Ausgabe geht dabei trotzdem an den Inhaber.

Um vollständig abgerechnete Orders zu schließen und die Rent zurückzuholen, verwenden Sie closeLimitOrder (einzeln) oder closeAllLimitOrder (im Stapel). Um viele Orders auf einmal abzurechnen, packt settleAllLimitOrder so viele SettleLimitOrder-Aufrufe in eine v0-Transaktion, wie hineinpassen.

​

Offene Orders einer Wallet abrufen (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 liefert nicht ausgeführte und teilweise ausgeführte Orders in einer einzigen Antwort. totalAmount, filledAmount und pendingSettle unterscheiden die Phasen. Für die Historie geschlossener Orders verwenden Sie /limit-order/history/order/list-by-user?wallet=… (pro Wallet, paginiert über nextPageId). Für das vollständige Ereignisprotokoll einer bestimmten Order verwenden Sie /limit-order/history/event/list-by-pda?pda=….

​

Rust-CPI-Grundgerüst

// Cargo.toml — `master` pins anchor-lang =1.0.2.
// anchor-lang  = "=1.0.2"   // must match what raydium-clmm pins
// anchor-spl   = "=1.0.2"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "master", features = ["cpi"] }
//
// Same Anchor line as the CPMM sample in products/cpmm/code-demos, so both
// CPI crates can be dependencies of one program.

use anchor_lang::prelude::*;
use raydium_clmm::cpi;
use raydium_clmm::program::RaydiumClmm;
use raydium_clmm::cpi::accounts::SwapSingleV2;   // `SwapV2` is the instruction name,
                                                 // `SwapSingleV2` is the accounts struct

#[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, RaydiumClmm>,
    // `remaining_accounts` carries the tick_array and bitmap_extension accounts.
}

pub fn proxy_swap<'info>(
    ctx: Context<'info, ProxyClmmSwap<'info>>,
    amount: u64,
    other_amount_threshold: u64,
    sqrt_price_limit_x64: u128,
    is_base_input: bool,
) -> Result<()> {
    let cpi_accounts = SwapSingleV2 {
        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(),
    };
    // Anchor 1.0 takes the program's Pubkey here, not its AccountInfo. On the
    // 0.32 `master` branch this was `ctx.accounts.clmm_program.to_account_info()`.
    let cpi_ctx = CpiContext::new(*ctx.accounts.clmm_program.key, 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

• Ungenaue Tick-Endpunkte → TickAndSpacingNotMatch. Rasten Sie Ticks immer über TickUtil.getPriceAndTick ein (Singular TickUtil).
• Zu wenige Tick-Arrays in SwapV2 übergeben → NotEnoughTickArrayAccount. Übernehmen Sie die Liste aus swapInternal(...).accounts.
• Full-Range-Position ohne Bitmap-Erweiterung → Die PDA der Erweiterung muss beschreibbar sein. Das SDK übernimmt dies automatisch.
• Verwechslung von sqrt_price_x64 mit price → Ein Faktor-2-Fehler ist hier besonders unangenehm. Im Zweifel lassen Sie das SDK den Wert aus einem lesbaren Preis berechnen.
• Rewards zu früh einsammeln → Jedes Einsammeln ist ein DecreaseLiquidity ohne Liquidität und kostet eine Transaktion. Bündeln Sie Einsammlungen über harvestAllRewards für mehrere Positionen. Denken Sie dabei daran, dass dessen execute { sequentially: true } benötigt.
• NFT-Konten selbst schließen → ClosePosition verbrennt den NFT und schließt dessen ATA. Bei einem Token-2022-NFT-Mint wird auch dieser geschlossen. Ein klassischer SPL-Token-Mint bleibt dagegen mit Supply null bestehen, da dieses Programm Mints nicht schließen kann. Schließen Sie unterstützte Konten nicht separat, sonst bricht die Instruktion mit einem Revert ab.
• Limit-Order auf einem nicht abgestimmten Tick eröffnen → TickAndSpacingNotMatch. Quantisieren Sie Ticks immer über den exportierten Helfer getOrderTick.
• decreaseLimitOrder bei einer vollständig gefüllten Order aufrufen → InvalidOrderPhase. Verwenden Sie stattdessen settleLimitOrder und anschließend closeLimitOrder.
• Ein Flag enableDynamicFee erwarten → Es gibt kein solches Flag. Wenn Sie dynamicFeeConfig weglassen, entsteht einfach ein Pool mit statischer Gebühr, und zwar ohne Fehlermeldung. Wenn Sie dynamische Gebühren möchten, übergeben Sie den PublicKey des Konfigurationskontos, den Sie unter /main/clmm-dynamic-config auswählen.

​

Wie es weitergeht

• sdk-api/typescript-sdk – vollständige SDK-Oberfläche.
• sdk-api/rest-api – Endpunkte für Quotes und Pool-Metadaten.
• user-flows/create-clmm-pool – Anleitung ohne Code.
• integration-guides/aggregator – CLMM als Teil eines Routings einbinden.

Quellen:

• Raydium SDK v2
• Raydium SDK v2 demos
• raydium-io/raydium-clmm