CLMM 代码示例

本页内容由 AI 自动翻译，所有内容以英文版本为准。查看英文版 →

环境准备

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

本页的每个示例都对应 raydium-sdk-V2-demo/src/clmm 中的一个文件，每个小节旁边都附有对应的 GitHub 链接。初始化方式参考 demo 仓库中的 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() 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 会执行以下操作：

在推导之前，按字节顺序对 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 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 会计算该区间涉及哪些 tick array，并将其作为账户传入。它不需要打包任何初始化指令：不存在 init-tick-array 指令，OpenPosition* 会自行分配缺失的 tick array，费用由付款方承担。

增加现有仓位的流动性

源文件：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 });

减少流动性（同时领取手续费）

源文件：src/clmm/decreaseLiquidity.ts 和 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 });

若要仅领取手续费和奖励，请以 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 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();

每次关闭时都可以传入 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 is a MULTI-transaction builder: `sequentially` is required
// and the result is `txIds`, not `txId`.
const { txIds } = await execute({ sequentially: true });

harvestAllRewards 会遍历所传入的每个池中的每一个仓位，将用于结算手续费和奖励的零流动性 DecreaseLiquidity 调用（以及任何 UpdateRewardInfos）打包在一起，必要时拆分到多笔交易中。

Swap

来源：src/clmm/swap.ts 本示例与 src/clmm/swap.ts 保持一致，它使用 swapInternal 进行模拟，而不是 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 });

模拟过程会在链下按照与链上程序相同的逻辑遍历 tick map，并返回输出数量（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); // pick a calibration tier

const { execute, extInfo } = await raydium.clmm.createCustomizablePool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  // The two additions:
  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 string

不存在 enableDynamicFee、dynamicFeeConfigId 或 startTime 参数。只要传入 dynamicFeeConfig，就会启用动态手续费 —— 如果省略它，你会得到一个固定手续费的池，且不会报错。另外注意，SDK 的枚举成员名为 TokenOnlyA / TokenOnlyB，而链上 Rust 枚举的拼写是 Token0Only / Token1Only；两者的数值一致（FromInput = 0）。

createPool 在默认手续费、无动态手续费的场景下仍然可用。只要需要上述任一功能，就改用 createCustomizablePool。链上账户列表请参阅 products/clmm/instructions。

限价单

限价单会将用户的输入资产挂在单一 tick 上，当兑换跨过该 tick 时按先进先出（FIFO）的顺序成交。产出资金会在结算时转入所有者的 ATA；所有者无需在线即可完成成交。

开启限价单

该池不存在按池配置的限价单账户，也没有 getClmmLimitOrderConfigs() 辅助方法 —— 订单以 tick 作为索引。

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

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

// Limit price MUST be quantized to tick_spacing — getOrderTick does that.
const targetPrice = new Decimal(180);                              // sell SOL at 180 USDC
const orderData = getOrderTick({
  baseIn: true,                                                    // selling mintA
  mintADecimal: poolInfo.mintA.decimals,
  mintBDecimal: poolInfo.mintB.decimals,
  tickSpacing: poolInfo.config.tickSpacing,
  price: targetPrice,
});

// A sell order must sit above the current tick; a buy order below it.
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,                           // optional, defaults to 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,                 // optional; DecreaseLimitOrder adds this over Increase
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

decreaseLimitOrder 只能从订单中未成交的部分移除资产；已成交的部分会被锁定，直到结算完成。如果订单已全部成交，这两条指令都会以 InvalidOrderPhase 回滚。

结算已成交的订单

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

settleLimitOrder 会根据跟踪器读取订单的 unfilled_ratio_x64，计算已成交的产出，并将其转入所有者的 ATA。所有者可以自行调用；limit_order_admin（链下运维 keeper）也可以代为调用，但产出仍然归所有者。如需关闭已完全结算的订单以回收租金，可使用 closeLimitOrder（单个）或 closeAllLimitOrder（批量）。如需一次结算多个订单，settleAllLimitOrder 会将尽可能多的 SettleLimitOrder 调用打包进一笔 v0 交易。

列出钱包中挂单的订单（链下）

// API helper. See 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 — `master` pins anchor-lang =1.0.2.
// anchor-lang  = "=1.0.2"   // must match what raydium-clmm pins
// anchor-spl   = "=1.0.2"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "master", features = ["cpi"] }
//
// Same Anchor line as the CPMM sample in products/cpmm/code-demos, so both
// CPI crates can be dependencies of one program.

use anchor_lang::prelude::*;
use raydium_clmm::cpi;
use raydium_clmm::program::RaydiumClmm;
use raydium_clmm::cpi::accounts::SwapSingleV2;   // `SwapV2` is the instruction name,
                                                 // `SwapSingleV2` is the accounts struct

#[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` carries the tick_array and bitmap_extension accounts.
}

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 takes the program's Pubkey here, not its AccountInfo. On the
    // 0.32 `master` branch this was `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)
}

SwapV2 的剩余账户顺序如下：

[tick_array_bitmap_extension?, tick_array_0, tick_array_1, …]

如果兑换从不需要扩展账户，则省略它；否则它就是第一个剩余账户。

常见陷阱

tick 端点未对齐间距 → TickAndSpacingNotMatch。请始终通过 TickUtil.getPriceAndTick（注意是单数的 TickUtil）进行对齐。
SwapV2 中提供的 tick array 数量不足 → NotEnoughTickArrayAccount。请从 swapInternal(...).accounts 中获取该列表。
全范围仓位未使用 bitmap 扩展 → 扩展 PDA 必须可写。SDK 会自动处理这一点。
把 sqrt_price_x64 误当作 price → 这里的 2 倍系数错误尤其难排查。如有疑问，请让 SDK 根据可读的价格进行计算。
过于频繁地领取奖励 → 每次领取都是一笔零流动性的 DecreaseLiquidity，且各自占用一笔交易。请通过 harvestAllRewards 批量处理多个仓位，并注意其 execute 需要传入 { sequentially: true }。
自行关闭 NFT 账户 → ClosePosition 会销毁 NFT 并关闭其 ATA。对于 Token-2022 NFT mint，它同样会将其关闭；而经典 SPL Token mint 则会保留，供应量为零，因为该程序无法关闭 mint。请勿单独关闭受支持的账户，否则指令会回滚。
在未对齐间距的 tick 上开立限价单 → TickAndSpacingNotMatch。请始终通过导出的 getOrderTick 辅助函数进行量化。
对已完全成交的订单调用 decreaseLimitOrder → InvalidOrderPhase。请改用 settleLimitOrder，然后再调用 closeLimitOrder。
以为存在 enableDynamicFee 标志 → 实际上并不存在。省略 dynamicFeeConfig 只会创建一个静态费率池，不会有任何提示或报错。如果你需要动态费率，请传入配置账户的 PublicKey，可从 /main/clmm-dynamic-config 中选取。

下一步

sdk-api/typescript-sdk — 完整的 SDK 接口说明。
sdk-api/rest-api — 报价与池元数据接口。
user-flows/create-clmm-pool — 无需编码的操作流程说明。
integration-guides/aggregator — 将 CLMM 纳入聚合路由路径的方法。

来源：

产品

算法

环境准备

创建 CLMM 池

在指定区间开仓

增加现有仓位的流动性

减少流动性（同时领取手续费）

领取奖励

Swap

创建可自定义的 CLMM 池

限价单

开启限价单

增加 / 减少已开启的订单

结算已成交的订单

列出钱包中挂单的订单（链下）

Rust CPI 骨架

常见陷阱

下一步

​环境准备

​创建 CLMM 池

​在指定区间开仓

​增加现有仓位的流动性

​减少流动性（同时领取手续费）

​领取奖励

​Swap

​创建可自定义的 CLMM 池

​限价单

​开启限价单

​增加 / 减少已开启的订单

​结算已成交的订单

​列出钱包中挂单的订单（链下）

​Rust CPI 骨架

​常见陷阱

​下一步

环境准备

创建 CLMM 池

在指定区间开仓

增加现有仓位的流动性

减少流动性（同时领取手续费）

领取奖励

Swap

创建可自定义的 CLMM 池

限价单

开启限价单

增加 / 减少已开启的订单

结算已成交的订单

列出钱包中挂单的订单（链下）

Rust CPI 骨架

常见陷阱

下一步