CLMM-Code-Demos

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 2026-09-09 gegen die 0.2.64-alpha-Quelle auf Solana mainnet-beta überprüft. Das Rust-CPI-Skelett am Ende zielt auf raydium-clmm im Branch chore/upgrade-anchor, Anchor 1.0.2, denselben Pin wie die CPMM-Seite, sodass beide in einer Crate leben können. master pinnt immer noch 0.32.1. Programm-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

Jede Demo auf dieser Seite spiegelt eine Datei in raydium-sdk-V2-demo/src/clmm wider; 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

// getClmmConfigs() gibt ApiClmmConfigInfo zurück (id ist ein String). createPool erwartet
// ClmmConfigInfo, das eine PublicKey-id plus fundOwner/description benötigt — konvertieren:
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 pro SOL
const { execute, extInfo } = await raydium.clmm.createPool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  txVersion: TxVersion.V0,   // kein `startTime` — CreateConcentratedPool hat kein solches Feld
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool:", extInfo.address.id, "tx:", txId);   // bereits ein base58-String

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 Konten observation und tick_array_bitmap_extension.
Zahlt die von ammConfig definierte Pool-Erstellungsgebühr.

Öffnen Sie eine Position in einem gewählten Bereich

Quelle: src/clmm/createPosition.ts

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

const POOL_ID = "<POOL_ID>";   // base58-String
// Hinweis: CLMMs getPoolInfoFromRpc gibt `rpcPoolInfo` zurück, nicht `rpcData` (CPMMs tut es)
const { poolInfo, poolKeys, rpcPoolInfo } = await raydium.clmm.getPoolInfoFromRpc(POOL_ID);

// Wählen Sie einen Preisbereich. Hier: ±10% des aktuellen.
const currentPrice = new Decimal(poolInfo.price);
const lowerPrice   = currentPrice.mul(0.9);
const upperPrice   = currentPrice.mul(1.1);

// Auf gültige Ticks für das tick_spacing dieses Pools ausrichten.
// Die Klasse ist TickUtil (Singular), und sie nimmt Dezimalzahlen + tickSpacing, nicht 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,
});

// Wie viel von jedem Token einzahlen.
const inputAmount = new BN(10_000_000);  // 0.01 SOL

// getLiquidityAmountOutFromAmountIn ist asynchron — warten Sie darauf.
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 geöffnet, tx:", txId);

Das SDK berechnet, welche Tick-Arrays der Bereich berührt, und übergibt sie als Konten. Es muss keine Init-Anweisung bündeln — es gibt keine Init-Tick-Array-Anweisung; OpenPosition* weist selbst ein fehlendes Tick-Array zu, auf Kosten des Zahlers.

Erhöhen Sie die Liquidität einer bestehenden Position

Quelle: src/clmm/increaseLiquidity.ts

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

// Es gibt kein getPositionInfo — zählen Sie die Positionen des Wallets auf und wählen Sie eine.
const allPositions = await raydium.clmm.getOwnerPositionInfo({
  programId: poolInfo.programId,
});
const positionAccount = allPositions.find((p) => p.nftMint.equals(positionNftMint));
if (!positionAccount) throw new Error("Position für diesen Wallet nicht gefunden");

const { execute } = await raydium.clmm.increasePositionFromBase({
  poolInfo,
  ownerPosition: positionAccount,
  ownerInfo: { useSOLBalance: true },   // erforderlich
  base: "MintA",
  baseAmount: new BN(5_000_000),
  otherAmountMax: new BN(1_000_000_000),
  txVersion: TxVersion.V0,              // kein poolKeys-Member bei diesem Aufruf
});

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,
  ownerInfo: {                       // erforderlich; closePosition lebt hier drin
    useSOLBalance: true,
    closePosition: false,
  },
  liquidity: positionAccount.liquidity.divn(2),   // halbieren
  amountMinA: new BN(0),
  amountMinB: new BN(0),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Um nur Gebühren und Rewards zu sammeln, rufen Sie decreaseLiquidity mit liquidity = new BN(0) auf. Die Nebenwirkung der Anweisung ist die Abrechnung von token_fees_owed_{0,1} und reward_amount_owed und deren Übertragung — dies ist die einzige Möglichkeit, eine davon zu sammeln. Um die Position nach dem Nullstellen der Liquidität und Gebühren vollständig zu schließen, übergeben Sie ownerInfo: { 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 Programmquellbranch 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 halten Sie die deklarierten Konten unverändert und hängen Sie den Pool an:

// CLMM-Programm: siehe reference/program-addresses; Quelle ecb1577;
// Solana mainnet-beta; zuletzt verifiziert 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 mit alten und neuen Positionen kompatibel hält.

Sammeln Sie Reward(s)

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 ist ein MULTI-Transaction-Builder: `sequentially` ist erforderlich
// und das Ergebnis ist `txIds`, nicht `txId`.
const { txIds } = await execute({ sequentially: true });

harvestAllRewards durchläuft jede Position in jedem übergebenen Pool, bündelt die Zero-Liquidity-DecreaseLiquidity-Aufrufe, die Gebühren und Rewards abrechnen (plus alle UpdateRewardInfos), und teilt sie bei Bedarf auf Transaktionen auf.

Swap

Quelle: src/clmm/swap.ts

Dies spiegelt `src/clmm/swap.ts` wider, das mit `swapInternal` statt
`PoolUtils.computeAmountOutFormat` simuliert.

```ts
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 für exakte Ausgabe
  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 },   // erforderlich
  remainingAccounts: simulation.accounts,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Die Simulation durchläuft die Tick-Map offline mit derselben Logik wie das On-Chain-Programm und gibt die Ausgabemenge (amountCalculated) plus die genaue Kontoliste zurück, die der Swap berührt (accounts). Übergeben Sie immer die remainingAccounts, die die Simulation zurückgibt: zu wenige und der Swap wird mit NotEnoughTickArrayAccount mitten im Durchlauf rückgängig gemacht; veraltete verschwenden nur Compute.

PoolUtils.computeAmountOutFormat existiert immer noch, benötigt aber eine ComputeClmmPoolInfo (die computePoolInfo aus getPoolInfoFromRpc, nicht ein API-Pool-Objekt) plus zwei weitere erforderliche Argumente — tickarrayBitmapExtension und blockTimestamp — und es gibt keine raydium.clmm.fetchTickArrays-Methode (fetchTickArrays ist eine freie Funktion; die Modul-Level- Helfer sind PoolUtils.fetchMultiplePoolTickArrays und die tickData / tickArrays von getPoolInfoFromRpc).

Erstellen Sie einen anpassbaren CLMM-Pool

createCustomizablePool ist der Einstiegspunkt, der die dynamischen Gebühren und Single-Sided-Fee-Umschalter zum Zeitpunkt der Pool-Erstellung verfügbar macht. Es nimmt die Form von createPool plus zwei 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); // Kalibrierungstier wählen

const { execute, extInfo } = await raydium.clmm.createCustomizablePool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  // Die zwei Ergänzungen:
  collectFeeOn:      CollectFeeOn.TokenOnlyB,   // FromInput | TokenOnlyA | TokenOnlyB
  dynamicFeeConfig:  new PublicKey(dynamicFeeConfig!.id),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });
console.log("Anpassbarer Pool:", extInfo.address.id);   // base58-String

Es gibt kein enableDynamicFee-Flag und keinen dynamicFeeConfigId-Parameter, und keinen startTime. Das Übergeben von dynamicFeeConfig ist das, was dynamische Gebühren aktiviert — lassen Sie es weg und Sie erhalten einen statischen Gebühren-Pool, ohne Fehler. Beachten Sie auch, dass die SDK-Enum-Member TokenOnlyA / TokenOnlyB sind, während die On-Chain-Rust-Enum sie als Token0Only / Token1Only schreibt; die numerischen Werte stimmen überein (FromInput = 0).

createPool funktioniert weiterhin für den Standard-Gebühren-, kein-dynamisches-Gebühren-Pfad. Verwenden Sie createCustomizablePool, wann immer Sie einen der beiden 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 die ATA des Eigentümers gepusht; der Eigentümer muss nicht online sein, um gefüllt zu werden.

Öffnen Sie eine Limit Order

Es gibt kein Pool-spezifisches Limit-Order-Config-Konto und keinen `getClmmLimitOrderConfigs()`-Helfer — Orders werden nach Tick verschlüsselt.

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

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

// Der Limit-Preis MUSS auf tick_spacing quantisiert sein — getOrderTick macht das.
const targetPrice = new Decimal(180);                              // SOL bei 180 USDC verkaufen
const orderData = getOrderTick({
  baseIn: true,                                                    // mintA verkaufen
  mintADecimal: poolInfo.mintA.decimals,
  mintBDecimal: poolInfo.mintB.decimals,
  tickSpacing: poolInfo.config.tickSpacing,
  price: targetPrice,
});

// Eine Verkaufsorder muss über dem aktuellen Tick sitzen; eine Kauforder darunter.
if (orderData.tick < rpcData.tickCurrent) throw new Error("Verkaufspreis muss > aktueller Preis sein");

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, standardmäßig 0
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Limit Order geöffnet:", extInfo.limitOrder.toBase58(), "tx:", txId);

Das SDK leitet die LimitOrderState-PDA aus (owner, nonce PDA, order nonce) ab, erhöht die Pro-Wallet-LimitOrderNonce und fügt die Order in die FIFO-Kohorte bei diesem Tick ein.

Erhöhen / verringern Sie eine offene Order

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 fügt dies über Increase hinzu
  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

// settleLimitOrder nimmt NUR die Order-PDA — keine poolInfo, keine poolKeys.
await raydium.clmm.settleLimitOrder({
  limitOrder,
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

settleLimitOrder liest die unfilled_ratio_x64 der Order gegen den Kohorten-Tracker, berechnet die gefüllte Ausgabe und überträgt sie an die ATA des Eigentümers. Der Eigentümer kann dies selbst aufrufen; limit_order_admin (ein Off-Chain-Betriebswächter) kann es auch im Namen des Eigentümers aufrufen — die Ausgabe geht immer noch an den Eigentümer. Zum Schließen vollständig abgerechneter Orders zur Rückgewinnung von Miete verwenden Sie closeLimitOrder (einzeln) oder closeAllLimitOrder (Batch). Zum Abrechnen vieler auf einmal packt settleAllLimitOrder so viele SettleLimitOrder-Aufrufe, wie in eine v0-Tx passen.

Auflisten der geparkten Orders eines Wallets (Off-Chain)

// API-Helfer. Siehe 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 Nutzlast zurück (totalAmount / filledAmount / pendingSettle unterscheiden die Phasen). Für die Verlaufshistorie geschlossener Orders 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

// Cargo.toml — der Branch ist wichtig: `master` pinnt immer noch anchor-lang 0.32.1.
// anchor-lang  = "=1.0.2"   // muss mit dem übereinstimmen, das raydium-clmm pinnt
// anchor-spl   = "=1.0.2"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "chore/upgrade-anchor", features = ["cpi"] }
//
// Dieselbe Anchor-Zeile wie das CPMM-Beispiel in products/cpmm/code-demos, sodass beide
// CPI-Crates Abhängigkeiten eines Programms sein können.

use anchor_lang::prelude::*;
use raydium_clmm::cpi;
use raydium_clmm::program::RaydiumClmm;
use raydium_clmm::cpi::accounts::SwapSingleV2;   // `SwapV2` ist der Anweisungsname,
                                                 // `SwapSingleV2` ist die Accounts-Struktur

#[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` trägt die tick_array- und bitmap_extension-Konten.
}

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 nimmt hier den Pubkey des Programms, nicht sein AccountInfo. Im
    // 0.32-`master`-Branch war dies `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)
}

Verbleibende Kontenreihenfolge 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 → TickAndSpacingNotMatch. Immer über TickUtil.getPriceAndTick ausrichten (Singular TickUtil).
Nicht genug Tick-Arrays in SwapV2 bereitgestellt → NotEnoughTickArrayAccount. Nehmen Sie die Liste aus swapInternal(...).accounts.
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 menschenlesbaren Preis berechnen.
Rewards zu eifrig sammeln → jede Sammlung ist ein Zero-Liquidity-DecreaseLiquidity und kostet eine Transaktion. Batch über harvestAllRewards über viele Positionen, und denken Sie daran, dass sein execute { sequentially: true } benötigt.
NFT-Konten selbst schließen → ClosePosition verbrennt das NFT und schließt sein ATA. Es schließt auch ein Token-2022-NFT-Mint; ein klassisches SPL-Token-Mint bleibt bei Angebot Null, weil 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-spaced Tick → TickAndSpacingNotMatch. Immer über den exportierten getOrderTick-Helfer quantisieren.
Aufrufen von decreaseLimitOrder bei einer vollständig gefüllten Order → InvalidOrderPhase. Verwenden Sie stattdessen settleLimitOrder dann closeLimitOrder.
Erwarten eines enableDynamicFee-Flags → es gibt keines. Das Weglassen von dynamicFeeConfig erstellt einfach einen statischen Gebühren-Pool, stillschweigend und ohne Fehler. Wenn Sie dynamische Gebühren wollten, übergeben Sie die PublicKey des Config-Kontos, ausgewählt aus /main/clmm-dynamic-config.

Wo es weitergeht

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

Auflisten der geparkten Orders eines Wallets (Off-Chain)

Rust-CPI-Skelett

Häufige Fallstricke

Wo es weitergeht

​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

​Auflisten der geparkten Orders eines Wallets (Off-Chain)

​Rust-CPI-Skelett

​Häufige Fallstricke

​Wo es weitergeht

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

Auflisten der geparkten Orders eines Wallets (Off-Chain)

Rust-CPI-Skelett

Häufige Fallstricke

Wo es weitergeht