CLMM hesapları

CLMM pool’unun kullandığı her hesap: PoolState, AmmConfig, TickArrayState, TickArrayBitmapExtension, PersonalPositionState ve Observation.

Bu sayfa yapay zekâ tarafından otomatik olarak çevrilmiştir. İngilizce sürüm esas alınır.

İngilizce sürümü görüntüle →

Bu sayfa her hesabın düzenini ve rolünü açıklar. Seed’ler kanonik olup reference/program-addresses sayfasında listelenmiştir. CLMM pool’u, CPMM pool’undan daha fazla hesap içerir; bunun nedeni likiditenin tick aralığı boyunca seyrek biçimde depolanmasıdır. Bu seyrekliği anlamak, sayfanın büyük bölümünü oluşturur.

​

Hesap envanteri

Canlı bir CLMM pool’u aşağıdaki hesap aileleriyle tanımlanır. İki mint ve bunların vault’ları dışındaki tüm hesaplar CLMM programına aittir.

Hesap	Amaç	Pool başına adet
AmmConfig	Ücret kademesi: işlem ücreti oranı, protokol payı, fon payı, varsayılan tick-spacing. Bu kademedeki tüm pool’larda ortaklaşa kullanılır.	1 (paylaşımlı)
PoolState	Mevcut sqrt_price_x64, mevcut tick, toplam likidite, ücret büyüme genelleri, ödül bilgisi, gözlem işaretçisi.	1
TickArrayState	TICK_ARRAY_SIZE adet bitişik tick’ten oluşan bir blok. Yalnızca talep üzerine başlatılır.	0 ≤ N ≤ aralık
TickArrayBitmapExtension	PoolState içindeki satır içi bitmap’in ötesindeki tick array’lerin varlığını izleyen taşma bitmap’i.	0 veya 1
PersonalPositionState	Her LP pozisyonu için bir tane. Aralığı, likiditeyi ve en son görülen ücret/ödül büyümesini depolar. Yetki = NFT sahibi.	Pozisyon başına 1
Pozisyon NFT mint’i	Arzı 1 olan, PersonalPositionState ile ilişkilendirilmiş mint. Transferi, pozisyonu transfer eder.	Pozisyon başına 1
ObservationState	TWAP için fiyat gözlemlerinin halka arabelleği.	1
token_0_vault, token_1_vault	Pool’un bakiyelerini tutan token hesapları. Pool yetkisi tarafından sahiplenilir.	2
DynamicFeeConfig	Dinamik ücret mekanizması için yeniden kullanılabilir parametre seti. create_customizable_pool aracılığıyla oluşturulan pool’lar tercihli olarak dahil olabilir. Yönetici tarafından yönetilir.	paylaşımlı (indekse göre)
LimitOrderState	Her açık limit emir için bir tane. Sahibi, tick’i, yönü, toplam tutarı ve kapatılmış çıktı anlık görüntüsünü kaydeder.	Emir başına 1
LimitOrderNonce	Benzersiz emir PDA’larını türeten (cüzdan, nonce_index) başına sayaç.	(cüzdan, indeks) başına 1

​

PoolState

Pool’un canlı durumu; her swap’ta ve her pozisyon değişikliğinde okunur.

// 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,
    pub padding: [u8; 6],

    // 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],
}

Gerçekte dokunacağınız alanlar:

• sqrt_price_x64 ve tick_current, pool’un fiyat durumunu temsil eder. Her swap’ta birlikte güncellenir. tick_current, log_{1.0001}(price) ifadesinin tabanıdır.
• liquidity, aktif likiditeyi temsil eder; yani aralığı tick_current’ı içeren tüm pozisyonların L değerlerinin toplamıdır. Bir swap bir tick’i geçtiğinde ve bir pozisyon açıldığında/kapatıldığında/yeniden boyutlandırıldığında değişir.
• fee_growth_global_{0,1}_x64, tüm pool geçmişi boyunca likidite birimi başına kazanılan kümülatif ücretlerdir. Pozisyonlar, kendilerine ne kadar ücret düştüğünü hesaplamak için bunu okur.
• tick_spacing, başlatma sırasında AmmConfig’e kilitlenir ve asla değişmez. Hangi tick indekslerinin pozisyon bitiş noktası olarak kullanılabileceğini belirler.
• tick_array_bitmap, spot fiyat etrafındaki yaygın kullanım aralığını kapsayan satır içi bir bitmap’tir. Pozisyonları çok uzağa ulaşan pool’larda taşma takibi, ayrı bir TickArrayBitmapExtension hesabında tutulur.
• fee_on, pool oluşturulurken sabitlenir. 0 (FromInput), klasik Uniswap-V3 davranışını yeniden üretir. 1 ve 2, swap ücretini kitabın tek bir tarafına yönlendirir; ödünleşimler için bkz. products/clmm/fees.
• dynamic_fee_info, dinamik ücret farkı için volatilite durumunu taşır. Etkinleştirildiğinde, her swap AmmConfig.trade_fee_rate’in üzerine bir dynamic_fee_component yeniden hesaplar. Düzeni aşağıdaki DynamicFeeInfo başlığında belgelenmiştir; dinamik ücretsiz pool’lar bu struct’ın tamamını sıfır olarak bırakır.

​

AmmConfig

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

    pub owner:             Pubkey,        // admin
    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,
    pub padding: [u64; 3],
}

Yayımlanmış tipik CLMM ücret kademesi seti (doğrulamak için GET https://api-v3.raydium.io/main/clmm-config):

İndeks	trade_fee_rate	Tick spacing	Tipik kullanım
0	100 (%0,01)	1	Stabil çiftler, USDC/USDT
1	500 (%0,05)	10	Birbiriyle ilişkili blue-chip’ler
2	2_500 (%0,25)	60	Standart çiftler
3	10_000 (%1,00)	120	Volatil veya uzun kuyruklu tokenlar

protocol_fee_rate ve fund_fee_rate, işlem ücretinin kesirlerini temsil eder; CPMM ile aynı konvansiyondur. Bkz. products/clmm/fees.

​

TickArrayState

CLMM, tick başına tek bir kayıt depolamaz; bu milyarlarca hesap anlamına gelirdi. Bunun yerine TICK_ARRAY_SIZE adet bitişik başlatılmış-ya-da-başlatılmamış tick’i (program sürümüne bağlı olarak tipik olarak 60 veya 88) tembel bir şekilde ilk kullanımda oluşturulan bir TickArrayState içinde gruplar.

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],
}

Dört limit emir alanı, hiçbir zaman limit emir için kullanılmamış her tick’te sıfırdır. Bir tick’te emirler açıldığında program bunları bir dizi kohort olarak izler:

• order_phase, kohort kimliğidir. Bir kohort “tamamen doldurulmamış” durumundan “kısmen doldurulmuş” durumuna her geçtiğinde bir artar.
• orders_amount, mevcut (en yeni) kohortun giriş tokeni toplamıdır.
• part_filled_orders_remaining, devam eden swap’lar tarafından doldurulmakta olan bir önceki kohoru izler.
• unfilled_ratio_x64, kohort üzerinde taşınan bir Q64.64 çarpanıdır: bir swap kohortun %X’ini doldurduğunda oran (1 − X) ile çarpılır. Her açık emir, açılış anındaki kendi (order_phase, unfilled_ratio_x64) anlık görüntüsünü depolar; bu sayede kapatma hesabı anlık görüntülerin karşılaştırılmasına indirgenir.

Kurallar:

• Bir pozisyon bitiş noktası tick’i t, t % tick_spacing == 0 koşulunu sağlamalıdır. Program, spacing dışındaki pozisyonları reddeder.
• Tick’in array’i, floor(t / (TICK_ARRAY_SIZE * tick_spacing)) * (TICK_ARRAY_SIZE * tick_spacing) konumunda yer alır.
• Tick array tembel olarak başlatılır: başlatılmamış bir array’e ilk dokunan pozisyon veya swap onu oluşturur ve rent’i öder.
• Tick array program tarafından hiçbir zaman kapatılmaz. Bir kez tahsis edildikten sonra, içindeki her tick liquidity_gross == 0’a dönsе bile pool’un ömrü boyunca varlığını sürdürür. Sonraki pozisyonlar ve swap’lar mevcut hesabı ek rent ödemeksizin yeniden kullanır. Tick array’ler için ClosePosition kaynaklı bir temizleme yolu yoktur.

​

TickArrayBitmapExtension

PoolState.tick_array_bitmap (satır içi) “spot fiyata yakın” aralığı kapsar — ±1.024 tick array. Bu aralığın dışında (aşırı tick değerleri için) program bir uzantı hesabı tutar:

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

Pozisyon aralığınız “normalse” uzantı hesabını hiç düşünmenize gerek yoktur. Tam aralıklı pozisyonlar (örn. (MIN_TICK, MAX_TICK)) için gereklidir; SDK bunu sizin adınıza çözer.

​

Pozisyonlar

Bir CLMM pozisyonu, bir mint ile birlikte üç hesaptan oluşan bir pakettir:

​

Pozisyon NFT mint’i

Arzı 1 olan bir SPL Token mint’i. Mint’in adresi deterministik bir PDA’dır; sahibinin cüzdanındaki pozisyon NFT’si yalnızca o tek tokeni tutan bir ATA’dır. NFT’yi transfer etmek, pozisyonu el değiştirmenin yoludur — program yetkilendirmeyi durumda depolanan bir Pubkey’e değil, NFT’nin ATA bakiyesinin mevcut sahibine bağlar.

​

PersonalPositionState

Her açık pozisyon için bir tane. NFT mint’iyle anahtarlanır.

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 (kullanımdan kaldırıldı)

Eski CLMM sürümleri, (pool, tick_lower, tick_upper) başına toplu muhasebe bilgilerini bir ProtocolPositionState PDA’sında saklıyordu. Yeni sürümler artık bu hesabı oluşturmuyor veya okumуyor. Yuva, ABI uyumluluğu için OpenPosition / IncreaseLiquidity / DecreaseLiquidity hesap listelerinde UncheckedAccount olarak görünmeye devam etmektedir; ancak program artık ona yazmamaktadır. Zincir üzerindeki mevcut hesaplar artık kullanılmayan kalıntılardır; yönetici, bunların rent’ini geri almak için CloseProtocolPosition’ı çağırabilir.

Toplu aralık muhasebesi artık TickArrayState içindeki iki bitiş noktası tick’inden (liquidity_gross, liquidity_net ve tick başına fee_growth_outside_* / reward_growths_outside_x64) doğrudan türetilmektedir. fee_growth_inside = global − outside_lower − outside_upper formülü, toplu pozisyon hesabı olmadan çalışmaya devam etmektedir.

​

Gözlem

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],
}

CLMM’nin gözlem arabelleği kümülatif bir fiyat değil, kümülatif bir tick depolar. Dış tüketiciler geometrik ortalama fiyatı bir aralık üzerinden (tick_cumulative[t1] − tick_cumulative[t0]) / (t1 − t0) ile hesaplar ve ardından price = 1.0001 ** tick uygular. Bkz. algorithms/clmm-math.

​

DynamicFeeConfig ve DynamicFeeInfo

Dinamik ücret parametreleri iki yerde bulunur. Yeniden kullanılabilir şablon olan DynamicFeeConfig, yönetici tarafından yönetilir ve dahil olan pool’larda paylaşılır. Pool başına çalışma zamanı durumu olan DynamicFeeInfo ise PoolState içine gömülüdür ve her swap tarafından güncellenir.

​

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’i: ["dynamic_fee_config", index.to_be_bytes()]. create_dynamic_fee_config (yönetici kısıtlı) aracılığıyla oluşturulur ve update_dynamic_fee_config ile değiştirilir. enable_dynamic_fee = true ile oluşturulan bir pool, oluşturulma anında yapılandırmanın beş kalibrasyon parametresini (filter_period, decay_period, reduction_factor, dynamic_fee_control, max_volatility_accumulator) kendi DynamicFeeInfo’suna anlık görüntü olarak kaydeder; DynamicFeeConfig’te yapılan sonraki düzenlemeler mevcut pool’ları geriye dönük olarak etkilemez.

​

DynamicFeeInfo (PoolState içine gömülü)

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],
}

Alt dört alan durum bilgisidir; üstteki beş alan DynamicFeeConfig’ten kopyalanan kalibrasyon değerleridir. Ücret matematiği ve bozunma kuralları products/clmm/math ve products/clmm/fees altında belgelenmiştir.

Formül tarafından kullanılan sabitler:

Sabit	Değer	Anlam
VOLATILITY_ACCUMULATOR_SCALE	10_000	Volatilite biriktiricisinin granülaritesi
REDUCTION_FACTOR_DENOMINATOR	10_000	reduction_factor için payda
DYNAMIC_FEE_CONTROL_DENOMINATOR	100_000	dynamic_fee_control için payda
MAX_FEE_RATE_NUMERATOR	100_000	Elde edilen ücret oranına %10’luk sabit üst sınır

​

LimitOrderState

Her açık limit emir için bir hesap.

// 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],
}

Yaşam döngüsü:

1. Açma — kullanıcı open_limit_order’ı çağırır, total_amount kadar giriş tokenini yatırır ve emir bir TickState kohortuna bağlanır.
2. (isteğe bağlı) Artırma / Azaltma — increase_limit_order, total_amount’a ekler; decrease_limit_order, doldurulmamış tokenleri (ve o noktaya kadar kapatılmış çıktıyı) iade eder.
3. Kapatma — kohort tamamen veya kısmen dolduğunda, sahip ya da operasyonel bekçi, çıktı tokenlerini sahibin ATA’sına göndermek için settle_limit_order’ı çağırır.
4. Kapama — unfilled_amount == 0 olduğunda hesap kapatılabilir. Rent her zaman owner’a geri döner.

PDA seed’i: [owner.as_ref(), limit_order_nonce.key().as_ref(), limit_order_nonce.order_nonce.to_be_bytes().as_ref()]. Emir PDA’sı bu nedenle (owner, nonce_index, order_nonce) başına benzersizdir.

​

LimitOrderNonce

Tek bir kullanıcının PDA çakışması olmadan birden fazla paralel limit emir hattı yürütmesine olanak tanıyan (cüzdan, nonce_index) başına sayaç.

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],
}

PDA seed’i: [user_wallet.as_ref(), &[nonce_index]]. Çoğu istemci nonce_index = 0 kullanır ve kardinaliteyi order_nonce’a bırakır.

​

Temel hesapların türetilmesi

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

Tam seed dizelerini her zaman zincir üzerindeki IDL ve reference/program-addresses sayfasıyla çapraz doğrulamanız önerilir.

​

Yaşam döngüsü hızlı başvurusu

Olay	Oluşturulan hesaplar	Yok edilen hesaplar
CreatePool	poolState, observation, token_0_vault, token_1_vault	—
OpenPosition[WithToken22Nft]	NFT mint + ATA, personalPosition, muhtemelen yeni tickArrayState(ler), henüz mevcut değilse tickArrayBitmapExtension	—
IncreaseLiquidity	Muhtemelen yeni tickArrayState(ler)	—
DecreaseLiquidity	—	Muhtemelen tick girişlerini temizler (ancak tickArrayState kendisi kapatılmaz)
ClosePosition	—	NFT mint, personalPosition
SwapV2	Muhtemelen yeni tickArrayState	—
OpenLimitOrder	limitOrderState, muhtemelen limitOrderNonce (gerekirse başlatır), muhtemelen yeni tickArrayState	—
IncreaseLimitOrder	—	—
DecreaseLimitOrder	—	Emir tamamen tükenirse limitOrderState’i kapatır
SettleLimitOrder	—	—
CloseLimitOrder	—	limitOrderState (rent → owner)
CreateDynamicFeeConfig	dynamicFeeConfig	—
CreateCustomizablePool	poolState, observation, vault’lar — CreatePool ile aynı. enable_dynamic_fee = true ise dynamicFeeConfig’in anlık görüntüsünü alır.	—
CollectRewards	—	—
UpdateRewardInfos	—	—
CloseProtocolPosition (yönetici)	—	Kullanımdan kalkmış protocolPositionState (rent → yönetici)

TickArrayState hesapları program tarafından hiçbir zaman kapatılmaz — pool’un ömrü boyunca varlığını sürdürürler. Bir tick array başlatıldıktan sonra, içindeki her tick liquidity_gross == 0’a dönsе bile zincir üzerinde kalmaya devam eder. Mevcut bir tick array’i yeniden kullanmak ücretsizdir; yalnızca daha önce hiç başlatılmamış bir array’e ilk dokunan pozisyon rent’i öder.

​

Neyi nerede okuyacaksınız

• Tick matematiği ve aralık mekaniği: products/clmm/ticks-and-positions.
• Swap akışı ve ücret büyüme matematiği: products/clmm/math.
• Talimat hesap listeleri: products/clmm/instructions.
• Ücretler ve ödül tahakkuku: products/clmm/fees.
• Kanonik program kimliği ve seed’ler: reference/program-addresses.

Kaynaklar:

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