Akun CLMM

Setiap akun yang disentuh pool CLMM: PoolState, AmmConfig, TickArrayState, TickArrayBitmapExtension, PersonalPositionState, dan Observation.

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

Lihat versi bahasa Inggris →

Halaman ini menjelaskan tata letak dan peran setiap akun. Seed bersifat kanonik dan tercantum di reference/program-addresses. Pool CLMM lebih berat dalam hal akun dibanding pool CPMM karena likuiditas disimpan secara sparse di seluruh rentang tick; memahami sparsity ini adalah inti dari halaman ini.

​

Inventaris akun

Pool CLMM yang aktif dijelaskan oleh keluarga akun berikut. Semua dimiliki oleh program CLMM kecuali dua mint dan vault mereka.

Akun	Tujuan	Jumlah per pool
AmmConfig	Tingkat biaya: tingkat biaya perdagangan, bagian protokol, bagian dana, tick-spacing default. Dibagikan di semua pool dalam tingkat ini.	1 (dibagikan)
PoolState	sqrt_price_x64 saat ini, tick saat ini, total likuiditas, global fee growth, info reward, observation pointer.	1
TickArrayState	Blok TICK_ARRAY_SIZE tick yang berdekatan. Hanya diinisialisasi sesuai permintaan.	0 ≤ N ≤ range
TickArrayBitmapExtension	Bitmap overflow yang melacak tick array mana yang ada di luar bitmap inline di PoolState.	0 atau 1
PersonalPositionState	Satu per posisi LP. Menyimpan rentang, likuiditas, dan fee/reward growth terakhir yang terlihat. Authority = pemilik NFT.	1 per posisi
Position NFT mint	Mint dengan supply 1, terkait dengan PersonalPositionState. Token account-nya tidak dibekukan secara default; V2 open membekukannya hanya ketika mint yang mendasar cocok dengan filter restricted-issuer.	1 per posisi
ObservationState	Ring buffer observasi harga untuk TWAP.	1
token_0_vault, token_1_vault	Token account yang menyimpan saldo pool. Dimiliki oleh pool authority.	2
DynamicFeeConfig	Set parameter yang dapat digunakan kembali untuk mekanisme dynamic-fee. Pool yang dibuat via create_customizable_pool dapat memilih untuk mengikuti. Dikelola admin.	dibagikan (per index)
LimitOrderState	Satu per limit order terbuka. Mencatat pemilik, tick, side, jumlah total, snapshot settled-output.	1 per order
LimitOrderNonce	Per-(wallet, nonce_index) counter yang menurunkan PDA order unik.	1 per (wallet, index)

​

PoolState

Status pool yang aktif, dibaca pada setiap swap dan setiap perubahan posisi.

// programs/amm/src/states/pool.rs
pub struct PoolState {
    pub bump:           [u8; 1],
    pub amm_config:     Pubkey,            // fee tier binding
    pub owner:          Pubkey,            // admin (multisig)
    pub token_mint_0:   Pubkey,
    pub token_mint_1:   Pubkey,
    pub token_vault_0:  Pubkey,
    pub token_vault_1:  Pubkey,
    pub observation_key: Pubkey,

    pub mint_decimals_0: u8,
    pub mint_decimals_1: u8,
    pub tick_spacing:   u16,               // inherited from amm_config at init

    pub liquidity:      u128,              // total active (in-range) liquidity
    pub sqrt_price_x64: u128,              // Q64.64 of sqrt(price)
    pub tick_current:   i32,               // current tick index

    pub padding3:       u16,
    pub padding4:       u16,

    // Global fee growth per unit of liquidity, Q64.64.
    pub fee_growth_global_0_x64: u128,
    pub fee_growth_global_1_x64: u128,

    // Accrued-but-not-swept protocol fees (per mint).
    pub protocol_fees_token_0: u64,
    pub protocol_fees_token_1: u64,

    // Reserved padding for future upgrades.
    pub padding5: [u128; 4],

    // Status bitmask. Bits 0-5: open-position, decrease-liquidity,
    // collect-fee, collect-reward, swap, limit-order. A set bit disables
    // the corresponding operation.
    pub status:  u8,

    // Fee-collection mode (CollectFeeOn).
    //   0 = FromInput (deduct fee from the swap input — Uniswap-V3 default)
    //   1 = Token0Only (always deduct fee from token0 vault)
    //   2 = Token1Only (always deduct fee from token1 vault)
    pub fee_on: u8,

    // Client-supplied index (u16 LE) folded into the pool PDA seeds by
    // create_customizable_pool_v2. [0, 0] for pools created via CreatePool /
    // CreateCustomizablePool (the seed component collapses to empty).
    pub seed_index: [u8; 2],
    pub padding: [u8; 4],

    // Live reward streams (up to REWARD_NUM = 3).
    pub reward_infos: [RewardInfo; 3],

    // Inline bitmap tracking initialized tick-arrays in the primary range.
    pub tick_array_bitmap: [u64; 16],

    // Reserved padding for future upgrades.
    pub padding6: [u64; 4],

    pub fund_fees_token_0: u64,
    pub fund_fees_token_1: u64,

    pub open_time:    u64,                 // currently disabled by the program
    pub recent_epoch: u64,

    // Per-pool dynamic-fee state. Zero-valued unless the pool was
    // created with `enable_dynamic_fee = true` via create_customizable_pool.
    pub dynamic_fee_info: DynamicFeeInfo,

    // Reserved for future upgrades.
    pub padding1: [u64; 14],
    pub padding2: [u64; 32],
}

Field yang benar-benar akan Anda sentuh:

• sqrt_price_x64 dan tick_current adalah status harga pool. Keduanya diperbarui bersama pada setiap swap. tick_current adalah floor dari log_{1.0001}(price).
• liquidity adalah likuiditas aktif — jumlah nilai L untuk semua posisi yang rentangnya berisi tick_current. Berubah setiap kali swap melintasi tick dan setiap kali posisi dibuka/ditutup/diubah ukurannya.
• fee_growth_global_{0,1}_x64 adalah biaya kumulatif yang diperoleh per unit likuiditas di seluruh riwayat pool. Posisi membaca ini untuk menghitung apa yang mereka terima.
• tick_spacing terkunci ke AmmConfig saat inisialisasi dan tidak pernah berubah. Ini menentukan indeks tick mana yang diizinkan menjadi endpoint posisi.
• tick_array_bitmap adalah bitmap inline yang mencakup rentang tick yang umum digunakan di sekitar spot price. Untuk pool yang posisinya menjangkau jauh, pelacakan overflow hidup di TickArrayBitmapExtension terpisah.
• fee_on ditetapkan saat pembuatan pool. 0 (FromInput) mereproduksi perilaku klasik Uniswap-V3. 1 dan 2 mengarahkan biaya swap ke satu sisi buku — lihat products/clmm/fees untuk trade-off.
• seed_index adalah [0, 0] untuk setiap pool yang dibuat melalui CreatePool / CreateCustomizablePool (satu pool kanonik per pasangan). Nilai non-zero berarti pool dibuat via CreateCustomizablePoolV2 (bernama CreatePermissionedPool sebelum 2026-10-22) dan indeks adalah bagian dari seed PDA pool, memungkinkan beberapa pool hidup berdampingan untuk (config, mint0, mint1) yang sama. Untuk menurunkan ulang alamat pool seperti itu, Anda harus mengetahui seed_index-nya.
• dynamic_fee_info membawa status volatilitas untuk surcharge dynamic-fee. Ketika diaktifkan, setiap swap menghitung ulang dynamic_fee_component di atas AmmConfig.trade_fee_rate. Tata letak didokumentasikan di bawah DynamicFeeInfo; pool tanpa dynamic fee membiarkan seluruh struct bernilai nol.

​

AmmConfig

pub struct AmmConfig {
    pub bump: u8,
    pub index: u16,                       // uses "amm_config"+u16 seed

    pub owner:             Pubkey,        // protocol-fee owner (CollectProtocolFee)
    pub protocol_fee_rate: u32,           // fraction of trade fee to protocol, denom 1e6
    pub trade_fee_rate:    u32,           // trade fee in 1e6ths of volume
    pub tick_spacing:      u16,           // default spacing for pools using this config
    pub fund_fee_rate:     u32,           // fraction of trade fee to fund, denom 1e6
    pub padding_u32: u32,

    pub fund_owner: Pubkey,               // fund-fee owner (CollectFundFee)
    pub padding: [u64; 3],
}

Sejak upgrade 2026-09, CreateAmmConfig menulis protocol_fee_owner::ID yang dikodekan keras program ke dalam owner dan fund_fee_owner::ID ke dalam fund_owner. Sebelumnya, ia menyalin kunci penandatangan admin ke keduanya. Config yang ada mempertahankan apa pun yang mereka buat atau putar ke, jadi baca kedua field dari akun. Parameter UpdateAmmConfig 3 / 4 masih memutar mereka. Alamat ada di reference/program-addresses.

Set tingkat biaya CLMM yang dipublikasikan secara khas (konfirmasi terhadap GET https://api-v3.raydium.io/main/clmm-config):

Index	trade_fee_rate	Tick spacing	Penggunaan khas
0	100 (0.01%)	1	Pasangan stabil, USDC/USDT
1	500 (0.05%)	10	Blue-chip berkorelasi
2	2_500 (0.25%)	60	Pasangan standar
3	10_000 (1.00%)	120	Volatile atau long-tail

protocol_fee_rate dan fund_fee_rate adalah fraksi dari biaya perdagangan; konvensi yang sama dengan CPMM. Lihat products/clmm/fees.

​

TickArrayState

CLMM tidak menyimpan satu catatan per tick. Itu akan menjadi miliaran akun. Sebaliknya, CLMM mengelompokkan TICK_ARRAY_SIZE tick yang berdekatan (diinisialisasi atau tidak) (biasanya 60 atau 88 tergantung versi program) ke dalam TickArrayState yang dibuat secara malas saat pertama kali digunakan.

pub const TICK_ARRAY_SIZE: usize = 60;
pub const TICK_ARRAY_SIZE_USIZE: usize = 60;

pub struct TickArrayState {
    pub pool_id:                Pubkey,
    pub start_tick_index:       i32,                            // lowest tick in this array
    pub ticks:                  [TickState; TICK_ARRAY_SIZE],   // 60 entries
    pub initialized_tick_count: u8,
    pub recent_epoch:           u64,
    pub padding:                [u8; 107],
}

pub struct TickState {
    pub tick:                       i32,
    pub liquidity_net:              i128,                       // ΔL when crossing this tick upward
    pub liquidity_gross:            u128,                       // total L referencing this tick
    pub fee_growth_outside_0_x64:   u128,                       // see math.mdx
    pub fee_growth_outside_1_x64:   u128,
    pub reward_growths_outside_x64: [u128; 3],

    // Limit-order bookkeeping. All zero for ticks that have never carried
    // a limit order. See products/clmm/math for the matching algorithm.
    pub order_phase:                  u64,                      // monotonic FIFO cohort id
    pub orders_amount:                u64,                      // unfilled tokens in current cohort
    pub part_filled_orders_remaining: u64,                      // remaining tokens of partially-filled cohort
    pub unfilled_ratio_x64:           u128,                     // Q64.64; starts at 1.0 and shrinks as fills occur

    pub padding:                    [u32; 3],
}

Empat field limit-order bernilai nol pada tick apa pun yang tidak pernah digunakan untuk limit order. Ketika order dibuka pada tick, program melacaknya sebagai urutan cohort:

• order_phase adalah id cohort. Nilainya bertambah setiap kali cohort bertransisi dari “semua unfilled” menjadi “partially filled.”
• orders_amount adalah total input-token dari cohort saat ini (terbaru).
• part_filled_orders_remaining melacak cohort sebelumnya yang sedang diisi oleh swap yang sedang berlangsung.
• unfilled_ratio_x64 adalah pengali Q64.64 yang dibawa pada cohort: ketika swap mengisi X% dari cohort, rasio dikalikan dengan (1 − X). Setiap open order menyimpan snapshot (order_phase, unfilled_ratio_x64) miliknya sendiri saat waktu pembukaan, jadi matematika settle berkurang menjadi membandingkan snapshot.

Aturan:

• Tick endpoint posisi t harus memenuhi t % tick_spacing == 0. Program menolak posisi yang tidak sesuai spacing.
• Array tick berada di floor(t / (TICK_ARRAY_SIZE * tick_spacing)) * (TICK_ARRAY_SIZE * tick_spacing).
• Tick array diinisialisasi secara malas: posisi atau swap pertama yang menyentuh array yang belum diinisialisasi membuatnya, membayar rent.
• Tick array tidak pernah ditutup oleh program. Setelah dialokasikan, tick array bertahan selama masa hidup pool, bahkan setelah setiap tick di dalamnya kembali ke liquidity_gross == 0. Posisi dan swap berikutnya menggunakan kembali akun yang ada tanpa rent tambahan. Tidak ada jalur pembersihan yang didorong ClosePosition untuk tick array.

​

TickArrayBitmapExtension

PoolState.tick_array_bitmap (inline) mencakup rentang “dekat spot” — ±512 tick array (TICK_ARRAY_BITMAP_SIZE = 512; field [u64; 16] adalah 1.024 bit yang dibagi rata antara indeks start negatif dan positif, jadi indeks array −512 … +511). Di luar rentang itu (untuk nilai tick ekstrem), program mempertahankan akun extension:

pub struct TickArrayBitmapExtension {
    pub pool_id: Pubkey,
    pub positive_tick_array_bitmap: [[u64; 8]; 14],
    pub negative_tick_array_bitmap: [[u64; 8]; 14],
}

Jika rentang posisi Anda “normal”, Anda tidak perlu memikirkan akun extension. Posisi full-range (misalnya, (MIN_TICK, MAX_TICK)) memerlukan extension; SDK menyelesaikannya untuk Anda.

​

Posisi

Posisi CLMM adalah bundel dari tiga akun plus mint:

​

Position NFT mint

Mint SPL Token atau Token-2022 dengan supply 1. Position NFT di dompet pemilik adalah ATA yang memegang token tunggal itu. Program mengikat otorisasi ke pemegang saat ini dari saldo ATA NFT, bukan ke Pubkey yang disimpan dalam state.

Position NFT mint baru menetapkan pool_state sebagai freeze authority mereka sebelum minting token tunggal dan menghapus mint authority. Menetapkan freeze authority tidak dengan sendirinya membekukan akun NFT. Akun tetap unfrozen dan dapat ditransfer kecuali kedua kondisi berlaku: pemanggil menggunakan OpenPositionV2 atau OpenPositionWithToken22Nft, dan freeze authority dari setidaknya satu mint vault yang mendasar muncul di daftar restricted-issuer CLMM. Hanya kemudian CLMM membekukan akun NFT setelah minting. Ini tidak mengubah byte PersonalPositionState atau PoolState apa pun.

​

PersonalPositionState

Satu per posisi terbuka. Dikey dari NFT mint.

pub struct PersonalPositionState {
    pub bump: [u8; 1],
    pub nft_mint: Pubkey,                 // this position's NFT mint
    pub pool_id:  Pubkey,

    pub tick_lower_index: i32,
    pub tick_upper_index: i32,

    pub liquidity: u128,                  // this position's L

    // Fee-growth snapshots at last time the position was touched.
    pub fee_growth_inside_0_last_x64: u128,
    pub fee_growth_inside_1_last_x64: u128,
    pub token_fees_owed_0: u64,           // accrued since last collect
    pub token_fees_owed_1: u64,

    pub reward_infos: [PositionRewardInfo; 3],
    pub recent_epoch: u64,
    pub padding: [u64; 7],
}

pub struct PositionRewardInfo {
    pub growth_inside_last_x64: u128,
    pub reward_amount_owed: u64,
}

​

ProtocolPositionState (deprecated)

Rilis CLMM yang lebih lama menyimpan bookkeeping agregat per-(pool, tick_lower, tick_upper) dalam PDA ProtocolPositionState. Rilis yang lebih baru tidak lagi membuat atau membaca akun ini. Slot masih muncul di daftar akun OpenPosition / IncreaseLiquidity / DecreaseLiquidity sebagai UncheckedAccount untuk kompatibilitas ABI, tetapi program tidak menulis ke dalamnya. Akun yang ada on-chain adalah vestigial; admin dapat memanggil CloseProtocolPosition untuk mengklaim kembali rent untuk mereka.

Bookkeeping range agregat sekarang diturunkan langsung dari dua tick endpoint (liquidity_gross, liquidity_net, dan per-tick fee_growth_outside_* / reward_growths_outside_x64) dalam TickArrayState. Formula fee-growth-inside fee_growth_inside = global − outside_lower − outside_upper terus bekerja tanpa akun posisi agregat.

​

Observation

pub const OBSERVATION_NUM: usize = 100;

pub struct Observation {
    pub block_timestamp: u32,
    pub tick_cumulative: i64,                            // Σ tick_current × Δt
    pub padding:         [u64; 4],
}

pub struct ObservationState {
    pub initialized:       bool,
    pub recent_epoch:      u64,
    pub observation_index: u16,
    pub pool_id:           Pubkey,
    pub observations:      [Observation; OBSERVATION_NUM], // 100 entries
    pub padding:           [u64; 4],
}

Buffer observation CLMM menyimpan cumulative tick, bukan cumulative price. Konsumen eksternal menghitung geometric-mean price selama interval dari (tick_cumulative[t1] − tick_cumulative[t0]) / (t1 − t0) dan kemudian price = 1.0001 ** tick. Lihat algorithms/clmm-math.

​

DynamicFeeConfig dan DynamicFeeInfo

Parameter dynamic fee berada di dua tempat. Template yang dapat digunakan kembali — DynamicFeeConfig — dikelola admin dan dibagikan di seluruh pool yang opt-in. State runtime per-pool — DynamicFeeInfo — tertanam dalam PoolState dan diperbarui oleh setiap swap.

​

DynamicFeeConfig

// programs/amm/src/states/pool_fee.rs
pub struct DynamicFeeConfig {
    pub index:                       u16,    // identifier; PDA seed component
    pub filter_period:               u16,    // seconds — within this window the volatility reference is held
    pub decay_period:                u16,    // seconds — beyond this window the reference fully decays
    pub reduction_factor:            u16,    // fixed-point in [1, 10_000); applied at decay
    pub dynamic_fee_control:         u32,    // fixed-point in (0, 100_000); fee-rate gain
    pub max_volatility_accumulator:  u32,    // ceiling on the volatility accumulator
    pub padding:                     [u64; 8],
}

PDA seed: ["dynamic_fee_config", index.to_be_bytes()]. Dibuat melalui create_dynamic_fee_config (admin-gated) dan dimodifikasi melalui update_dynamic_fee_config. Pool yang dibuat dengan enable_dynamic_fee = true mengambil snapshot lima parameter kalibrasi config (filter_period, decay_period, reduction_factor, dynamic_fee_control, max_volatility_accumulator) ke dalam DynamicFeeInfo miliknya sendiri saat waktu pembuatan; edit kemudian ke DynamicFeeConfig tidak mempengaruhi pool yang ada secara retroaktif.

​

DynamicFeeInfo (tertanam dalam PoolState)

pub struct DynamicFeeInfo {
    pub filter_period:                u16,
    pub decay_period:                 u16,
    pub reduction_factor:             u16,
    pub dynamic_fee_control:          u32,
    pub max_volatility_accumulator:   u32,
    pub tick_spacing_index_reference: i32,    // tick-spacing-units; reference for next swap
    pub volatility_reference:         u32,    // running floor for the accumulator
    pub volatility_accumulator:       u32,    // current cumulative volatility (capped)
    pub last_update_timestamp:        u64,
    pub padding:                      [u8; 46],
}

Empat field terbawah adalah state; lima field teratas adalah kalibrasi yang disalin dari DynamicFeeConfig. Matematika fee dan aturan decay didokumentasikan di bawah products/clmm/math dan products/clmm/fees.

Konstanta yang digunakan oleh formula:

Konstanta	Nilai	Makna
VOLATILITY_ACCUMULATOR_SCALE	10_000	Granularitas volatility accumulator
REDUCTION_FACTOR_DENOMINATOR	10_000	Denominator untuk reduction_factor
DYNAMIC_FEE_CONTROL_DENOMINATOR	100_000	Denominator untuk dynamic_fee_control
MAX_FEE_RATE_NUMERATOR	100_000	Hard cap 10% pada fee rate yang dihasilkan

​

LimitOrderState

Satu akun per open limit order.

// programs/amm/src/states/limit_order.rs
pub struct LimitOrderState {
    pub pool_id:            Pubkey,
    pub owner:              Pubkey,
    pub tick_index:         i32,
    pub zero_for_one:       bool,    // direction: true sells token0 for token1
    pub order_phase:        u64,     // snapshot of TickState.order_phase at open time
    pub total_amount:       u64,     // input-token amount placed
    pub filled_amount:      u64,     // informational; computed precisely on settle
    pub settle_base:        u64,     // unfilled remainder at last settle/decrease
    pub settled_output:     u64,     // cumulative output-token paid to owner
    pub open_time:          u64,
    pub unfilled_ratio_x64: u128,    // Q64.64 snapshot of TickState.unfilled_ratio_x64 at open
    pub padding:            [u64; 4],
}

Lifecycle:

1. Open — pengguna memanggil open_limit_order, menyetor total_amount dari input token, order terikat pada cohort TickState.
2. (opsional) Increase / Decrease — increase_limit_order menambah total_amount; decrease_limit_order mengembalikan token unfilled (dan output yang sudah settled hingga saat itu).
3. Settle — ketika cohort fully atau partially filled, pemilik atau operational keeper memanggil settle_limit_order untuk mendorong output token ke ATA pemilik.
4. Close — setelah unfilled_amount == 0, akun dapat ditutup. Rent selalu kembali ke owner.

PDA seed: [owner.as_ref(), limit_order_nonce.key().as_ref(), limit_order_nonce.order_nonce.to_be_bytes().as_ref()]. Order PDA oleh karena itu unik per (owner, nonce_index, order_nonce).

​

LimitOrderNonce

Penghitung per-(wallet, nonce_index) yang memungkinkan satu pengguna menjalankan beberapa pipeline limit order secara paralel tanpa tabrakan pada PDA.

pub struct LimitOrderNonce {
    pub user_wallet: Pubkey,
    pub nonce_index: u8,             // user-chosen, 0..255
    pub order_nonce: u64,            // monotonic, incremented every time a new order is opened
    pub padding:     [u64; 4],
}

Seed PDA: [user_wallet.as_ref(), &[nonce_index]]. Sebagian besar klien menggunakan nonce_index = 0 dan membiarkan order_nonce membawa kardinalitas.

​

Permission (sudah dihapus)

Akun Permission dihapus dalam upgrade 2026-10-22. Akun ini sebelumnya mengontrol CreatePermissionedPool, yang sekarang menjadi CreateCustomizablePoolV2 tanpa izin. Program tidak lagi membaca atau menutup akun-akun ini, dan instruksi CreatePermissionPda / ClosePermissionPda sudah hilang. PDA yang dibuat sebelum upgrade (["permission", authority], 280 byte) tetap berada di chain sebagai data inert; abaikan saat memindai akun milik CLMM.

​

Menurunkan akun kunci

import { PublicKey } from "@solana/web3.js";

const CLMM_PROGRAM_ID = new PublicKey(
  "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK"
); // see reference/program-addresses

function i32ToBytes(n: number): Buffer {
  const b = Buffer.alloc(4);
  b.writeInt32BE(n);
  return b;
}

export function deriveClmmAccounts(
  ammConfig: PublicKey,
  token0Mint: PublicKey,           // must already be sorted
  token1Mint: PublicKey,
) {
  const [poolState] = PublicKey.findProgramAddressSync(
    [Buffer.from("pool"), ammConfig.toBuffer(),
     token0Mint.toBuffer(), token1Mint.toBuffer()],
    CLMM_PROGRAM_ID,
  );
  // NOTE: pools created via CreateCustomizablePoolV2 append a non-zero u16
  // seed_index (LE) as a 5th seed — see deriveCustomizablePoolV2 below.
  const [observation] = PublicKey.findProgramAddressSync(
    [Buffer.from("observation"), poolState.toBuffer()],
    CLMM_PROGRAM_ID,
  );
  const [tickArrayBitmapExtension] = PublicKey.findProgramAddressSync(
    [Buffer.from("pool_tick_array_bitmap_extension"), poolState.toBuffer()],
    CLMM_PROGRAM_ID,
  );
  return { poolState, observation, tickArrayBitmapExtension };
}

export function deriveTickArray(
  pool: PublicKey,
  startTickIndex: number,
) {
  const [tickArray] = PublicKey.findProgramAddressSync(
    [Buffer.from("tick_array"), pool.toBuffer(), i32ToBytes(startTickIndex)],
    CLMM_PROGRAM_ID,
  );
  return tickArray;
}

export function deriveDynamicFeeConfig(index: number) {
  const idx = Buffer.alloc(2);
  idx.writeUInt16BE(index);
  const [pda] = PublicKey.findProgramAddressSync(
    [Buffer.from("dynamic_fee_config"), idx],
    CLMM_PROGRAM_ID,
  );
  return pda;
}

export function deriveCustomizablePoolV2(
  ammConfig: PublicKey,
  token0Mint: PublicKey,           // must already be sorted
  token1Mint: PublicKey,
  seedIndex: number,               // non-zero u16
) {
  const idx = Buffer.alloc(2);
  idx.writeUInt16LE(seedIndex);    // little-endian, unlike the u16 seeds above
  const [pool] = PublicKey.findProgramAddressSync(
    [Buffer.from("pool"), ammConfig.toBuffer(),
     token0Mint.toBuffer(), token1Mint.toBuffer(), idx],
    CLMM_PROGRAM_ID,
  );
  return pool;
}

export function deriveLimitOrderNonce(
  wallet: PublicKey,
  nonceIndex: number,
) {
  const [pda] = PublicKey.findProgramAddressSync(
    [wallet.toBuffer(), Buffer.from([nonceIndex & 0xff])],
    CLMM_PROGRAM_ID,
  );
  return pda;
}

export function deriveLimitOrder(
  wallet: PublicKey,
  nonceAccount: PublicKey,
  orderNonce: bigint,
) {
  const nonceBytes = Buffer.alloc(8);
  nonceBytes.writeBigUInt64BE(orderNonce);
  const [pda] = PublicKey.findProgramAddressSync(
    [wallet.toBuffer(), nonceAccount.toBuffer(), nonceBytes],
    CLMM_PROGRAM_ID,
  );
  return pda;
}

export function derivePersonalPosition(nftMint: PublicKey) {
  const [personalPosition] = PublicKey.findProgramAddressSync(
    [Buffer.from("position"), nftMint.toBuffer()],
    CLMM_PROGRAM_ID,
  );
  return personalPosition;
}

String seed yang tepat harus selalu diperiksa ulang terhadap IDL on-chain dan reference/program-addresses.

​

Referensi cepat siklus hidup

Peristiwa	Akun dibuat	Akun dihapus
CreatePool	poolState, observation, token_0_vault, token_1_vault	—
OpenPosition[V2] / OpenPositionWithToken22Nft	NFT mint + ATA, personalPosition, kemungkinan tickArrayState baru, tickArrayBitmapExtension jika belum ada; dapat membekukan NFT ATA untuk pool dengan penerbit terbatas	—
IncreaseLiquidity	Kemungkinan tickArrayState baru	—
DecreaseLiquidity	—	Kemungkinan menghapus entri tick (tetapi tickArrayState itu sendiri tidak ditutup)
ClosePosition	—	NFT ATA, personalPosition, dan Token-2022 NFT mint; NFT mint SPL klasik tetap pada supply nol. Jalur beku pertama kali dicairkan melalui pool yang dilewatkan dalam akun sisa.
SwapV2	Kemungkinan tickArrayState baru	—
OpenLimitOrder	limitOrderState, kemungkinan limitOrderNonce (init-if-needed), kemungkinan tickArrayState baru	—
IncreaseLimitOrder	—	—
DecreaseLimitOrder	—	Menutup limitOrderState jika order sepenuhnya dikonsumsi
SettleLimitOrder	—	—
CloseLimitOrder	—	limitOrderState (rent → owner)
CreateDynamicFeeConfig	dynamicFeeConfig	—
CreateCustomizablePool	poolState, observation, vault — sama seperti CreatePool. Snapshot dynamicFeeConfig jika enable_dynamic_fee = true.	—
CreateCustomizablePoolV2	poolState (pada alamat yang diturunkan dari seed_index), observation, vault — seperti CreateCustomizablePool. Tanpa izin.	—
CollectRewards	—	—
UpdateRewardInfos	—	—
CloseProtocolPosition (admin)	—	protocolPositionState vestigial (rent → admin)

Akun TickArrayState tidak pernah ditutup oleh program — akun tersebut bertahan selama masa hidup pool. Setelah array tick diinisialisasi, akun tersebut tetap berada di chain bahkan ketika setiap tick di dalamnya kembali ke liquidity_gross == 0. Menggunakan kembali array tick yang sudah ada gratis; hanya posisi pertama yang menyentuh array yang belum pernah diinisialisasi yang membayar rentnya.

​

Apa yang dibaca di mana

• Matematika tick dan mekanik range: products/clmm/ticks-and-positions.
• Swap walk dan matematika fee-growth: products/clmm/math.
• Daftar akun instruksi: products/clmm/instructions.
• Akrual biaya dan reward: products/clmm/fees.
• ID program dan seed kanonik: reference/program-addresses.

Sumber:

• raydium-io/raydium-clmm — programs/amm/src/states