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 スケルトンは raydium-clmm の chore/upgrade-anchor ブランチ、Anchor 1.0.2 を対象としており、CPMM ページと同じピンなので、両者は 1 つのクレート内に共存できます。master はまだ 0.32.1 をピンしています。プログラム 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);        // 1 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` を返します。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 に対して有効なティックにスナップします。
// クラスは TickUtil（単数）で、poolInfo ではなく decimals + tickSpacing を取ります。
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 は範囲が接するティック配列を計算し、それらをアカウントとして渡します。init 命令をバンドルする必要はありません。init-tick-array 命令はなく、OpenPosition* は不足しているティック配列を自身で割り当てます。支払者の費用で。

既存ポジションのリクイディティを増加

ソース：src/clmm/increaseLiquidity.ts

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

// getPositionInfo はありません。ウォレットのポジションを列挙して 1 つを選びます。
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 は、CLMM がアカウントをバーンする前にそれを解凍できるように、ポジションのプール ID を最初の残りアカウントとして追加する必要があります。プログラムソースブランチには 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 が凍結されている場合にのみそれを読み取ります。これにより、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 は複数トランザクションビルダーです：`sequentially` が必須で、
// 結果は `txId` ではなく `txIds` です。
const { txIds } = await execute({ sequentially: true });

harvestAllRewards は渡されたすべてのプール上のすべてのポジションを走査し、手数料とリワードを決済するゼロリクイディティ DecreaseLiquidity 呼び出し（および任意の UpdateRewardInfos）をバッチ処理し、必要に応じてトランザクション全体に分割します。

スワップ

ソース：src/clmm/swap.ts

これは `src/clmm/swap.ts` をミラーしており、`PoolUtils.computeAmountOutFormat` ではなく
`swapInternal` でシミュレートします。

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

シミュレーションはオンチェーンプログラムと同じロジックでティックマップをオフチェーンで走査し、出力額（amountCalculated）とスワップが接するアカウントの正確なリスト（accounts）を返します。シミュレーションが返す remainingAccounts を常に渡してください。不足していると、スワップは NotEnoughTickArrayAccount でウォーク途中に戻ります。古いものは単にコンピュートを浪費します。

PoolUtils.computeAmountOutFormat はまだ存在しますが、ComputeClmmPoolInfo（getPoolInfoFromRpc からの computePoolInfo。API プールオブジェクトではない）と 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); // キャリブレーションティアを選択

const { execute, extInfo } = await raydium.clmm.createCustomizablePool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  // 2 つの追加：
  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 enum メンバーは TokenOnlyA / TokenOnlyB ですが、オンチェーン Rust enum は Token0Only / Token1Only と綴ります。数値は一致します（FromInput = 0）。

createPool はデフォルト手数料、動的手数料なしのパスで機能し続けます。どちらかのノブが必要な場合は常に createCustomizablePool を使用してください。オンチェーンアカウントリストについては products/clmm/instructions を参照してください。

リミットオーダー

リミットオーダーはユーザー入力を単一ティックに駐車し、スワップがそのティックを横切るときに FIFO で満たされます。出力は決済時に所有者の ATA にプッシュされます。所有者がオンラインである必要はありません。

リミットオーダーを開設

プール単位のリミットオーダー設定アカウントはなく、`getClmmLimitOrderConfigs()` ヘルパーもありません。オーダーはティックでキーイングされます。

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

// 売却オーダーは現在のティックより上に座る必要があります。買いオーダーはその下。
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 をバンプし、そのティックの 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 は v0 tx に収まるだけ多くの SettleLimitOrder 呼び出しをパックします。

ウォレットの駐車中のオーダーをリスト（オフチェーン）

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

アクティブオーダーエンドポイントは、未充足と部分充足の両方のオーダーを 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` はまだ anchor-lang 0.32.1 をピンしています。
// anchor-lang  = "=1.0.2"   // raydium-clmm がピンするものと一致する必要があります
// anchor-spl   = "=1.0.2"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "chore/upgrade-anchor", features = ["cpi"] }
//
// products/cpmm/code-demos の CPMM サンプルと同じ Anchor 行なので、両方の
// CPI クレートは 1 つのプログラムの依存関係になることができます。

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 とビットマップ拡張アカウントを運びます。
}

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 はプログラムの Pubkey をここに取ります。AccountInfo ではありません。0.32
    // `master` ブランチではこれは `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 をルーティング。

ソース：

プロダクト

アルゴリズム

セットアップ

CLMM プールの作成

選択した範囲でポジションを開設

既存ポジションのリクイディティを増加

リクイディティを減少（同時に手数料を回収）

リワードを回収

スワップ

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

リミットオーダー

リミットオーダーを開設

開いているオーダーを増加 / 減少

充足されたオーダーを決済

ウォレットの駐車中のオーダーをリスト（オフチェーン）

Rust CPI スケルトン

よくある落とし穴

次に進む

​セットアップ

​CLMM プールの作成

​選択した範囲でポジションを開設

​既存ポジションのリクイディティを増加

​リクイディティを減少（同時に手数料を回収）

​リワードを回収

​スワップ

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

​リミットオーダー

​リミットオーダーを開設

​開いているオーダーを増加 / 減少

​充足されたオーダーを決済

​ウォレットの駐車中のオーダーをリスト（オフチェーン）

​Rust CPI スケルトン

​よくある落とし穴

​次に進む

セットアップ

CLMM プールの作成

選択した範囲でポジションを開設

既存ポジションのリクイディティを増加

リクイディティを減少（同時に手数料を回収）

リワードを回収

スワップ

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

リミットオーダー

リミットオーダーを開設

開いているオーダーを増加 / 減少

充足されたオーダーを決済

ウォレットの駐車中のオーダーをリスト（オフチェーン）

Rust CPI スケルトン

よくある落とし穴

次に進む