> ## Documentation Index > Fetch the complete documentation index at: https://docs.raydium.io/llms.txt > Use this file to discover all available pages before exploring further. # 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 →](/products/clmm/accounts) Bu sayfa her hesabın **düzenini ve rolünü** açıklar. Seed'ler kanonik olup [`reference/program-addresses`](/tr/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. ```rust theme={null} // 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`](/tr/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` ```rust theme={null} 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`](/tr/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. ```rust theme={null} 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: ```rust theme={null} 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. ```rust theme={null} 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 ```rust theme={null} 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`](/tr/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` ```rust theme={null} // 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ü) ```rust theme={null} 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`](/tr/products/clmm/math) ve [`products/clmm/fees`](/tr/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. ```rust theme={null} // 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ç. ```rust theme={null} 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 ```ts theme={null} 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`](/tr/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`](/tr/products/clmm/ticks-and-positions). * **Swap akışı ve ücret büyüme matematiği**: [`products/clmm/math`](/tr/products/clmm/math). * **Talimat hesap listeleri**: [`products/clmm/instructions`](/tr/products/clmm/instructions). * **Ücretler ve ödül tahakkuku**: [`products/clmm/fees`](/tr/products/clmm/fees). * **Kanonik program kimliği ve seed'ler**: [`reference/program-addresses`](/tr/reference/program-addresses). Kaynaklar: * [`raydium-io/raydium-clmm` — `programs/amm/src/states`](https://github.com/raydium-io/raydium-clmm)