Demo kode CLMM

Contoh TypeScript dari awal hingga akhir: membuat pool CLMM, membuka posisi pada rentang harga pilihan, menyesuaikan likuiditas, melakukan swap, serta mengumpulkan biaya dan reward.

Halaman ini diterjemahkan secara otomatis oleh AI. Versi bahasa Inggris adalah acuan resmi.

Lihat versi bahasa Inggris →

​

Pengaturan

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

Setiap demo di halaman ini mengikuti berkas di raydium-sdk-V2-demo/src/clmm. Tautan GitHub berada di samping setiap bagian. Inisialisasi mengikuti config.ts.template di repositori demo (sumber). Untuk integrasi yang tidak sederhana, disableFeatureCheck: true direkomendasikan:

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;

​

Membuat pool CLMM

Sumber: 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 akan:

• Mengurutkan mint1/mint2 berdasarkan urutan byte sebelum derivasi.
• Menghitung sqrt_price_x64 = floor(sqrt(initialPrice × 10^(dB−dA)) × 2^64).
• Membuat akun observation dan tick_array_bitmap_extension.
• Membayar biaya pembuatan pool yang ditentukan oleh ammConfig.

​

Membuka posisi pada rentang harga pilihan

Sumber: 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 menghitung tick array mana saja yang tersentuh oleh rentang tersebut dan meneruskannya sebagai akun. Tidak perlu menyertakan instruksi inisialisasi tambahan, karena memang tidak ada instruksi init-tick-array. OpenPosition* sendiri mengalokasikan tick array yang belum ada, dengan biaya ditanggung oleh payer.

​

Menambah likuiditas pada posisi yang sudah ada

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

​

Mengurangi likuiditas (sekaligus mengumpulkan biaya)

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

Untuk hanya mengumpulkan biaya dan reward, panggil decreaseLiquidity dengan liquidity = new BN(0). Efek samping instruksi ini adalah menyelesaikan token_fees_owed_{0,1} dan reward_amount_owed, lalu mentransfernya keluar. Ini satu-satunya cara untuk mengumpulkan keduanya.

Untuk menutup posisi sepenuhnya setelah likuiditas dan biaya dinolkan, berikan ownerInfo: { closePosition: true } pada pemanggilan decreaseLiquidity terakhir. SDK akan menambahkan ClosePosition dan membakar NFT-nya.

Posisi restricted-issuer memerlukan close builder yang kompatibel. Posisi ini memiliki akun token NFT yang dibekukan. ClosePosition harus menambahkan ID pool posisi sebagai akun remaining pertama agar CLMM dapat mencairkan akun tersebut sebelum membakarnya. Cabang kode program tidak menyertakan perubahan SDK. Pastikan rilis SDK Anda secara eksplisit mendukung jalur close yang dibekukan sebelum mengaktifkan pembuatan posisi restricted-issuer.

Untuk klien Anchor langsung, biarkan akun yang dideklarasikan tetap dan tambahkan pool:

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

Anda boleh menyertakan poolId pada setiap close. CLMM hanya membacanya ketika positionNftAccount dibekukan, sehingga satu jalur klien tetap kompatibel dengan posisi lama maupun baru.

​

Mengumpulkan reward

Sumber: 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 memproses setiap posisi di setiap pool yang diberikan. Ia mengelompokkan pemanggilan DecreaseLiquidity bernilai likuiditas nol yang menyelesaikan biaya dan reward (ditambah UpdateRewardInfos jika ada), lalu membaginya ke beberapa transaksi bila diperlukan.

​

Swap

Sumber: src/clmm/swap.ts

Contoh ini mengikuti src/clmm/swap.ts, yang melakukan simulasi dengan swapInternal, bukan 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 });

Simulasi menelusuri tick map secara off-chain dengan logika yang sama seperti program on-chain, lalu mengembalikan jumlah output (amountCalculated) beserta daftar akun persis yang akan disentuh oleh swap (accounts).

Selalu sertakan remainingAccounts yang dikembalikan simulasi: jika kurang, swap akan gagal di tengah penelusuran dengan NotEnoughTickArrayAccount; jika berlebih atau sudah usang, hanya membuang compute.

PoolUtils.computeAmountOutFormat masih tersedia, tetapi memerlukan ComputeClmmPoolInfo (yaitu computePoolInfo dari getPoolInfoFromRpc, bukan objek pool dari API) serta dua argumen wajib lainnya — tickarrayBitmapExtension dan blockTimestamp. Selain itu, tidak ada metode raydium.clmm.fetchTickArrays (fetchTickArrays adalah fungsi mandiri; helper tingkat modul yang tersedia adalah PoolUtils.fetchMultiplePoolTickArrays serta tickData / tickArrays yang dikembalikan oleh getPoolInfoFromRpc).

​

Membuat pool CLMM yang dapat dikustomisasi

createCustomizablePool adalah titik masuk yang menyediakan sakelar dynamic-fee dan single-sided-fee saat pool dibuat. Fungsi ini memakai bentuk parameter createPool ditambah dua parameter tambahan:

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); // pilih tingkat kalibrasi

const { execute, extInfo } = await raydium.clmm.createCustomizablePool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  // Dua parameter tambahan:
  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);   // string base58

Tidak ada parameter enableDynamicFee, dynamicFeeConfigId, maupun startTime. Menyediakan dynamicFeeConfig adalah yang mengaktifkan dynamic fee — jika dihilangkan, Anda mendapatkan pool dengan fee statis tanpa muncul error. Perhatikan juga bahwa anggota enum di SDK adalah TokenOnlyA / TokenOnlyB, sedangkan enum Rust on-chain menulisnya sebagai Token0Only / Token1Only; nilai numeriknya sama (FromInput = 0).

createPool tetap berfungsi untuk jalur fee default tanpa dynamic fee. Gunakan createCustomizablePool jika Anda membutuhkan salah satu dari kedua opsi tersebut. Lihat products/clmm/instructions untuk daftar akun on-chain.

​

Limit order

Limit order menyimpan input pengguna pada satu tick dan diisi secara FIFO ketika swap melintasi tick tersebut. Output dikirim ke ATA pemilik saat settlement; pemilik tidak perlu online agar order-nya terisi.

​

Membuka limit order

Tidak ada akun konfigurasi limit order per pool maupun helper getClmmLimitOrderConfigs() — order diidentifikasi berdasarkan tick.

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

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

// Harga limit HARUS dikuantisasi ke tick_spacing — getOrderTick melakukannya.
const targetPrice = new Decimal(180);                              // jual SOL di 180 USDC
const orderData = getOrderTick({
  baseIn: true,                                                    // menjual mintA
  mintADecimal: poolInfo.mintA.decimals,
  mintBDecimal: poolInfo.mintB.decimals,
  tickSpacing: poolInfo.config.tickSpacing,
  price: targetPrice,
});

// Order jual harus berada di atas tick saat ini; order beli di bawahnya.
if (orderData.tick < rpcData.tickCurrent) throw new Error("harga jual harus > harga saat ini");

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,                           // opsional,默认 0
  txVersion: TxVersion.V0,
});

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

SDK menurunkan PDA LimitOrderState dari (owner, nonce PDA, order nonce), menaikkan LimitOrderNonce per dompet, dan memasukkan order ke dalam antrean FIFO pada tick tersebut.

​

Menambah / mengurangi order yang terbuka

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,                 // opsional; DecreaseLimitOrder menambahkannya di atas Increase
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

decreaseLimitOrder hanya dapat menarik dari bagian order yang belum terisi; bagian yang sudah terisi terkunci hingga settlement. Kedua instruksi akan gagal dengan InvalidOrderPhase jika order sudah terisi penuh.

​

Settle order yang sudah terisi

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

settleLimitOrder membaca unfilled_ratio_x64 order terhadap cohort tracker, menghitung output yang sudah terisi, lalu mentransfernya ke ATA pemilik. Pemilik dapat memanggil fungsi ini sendiri; limit_order_admin (keeper operasional off-chain) juga dapat memanggilnya atas nama pemilik — output tetap dikirim ke pemilik.

Untuk menutup order yang sudah settle sepenuhnya guna mengambil kembali rent, gunakan closeLimitOrder (satu order) atau closeAllLimitOrder (batch). Untuk men-settle banyak order sekaligus, settleAllLimitOrder mengemas sebanyak mungkin pemanggilan SettleLimitOrder ke dalam satu tx v0.

​

Daftar order yang tersimpan di dompet (off-chain)

// Helper API. Lihat 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());

Endpoint order aktif mengembalikan order yang belum terisi maupun yang terisi sebagian dalam satu payload (totalAmount / filledAmount / pendingSettle membedakan fasenya). Untuk riwayat order yang sudah ditutup gunakan /limit-order/history/order/list-by-user?wallet=… (per dompet, dipaginasi dengan nextPageId); untuk log event lengkap dari order tertentu gunakan /limit-order/history/event/list-by-pda?pda=….

​

Kerangka CPI Rust

// Cargo.toml — `master` mengunci anchor-lang =1.0.2.
// anchor-lang  = "=1.0.2"   // harus sesuai dengan versi yang dikunci raydium-clmm
// anchor-spl   = "=1.0.2"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "master", features = ["cpi"] }
//
// Lini Anchor yang sama dengan contoh CPMM di products/cpmm/code-demos, sehingga
// kedua crate CPI dapat menjadi dependensi dari satu program.

use anchor_lang::prelude::*;
use raydium_clmm::cpi;
use raydium_clmm::program::RaydiumClmm;
use raydium_clmm::cpi::accounts::SwapSingleV2;   // `SwapV2` adalah nama instruksi,
                                                 // `SwapSingleV2` adalah struct akun

#[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` memuat akun tick_array dan bitmap_extension.
}

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 menerima Pubkey program ini, bukan AccountInfo-nya. Pada branch
    // `master` 0.32, nilainya adalah `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)
}

Urutan remaining account untuk SwapV2:

[tick_array_bitmap_extension?, tick_array_0, tick_array_1, …]

Jika swap tidak pernah membutuhkan extension, hilangkan saja; jika tidak, extension menjadi remaining account pertama.

​

Kesalahan umum

• Titik ujung tick yang tidak sesuai spacing → TickAndSpacingNotMatch. Selalu sesuaikan dengan TickUtil.getPriceAndTick (TickUtil dalam bentuk tunggal).
• Jumlah tick array di SwapV2 tidak cukup → NotEnoughTickArrayAccount. Ambil daftarnya dari swapInternal(...).accounts.
• Posisi full-range tanpa bitmap extension → PDA extension harus bisa ditulis (writable). SDK menanganinya secara otomatis.
• Menyamakan sqrt_price_x64 dengan price → kesalahan faktor 2 di sini sangat merepotkan. Jika ragu, biarkan SDK menghitungnya dari harga yang mudah dibaca.
• Mengklaim reward terlalu sering → setiap klaim adalah DecreaseLiquidity dengan likuiditas nol dan memerlukan satu transaksi. Gabungkan dengan harvestAllRewards untuk banyak posisi sekaligus, dan ingat bahwa execute-nya membutuhkan { sequentially: true }.
• Menutup akun NFT secara manual → ClosePosition membakar NFT dan menutup ATA-nya. Instruksi ini juga menutup mint NFT Token-2022. Mint SPL Token klasik tetap ada dengan supply nol, karena program tersebut tidak dapat menutup mint. Jangan menutup akun yang didukung secara terpisah, karena instruksi akan gagal.
• Membuka limit order pada tick yang tidak sesuai spacing → TickAndSpacingNotMatch. Selalu kuantisasi dengan helper getOrderTick yang diekspor.
• Memanggil decreaseLimitOrder pada order yang sudah terisi penuh → InvalidOrderPhase. Gunakan settleLimitOrder lalu closeLimitOrder sebagai gantinya.
• Mengharapkan flag enableDynamicFee → flag tersebut tidak ada. Jika dynamicFeeConfig dihilangkan, pool yang dibuat hanya akan memakai biaya statis, tanpa peringatan atau error. Jika Anda ingin menggunakan biaya dinamis, berikan PublicKey dari akun konfigurasi yang dipilih dari /main/clmm-dynamic-config.

​

Langkah selanjutnya

• sdk-api/typescript-sdk — referensi lengkap SDK.
• sdk-api/rest-api — endpoint quote dan metadata pool.
• user-flows/create-clmm-pool — panduan membuat pool tanpa kode.
• integration-guides/aggregator — merutekan CLMM sebagai bagian dari sebuah jalur swap.

Sumber:

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