Ví dụ mã CLMM

Ví dụ TypeScript đầu cuối: tạo pool CLMM, mở position trong khoảng giá tùy chọn, điều chỉnh thanh khoản, swap, và thu phí cùng phần thưởng.

Trang này được dịch tự động bằng AI. Phiên bản tiếng Anh là bản chính thức.

Xem bản tiếng Anh →

​

Thiết lập

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

Mọi demo trên trang này tương ứng với một tệp trong raydium-sdk-V2-demo/src/clmm; liên kết GitHub nằm ngay cạnh mỗi phần. Phần khởi tạo theo tệp config.ts.template của demo repo (nguồn). Với mọi tích hợp không đơn giản, nên đặt disableFeatureCheck: true:

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;

​

Tạo pool CLMM

Nguồn: 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 sẽ:

• Sắp xếp mint1/mint2 theo thứ tự byte trước khi suy ra địa chỉ.
• Tính sqrt_price_x64 = floor(sqrt(initialPrice × 10^(dB−dA)) × 2^64).
• Tạo các tài khoản observation và tick_array_bitmap_extension.
• Thanh toán phí tạo pool được quy định bởi ammConfig.

​

Mở position trong khoảng giá đã chọn

Nguồn: 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 tính toán các tick array mà khoảng giá chạm tới và truyền chúng vào dưới dạng accounts. SDK không cần gộp lệnh khởi tạo nào: không tồn tại lệnh init-tick-array. OpenPosition* tự cấp phát tick array còn thiếu, với chi phí do payer chi trả.

​

Tăng thanh khoản cho position hiện có

Nguồn: 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 });

​

Giảm thanh khoản (đồng thời thu phí)

Nguồn: src/clmm/decreaseLiquidity.ts và 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 });

Để chỉ thu phí và phần thưởng, gọi decreaseLiquidity với liquidity = new BN(0). Tác dụng phụ của lệnh này là quyết toán token_fees_owed_{0,1} và reward_amount_owed, rồi chuyển chúng ra khỏi pool. Đây là cách duy nhất để thu một trong hai khoản này.

Để đóng position hoàn toàn sau khi đưa thanh khoản và phí về 0, truyền ownerInfo: { closePosition: true } ở lệnh decreaseLiquidity cuối cùng. SDK sẽ thêm ClosePosition và đốt NFT.

Position của issuer bị hạn chế cần trình tạo lệnh đóng tương thích. Các position này có tài khoản token NFT bị đóng băng. ClosePosition phải thêm pool ID của position làm tài khoản remaining đầu tiên để CLMM có thể mở băng tài khoản trước khi đốt. Nhánh mã nguồn chương trình không bao gồm thay đổi nào ở SDK. Trước khi bật tạo position của issuer bị hạn chế, hãy xác nhận rằng phiên bản SDK của bạn hỗ trợ rõ ràng luồng đóng khi tài khoản bị đóng băng.

Với client Anchor gọi trực tiếp, giữ nguyên các tài khoản đã khai báo và thêm pool vào:

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

Bạn có thể truyền poolId ở mọi lần đóng. CLMM chỉ đọc giá trị này khi positionNftAccount bị đóng băng, nhờ đó một đường dẫn client duy nhất vẫn tương thích với cả position cũ và position mới.

​

Thu phần thưởng

Nguồn: 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 duyệt mọi position trên mọi pool được truyền vào, gom các lệnh DecreaseLiquidity có thanh khoản bằng 0 dùng để quyết toán phí và phần thưởng (cùng mọi UpdateRewardInfos nếu có), rồi chia chúng sang nhiều giao dịch khi cần.

​

Swap

Nguồn: src/clmm/swap.ts

Ví dụ này bám theo src/clmm/swap.ts, nhưng mô phỏng bằng swapInternal thay vì 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 });

Quá trình mô phỏng duyệt tick map ngoài chuỗi theo cùng logic với chương trình on-chain, rồi trả về số lượng token nhận được (amountCalculated) cùng danh sách tài khoản chính xác mà lệnh swap sẽ truy cập (accounts).

Luôn truyền remainingAccounts mà bước mô phỏng trả về: nếu thiếu, swap sẽ bị revert giữa chừng với lỗi NotEnoughTickArrayAccount; nếu thừa hoặc đã cũ thì chỉ lãng phí compute.

PoolUtils.computeAmountOutFormat vẫn tồn tại, nhưng nó cần một ComputeClmmPoolInfo (là computePoolInfo lấy từ getPoolInfoFromRpc, không phải đối tượng pool từ API) và thêm hai tham số bắt buộc là tickarrayBitmapExtension và blockTimestamp. Ngoài ra, không tồn tại phương thức raydium.clmm.fetchTickArrays (fetchTickArrays là một hàm độc lập; các hàm hỗ trợ ở cấp module là PoolUtils.fetchMultiplePoolTickArrays, cùng với tickData / tickArrays được trả về bởi getPoolInfoFromRpc).

​

Tạo pool CLMM tùy chỉnh được

createCustomizablePool là hàm đầu vào cho phép bật/tắt phí động và phí một phía ngay tại thời điểm tạo pool. Hàm này nhận cùng tham số với createPool, cộng thêm hai tham số bổ sung:

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); // chọn một mức hiệu chỉnh

const { execute, extInfo } = await raydium.clmm.createCustomizablePool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  // Hai tham số bổ sung:
  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);   // chuỗi base58

Không có tham số enableDynamicFee, dynamicFeeConfigId hay startTime. Chính việc truyền dynamicFeeConfig mới bật phí động. Nếu bỏ tham số này, bạn sẽ nhận được một pool phí tĩnh mà không có bất kỳ lỗi nào. Ngoài ra, các thành viên enum trong SDK là TokenOnlyA / TokenOnlyB, trong khi enum Rust on-chain viết là Token0Only / Token1Only. Giá trị số tương ứng là giống nhau (FromInput = 0).

createPool vẫn hoạt động cho trường hợp dùng phí mặc định, không có phí động. Hãy dùng createCustomizablePool khi bạn cần một trong hai tùy chọn trên. Xem products/clmm/instructions để biết danh sách tài khoản on-chain.

​

Lệnh giới hạn (Limit orders)

Lệnh giới hạn giữ tiền đầu vào của người dùng tại một tick duy nhất và được khớp theo nguyên tắc FIFO khi một lệnh swap vượt qua tick đó. Kết quả được chuyển về ATA của chủ lệnh tại thời điểm quyết toán; chủ lệnh không cần trực tuyến để lệnh được khớp.

​

Mở lệnh giới hạn

Không có tài khoản cấu hình lệnh giới hạn riêng cho từng pool và cũng không có hàm hỗ trợ getClmmLimitOrderConfigs(). Các lệnh được định danh theo tick.

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

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

// Giá giới hạn BẮT BUỘC phải được làm tròn theo tick_spacing — getOrderTick sẽ làm việc này.
const targetPrice = new Decimal(180);                              // bán SOL với giá 180 USDC
const orderData = getOrderTick({
  baseIn: true,                                                    // bán mintA
  mintADecimal: poolInfo.mintA.decimals,
  mintBDecimal: poolInfo.mintB.decimals,
  tickSpacing: poolInfo.config.tickSpacing,
  price: targetPrice,
});

// Lệnh bán phải nằm trên tick hiện tại; lệnh mua phải nằm dưới tick hiện tại.
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,                           // không bắt buộc, mặc định là 0
  txVersion: TxVersion.V0,
});

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

SDK sẽ suy ra PDA LimitOrderState từ (owner, nonce PDA, order nonce), tăng LimitOrderNonce của từng ví, và đưa lệnh vào nhóm FIFO tại tick đó.

​

Tăng / giảm một lệnh đang mở

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,                 // không bắt buộc; DecreaseLimitOrder thêm tham số này so với Increase
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

decreaseLimitOrder chỉ có thể rút phần chưa khớp của lệnh; phần đã khớp bị khóa cho đến khi quyết toán. Cả hai lệnh đều revert với InvalidOrderPhase nếu lệnh đã được khớp hoàn toàn.

​

Quyết toán lệnh đã khớp

// settleLimitOrder CHỈ nhận PDA của lệnh — không cần poolInfo, không cần poolKeys.
await raydium.clmm.settleLimitOrder({
  limitOrder,
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

settleLimitOrder đọc unfilled_ratio_x64 của lệnh so với bộ theo dõi nhóm, tính toán lượng token đã khớp và chuyển về ATA của chủ lệnh. Chủ lệnh có thể tự gọi hàm này; limit_order_admin (một keeper vận hành ngoài chuỗi) cũng có thể gọi thay chủ lệnh, nhưng kết quả vẫn được chuyển về cho chủ lệnh.

Để đóng các lệnh đã quyết toán hoàn toàn nhằm thu hồi rent, hãy dùng closeLimitOrder (từng lệnh) hoặc closeAllLimitOrder (theo lô). Để quyết toán nhiều lệnh cùng lúc, settleAllLimitOrder sẽ gom càng nhiều lệnh SettleLimitOrder càng tốt vào một giao dịch v0.

​

Liệt kê các lệnh đang treo của ví (ngoài chuỗi)

// Hàm hỗ trợ API. Xem 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 danh sách lệnh đang hoạt động trả về cả lệnh chưa khớp và lệnh khớp một phần trong cùng một payload; các trường totalAmount / filledAmount / pendingSettle giúp phân biệt từng giai đoạn. Để xem lịch sử lệnh đã đóng, hãy dùng /limit-order/history/order/list-by-user?wallet=… (theo từng ví, phân trang bằng nextPageId); để xem toàn bộ nhật ký sự kiện của một lệnh cụ thể, hãy dùng /limit-order/history/event/list-by-pda?pda=….

​

Khung CPI bằng Rust

// Cargo.toml — `master` ghim anchor-lang =1.0.2.
// anchor-lang  = "=1.0.2"   // phải khớp với phiên bản raydium-clmm ghim
// anchor-spl   = "=1.0.2"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "master", features = ["cpi"] }
//
// Cùng dòng Anchor với ví dụ CPMM trong products/cpmm/code-demos, nên hai
// crate CPI có thể cùng là dependency của một chương trình.

use anchor_lang::prelude::*;
use raydium_clmm::cpi;
use raydium_clmm::program::RaydiumClmm;
use raydium_clmm::cpi::accounts::SwapSingleV2;   // `SwapV2` là tên lệnh,
                                                 // `SwapSingleV2` là struct accounts

#[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` chứa các tài khoản tick_array và 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 nhận Pubkey của chương trình ở đây, không nhận AccountInfo. Trên nhánh `master` 0.32,
    // đoạn này là `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)
}

Thứ tự remaining-account cho SwapV2:

[tick_array_bitmap_extension?, tick_array_0, tick_array_1, …]

Nếu swap không bao giờ cần extension, bạn có thể bỏ qua nó; ngược lại, nó là remaining account đầu tiên.

​

Những lỗi thường gặp

• Tick đầu mút không khớp bước tick (tick spacing) → TickAndSpacingNotMatch. Luôn căn chỉnh qua TickUtil.getPriceAndTick (dùng TickUtil số ít).
• Không cung cấp đủ tick array trong SwapV2 → NotEnoughTickArrayAccount. Lấy danh sách từ swapInternal(...).accounts.
• Vị trí full-range nhưng thiếu bitmap extension → PDA của extension phải có quyền ghi; SDK tự xử lý việc này.
• Nhầm sqrt_price_x64 với price → nhầm lẫn hệ số 2 ở đây đặc biệt khó chịu. Khi không chắc, hãy để SDK tính từ giá dễ đọc cho con người.
• Thu phần thưởng quá thường xuyên → mỗi lần thu là một DecreaseLiquidity với liquidity bằng không và tốn một giao dịch. Hãy gom nhiều vị thế bằng harvestAllRewards, và nhớ rằng execute của hàm này cần { sequentially: true }.
• Tự đóng tài khoản NFT → ClosePosition đốt NFT và đóng ATA của nó. Lệnh này cũng đóng mint NFT Token-2022; còn mint SPL Token cổ điển vẫn tồn tại với supply bằng không vì chương trình đó không thể đóng mint. Đừng tự đóng các tài khoản được hỗ trợ riêng, nếu không lệnh sẽ bị revert.
• Mở lệnh limit tại tick không nằm trên bước tick → TickAndSpacingNotMatch. Luôn lượng tử hóa bằng hàm trợ giúp getOrderTick được export.
• Gọi decreaseLimitOrder trên lệnh đã khớp hoàn toàn → InvalidOrderPhase. Thay vào đó, hãy dùng settleLimitOrder rồi closeLimitOrder.
• Kỳ vọng có cờ enableDynamicFee → không tồn tại cờ này. Bỏ qua dynamicFeeConfig chỉ đơn giản tạo một pool phí cố định, âm thầm và không báo lỗi. Nếu bạn muốn phí động, hãy truyền PublicKey của tài khoản cấu hình, lấy từ /vi/main/clmm-dynamic-config.

​

Bước tiếp theo

• sdk-api/typescript-sdk — toàn bộ giao diện SDK.
• sdk-api/rest-api — các endpoint báo giá và metadata pool.
• user-flows/create-clmm-pool — hướng dẫn không dùng code.
• integration-guides/aggregator — định tuyến CLMM như một phần của đường đi swap.

Nguồn:

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