Các ví dụ mã CLMM

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 →

Biểu ngữ phiên bản. Tất cả các ví dụ TypeScript nhắm tới @raydium-io/raydium-sdk-v2@0.2.64-alpha; chúng được thực thi lần cuối với 0.2.42-alpha (2026-04) và chữ ký gọi của chúng được kiểm tra lại với mã nguồn 0.2.64-alpha vào ngày 2026-09-09, trên Solana mainnet-beta. Bộ xương CPI Rust ở cuối nhắm tới raydium-clmm trên master, cố định Anchor =0.32.1 — không phải 1.0.2 mà trang CPMM sử dụng; hai cái này không thể cùng tồn tại trong một crate. ID chương trình đến từ reference/program-addresses thông qua SDK.

Thiết lập

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

Mỗi ví dụ trên trang này phản ánh một tệp trong raydium-sdk-V2-demo/src/clmm; liên kết GitHub nằm bên cạnh mỗi phần. Bootstrap tuân theo config.ts.template của kho demo (nguồn) — disableFeatureCheck: true là cài đặt được khuyến nghị cho bất kỳ tích hợp không tầm thường nào:

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() trả về ApiClmmConfigInfo (id là một chuỗi). createPool muốn
// ClmmConfigInfo, cần PublicKey id cộng với fundOwner/description — chuyển đổi:
const clmmConfigs = await raydium.api.getClmmConfigs();
const picked = clmmConfigs.find((c) => c.index === 1)!;        // tầng 0.05%
const ammConfig = { ...picked, id: new PublicKey(picked.id), fundOwner: "", description: "" };

const initialPrice = new Decimal(160);        // 160 USDC trên SOL
const { execute, extInfo } = await raydium.clmm.createPool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  txVersion: TxVersion.V0,   // không có `startTime` — CreateConcentratedPool không có trường như vậy
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool:", extInfo.address.id, "tx:", txId);   // đã là chuỗi base58

SDK:

Sắp xếp mint1/mint2 theo thứ tự byte trước khi dẫn xuất.
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.
Trả phí tạo pool được xác định bởi ammConfig.

Mở vị trí trong khoảng được chọn

Nguồn: src/clmm/createPosition.ts

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

const POOL_ID = "<POOL_ID>";   // chuỗi base58
// lưu ý: getPoolInfoFromRpc của CLMM trả về `rpcPoolInfo`, không phải `rpcData` (của CPMM)
const { poolInfo, poolKeys, rpcPoolInfo } = await raydium.clmm.getPoolInfoFromRpc(POOL_ID);

// Chọn khoảng giá. Ở đây: ±10% của hiện tại.
const currentPrice = new Decimal(poolInfo.price);
const lowerPrice   = currentPrice.mul(0.9);
const upperPrice   = currentPrice.mul(1.1);

// Snap tới các tick hợp lệ cho tick_spacing của pool này.
// Lớp là TickUtil (số ít), và nó lấy decimals + tickSpacing, không phải 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,
});

// Bao nhiêu của mỗi token để gửi.
const inputAmount = new BN(10_000_000);  // 0.01 SOL

// getLiquidityAmountOutFromAmountIn là async — await nó.
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("Vị trí được mở, tx:", txId);

SDK tính toán tick array nào mà khoảng chạm tới và chuyển chúng dưới dạng tài khoản. Nó không cần phải gói bất kỳ lệnh init nào — không có lệnh init-tick-array; OpenPosition* tự cấp phát tick array bị thiếu, với chi phí của người trả tiền.

Tăng thanh khoản trên vị trí hiện có

Nguồn: src/clmm/increaseLiquidity.ts

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

// Không có getPositionInfo — liệt kê các vị trí của ví và chọn một.
const allPositions = await raydium.clmm.getOwnerPositionInfo({
  programId: poolInfo.programId,
});
const positionAccount = allPositions.find((p) => p.nftMint.equals(positionNftMint));
if (!positionAccount) throw new Error("vị trí không tìm thấy cho ví này");

const { execute } = await raydium.clmm.increasePositionFromBase({
  poolInfo,
  ownerPosition: positionAccount,
  ownerInfo: { useSOLBalance: true },   // bắt buộc
  base: "MintA",
  baseAmount: new BN(5_000_000),
  otherAmountMax: new BN(1_000_000_000),
  txVersion: TxVersion.V0,              // không có thành viên poolKeys trên lệnh gọi này
});

await execute({ sendAndConfirm: true });

Giảm thanh khoản (và thu thập phí cùng lúc)

Nguồn: src/clmm/decreaseLiquidity.ts và src/clmm/closePosition.ts

const { execute } = await raydium.clmm.decreaseLiquidity({
  poolInfo,
  poolKeys,
  ownerPosition: positionAccount,
  ownerInfo: {                       // bắt buộc; closePosition nằm ở đây
    useSOLBalance: true,
    closePosition: false,
  },
  liquidity: positionAccount.liquidity.divn(2),   // giảm một nửa
  amountMinA: new BN(0),
  amountMinB: new BN(0),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Để chỉ thu thập phí và phần thưởng, gọi decreaseLiquidity với liquidity = new BN(0). Tác dụng phụ của lệnh là giải quyết token_fees_owed_{0,1} và reward_amount_owed và chuyển chúng ra — đây là cách duy nhất để thu thập bất kỳ cái nào. Để đóng vị trí hoàn toàn sau khi xóa thanh khoản và phí, hãy chuyển ownerInfo: { closePosition: true } trên lệnh gọi decreaseLiquidity cuối cùng. SDK nối thêm ClosePosition và đốt NFT.

Các vị trí phát hành bị hạn chế yêu cầu trình xây dựng đóng tương thích. Các vị trí này có tài khoản token NFT bị đóng băng. ClosePosition phải nối ID pool của vị trí dưới dạng tài khoản còn lại đầu tiên để CLMM có thể rã đông tài khoản trước khi đốt nó. Nhánh nguồn chương trình không bao gồm thay đổi SDK. Xác nhận rằng phiên bản SDK của bạn hỗ trợ rõ ràng đường dẫn đóng bị đóng băng trước khi bật tạo vị trí phát hành bị hạn chế.

Đối với máy khách Anchor trực tiếp, giữ các tài khoản được khai báo không thay đổi và nối thêm pool:

// Chương trình CLMM: xem reference/program-addresses; nguồn ecb1577;
// Solana mainnet-beta; xác minh lần cuối 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ể chuyển poolId trên mỗi lần đóng. CLMM chỉ đọc nó khi positionNftAccount bị đóng băng, điều này giữ một đường dẫn máy khách tương thích với các vị trí cũ và mới.

Thu thập 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 là trình xây dựng MULTI-transaction: `sequentially` là bắt buộc
// và kết quả là `txIds`, không phải `txId`.
const { txIds } = await execute({ sequentially: true });

harvestAllRewards đi qua mỗi vị trí trên mỗi pool được chuyển vào, ghép các lệnh gọi DecreaseLiquidity không thanh khoản giải quyết phí và phần thưởng (cộng với bất kỳ UpdateRewardInfos), và chia chúng thành các giao dịch nếu cần.

Swap

Nguồn: src/clmm/swap.ts

Điều này phản ánh `src/clmm/swap.ts`, mô phỏng với `swapInternal` thay vì
`PoolUtils.computeAmountOutFormat`.

```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 cho 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 },   // bắt buộc
  remainingAccounts: simulation.accounts,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Mô phỏng đi qua bản đồ tick ngoài chuỗi với logic giống như chương trình trên chuỗi và trả về số lượng ra (amountCalculated) cộng với danh sách tài khoản chính xác mà swap sẽ chạm tới (accounts). Luôn chuyển remainingAccounts mà mô phỏng trả về: quá ít và swap sẽ hoàn nguyên giữa chừng với NotEnoughTickArrayAccount; những cái cũ chỉ lãng phí tính toán.

PoolUtils.computeAmountOutFormat vẫn tồn tại, nhưng nó cần ComputeClmmPoolInfo ( computePoolInfo từ getPoolInfoFromRpc, không phải đối tượng pool API) cộng với hai đối số bắt buộc khác — tickarrayBitmapExtension và blockTimestamp — và không có phương thức raydium.clmm.fetchTickArrays (fetchTickArrays là hàm tự do; các trợ giúp cấp mô-đun là PoolUtils.fetchMultiplePoolTickArrays và tickData / tickArrays được trả về bởi getPoolInfoFromRpc).

Tạo pool CLMM có thể tùy chỉnh

createCustomizablePool là điểm vào công khai các công tắc phí động và phí một phía tại thời điểm tạo pool. Nó lấy hình dạng của createPool cộng với hai 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 tầng hiệu chỉnh

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

await execute({ sendAndConfirm: true });
console.log("Pool có thể tùy chỉnh:", extInfo.address.id);   // chuỗi base58

Không có cờ enableDynamicFee và không có tham số dynamicFeeConfigId, và không có startTime. Cung cấp dynamicFeeConfig là những gì bật phí động — bỏ qua nó và bạn nhận được pool phí tĩnh, không có lỗi. Lưu ý rằng các thành viên enum SDK là TokenOnlyA / TokenOnlyB, trong khi enum Rust trên chuỗi đánh vần chúng Token0Only / Token1Only; các giá trị số khớp (FromInput = 0).

createPool tiếp tục hoạt động cho đường dẫn phí mặc định, không có phí động. Sử dụng createCustomizablePool bất cứ khi nào bạn cần một trong hai công tắc. Xem products/clmm/instructions để biết danh sách tài khoản trên chuỗi.

Lệnh giới hạn

Lệnh giới hạn đỗ đầu vào của người dùng tại một tick duy nhất và được điền FIFO khi swap vượt qua tick đó. Đầu ra được đẩy tới ATA của chủ sở hữu tại thời điểm giải quyết; chủ sở hữu không cần phải trực tuyến để được điền.

Mở lệnh giới hạn

Không có tài khoản cấu hình lệnh giới hạn cho mỗi pool và không có trợ giúp `getClmmLimitOrderConfigs()` — các lệnh được khóa bằng tick.

```ts
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 PHẢI được lượng tử hóa thành tick_spacing — getOrderTick làm điều đó.
const targetPrice = new Decimal(180);                              // bán SOL ở 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 dưới nó.
if (orderData.tick < rpcData.tickCurrent) throw new Error("giá bán phải > giá hiện tại");

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,                           // tùy chọn, mặc định là 0
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Lệnh giới hạn được mở:", extInfo.limitOrder.toBase58(), "tx:", txId);

SDK dẫn xuất PDA LimitOrderState từ (owner, nonce PDA, order nonce), tăng LimitOrderNonce cho mỗi ví, và chèn lệnh vào nhóm FIFO tại tick đó.

Tăng / giảm lệnh 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,                 // tùy chọn; DecreaseLimitOrder thêm cái này so với Increase
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

decreaseLimitOrder chỉ có thể loại bỏ từ phần chưa điền của lệnh; phần đã điền bị khóa cho đến khi giải quyết. Cả hai lệnh đều hoàn nguyên với InvalidOrderPhase nếu lệnh đã được điền hoàn toàn.

Giải quyết lệnh đã điền

// settleLimitOrder chỉ lấy PDA lệnh — không có poolInfo, không có 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 trình theo dõi nhóm, tính toán đầu ra đã điền, và chuyển nó tới ATA của chủ sở hữu. Chủ sở hữu có thể gọi cái này chính họ; limit_order_admin (một người giữ hoạt động ngoài chuỗi) cũng có thể gọi nó thay mặt chủ sở hữu — đầu ra vẫn đi tới chủ sở hữu. Để đóng các lệnh đã giải quyết hoàn toàn để khôi phục tiền thuê, hãy sử dụng closeLimitOrder (đơn) hoặc closeAllLimitOrder (hàng loạt). Để giải quyết nhiều cái cùng lúc, settleAllLimitOrder đóng gói bao nhiêu lệnh gọi SettleLimitOrder vừa vào tx v0.

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

// Trợ giúp 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());

Điểm cuối lệnh hoạt động trả về cả lệnh chưa điền và lệnh được điền một phần trong một tải trọng (totalAmount / filledAmount / pendingSettle phân biệt các giai đoạn). Để lịch sử lệnh đóng sử dụng /limit-order/history/order/list-by-user?wallet=… (cho mỗi ví, phân trang theo nextPageId); để nhật ký sự kiện đầy đủ của một lệnh cụ thể sử dụng /limit-order/history/event/list-by-pda?pda=….

Bộ xương CPI Rust

// Cargo.toml — CLMM vẫn ở Anchor 0.32, vì vậy nó không thể chia sẻ crate với
// mẫu CPMM trong products/cpmm/code-demos (cố định =1.0.2).
// anchor-lang  = "=0.32.1"
// anchor-spl   = "=0.32.1"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "master", features = ["cpi"] }

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 tài khoản

#[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` mang các tài khoản tick_array và bitmap_extension.
}

pub fn proxy_swap(
    ctx: Context<ProxyClmmSwap>,
    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 0.32 lấy AccountInfo của chương trình ở đây. KHÔNG thay đổi cái này thành
    // Pubkey — đó là hình thức Anchor 1.0, mà CLMM không sử dụng.
    let cpi_ctx = CpiContext::new(ctx.accounts.clmm_program.to_account_info(), 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ự tài khoản còn lại cho SwapV2:

[tick_array_bitmap_extension?, tick_array_0, tick_array_1, …]

Nếu swap không bao giờ cần phần mở rộng, bỏ qua nó; nếu không, nó là tài khoản còn lại đầu tiên.

Những cạm bẫy phổ biến

Điểm cuối tick không cách đều → TickAndSpacingNotMatch. Luôn snap qua TickUtil.getPriceAndTick (TickUtil số ít).
Không đủ tick array được cung cấp trong SwapV2 → NotEnoughTickArrayAccount. Lấy danh sách từ swapInternal(...).accounts.
Vị trí phạm vi đầy đủ mà không có phần mở rộng bitmap → PDA phần mở rộng phải có thể ghi; SDK xử lý điều này tự động.
Nhầm lẫn sqrt_price_x64 với price → một sự nhầm lẫn hệ số-2 ở đây đặc biệt đau đớn. Khi nghi ngờ, hãy để SDK tính toán nó từ giá có thể đọc được của con người.
Thu thập phần thưởng quá sớm → mỗi lần thu thập là DecreaseLiquidity không thanh khoản và tốn một giao dịch. Ghép qua harvestAllRewards trên nhiều vị trí, và nhớ rằng execute của nó cần { sequentially: true }.
Đóng tài khoản NFT của bạn → ClosePosition đốt NFT và đóng ATA của nó. Nó cũng đóng mint NFT Token-2022; mint SPL Token cổ điển vẫn ở mức cung cấp bằng không vì chương trình đó không thể đóng mint. Không đóng các tài khoản được hỗ trợ riêng biệt hoặc lệnh sẽ hoàn nguyên.
Mở lệnh giới hạn tại tick không cách đều → TickAndSpacingNotMatch. Luôn lượng tử hóa qua trợ giúp getOrderTick được xuất.
Gọi decreaseLimitOrder trên lệnh được điền hoàn toàn → InvalidOrderPhase. Sử dụng settleLimitOrder rồi closeLimitOrder thay thế.
Mong đợi cờ enableDynamicFee → không có cái nào. Bỏ qua dynamicFeeConfig đơn giản tạo pool phí tĩnh, im lặng và không có lỗi. Nếu bạn muốn phí động, hãy chuyển PublicKey của tài khoản cấu hình, được chọn từ /main/clmm-dynamic-config.

Tiếp theo đi đâu

sdk-api/typescript-sdk — bề mặt SDK hoàn chỉnh.
sdk-api/rest-api — các điểm cuối báo giá và siêu dữ liệu pool.
user-flows/create-clmm-pool — hướng dẫn không mã.
integration-guides/aggregator — định tuyến CLMM như một phần của đường dẫn.

Nguồn:

Products

Algorithms

Thiết lập

Tạo pool CLMM

Mở vị trí trong khoảng được chọn

Tăng thanh khoản trên vị trí hiện có

Giảm thanh khoản (và thu thập phí cùng lúc)

Thu thập phần thưởng

Swap

Tạo pool CLMM có thể tùy chỉnh

Lệnh giới hạn

Mở lệnh giới hạn

Tăng / giảm lệnh mở

Giải quyết lệnh đã điền

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

Bộ xương CPI Rust

Những cạm bẫy phổ biến

Tiếp theo đi đâu

​Thiết lập

​Tạo pool CLMM

​Mở vị trí trong khoảng được chọn

​Tăng thanh khoản trên vị trí hiện có

​Giảm thanh khoản (và thu thập phí cùng lúc)

​Thu thập phần thưởng

​Swap

​Tạo pool CLMM có thể tùy chỉnh

​Lệnh giới hạn

​Mở lệnh giới hạn

​Tăng / giảm lệnh mở

​Giải quyết lệnh đã điền

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

​Bộ xương CPI Rust

​Những cạm bẫy phổ biến

​Tiếp theo đi đâu

Thiết lập

Tạo pool CLMM

Mở vị trí trong khoảng được chọn

Tăng thanh khoản trên vị trí hiện có

Giảm thanh khoản (và thu thập phí cùng lúc)

Thu thập phần thưởng

Swap

Tạo pool CLMM có thể tùy chỉnh

Lệnh giới hạn

Mở lệnh giới hạn

Tăng / giảm lệnh mở

Giải quyết lệnh đã điền

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

Bộ xương CPI Rust

Những cạm bẫy phổ biến

Tiếp theo đi đâu