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 的返回 `rpcData`）
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 tx 中。

列出钱包的停泊订单（离线）

// 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 框架

常见陷阱

接下来去哪里