> ## 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. # Kurva bonding LaunchLab > Rumus kurva yang didukung LaunchLab, biaya beli dan jual bentuk tertutup, penurunan ambang kelulusan, dan penjelasan numerik terperinci tentang peluncuran dari pembelian pertama hingga kelulusan. **Halaman ini diterjemahkan secara otomatis oleh AI. Versi bahasa Inggris adalah acuan resmi.** [Lihat versi bahasa Inggris →](/products/launchlab/bonding-curve) LaunchLab mendukung tiga bentuk kurva yang dipilih saat `Initialize`: **constant-product** (paling umum, bentuk virtual-reserve dari kurva standar `x · y = k`), **linear-price**, dan **fixed-price**. Rumus ambang kelulusan dibagikan di ketiga bentuk ini. Halaman ini membahas matemnya constant-product secara detail; bentuk linear dan fixed dirangkum di akhir. ## Parameter yang tersimpan di `LaunchState` | Field | Arti | | ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------- | | `curve_type` | `0` = constant-product (virtual-reserves), `1` = fixed-price, `2` = linear-price. | | `base_supply_max` | Total token base yang dapat dikurasi kurva. | | `base_supply_graduation` | Token base yang harus dijual untuk mencapai kelulusan. Biasanya `0.8 × base_supply_max`; sisa 20% menjadi LP awal pool pasca-kelulusan. | | `quote_reserve_target` | Jumlah quote yang memicu kelulusan. Diturunkan saat `Initialize` dari parameter kurva + `base_supply_graduation`. | | `virtual_base` / `virtual_quote` | Seed virtual-reserve untuk kurva constant-product. | | `migrate_type` | Memilih target kelulusan: AMM v4 vs CPMM. Lihat [`instructions`](/id/products/launchlab/instructions). | | `fees.buy_numerator / buy_denominator` | Biaya sisi beli, misalnya `100 / 10_000 = 1.00%`. | | `fees.sell_numerator / sell_denominator` | Biaya sisi jual. Sering sama dengan beli. | | `fees.protocol_share`, `fees.creator_share`, `fees.lp_share` | Pembagian di atas, berjumlah denominator. | Nama field dalam struct Rust cocok dengan field `PoolState` yang dijelaskan di [`accounts`](/id/products/launchlab/accounts); unit di atas adalah konseptual. ## Kurva constant-product dengan virtual reserves (`curve_type = 0`) Kurva default dan paling banyak digunakan. Semua peluncuran gaya Pump menggunakan bentuk ini. Kurva berpura-pura ada **virtual quote reserve** `V_q` dan **virtual base reserve** `V_b` dari awal (disimpan sebagai `virtual_quote` dan `virtual_base` di `PoolState`), jadi pool efektif terlihat seperti CPMM dengan reserve tersebut. Pembelian mengikuti matematika `x · y = k`: ``` (V_q + real_quote_in_after_fee) × (V_b + real_base_remaining − base_out) = V_q × V_b ``` diselesaikan untuk `base_out`: ``` base_out = (V_b + real_base_remaining) × quote_in_after_fee / (V_q + real_quote_in_after_fee) ``` Harga efektif pada base-terjual `s`: ``` price(s) = (V_q + real_quote_in(s)) / (V_b + real_base_remaining(s)) ``` Invarian `x · y = k` yang sama yang diterapkan LaunchLab sebelum kelulusan adalah literal kurva CPMM (atau AMM v4) pasca-kelulusan, jadi penyerahan kelulusan bersifat mekanis mulus: harga marginal pada `base_sold = base_supply_graduation` sama dengan harga pool pasca-kelulusan dibuka dengan `(quote_vault, base_vault_remaining)` sebagai reserve-nya. ## Kurva fixed-price (`curve_type = 1`) Kurva harga datar. Setiap beli/jual terjadi pada harga konstan, dapat dikonfigurasi saat `Initialize`: ``` price(s) = virtual_quote / virtual_base (konstan untuk semua s) ``` Berguna untuk peluncuran adil di mana tim menginginkan harga seragam untuk semua peserta terlepas dari kapan mereka membeli. Kelulusan dipicu saat `base_supply_graduation` telah terjual (hubungan biaya linear membuat derivasi `quote_reserve_target` sederhana). ## Kurva linear-price (`curve_type = 2`) Harga meningkat linier dengan `base_sold`: ``` price(s) = a · s (a = kemiringan, diturunkan dari virtual_base / virtual_quote) ``` Biaya terintegrasi: ``` cost(s_0, s_1) = a · (s_1² − s_0²) / 2 ``` Kuadratik dalam `base_sold` — pembeli awal membayar mendekati nol, pembeli terlambat membayar jauh lebih banyak, dengan harga marginal selalu naik pada kemiringan tetap. Implementasi on-chain ada di `curve/linear_price.rs`. ## Perbandingan bentuk kurva ``` harga │ linear (ekor curam) linear (curve_type = 2) │ ╱ │ ╱ │ ╱ const-product (curve_type = 0) │ ╱ ╱ │ ╱ ╱ │ ╱ ╱ │ ╱ ╱ │╱_____╱_______________________ fixed-price (curve_type = 1) └──────────────────────────────── base_terjual 0 S_grad S_maks ``` ## Ambang kelulusan `quote_reserve_target` dihitung saat `Initialize` sebagai quote yang diperlukan untuk mendorong `base_sold` dari 0 ke `base_supply_graduation`: ``` quote_reserve_target = cost(0, base_supply_graduation) × (1 + buy_fee_rate) ^^^^^^^^^^^^^^^^^ aproksimasi; bentuk eksak cocok dengan pembulatan biaya di Buy. ``` Peluncuran kelulusan segera setelah `quote_vault.balance ≥ quote_reserve_target`. Karena pembelian datang dalam ukuran diskrit, saldo aktual saat kelulusan dapat sedikit melebihi target — surplus menjadi likuiditas quote sisi tambahan di pool CPMM yang dihasilkan. ## Contoh terperinci — peluncuran kuadratik Parameter: * `base_supply_max = 1_000_000_000` (1 miliar token base, 6 desimal) * `base_supply_graduation = 800_000_000` (80% terjual memicu kelulusan) * `k = 40` (skala harga) * Biaya: 1% beli, 1% jual, pembagian `lp:creator:protocol = 60:20:20`. **Harga awal** (`s = 0`): `0` (kuadratik murni dimulai dari nol). **Harga pada 50% terjual** (`s = 500_000_000`): ``` price = 40 × (500e6 / 1e9)² = 40 × 0.25 = 10 (quote per base, 6 desimal) ``` **Harga saat kelulusan** (`s = 800_000_000`): ``` price = 40 × (800e6 / 1e9)² = 40 × 0.64 = 25.6 ``` **Quote diperlukan untuk mencapai kelulusan** (biaya terintegrasi): ``` cost(0, 800_000_000) = (40 / (3 × 1e18)) × ((800e6)³ − 0) = (40 / 3e18) × 5.12e26 ≈ 6.827e9 ``` Jadi ≈ 6.827 unit quote-native (dalam mint quote 6-desimal apa pun yang dikonfigurasi, misalnya \~6.827 USDC jika quote-nya USDC). **Biaya diterapkan di atas**: ``` quote_reserve_target ≈ 6.827e9 × 1.01 ≈ 6.895e9 (6.895 USDC) ``` **Pembelian pertama** dari `10 USDC`: * Status virtual: `s = 0`, `quote_vault = 0`. * Kurangi biaya: `quote_after_fee = 10 × 0.99 = 9.9`. * Selesaikan `(40 / (3e18)) × s³ = 9.9` ⇒ `s ≈ 6.22e6` token base dibeli. * Biaya 1% (`0.1 USDC`) dibagi: lp `0.06`, creator `0.02`, protocol `0.02`. Bagian lp tetap di `quote_vault`; dua lainnya rute ke penghitung akrual masing-masing. **Beli pada 75% terjual** (mendekati kelulusan): Sama 10 USDC membeli jauh lebih sedikit base sekarang karena kurvanya curam. Penyelesaian Newton di `s₀ = 750e6` dengan `quote_in_after_fee = 9.9` memberikan kira-kira `∆s ≈ 0.4e6` — pengurangan \~15× dalam base per USDC dibandingkan pembelian pertama. ## Mekanika biaya selama fase kurva Pada setiap `Buy`: ``` 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` ditinggalkan di `quote_vault`. Ini membuat kurva efektif lebih ketat (lebih banyak quote reserve terhadap suplai base yang sama). * `protocol_share` meningkatkan `LaunchState.state_data.protocol_fees_quote`. * `creator_share` meningkatkan `LaunchState.state_data.creator_fees_quote`. Pada `Sell` pembagian yang sama berlaku tetapi biaya diambil dari outbound `quote_out`. Kedua penghitung disapu melalui `CollectFees` (admin atau creator, masing-masing ke penghitung mereka sendiri). ## Presisi * Jumlah sisi base: `u64`. * Jumlah sisi quote: `u64`. * Kubus / produk perantara: `u128`. * Penyelesaian Newton untuk "beli exact quote" dan "jual exact quote" beriterasi dalam `u128` fixed-point dengan jumlah iterasi maksimum yang dapat dikonfigurasi (default 10). Mode kegagalan adalah `NotConverged` — jarang di luar kasus tepi mendekati kelulusan. ## Penyerahan ke CPMM Saat `Graduate` diaktifkan: ``` cpmm_quote_reserve = quote_vault − swept_protocol_fees − swept_creator_fees cpmm_base_reserve = base_vault // yaitu base_supply_max − base_sold cpmm_initial_price = cpmm_quote_reserve / cpmm_base_reserve ``` Untuk kurva kuadratik, `cpmm_initial_price` adalah `price(base_sold)` secara mekanis (ini adalah harga kurva marginal saat momen penyerahan). Pool CPMM membuka pada harga yang tepat, jadi pengamat yang beralih dari UI kurva ke UI CPMM tidak melihat lompatan. ## Ke mana selanjutnya * [`products/launchlab/accounts`](/id/products/launchlab/accounts) — field `LaunchState` menyimpan parameter ini. * [`products/launchlab/instructions`](/id/products/launchlab/instructions) — daftar akun `Buy`, `Sell`, `Graduate`. * [`algorithms/constant-product`](/id/algorithms/constant-product) — matematika CPMM yang digunakan pool pasca-kelulusan. Sumber: * [Modul `LaunchLab` Raydium SDK v2](https://github.com/raydium-io/raydium-sdk-V2) * Sumber program Raydium LaunchLab