CLMM コードデモ

エンドツーエンドの TypeScript の例：CLMM プールの作成、任意の価格帯でのポジションのオープン、リクイディティの調整、スワップ、フィーとリワードの回収。

このページは AI による自動翻訳です。すべての内容は英語版を正とします。

英語版を表示 →

​

セットアップ

このページのすべてのデモは、raydium-sdk-V2-demo/src/clmm 内のファイルに対応しています。各セクションの横に GitHub へのリンクがあります。初期化処理はデモリポジトリの config.ts.template に従います（ソース）。本格的な連携では、disableFeatureCheck: true を設定することを推奨します。

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

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 配列に触れるかを計算し、それらをアカウントとして渡します。初期化用の命令をバンドルする必要はありません。init-tick-array 命令は存在せず、OpenPosition* が不足している tick 配列を支払者の負担で自動的に割り当てます。

​

既存のポジションにリクイディティを追加する

ソース：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 が精算され、外部に送金されます。どちらかを回収する方法は、これonly です。

流動性とフィーをゼロにした後にポジションを完全にクローズするには、最後の decreaseLiquidity 呼び出しで ownerInfo: { closePosition: true } を渡します。SDK は ClosePosition を追加し、NFT をバーンします。

制限付き発行者のポジションには、対応するクローズビルダーが必要です。 これらのポジションでは NFT のトークンアカウントが凍結されています。CLMM がバーンの前にアカウントを解凍できるよう、ClosePosition はポジションのプール ID を残りのアカウントの先頭に追加する必要があります。プログラムのソースブランチには 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 が凍結されている場合のみです。そのため、1 つのクライアントの処理で古いポジションと新しいポジションの両方に対応できます。

​

リワードを回収する

ソース：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）をまとめます。必要な場合は、それらを複数のトランザクションに分割します。

​

スワップ

ソース：src/clmm/swap.ts

このサンプルは src/clmm/swap.ts を再現したものです。PoolUtils.computeAmountOutFormat ではなく swapInternal を使ってシミュレーションを行います。

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 });

シミュレーションは、オンチェーンプログラムと同じロジックでティックマップをオフチェーン上で走査し、出力量（amountCalculated）と、スワップが触れる正確なアカウント一覧（accounts）を返します。

シミュレーションが返した remainingAccounts は必ず渡してください。数が足りないとスワップは走査の途中で NotEnoughTickArrayAccount によりリバートします。古いアカウントを渡した場合はリバートはしませんが、計算リソースを無駄に消費します。

PoolUtils.computeAmountOutFormat も引き続き存在しますが、ComputeClmmPoolInfo（API のプールオブジェクトではなく、getPoolInfoFromRpc が返す computePoolInfo）と、さらに 2 つの必須引数（tickarrayBitmapExtension と blockTimestamp）が必要です。また、raydium.clmm.fetchTickArrays メソッドは存在しません。fetchTickArrays はフリー関数で、モジュールレベルのヘルパーは PoolUtils.fetchMultiplePoolTickArrays と、getPoolInfoFromRpc が返す tickData / tickArrays です。

​

カスタマイズ可能な CLMM プールの作成

createCustomizablePool は、プール作成時に動的手数料と片側手数料のトグルを指定できるエントリーポイントです。引数は createPool と同じ形に、2 つの項目を追加したものになります。

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 を参照してください。

​

指値注文

指値注文は、ユーザーの入力資産を単一のティックに預けておき、スワップがそのティックを横切ったときに先入れ先出し（FIFO）で約定させる仕組みです。出力はセトルの時点で所有者の ATA に送られるため、約定のために所有者がオンラインである必要はありません。

​

指値注文の作成

プールごとの指値注文設定アカウントや getClmmLimitOrderConfigs() ヘルパーは存在しません。注文はティックをキーとして管理されます。

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 を更新して、注文をそのティックの 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 も、所有者の代わりに呼び出せます。その場合も出力は所有者に送られます。

完全に決済された注文のレントを回収するには、closeLimitOrder（単一）または closeAllLimitOrder（一括）を使用します。複数の注文をまとめて決済する場合は、settleAllLimitOrder が v0 トランザクションに収まる範囲で SettleLimitOrder の呼び出しをまとめます。

​

ウォレットの未約定注文の一覧取得（オフチェーン）

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

有効な注文のエンドポイントは、未約定と一部約定の両方の注文を 1 つのペイロードで返します。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, …]

スワップでビットマップ拡張が不要な場合は省略してください。必要な場合は、残りアカウントの先頭に配置します。

​

よくある落とし穴

• ティック範囲の端点が間隔に合っていない → TickAndSpacingNotMatch。必ず TickUtil.getPriceAndTick を使ってスナップしてください（TickUtil は単数形）。
• SwapV2 に供給するティック配列が不足している → NotEnoughTickArrayAccount。一覧は swapInternal(...).accounts から取得してください。
• ビットマップ拡張なしでフルレンジのポジションを作成している → 拡張の PDA は書き込み可能である必要があります。SDK がこれを自動的に処理します。
• sqrt_price_x64 を price と取り違えている → ここでの 2 倍の誤差は特に厄介です。迷ったら、人が読める価格から SDK に計算させてください。
• 報酬の回収が頻繁すぎる → 回収のたびにゼロ流動性の DecreaseLiquidity が実行され、トランザクションが 1 件ずつ発生します。複数のポジションをまとめて処理するには harvestAllRewards を使い、その execute には { sequentially: true } が必要な点に注意してください。
• NFT アカウントを自分でクローズしている → ClosePosition は NFT をバーンし、その ATA もクローズします。Token-2022 の NFT ミントもクローズされます。一方、従来の SPL Token ミントは、そのプログラムではミントをクローズできないため、供給量ゼロのまま残ります。対応しているアカウントを個別にクローズしないでください。そうすると命令がリバートします。
• ティック間隔に合っていない位置で指値注文を開いている → 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 を組み込む方法。

出典：

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