> ## 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. # LaunchLab bonding curve > LaunchLab'ın desteklediği eğri formülleri, kapalı form alım ve satış maliyeti, mezuniyet eşiği türetimi ve ilk alımdan mezuniyete kadar bir başlatmanın işlenmiş sayısal açıklaması. **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/launchlab/bonding-curve) LaunchLab, `Initialize` sırasında seçilen üç eğri şeklini destekler: **constant-product** (en yaygın, standart `x · y = k` eğrisinin sanal-rezerv formu), **linear-price** ve **fixed-price**. Mezuniyet eşiği formülü üç şekil arasında paylaşılır. Bu sayfa constant-product matematiğini ayrıntılı olarak açıklar; linear ve fixed formlar sonunda özetlenmiştir. ## `LaunchState` üzerinde depolanan parametreler | Alan | Anlamı | | - | - | | `curve_type` | `0` = constant-product (sanal-rezervler), `1` = fixed-price, `2` = linear-price. | | `base_supply_max` | Eğrinin hiç bir zaman basabileceği toplam base token sayısı. | | `base_supply_graduation` | Mezuniyete ulaşmak için satılması gereken base token sayısı. Genellikle `0.8 × base_supply_max`; kalan %20 mezuniyet sonrası havuzun ilk LP'si olur. | | `quote_reserve_target` | Mezuniyeti tetikleyen quote miktarı. `Initialize` sırasında eğri parametreleri + `base_supply_graduation` kullanılarak türetilir. | | `virtual_base` / `virtual_quote` | Constant-product eğrisi için sanal-rezerv tohumları. | | `migrate_type` | Yeni başlatma için `CPSWAP` olmalıdır. Depolanan AMM v4 değeri yalnızca eski durumdur. Bkz. [`instructions`](/tr/products/launchlab/instructions). | | `fees.buy_numerator / buy_denominator` | Alım tarafı ücreti, örn. `100 / 10_000 = 1.00%`. | | `fees.sell_numerator / sell_denominator` | Satış tarafı ücreti. Genellikle alım ile aynı. | | `fees.protocol_share`, `fees.creator_share`, `fees.lp_share` | Yukarıdakilerin bölünmesi, paydaya toplamı. | Rust struct'taki alan adları [`accounts`](/tr/products/launchlab/accounts) içinde açıklanan `PoolState` alanlarıyla eşleşir; yukarıdaki birimler kavramsal olarak verilmiştir. ## Sanal rezervlerle constant-product eğrisi (`curve_type = 0`) Varsayılan ve en çok kullanılan eğri. Pump tarzı başlatmalar hepsi bu formu kullanır. Eğri, başından itibaren bir **sanal quote rezervi** `V_q` ve bir **sanal base rezervi** `V_b` olduğunu varsayar (`PoolState` üzerinde `virtual_quote` ve `virtual_base` olarak depolanır), böylece etkili havuz bu rezervlerle bir CPMM gibi görünür. Alımlar `x · y = k` matematiğini takip eder: ``` (V_q + real_quote_in_after_fee) × (V_b + real_base_remaining − base_out) = V_q × V_b ``` `base_out` için çözüldüğünde: ``` base_out = (V_b + real_base_remaining) × quote_in_after_fee / (V_q + real_quote_in_after_fee) ``` Base satıldığında `s` etkili fiyat: ``` price(s) = (V_q + real_quote_in(s)) / (V_b + real_base_remaining(s)) ``` LaunchLab'ın mezuniyet öncesi uyguladığı aynı `x · y = k` değişmezi, mezuniyet sonrası CPMM eğrisidir, bu nedenle geçiş mekanik olarak sorunsuz olur: `base_sold = base_supply_graduation` konumundaki marjinal fiyat, mezuniyet sonrası havuzun `(quote_vault, base_vault_remaining)` rezervleriyle açıldığı fiyata eşittir. ## Fixed-price eğrisi (`curve_type = 1`) Düz fiyat eğrisi. Her alım/satış sabit bir fiyattan gerçekleşir, `Initialize` sırasında yapılandırılabilir: ``` price(s) = virtual_quote / virtual_base (tüm s için sabit) ``` Takımın ne zaman satın aldıklarından bağımsız olarak tüm katılımcılar için tekdüze fiyatlandırma istediği adil başlatmalar için yararlıdır. Mezuniyet, `base_supply_graduation` satıldığında tetiklenir (doğrusal maliyet ilişkisi `quote_reserve_target` türetimini basit hale getirir). ## Linear-price eğrisi (`curve_type = 2`) Fiyat `base_sold` ile doğrusal olarak artar: ``` price(s) = a · s (a = eğim, virtual_base / virtual_quote'dan türetilir) ``` Entegre maliyet: ``` cost(s_0, s_1) = a · (s_1² − s_0²) / 2 ``` `base_sold` içinde ikinci dereceden — erken alıcılar neredeyse sıfır öderken, geç alıcılar önemli ölçüde daha fazla öder, marjinal fiyat her zaman sabit bir eğimde yükselir. Zincir üstü uygulama `curve/linear_price.rs` içinde yer alır. ## Eğri şekli karşılaştırması ``` price │ linear (steep tail) linear (curve_type = 2) │ ╱ │ ╱ │ ╱ const-product (curve_type = 0) │ ╱ ╱ │ ╱ ╱ │ ╱ ╱ │ ╱ ╱ │╱_____╱_______________________ fixed-price (curve_type = 1) └──────────────────────────────── base_sold 0 S_grad S_max ``` ## Mezuniyet eşiği `quote_reserve_target`, `Initialize` sırasında `base_sold` değerini 0'dan `base_supply_graduation`'a çıkarmak için gereken quote olarak hesaplanır: ``` quote_reserve_target = cost(0, base_supply_graduation) × (1 + buy_fee_rate) ^^^^^^^^^^^^^^^^^ yaklaşık; tam form Buy sırasında kullanılan ücret yuvarlamayı eşleştirir. ``` Bir başlatma, `quote_vault.balance ≥ quote_reserve_target` olur olmaz mezun olur. Alımlar ayrık boyutlarda geldiğinden, mezuniyet sırasındaki gerçek bakiye hedefi biraz aşabilir — fazlalık, ortaya çıkan CPMM havuzunda ekstra quote tarafı likidite olur. ## İşlenmiş örnek — ikinci dereceden bir başlatma Parametreler: * `base_supply_max = 1_000_000_000` (1 milyar base token, 6 ondalık) * `base_supply_graduation = 800_000_000` (%80 satıldığında mezuniyet tetiklenir) * `k = 40` (fiyat ölçeği) * Ücretler: %1 alım, %1 satış, bölünme `lp:creator:protocol = 60:20:20`. **İlk fiyat** (`s = 0`): `0` (saf ikinci dereceden sıfırdan başlar). **%50 satıldığında fiyat** (`s = 500_000_000`): ``` price = 40 × (500e6 / 1e9)² = 40 × 0.25 = 10 (base başına quote, 6 ondalık) ``` **Mezuniyette fiyat** (`s = 800_000_000`): ``` price = 40 × (800e6 / 1e9)² = 40 × 0.64 = 25.6 ``` **Mezuniyete ulaşmak için gereken quote** (entegre maliyet): ``` cost(0, 800_000_000) = (40 / (3 × 1e18)) × ((800e6)³ − 0) = (40 / 3e18) × 5.12e26 ≈ 6.827e9 ``` Yani ≈ 6.827 quote-native birimi (yapılandırılan 6 ondalık quote mint'inde, örn. quote USDC ise \~6.827 USDC). **Üzerine uygulanan ücret**: ``` quote_reserve_target ≈ 6.827e9 × 1.01 ≈ 6.895e9 (6.895 USDC) ``` **İlk alım** `10 USDC`: * Sanal durum: `s = 0`, `quote_vault = 0`. * Ücreti çıkar: `quote_after_fee = 10 × 0.99 = 9.9`. * `(40 / (3e18)) × s³ = 9.9e6` çöz — 9.9 USDC'nin yerel 6 ondalıklı birimlerdeki karşılığı, yukarıdaki `6.827e9` ile aynı birimler ⇒ `s ≈ 9.06e7` base token satın alındı. * %1 ücret (`0.1 USDC`) bölünmesi: lp `0.06`, creator `0.02`, protocol `0.02`. LP payı `quote_vault`'ta kalır; diğer ikisi ilgili tahakkuk sayaçlarına yönlendirilir. **%75 satıldığında alım** (mezuniyete yaklaşırken): Aynı 10 USDC, eğri dik olduğu için artık çok daha az base satın alır. `s₀ = 750e6` konumunda `quote_in_after_fee = 9.9e6` ile çözüm `∆s ≈ 4.4e5` verir — ilk alıma kıyasla USDC başına base'de **\~200 kat** azalma. ## Eğri aşaması sırasında ücret mekaniği Her `Buy` sırasında: ``` gross_fee = ceil(quote_in_gross × buy_numerator / buy_denominator) lp_share = gross_fee × fees.lp_share / fees.total_share protocol_share = gross_fee × fees.protocol_share / fees.total_share creator_share = gross_fee × fees.creator_share / fees.total_share ``` * `lp_share` `quote_vault`'ta kalır. Bu, etkili eğriyi daha sıkı hale getirir (aynı base arzına karşı daha fazla quote rezervi). * `protocol_share` `LaunchState.state_data.protocol_fees_quote` değerini artırır. * `creator_share` `LaunchState.state_data.creator_fees_quote` değerini artırır. `Sell` sırasında aynı bölünme uygulanır ancak ücret giden `quote_out`'tan alınır. Her iki sayaç da `CollectFees` aracılığıyla taranır (yönetici veya yaratıcı, her biri kendi sayacına). ## Hassasiyet * Base tarafı miktarları: `u64`. * Quote tarafı miktarları: `u64`. * Ara küpler / ürünler: `u128`. * "Tam quote satın al" ve "tam quote sat" **kapalı biçimde** tersine çevrilir — sabit-çarpım eğrisi cebirsel olarak, sabit-fiyat eğrisi bölme ile, doğrusal-fiyat eğrisi bir karekök ile. Programda Newton çözücü yoktur, yineleme sınırı yoktur ve `NotConverged` hatası da yoktur. ## CPMM'ye geçiş `Graduate` tetiklendiğinde: ``` cpmm_quote_reserve = quote_vault − swept_protocol_fees − swept_creator_fees cpmm_base_reserve = base_vault // yani base_supply_max − base_sold cpmm_initial_price = cpmm_quote_reserve / cpmm_base_reserve ``` **Sabit-çarpım** eğrisi için — LaunchLab'ın varsayılanı ve canlı olan tek tür — `cpmm_initial_price` tam olarak `price(base_sold)` değeridir, yani geçiş anındaki marjinal eğri fiyatı; bu nedenle eğri arayüzünden CPMM arayüzüne geçen bir gözlemci hiçbir sıçrama görmez. İkinci dereceli fiyat eğrisinde ise durum böyle değildir: entegre ortalama marjinal fiyatın üzerinde kalır (yukarıdaki örnekte `4/3` katı), dolayısıyla geçişte bir basamak beklenir. ## Sonraki adımlar * [`products/launchlab/accounts`](/tr/products/launchlab/accounts) — bu parametreleri depolayan `LaunchState` alanları. * [`products/launchlab/instructions`](/tr/products/launchlab/instructions) — `Buy`, `Sell`, `Graduate` hesap listeleri. * [`algorithms/constant-product`](/tr/algorithms/constant-product) — mezuniyet sonrası havuzun kullandığı CPMM matematiği. Kaynaklar: * [Raydium SDK v2 `LaunchLab` modülü](https://github.com/raydium-io/raydium-sdk-V2) * Raydium LaunchLab program kaynağı This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.