CLMM 程式碼示例

本頁內容由 AI 自動翻譯，所有內容以英文版本為準。查看英文版 →

版本說明。 所有 TypeScript 示例針對 @raydium-io/raydium-sdk-v2@0.2.64-alpha；最後執行於 0.2.42-alpha（2026-04），並於 2026-09-09 針對 Solana mainnet-beta 重新檢查了 0.2.64-alpha 原始碼中的呼叫簽名。末尾的 Rust CPI 骨架針對 master 分支上的 raydium-clmm，其中 Anchor 版本為 =0.32.1 — 不是 CPMM 頁面使用的 1.0.2；兩者無法共存於一個 crate 中。程式 ID 來自 reference/program-addresses 透過 SDK。

設定

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

本頁的每個示例都對應 raydium-sdk-V2-demo/src/clmm 中的一個檔案；GitHub 連結位於每個章節旁邊。初始化遵循示例倉庫的 config.ts.template（原始碼）— 對於任何非平凡的整合，建議設定 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;

建立 CLMM 流動性池

原始碼：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() 傳回 ApiClmmConfigInfo（id 是字串）。createPool 需要
// ClmmConfigInfo，其中需要 PublicKey id 加上 fundOwner/description — 進行轉換：
const clmmConfigs = await raydium.api.getClmmConfigs();
const picked = clmmConfigs.find((c) => c.index === 1)!;        // 0.05% 級別
const ammConfig = { ...picked, id: new PublicKey(picked.id), fundOwner: "", description: "" };

const initialPrice = new Decimal(160);        // 每 SOL 160 USDC
const { execute, extInfo } = await raydium.clmm.createPool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  txVersion: TxVersion.V0,   // 無 `startTime` — CreateConcentratedPool 沒有此欄位
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool:", extInfo.address.id, "tx:", txId);   // 已是 base58 字串

SDK 會：

在推導前按位元組順序排序 mint1/mint2。
計算 sqrt_price_x64 = floor(sqrt(initialPrice × 10^(dB−dA)) × 2^64)。
建立 observation 和 tick_array_bitmap_extension 帳戶。
支付由 ammConfig 定義的流動性池建立費用。

在選定範圍內開設部位

原始碼：src/clmm/createPosition.ts

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

const POOL_ID = "<POOL_ID>";   // base58 字串
// 注意：CLMM 的 getPoolInfoFromRpc 傳回 `rpcPoolInfo`，不是 `rpcData`（CPMM 的會）
const { poolInfo, poolKeys, rpcPoolInfo } = await raydium.clmm.getPoolInfoFromRpc(POOL_ID);

// 選擇價格範圍。這裡：當前價格的 ±10%。
const currentPrice = new Decimal(poolInfo.price);
const lowerPrice   = currentPrice.mul(0.9);
const upperPrice   = currentPrice.mul(1.1);

// 對齊此流動性池 tick_spacing 的有效 tick。
// 類別是 TickUtil（單數），它接受 decimals + tickSpacing，不是 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,
});

// 要存入的每種代幣數量。
const inputAmount = new BN(10_000_000);  // 0.01 SOL

// getLiquidityAmountOutFromAmountIn 是非同步的 — 需要 await。
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 計算該範圍涉及的 tick 陣列，並將其作為帳戶傳遞。它不需要捆綁任何初始化指令 — 沒有初始化 tick 陣列指令；OpenPosition* 會自行分配缺失的 tick 陣列，費用由支付者承擔。

增加現有部位的流動性

原始碼：src/clmm/increaseLiquidity.ts

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

// 沒有 getPositionInfo — 列舉錢包的部位並選擇一個。
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 },   // 必需
  base: "MintA",
  baseAmount: new BN(5_000_000),
  otherAmountMax: new BN(1_000_000_000),
  txVersion: TxVersion.V0,              // 此呼叫上沒有 poolKeys 成員
});

await execute({ sendAndConfirm: true });

減少流動性（同時收取費用）

原始碼：src/clmm/decreaseLiquidity.ts 和 src/clmm/closePosition.ts

const { execute } = await raydium.clmm.decreaseLiquidity({
  poolInfo,
  poolKeys,
  ownerPosition: positionAccount,
  ownerInfo: {                       // 必需；closePosition 在這裡
    useSOLBalance: true,
    closePosition: false,
  },
  liquidity: positionAccount.liquidity.divn(2),   // 減半
  amountMinA: new BN(0),
  amountMinB: new BN(0),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

若要僅收取費用和獎勵，使用 liquidity = new BN(0) 呼叫 decreaseLiquidity。指令的副作用是結算 token_fees_owed_{0,1} 和 reward_amount_owed 並將其轉出 — 這是收取任一者的唯一方式。若要在清零流動性和費用後完全關閉部位，在最後的 decreaseLiquidity 呼叫上傳遞 ownerInfo: { closePosition: true }。SDK 會附加 ClosePosition 並燒毀 NFT。

受限發行人部位需要相容的關閉建構器。 這些部位有凍結的 NFT 代幣帳戶。ClosePosition 必須將部位的流動性池 ID 附加為第一個剩餘帳戶，以便 CLMM 可以在燒毀前解凍帳戶。程式原始碼分支不包括 SDK 變更。在啟用受限發行人部位建立之前，請確認你的 SDK 版本明確支援凍結關閉路徑。

對於直接 Anchor 用戶端，保持宣告的帳戶不變並附加流動性池：

// CLMM 程式：見 reference/program-addresses；原始碼 ecb1577；
// Solana mainnet-beta；最後驗證於 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();

你可以在每次關閉時傳遞 poolId。CLMM 只在 positionNftAccount 凍結時讀取它，這使一個用戶端路徑與舊部位和新部位相容。

收取獎勵

原始碼：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 是多交易建構器：需要 `sequentially`
// 結果是 `txIds`，不是 `txId`。
const { txIds } = await execute({ sequentially: true });

harvestAllRewards 遍歷傳入的每個流動性池上的每個部位，批次處理結算費用和獎勵的零流動性 DecreaseLiquidity 呼叫（加上任何 UpdateRewardInfos），並在需要時將其分散到多個交易中。

交換

原始碼：src/clmm/swap.ts

這對應 `src/clmm/swap.ts`，它使用 `swapInternal` 而不是
`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;             // 交換 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 表示精確輸出
  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 },   // 必需
  remainingAccounts: simulation.accounts,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

模擬使用與鏈上程式相同的邏輯離線遍歷 tick 地圖，並傳回輸出量（amountCalculated）加上交換將涉及的確切帳戶列表（accounts）。始終傳遞模擬傳回的 remainingAccounts：太少會導致交換在遍歷中途以 NotEnoughTickArrayAccount 回復；過時的只會浪費計算。

PoolUtils.computeAmountOutFormat 仍然存在，但它需要 ComputeClmmPoolInfo（來自 getPoolInfoFromRpc 的 computePoolInfo，不是 API 流動性池物件）加上另外兩個必需的引數 — tickarrayBitmapExtension 和 blockTimestamp — 並且沒有 raydium.clmm.fetchTickArrays 方法（fetchTickArrays 是自由函式；模組級別的輔助程式是 PoolUtils.fetchMultiplePoolTickArrays 和 getPoolInfoFromRpc 傳回的 tickData / tickArrays）。

建立可自訂的 CLMM 流動性池

createCustomizablePool 是入口點，在流動性池建立時公開動態費用和單邊費用切換。它採用 createPool 的形狀加上兩個新增項：

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); // 選擇一個校準級別

const { execute, extInfo } = await raydium.clmm.createCustomizablePool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  // 兩個新增項：
  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);   // base58 字串

沒有 enableDynamicFee 和沒有 dynamicFeeConfigId 參數，也沒有 startTime。 提供 dynamicFeeConfig 就是啟用動態費用的方式 — 省略它，你會得到靜態費用流動性池，沒有錯誤。另請注意，SDK 列舉成員是 TokenOnlyA / TokenOnlyB，而鏈上 Rust 列舉拼寫為 Token0Only / Token1Only；數值相符（FromInput = 0）。

createPool 繼續用於預設費用、無動態費用路徑。每當你需要任一旋鈕時，使用 createCustomizablePool。見 products/clmm/instructions 以了解鏈上帳戶列表。

限價單

限價單在單個 tick 處停泊使用者輸入，當交換穿過該 tick 時按 FIFO 方式成交。輸出在結算時推送到所有者的 ATA；所有者不需要在線即可成交。

開設限價單

沒有每個流動性池的限價單配置帳戶，也沒有 `getClmmLimitOrderConfigs()` 輔助程式 — 訂單由 tick 鍵入。

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

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

// 限價必須量化為 tick_spacing — getOrderTick 會執行此操作。
const targetPrice = new Decimal(180);                              // 以 180 USDC 賣出 SOL
const orderData = getOrderTick({
  baseIn: true,                                                    // 賣出 mintA
  mintADecimal: poolInfo.mintA.decimals,
  mintBDecimal: poolInfo.mintB.decimals,
  tickSpacing: poolInfo.config.tickSpacing,
  price: targetPrice,
});

// 賣單必須位於當前 tick 上方；買單位於下方。
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,                           // 可選，預設為 0
  txVersion: TxVersion.V0,
});

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

SDK 從 (owner, nonce PDA, order nonce) 推導 LimitOrderState PDA，碰撞每個錢包的 LimitOrderNonce，並將訂單插入該 tick 的 FIFO 隊列。

增加/減少開放訂單

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,                 // 可選；DecreaseLimitOrder 在 Increase 上新增此項
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

decreaseLimitOrder 只能從訂單的未成交部分移除；成交部分被鎖定直到結算。如果訂單已完全成交，兩個指令都會以 InvalidOrderPhase 回復。

結算已成交的訂單

// settleLimitOrder 只接受訂單 PDA — 沒有 poolInfo，沒有 poolKeys。
await raydium.clmm.settleLimitOrder({
  limitOrder,
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

settleLimitOrder 根據隊列追蹤器讀取訂單的 unfilled_ratio_x64，計算成交輸出，並將其轉移到所有者的 ATA。所有者可以自己呼叫此方法；limit_order_admin（離線操作保管人）也可以代表所有者呼叫它 — 輸出仍然進入所有者。若要關閉完全結算的訂單以恢復租金，使用 closeLimitOrder（單個）或 closeAllLimitOrder（批次）。若要同時結算許多訂單，settleAllLimitOrder 將盡可能多的 SettleLimitOrder 呼叫打包到 v0 交易中。

列出錢包的停泊訂單（離線）

// API 輔助程式。見 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());

活躍訂單端點在一個有效負載中傳回未成交和部分成交的訂單（totalAmount / filledAmount / pendingSettle 區分階段）。對於已關閉訂單的歷史記錄，使用 /limit-order/history/order/list-by-user?wallet=…（按錢包，按 nextPageId 分頁）；對於特定訂單的完整事件日誌，使用 /limit-order/history/event/list-by-pda?pda=…。

Rust CPI 骨架

// Cargo.toml — CLMM 仍在 Anchor 0.32 上，所以它無法與
// products/cpmm/code-demos 中的 CPMM 示例共享 crate（其中固定 =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` 是指令名稱，
                                                 // `SwapSingleV2` 是帳戶結構

#[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 和 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 在此處接受程式的 AccountInfo。不要將其變更為 Pubkey —
    // 那是 Anchor 1.0 形式，CLMM 不使用。
    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)
}

SwapV2 的剩餘帳戶順序：

[tick_array_bitmap_extension?, tick_array_0, tick_array_1, …]

如果交換永遠不需要擴展，省略它；否則它是第一個剩餘帳戶。

常見陷阱

非間距 tick 端點 → TickAndSpacingNotMatch。始終透過 TickUtil.getPriceAndTick（單數 TickUtil）對齊。
在 SwapV2 中提供的 tick 陣列不足 → NotEnoughTickArrayAccount。取得 swapInternal(...).accounts 傳回的列表。
沒有位圖擴展的全範圍部位 → 擴展 PDA 必須可寫；SDK 會自動處理此問題。
將 sqrt_price_x64 誤認為 price → 這裡的因子 2 混淆特別痛苦。如有疑問，讓 SDK 從人類可讀的價格計算它。
過於急切地收取獎勵 → 每次收取都是零流動性 DecreaseLiquidity，成本為一個交易。透過 harvestAllRewards 跨許多部位進行批次處理，並記住其 execute 需要 { sequentially: true }。
自己關閉 NFT 帳戶 → ClosePosition 燒毀 NFT 並關閉其 ATA。它也關閉 Token-2022 NFT 鑄幣；經典 SPL Token 鑄幣保持供應量為零，因為該程式無法關閉鑄幣。不要單獨關閉支援的帳戶，否則指令將回復。
在非間距 tick 開設限價單 → TickAndSpacingNotMatch。始終透過匯出的 getOrderTick 輔助程式進行量化。
在完全成交的訂單上呼叫 decreaseLimitOrder → InvalidOrderPhase。改用 settleLimitOrder 然後 closeLimitOrder。
期望 enableDynamicFee 旗標 → 沒有。省略 dynamicFeeConfig 只是建立靜態費用流動性池，無聲且無錯誤。如果你想要動態費用，傳遞從 /main/clmm-dynamic-config 選擇的配置帳戶的 PublicKey。

後續步驟

sdk-api/typescript-sdk — 完整 SDK 表面。
sdk-api/rest-api — 報價和流動性池元資料端點。
user-flows/create-clmm-pool — 非程式碼逐步說明。
integration-guides/aggregator — 將 CLMM 作為路徑的一部分進行路由。

來源：

產品

演算法

設定

建立 CLMM 流動性池

在選定範圍內開設部位

增加現有部位的流動性

減少流動性（同時收取費用）

收取獎勵

交換

建立可自訂的 CLMM 流動性池

限價單

開設限價單

增加/減少開放訂單

結算已成交的訂單

列出錢包的停泊訂單（離線）

Rust CPI 骨架

常見陷阱

後續步驟

​設定

​建立 CLMM 流動性池

​在選定範圍內開設部位

​增加現有部位的流動性

​減少流動性（同時收取費用）

​收取獎勵

​交換

​建立可自訂的 CLMM 流動性池

​限價單

​開設限價單

​增加/減少開放訂單

​結算已成交的訂單

​列出錢包的停泊訂單（離線）

​Rust CPI 骨架

​常見陷阱

​後續步驟

設定

建立 CLMM 流動性池

在選定範圍內開設部位

增加現有部位的流動性

減少流動性（同時收取費用）

收取獎勵

交換

建立可自訂的 CLMM 流動性池

限價單

開設限價單

增加/減少開放訂單

結算已成交的訂單

列出錢包的停泊訂單（離線）

Rust CPI 骨架

常見陷阱

後續步驟