CLMM kod örnekleri

Uçtan uca TypeScript örnekleri: bir CLMM havuzu oluşturun, seçtiğiniz fiyat aralığında pozisyon açın, likiditeyi ayarlayın, swap yapın ve işlem ücretlerini ile ödülleri toplayın.

Bu sayfa yapay zekâ tarafından otomatik olarak çevrilmiştir. İngilizce sürüm esas alınır.

İngilizce sürümü görüntüle →

​

Kurulum

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

Bu sayfadaki her örnek, raydium-sdk-V2-demo/src/clmm içindeki bir dosyaya karşılık gelir; ilgili GitHub bağlantısı her bölümün yanında yer alır. Başlangıç yapılandırması, demo deposundaki config.ts.template dosyasını takip eder (kaynak). Karmaşık bir entegrasyonda disableFeatureCheck: true ayarını kullanmanızı öneririz:

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;

​

CLMM havuzu oluşturma

Kaynak: 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

SDK şunları yapar:

• Türetme işleminden önce mint1/mint2 değerlerini bayt sırasına göre sıralar.
• sqrt_price_x64 = floor(sqrt(initialPrice × 10^(dB−dA)) × 2^64) değerini hesaplar.
• observation ve tick_array_bitmap_extension hesaplarını oluşturur.
• ammConfig ile tanımlanan havuz oluşturma ücretini öder.

​

Seçilen aralıkta pozisyon açma

Kaynak: 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);

SDK, aralığın dokunduğu tick dizilerini hesaplar ve bunları hesap olarak iletir. Ayrı bir init talimatı eklemeniz gerekmez; init-tick-array talimatı yoktur. OpenPosition* eksik bir tick dizisini kendisi oluşturur ve masrafını ödeyen cüzdan öder.

​

Mevcut bir pozisyonda likiditeyi artırma

Kaynak: 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 });

​

Likiditeyi azaltma (ve aynı anda ücretleri toplama)

Kaynak: src/clmm/decreaseLiquidity.ts ve 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 });

Yalnızca işlem ücretlerini ve ödülleri toplamak için decreaseLiquidity çağrısını liquidity = new BN(0) ile yapın. Talimatın yan etkisi, token_fees_owed_{0,1} ve reward_amount_owed alanlarını kapatıp bu tutarları dışarı aktarmaktır. İkisini de toplamanın tek yolu budur.

Likiditeyi ve ücretleri sıfırladıktan sonra pozisyonu tamamen kapatmak için son decreaseLiquidity çağrısında ownerInfo: { closePosition: true } değerini geçirin. SDK, ClosePosition talimatını ekler ve NFT’yi yakar.

Kısıtlı ihraççı pozisyonları uyumlu bir kapatma oluşturucusu gerektirir. Bu pozisyonların dondurulmuş bir NFT token hesabı vardır. CLMM hesabı yakmadan önce çözebilsin diye ClosePosition, pozisyonun havuz kimliğini ilk kalan hesap olarak eklemelidir. Program kaynak dalında bir SDK değişikliği yer almaz. Kısıtlı ihraççı pozisyonu oluşturmayı etkinleştirmeden önce SDK sürümünüzün dondurulmuş kapatma yolunu açıkça desteklediğini doğrulayın.

Doğrudan bir Anchor istemcisi kullanıyorsanız bildirilen hesapları olduğu gibi bırakın ve havuzu ekleyin:

// 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();

Her kapatma işleminde poolId değerini geçebilirsiniz. CLMM bu değeri yalnızca positionNftAccount donmuşsa okur. Böylece tek bir istemci yolu hem eski hem yeni pozisyonlarla uyumlu kalır.

​

Ödül(ler)i toplama

Kaynak: 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, geçirilen her havuzdaki her pozisyonu gezer. İşlem ücretlerini ve ödülleri kapatan sıfır likiditeli DecreaseLiquidity çağrılarını (ve varsa UpdateRewardInfos talimatlarını) gruplandırır. Gerektiğinde bunları birden fazla işleme böler.

​

Swap

Kaynak: src/clmm/swap.ts

Bu örnek, PoolUtils.computeAmountOutFormat yerine swapInternal ile simülasyon yapan src/clmm/swap.ts dosyasını yansıtır.

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 });

Simülasyon, tick haritasını zincir dışında on-chain programla aynı mantıkla gezer ve çıkan miktarı (amountCalculated) ile swap’ın dokunacağı tam hesap listesini (accounts) döndürür.

Simülasyonun döndürdüğü remainingAccounts değerlerini her zaman iletin: eksik olursa swap, yol boyunca NotEnoughTickArrayAccount hatasıyla geri döner; fazla veya eski hesaplar ise yalnızca gereksiz hesaplama maliyeti yaratır.

PoolUtils.computeAmountOutFormat hâlâ mevcuttur, ancak bir ComputeClmmPoolInfo nesnesi (getPoolInfoFromRpc fonksiyonunun döndürdüğü computePoolInfo, API pool nesnesi değil) ve iki ek zorunlu argüman — tickarrayBitmapExtension ve blockTimestamp — gerektirir. Ayrıca raydium.clmm.fetchTickArrays adında bir metot yoktur (fetchTickArrays bağımsız bir fonksiyondur; modül düzeyindeki yardımcılar PoolUtils.fetchMultiplePoolTickArrays ile getPoolInfoFromRpc tarafından döndürülen tickData ve tickArrays değerleridir).

​

Özelleştirilebilir bir CLMM havuzu oluşturma

createCustomizablePool, havuz oluşturma anında dinamik ücret ve tek taraflı ücret anahtarlarını sunan giriş noktasıdır. createPool ile aynı yapıyı kullanır, ancak buna iki ek parametre eklenir:

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); // bir kalibrasyon kademesi seçin

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

await execute({ sendAndConfirm: true });
console.log("Özelleştirilebilir havuz:", extInfo.address.id);   // base58 dizgisi

enableDynamicFee, dynamicFeeConfigId ve startTime parametreleri yoktur. Dinamik ücretleri etkinleştiren şey dynamicFeeConfig parametresinin verilmesidir — bu parametreyi atlarsanız hata almadan sabit ücretli bir havuz oluşturursunuz. Ayrıca SDK enum üyeleri TokenOnlyA / TokenOnlyB olarak adlandırılırken, on-chain Rust enum’ı bunları Token0Only / Token1Only olarak yazar; sayısal değerler eşleşir (FromInput = 0).

Varsayılan ücretli ve dinamik ücret kullanmayan yol için createPool çalışmaya devam eder. Bu iki ayardan birine ihtiyacınız olduğunda createCustomizablePool kullanın. Zincir üstü hesap listesi için products/clmm/instructions sayfasına bakın.

​

Limit emirleri

Limit emri, kullanıcının girdisini tek bir tick’te bekletir ve bir swap o tick’i geçtiğinde FIFO sırasıyla gerçekleştirilir. Çıktılar, uzlaşma (settle) anında sahibinin ATA hesabına gönderilir; emrin doldurulması için sahibinin çevrimiçi olması gerekmez.

​

Limit emri açma

Havuz başına bir limit emri yapılandırma hesabı yoktur ve getClmmLimitOrderConfigs() yardımcı fonksiyonu da yoktur — emirler tick’e göre anahtarlanır.

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

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

// Limit fiyatı MUTLAKA tick_spacing değerine kuantize edilmelidir — getOrderTick bunu yapar.
const targetPrice = new Decimal(180);                              // SOL'u 180 USDC'den satın
const orderData = getOrderTick({
  baseIn: true,                                                    // mintA satılıyor
  mintADecimal: poolInfo.mintA.decimals,
  mintBDecimal: poolInfo.mintB.decimals,
  tickSpacing: poolInfo.config.tickSpacing,
  price: targetPrice,
});

// Satış emri mevcut tick'in üzerinde, alış emri ise altında olmalıdır.
if (orderData.tick < rpcData.tickCurrent) throw new Error("satış fiyatı mevcut fiyattan yüksek olmalı");

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,                           // isteğe bağlı, varsayılan 0
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Limit emri açıldı:", extInfo.limitOrder.toBase58(), "tx:", txId);

SDK, LimitOrderState PDA’sını (owner, nonce PDA, order nonce) üçlüsünden türetir, cüzdan başına LimitOrderNonce değerini artırır ve emri o tick’teki FIFO kohortuna ekler.

​

Açık bir emri artırma / azaltma

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,                 // isteğe bağlı; DecreaseLimitOrder bunu Increase'e ek olarak alır
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

decreaseLimitOrder yalnızca emrin doldurulmamış kısmından miktar çıkarabilir; dolmuş kısım uzlaşmaya kadar kilitli kalır. Emir tamamen dolmuşsa her iki talimat da InvalidOrderPhase hatasıyla geri döner.

​

Dolmuş bir emri uzlaştırma

// settleLimitOrder YALNIZCA emir PDA'sını alır — poolInfo ya da poolKeys almaz.
await raydium.clmm.settleLimitOrder({
  limitOrder,
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

settleLimitOrder, emrin unfilled_ratio_x64 değerini kohort takipçisiyle karşılaştırır, dolan çıktıyı hesaplar ve bunu sahibinin ATA hesabına aktarır. Sahibi bu işlemi kendisi çağırabilir; zincir dışı bir operasyonel bekçi olan limit_order_admin da sahibi adına çağırabilir — çıktı yine sahibine gider.

Tamamen uzlaştırılmış emirleri kapatıp kira bedelini geri almak için tekil emirlerde closeLimitOrder, toplu olarak closeAllLimitOrder kullanın. Birçok emri birden uzlaştırmak için settleAllLimitOrder, bir v0 işlemine sığabildiği kadar SettleLimitOrder çağrısı ekler.

​

Bir cüzdanın bekleyen emirlerini listeleme (zincir dışı)

// API yardımcısı. Bkz. api-reference/temp-api-v1.
const active = await fetch(
  `https://temp-api-v1.raydium.io/limit-order/order/list?wallet=<cüzdan-public-key-niz>`,
).then((r) => r.json());

Aktif emirler uç noktası, dolmamış ve kısmen dolmuş emirleri tek bir yanıtta döndürür (totalAmount / filledAmount / pendingSettle alanları aşamaları ayırt eder). Kapanmış emirlerin geçmişi için /limit-order/history/order/list-by-user?wallet=… (cüzdan başına, nextPageId ile sayfalanmış) kullanın; belirli bir emrin tüm olay günlüğü için /limit-order/history/event/list-by-pda?pda=… kullanın.

​

Rust CPI iskeleti

// Cargo.toml — `master` anchor-lang =1.0.2 sürümüne sabitlenmiştir.
// anchor-lang  = "=1.0.2"   // raydium-clmm'in sabitlediği sürümle eşleşmelidir
// anchor-spl   = "=1.0.2"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "master", features = ["cpi"] }
//
// products/cpmm/code-demos içindeki CPMM örneğiyle aynı Anchor sürümü kullanılır; böylece
// iki CPI crate'i de tek bir programın bağımlılığı olabilir.

use anchor_lang::prelude::*;
use raydium_clmm::cpi;
use raydium_clmm::program::RaydiumClmm;
use raydium_clmm::cpi::accounts::SwapSingleV2;   // `SwapV2` talimat adıdır,
                                                 // `SwapSingleV2` hesap yapısıdır

#[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` tick_array ve bitmap_extension hesaplarını taşır.
}

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 burada programın AccountInfo değerini değil, Pubkey değerini alır. 0.32 `master`
    // dalında bu, `ctx.accounts.clmm_program.to_account_info()` idi.
    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)
}

SwapV2 için kalan hesap sırası:

[tick_array_bitmap_extension?, tick_array_0, tick_array_1, …]

Swap hiçbir zaman genişletmeye ihtiyaç duymuyorsa onu atlayın; aksi halde o, ilk kalan hesap olur.

​

Yaygın hatalar

• Tick uç noktalarının aralığa uymaması → TickAndSpacingNotMatch. Her zaman TickUtil.getPriceAndTick ile hizalayın (TickUtil, tekil olarak yazılır).
• SwapV2 içinde yeterli tick dizisi verilmemesi → NotEnoughTickArrayAccount. Listeyi swapInternal(...).accounts çıktısından alın.
• Bitmap uzantısı olmadan tam aralıklı pozisyon → Uzantı PDA’sı yazılabilir olmalıdır. SDK bunu otomatik olarak yönetir.
• sqrt_price_x64 değerini price ile karıştırmak → Burada 2 katı farkı oluşturan bir karışıklık özellikle sorunludur. Emin değilseniz, fiyatı SDK’ya okunabilir bir fiyattan hesaplatın.
• Ödülleri çok sık toplamak → Her toplama işlemi sıfır likiditeli bir DecreaseLiquidity işlemidir ve bir işlem maliyeti doğurur. Birden fazla pozisyon için harvestAllRewards ile toplu işlem yapın ve execute çağrısının { sequentially: true } parametresine ihtiyaç duyduğunu unutmayın.
• NFT hesaplarını kendiniz kapatmak → ClosePosition, NFT’yi yakar ve ilişkili ATA’sını kapatır. Token-2022 NFT mint’ini de kapatır. Klasik SPL Token mint’i ise, bu program mint’leri kapatamadığı için arzı sıfır olarak kalır. Desteklenen hesapları ayrıca kapatmayın; aksi halde işlem geri alınır.
• Limit emrini aralığa uymayan bir tick’te açmak → TickAndSpacingNotMatch. Her zaman dışa aktarılan getOrderTick yardımcı fonksiyonu ile tick değerini hizalayın.
• Tamamen gerçekleşmiş bir emirde decreaseLimitOrder çağırmak → InvalidOrderPhase. Bunun yerine önce settleLimitOrder, ardından closeLimitOrder kullanın.
• Bir enableDynamicFee bayrağı beklemek → Böyle bir bayrak yoktur. dynamicFeeConfig parametresini atlamak, hata vermeden sessizce sabit ücretli bir havuz oluşturur. Dinamik ücret istiyorsanız, yapılandırma hesabının PublicKey değerini /tr/main/clmm-dynamic-config sayfasından seçerek geçirin.

​

Sırada ne var

• sdk-api/typescript-sdk — SDK’nın tam yüzeyi.
• sdk-api/rest-api — fiyat teklifi ve havuz meta veri uç noktaları.
• user-flows/create-clmm-pool — koda dayanmayan adım adım anlatım.
• integration-guides/aggregator — CLMM’yi bir işlem yolunun parçası olarak yönlendirme.

Kaynaklar:

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