Demo kode CLMM

Halaman ini diterjemahkan secara otomatis oleh AI. Versi bahasa Inggris adalah acuan resmi.Lihat versi bahasa Inggris →

Spesifikasi versi. Semua demo TypeScript menargetkan @raydium-io/raydium-sdk-v2@0.2.64-alpha; terakhir dijalankan terhadap 0.2.42-alpha (2026-04) dan tanda tangan panggilan mereka diperiksa ulang terhadap sumber 0.2.64-alpha pada 2026-09-09, terhadap Solana mainnet-beta. Kerangka CPI Rust di akhir menargetkan raydium-clmm di master, yang mengunci Anchor =0.32.1 — bukan 1.0.2 yang digunakan halaman CPMM; keduanya tidak dapat hidup dalam satu crate. ID program berasal dari reference/program-addresses melalui SDK.

Setup

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

Setiap demo di halaman ini mencerminkan file di raydium-sdk-V2-demo/src/clmm; tautan GitHub berada di sebelah setiap bagian. Bootstrap mengikuti config.ts.template repo demo (sumber) — disableFeatureCheck: true adalah pengaturan yang direkomendasikan untuk integrasi apa pun yang tidak trivial:

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;

Buat pool CLMM

Sumber: 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() mengembalikan ApiClmmConfigInfo (id adalah string). createPool menginginkan
// ClmmConfigInfo, yang memerlukan id PublicKey plus fundOwner/description — konversi:
const clmmConfigs = await raydium.api.getClmmConfigs();
const picked = clmmConfigs.find((c) => c.index === 1)!;        // tier 0.05%
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,   // tidak ada `startTime` — CreateConcentratedPool tidak memiliki field seperti itu
});

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

SDK:

Mengurutkan mint1/mint2 berdasarkan urutan byte sebelum derivasi.
Menghitung sqrt_price_x64 = floor(sqrt(initialPrice × 10^(dB−dA)) × 2^64).
Membuat akun observation dan tick_array_bitmap_extension.
Membayar biaya pembuatan pool yang ditentukan oleh ammConfig.

Buka posisi dalam rentang pilihan

Sumber: src/clmm/createPosition.ts

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

const POOL_ID = "<POOL_ID>";   // string base58
// catatan: getPoolInfoFromRpc CLMM mengembalikan `rpcPoolInfo`, bukan `rpcData` (CPMM melakukannya)
const { poolInfo, poolKeys, rpcPoolInfo } = await raydium.clmm.getPoolInfoFromRpc(POOL_ID);

// Pilih rentang harga. Di sini: ±10% dari harga saat ini.
const currentPrice = new Decimal(poolInfo.price);
const lowerPrice   = currentPrice.mul(0.9);
const upperPrice   = currentPrice.mul(1.1);

// Snap ke tick yang valid untuk tick_spacing pool ini.
// Kelasnya adalah TickUtil (singular), dan mengambil desimal + tickSpacing, bukan 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,
});

// Berapa banyak setiap token untuk disimpan.
const inputAmount = new BN(10_000_000);  // 0.01 SOL

// getLiquidityAmountOutFromAmountIn adalah async — 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("Posisi dibuka, tx:", txId);

SDK menghitung tick array mana yang disentuh rentang dan meneruskannya sebagai akun. Tidak perlu menggabungkan instruksi init apa pun — tidak ada instruksi init-tick-array; OpenPosition* mengalokasikan tick array yang hilang sendiri, dengan biaya pembayar.

Tingkatkan likuiditas pada posisi yang ada

Sumber: src/clmm/increaseLiquidity.ts

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

// Tidak ada getPositionInfo — enumerasi posisi dompet dan pilih satu.
const allPositions = await raydium.clmm.getOwnerPositionInfo({
  programId: poolInfo.programId,
});
const positionAccount = allPositions.find((p) => p.nftMint.equals(positionNftMint));
if (!positionAccount) throw new Error("posisi tidak ditemukan untuk dompet ini");

const { execute } = await raydium.clmm.increasePositionFromBase({
  poolInfo,
  ownerPosition: positionAccount,
  ownerInfo: { useSOLBalance: true },   // diperlukan
  base: "MintA",
  baseAmount: new BN(5_000_000),
  otherAmountMax: new BN(1_000_000_000),
  txVersion: TxVersion.V0,              // tidak ada anggota poolKeys pada panggilan ini
});

await execute({ sendAndConfirm: true });

Kurangi likuiditas (dan kumpulkan biaya pada saat yang sama)

Sumber: src/clmm/decreaseLiquidity.ts dan src/clmm/closePosition.ts

const { execute } = await raydium.clmm.decreaseLiquidity({
  poolInfo,
  poolKeys,
  ownerPosition: positionAccount,
  ownerInfo: {                       // diperlukan; closePosition ada di sini
    useSOLBalance: true,
    closePosition: false,
  },
  liquidity: positionAccount.liquidity.divn(2),   // setengahkan
  amountMinA: new BN(0),
  amountMinB: new BN(0),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Untuk mengumpulkan biaya dan reward saja, panggil decreaseLiquidity dengan liquidity = new BN(0). Efek samping instruksi adalah menyelesaikan token_fees_owed_{0,1} dan reward_amount_owed serta mentransfernya — ini adalah satu-satunya cara untuk mengumpulkan keduanya. Untuk menutup posisi sepenuhnya setelah menolkan likuiditas dan biaya, teruskan ownerInfo: { closePosition: true } pada panggilan decreaseLiquidity terakhir. SDK menambahkan ClosePosition dan membakar NFT.

Posisi penerbit terbatas memerlukan pembangun penutup yang kompatibel. Posisi ini memiliki akun token NFT yang dibekukan. ClosePosition harus menambahkan ID pool posisi sebagai akun sisa pertama sehingga CLMM dapat mencairkan akun sebelum membakarnya. Cabang sumber program tidak menyertakan perubahan SDK. Konfirmasi bahwa rilis SDK Anda secara eksplisit mendukung jalur penutup beku sebelum mengaktifkan pembuatan posisi penerbit terbatas.

Untuk klien Anchor langsung, pertahankan akun yang dideklarasikan tidak berubah dan tambahkan pool:

// Program CLMM: lihat reference/program-addresses; sumber ecb1577;
// Solana mainnet-beta; terakhir diverifikasi 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();

Anda dapat meneruskan poolId pada setiap penutupan. CLMM membacanya hanya ketika positionNftAccount dibekukan, yang membuat satu jalur klien kompatibel dengan posisi lama dan baru.

Kumpulkan reward

Sumber: 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 adalah pembangun MULTI-transaksi: `sequentially` diperlukan
// dan hasilnya adalah `txIds`, bukan `txId`.
const { txIds } = await execute({ sequentially: true });

harvestAllRewards berjalan melalui setiap posisi di setiap pool yang diteruskan, mengelompokkan panggilan DecreaseLiquidity zero-liquidity yang menyelesaikan biaya dan reward (plus UpdateRewardInfos apa pun), dan membaginya di seluruh transaksi jika diperlukan.

Swap

Sumber: src/clmm/swap.ts

Ini mencerminkan `src/clmm/swap.ts`, yang mensimulasikan dengan `swapInternal` daripada
`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;             // 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 untuk 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 },   // diperlukan
  remainingAccounts: simulation.accounts,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Simulasi berjalan melalui peta tick off-chain dengan logika yang sama seperti program on-chain dan mengembalikan jumlah keluar (amountCalculated) plus daftar akun yang tepat yang akan disentuh swap (accounts). Selalu teruskan remainingAccounts yang dikembalikan simulasi: terlalu sedikit dan swap akan kembali di tengah-jalan dengan NotEnoughTickArrayAccount; yang sudah usang hanya membuang compute.

PoolUtils.computeAmountOutFormat masih ada, tetapi memerlukan ComputeClmmPoolInfo ( computePoolInfo dari getPoolInfoFromRpc, bukan objek pool API) ditambah dua argumen wajib lagi — tickarrayBitmapExtension dan blockTimestamp — dan tidak ada metode raydium.clmm.fetchTickArrays (fetchTickArrays adalah fungsi bebas; pembantu tingkat modul adalah PoolUtils.fetchMultiplePoolTickArrays dan tickData / tickArrays yang dikembalikan oleh getPoolInfoFromRpc).

Buat pool CLMM yang dapat disesuaikan

createCustomizablePool adalah titik masuk yang mengekspos toggle biaya dinamis dan biaya satu sisi pada waktu pembuatan pool. Ini mengambil bentuk createPool ditambah dua penambahan:

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); // pilih tier kalibrasi

const { execute, extInfo } = await raydium.clmm.createCustomizablePool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  // Dua penambahan:
  collectFeeOn:      CollectFeeOn.TokenOnlyB,   // FromInput | TokenOnlyA | TokenOnlyB
  dynamicFeeConfig:  new PublicKey(dynamicFeeConfig!.id),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });
console.log("Pool yang dapat disesuaikan:", extInfo.address.id);   // string base58

Tidak ada flag enableDynamicFee dan tidak ada parameter dynamicFeeConfigId, dan tidak ada startTime. Menyediakan dynamicFeeConfig adalah apa yang mengaktifkan biaya dinamis — abaikan dan Anda mendapatkan pool biaya statis, tanpa kesalahan. Perhatikan juga bahwa anggota enum SDK adalah TokenOnlyA / TokenOnlyB, sedangkan enum Rust on-chain mengejanya Token0Only / Token1Only; nilai numeriknya cocok (FromInput = 0).

createPool terus bekerja untuk jalur biaya default, tanpa biaya dinamis. Gunakan createCustomizablePool kapan pun Anda memerlukan salah satu tombol. Lihat products/clmm/instructions untuk daftar akun on-chain.

Limit order

Limit order memarkir input pengguna pada satu tick dan diisi FIFO ketika swap melintasi tick itu. Output didorong ke ATA pemilik pada waktu penyelesaian; pemilik tidak perlu online untuk diisi.

Buka limit order

Tidak ada akun konfigurasi limit-order per-pool dan tidak ada pembantu `getClmmLimitOrderConfigs()` — order diindeks berdasarkan tick.

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

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

// Harga limit HARUS dikuantisasi ke tick_spacing — getOrderTick melakukan itu.
const targetPrice = new Decimal(180);                              // jual SOL pada 180 USDC
const orderData = getOrderTick({
  baseIn: true,                                                    // menjual mintA
  mintADecimal: poolInfo.mintA.decimals,
  mintBDecimal: poolInfo.mintB.decimals,
  tickSpacing: poolInfo.config.tickSpacing,
  price: targetPrice,
});

// Order jual harus berada di atas tick saat ini; order beli di bawahnya.
if (orderData.tick < rpcData.tickCurrent) throw new Error("harga jual harus > harga saat ini");

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,                           // opsional, default ke 0
  txVersion: TxVersion.V0,
});

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

SDK menurunkan PDA LimitOrderState dari (owner, nonce PDA, order nonce), menaikkan LimitOrderNonce per-dompet, dan menyisipkan order ke dalam kohort FIFO pada tick itu.

Tingkatkan / kurangi order terbuka

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,                 // opsional; DecreaseLimitOrder menambahkan ini di atas Increase
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

decreaseLimitOrder hanya dapat menghapus dari bagian unfilled order; bagian yang diisi terkunci sampai penyelesaian. Kedua instruksi kembali dengan InvalidOrderPhase jika order sudah sepenuhnya diisi.

Selesaikan order yang diisi

// settleLimitOrder hanya mengambil PDA order — tidak ada poolInfo, tidak ada poolKeys.
await raydium.clmm.settleLimitOrder({
  limitOrder,
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

settleLimitOrder membaca unfilled_ratio_x64 order terhadap pelacak kohort, menghitung output yang diisi, dan mentransfernya ke ATA pemilik. Pemilik dapat memanggil ini sendiri; limit_order_admin (pemelihara operasional off-chain) juga dapat memanggilnya atas nama pemilik — output masih pergi ke pemilik. Untuk menutup order yang sepenuhnya diselesaikan untuk memulihkan sewa, gunakan closeLimitOrder (tunggal) atau closeAllLimitOrder (batch). Untuk menyelesaikan banyak sekaligus, settleAllLimitOrder mengemas sebanyak mungkin panggilan SettleLimitOrder yang sesuai dalam tx v0.

Daftar order yang diparkir dompet (off-chain)

// Pembantu API. Lihat 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());

Endpoint order aktif mengembalikan order unfilled dan partially-filled dalam satu payload (totalAmount / filledAmount / pendingSettle membedakan fase). Untuk riwayat order tertutup gunakan /limit-order/history/order/list-by-user?wallet=… (per-dompet, dipaginasi oleh nextPageId); untuk log acara lengkap order tertentu gunakan /limit-order/history/event/list-by-pda?pda=….

Kerangka CPI Rust

// Cargo.toml — CLMM masih di Anchor 0.32, jadi tidak dapat berbagi crate dengan
// sampel CPMM di products/cpmm/code-demos (yang mengunci =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` adalah nama instruksi,
                                                 // `SwapSingleV2` adalah struct akun

#[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` membawa akun tick_array dan 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 mengambil AccountInfo program di sini. JANGAN ubah ini menjadi
    // Pubkey — itu adalah bentuk Anchor 1.0, yang tidak digunakan 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)
}

Urutan akun sisa untuk SwapV2:

[tick_array_bitmap_extension?, tick_array_0, tick_array_1, …]

Jika swap tidak pernah memerlukan ekstensi, abaikan; jika tidak, itu adalah akun sisa pertama.

Jebakan umum

Endpoint tick off-spacing → TickAndSpacingNotMatch. Selalu snap melalui TickUtil.getPriceAndTick (singular TickUtil).
Tidak cukup tick array yang disediakan dalam SwapV2 → NotEnoughTickArrayAccount. Ambil daftar dari swapInternal(...).accounts.
Posisi full-range tanpa ekstensi bitmap → PDA ekstensi harus writable; SDK menangani ini secara otomatis.
Mengacaukan sqrt_price_x64 dengan price → kebingungan faktor-2 di sini sangat menyakitkan. Jika ragu, biarkan SDK menghitungnya dari harga yang dapat dibaca manusia.
Mengumpulkan reward terlalu cepat → setiap pengumpulan adalah DecreaseLiquidity zero-liquidity dan biaya satu transaksi. Batch melalui harvestAllRewards di banyak posisi, dan ingat execute memerlukan { sequentially: true }.
Menutup akun NFT sendiri → ClosePosition membakar NFT dan menutup ATA-nya. Ini juga menutup mint NFT Token-2022; mint SPL Token klasik tetap pada supply nol karena program itu tidak dapat menutup mint. Jangan tutup akun yang didukung secara terpisah atau instruksi akan kembali.
Membuka limit order pada tick non-spaced → TickAndSpacingNotMatch. Selalu kuantisasi melalui pembantu getOrderTick yang diekspor.
Memanggil decreaseLimitOrder pada order yang sepenuhnya diisi → InvalidOrderPhase. Gunakan settleLimitOrder kemudian closeLimitOrder sebagai gantinya.
Mengharapkan flag enableDynamicFee → tidak ada. Menghilangkan dynamicFeeConfig hanya membuat pool biaya statis, diam-diam dan tanpa kesalahan. Jika Anda menginginkan biaya dinamis, teruskan PublicKey akun konfigurasi, dipilih dari /main/clmm-dynamic-config.

Ke mana selanjutnya

sdk-api/typescript-sdk — permukaan SDK lengkap.
sdk-api/rest-api — endpoint quote dan metadata pool.
user-flows/create-clmm-pool — panduan non-kode.
integration-guides/aggregator — routing CLMM sebagai bagian dari jalur.

Sumber:

Products

Algorithms

Setup

Buat pool CLMM

Buka posisi dalam rentang pilihan

Tingkatkan likuiditas pada posisi yang ada

Kurangi likuiditas (dan kumpulkan biaya pada saat yang sama)

Kumpulkan reward

Swap

Buat pool CLMM yang dapat disesuaikan

Limit order

Buka limit order

Tingkatkan / kurangi order terbuka

Selesaikan order yang diisi

Daftar order yang diparkir dompet (off-chain)

Kerangka CPI Rust

Jebakan umum

Ke mana selanjutnya

​Setup

​Buat pool CLMM

​Buka posisi dalam rentang pilihan

​Tingkatkan likuiditas pada posisi yang ada

​Kurangi likuiditas (dan kumpulkan biaya pada saat yang sama)

​Kumpulkan reward

​Swap

​Buat pool CLMM yang dapat disesuaikan

​Limit order

​Buka limit order

​Tingkatkan / kurangi order terbuka

​Selesaikan order yang diisi

​Daftar order yang diparkir dompet (off-chain)

​Kerangka CPI Rust

​Jebakan umum

​Ke mana selanjutnya

Setup

Buat pool CLMM

Buka posisi dalam rentang pilihan

Tingkatkan likuiditas pada posisi yang ada

Kurangi likuiditas (dan kumpulkan biaya pada saat yang sama)

Kumpulkan reward

Swap

Buat pool CLMM yang dapat disesuaikan

Limit order

Buka limit order

Tingkatkan / kurangi order terbuka

Selesaikan order yang diisi

Daftar order yang diparkir dompet (off-chain)

Kerangka CPI Rust

Jebakan umum

Ke mana selanjutnya