> ## 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 > Die Kurvenformeln, die LaunchLab unterstützt, geschlossene Kauf- und Verkaufskosten, Herleitung des Graduierungsschwellwerts und ein ausgearbeitetes numerisches Beispiel eines Launches vom ersten Kauf bis zur Graduierung. **Diese Seite wurde mit KI automatisch übersetzt. Maßgeblich ist stets die englische Version.** [Englische Version ansehen →](/products/launchlab/bonding-curve) LaunchLab unterstützt drei Kurvenformen, die bei der Initialisierung (`Initialize`) gewählt werden: **constant-product** (die häufigste Form, eine virtuelle Reservevariante der Standard-Kurve `x · y = k`), **linear-price** und **fixed-price**. Die Formel für den Graduierungsschwellwert ist bei allen drei gleich. Diese Seite behandelt die Mathematik der constant-product-Kurve im Detail; die lineare und feste Form werden am Ende zusammengefasst. ## Parameter auf `LaunchState` | Feld | Bedeutung | | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `curve_type` | `0` = constant-product (virtuelle Reserven), `1` = fixed-price, `2` = linear-price. | | `base_supply_max` | Gesamtmenge an Base-Tokens, die die Kurve je prägen kann. | | `base_supply_graduation` | Base-Tokens, die verkauft werden müssen, um die Graduierung zu erreichen. Normalerweise `0.8 × base_supply_max`; die restlichen 20% werden zum anfänglichen LP des Post-Graduierungs-Pools. | | `quote_reserve_target` | Quote-Menge, die die Graduierung auslöst. Wird bei `Initialize` aus den Kurvenparametern und `base_supply_graduation` abgeleitet. | | `virtual_base` / `virtual_quote` | Virtuelle Reserve-Seeds für die constant-product-Kurve. | | `migrate_type` | Wählt das Graduierungsziel: AMM v4 vs. CPMM. Siehe [`instructions`](/de/products/launchlab/instructions). | | `fees.buy_numerator / buy_denominator` | Gebühr auf der Kauf-Seite, z. B. `100 / 10_000 = 1,00%`. | | `fees.sell_numerator / sell_denominator` | Gebühr auf der Verkaufs-Seite. Oft gleich wie auf der Kauf-Seite. | | `fees.protocol_share`, `fees.creator_share`, `fees.lp_share` | Aufteilung der obigen, summiert sich zu denominator. | Feldnamen in der Rust-Struktur entsprechen den `PoolState`-Feldern, die unter [`accounts`](/de/products/launchlab/accounts) beschrieben sind; Einheiten oben sind konzeptionell. ## Constant-product-Kurve mit virtuellen Reserven (`curve_type = 0`) Die Standard- und am häufigsten verwendete Kurve. Pump-ähnliche Launches verwenden alle diese Form. Die Kurve simuliert eine **virtuelle Quote-Reserve** `V_q` und eine **virtuelle Base-Reserve** `V_b` von Anfang an (gespeichert als `virtual_quote` und `virtual_base` auf `PoolState`), sodass der effektive Pool wie ein CPMM mit diesen Reserven aussieht. Käufe folgen der Mathematik von `x · y = k`: ``` (V_q + real_quote_in_after_fee) × (V_b + real_base_remaining − base_out) = V_q × V_b ``` gelöst für `base_out`: ``` base_out = (V_b + real_base_remaining) × quote_in_after_fee / (V_q + real_quote_in_after_fee) ``` Effektiver Preis bei Base-verkauft `s`: ``` price(s) = (V_q + real_quote_in(s)) / (V_b + real_base_remaining(s)) ``` Die gleiche `x · y = k` Invariante, die LaunchLab vor der Graduierung anwendet, ist dann wörtlich die CPMM- (oder AMM v4-) Kurve nach der Graduierung, sodass die Graduierungsübergabe mechanisch nahtlos ist: Der Grenzpreis bei `base_sold = base_supply_graduation` entspricht dem Preis, bei dem der Post-Graduierungs-Pool mit `(quote_vault, base_vault_remaining)` als seinen Reserven eröffnet wird. ## Fixed-price-Kurve (`curve_type = 1`) Eine Kurve mit konstanter Preis. Jeder Kauf/Verkauf findet zu einem konstanten Preis statt, der bei der Initialisierung (`Initialize`) konfigurierbar ist: ``` price(s) = virtual_quote / virtual_base (konstant für alle s) ``` Nützlich für faire Launches, bei denen das Team einen einheitlichen Preis für alle Teilnehmer unabhängig vom Zeitpunkt des Kaufs wünscht. Die Graduierung wird ausgelöst, wenn `base_supply_graduation` verkauft wurde (die lineare Kostenbeziehung macht `quote_reserve_target` einfach herzuleiten). ## Linear-price-Kurve (`curve_type = 2`) Der Preis steigt linear mit `base_sold`: ``` price(s) = a · s (a = Steigung, abgeleitet von virtual_base / virtual_quote) ``` Integrierte Kosten: ``` cost(s_0, s_1) = a · (s_1² − s_0²) / 2 ``` Quadratisch in `base_sold` — frühe Käufer zahlen nahe null, späte Käufer zahlen erheblich mehr, wobei der Grenzpreis immer mit einer festen Steigung ansteigt. Die On-Chain-Implementierung befindet sich in `curve/linear_price.rs`. ## Vergleich der Kurvenformen ``` Preis │ linear (steiler Schwanz) linear (curve_type = 2) │ ╱ │ ╱ │ ╱ const-product (curve_type = 0) │ ╱ ╱ │ ╱ ╱ │ ╱ ╱ │ ╱ ╱ │╱_____╱_______________________ fixed-price (curve_type = 1) └──────────────────────────────── base_sold 0 S_grad S_max ``` ## Graduierungsschwellwert `quote_reserve_target` wird bei `Initialize` als die Quote berechnet, die erforderlich ist, um `base_sold` von 0 auf `base_supply_graduation` zu treiben: ``` quote_reserve_target = cost(0, base_supply_graduation) × (1 + buy_fee_rate) ^^^^^^^^^^^^^^^^^ Annäherung; genaue Form entspricht der Gebühren- rundung bei Buy. ``` Ein Launch wird graduiert, sobald `quote_vault.balance ≥ quote_reserve_target`. Da Käufe in diskreten Größen erfolgen, kann der tatsächliche Saldo bei Graduierung den Schwellwert leicht überschreiten — der Überschuss wird zu zusätzlicher Liquidität auf der Quote-Seite im daraus resultierenden CPMM-Pool. ## Ausgearbeitetes Beispiel — ein quadratischer Launch Parameter: * `base_supply_max = 1_000_000_000` (1 Milliarde Base-Tokens, 6 Dezimalstellen) * `base_supply_graduation = 800_000_000` (80% verkauft löst Graduierung aus) * `k = 40` (Preisskala) * Gebühren: 1% Kauf, 1% Verkauf, Aufteilung `lp:creator:protocol = 60:20:20`. **Anfangspreis** (`s = 0`): `0` (reine quadratische Kurve beginnt bei null). **Preis bei 50% verkauft** (`s = 500_000_000`): ``` price = 40 × (500e6 / 1e9)² = 40 × 0,25 = 10 (Quote pro Base, 6 Dezimalstellen) ``` **Preis bei Graduierung** (`s = 800_000_000`): ``` price = 40 × (800e6 / 1e9)² = 40 × 0,64 = 25,6 ``` **Quote erforderlich, um die Graduierung zu erreichen** (integrierte Kosten): ``` cost(0, 800_000_000) = (40 / (3 × 1e18)) × ((800e6)³ − 0) = (40 / 3e18) × 5,12e26 ≈ 6,827e9 ``` So etwa 6,827 Quote-native Einheiten (in welchem auch immer 6-dezimalen Quote-Mint konfiguriert ist, z. B. \~6.827 USDC, wenn die Quote USDC ist). **Gebühr hinzugefügt**: ``` quote_reserve_target ≈ 6,827e9 × 1,01 ≈ 6,895e9 (6.895 USDC) ``` **Erster Kauf** von `10 USDC`: * Virtueller Zustand: `s = 0`, `quote_vault = 0`. * Gebühr abziehen: `quote_after_fee = 10 × 0,99 = 9,9`. * Löse `(40 / (3e18)) × s³ = 9,9` ⇒ `s ≈ 6,22e6` Base-Tokens gekauft. * 1% Gebühr (`0,1 USDC`) Aufteilung: lp `0,06`, creator `0,02`, protocol `0,02`. Der lp-Anteil bleibt in `quote_vault`; die anderen beiden leiten zu ihren jeweiligen Akkumulatoren weiter. **Kauf bei 75% verkauft** (annähernd Graduierung): Das gleiche 10 USDC kauft jetzt viel weniger Base, weil die Kurve steil ist. Ein Newton-Lösen bei `s₀ = 750e6` mit `quote_in_after_fee = 9,9` ergibt ungefähr `∆s ≈ 0,4e6` — eine \~15-fache Verringerung von Base pro USDC im Vergleich zum ersten Kauf. ## Gebühren-Mechanik während der Kurvenphase Bei jedem `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` bleibt in `quote_vault`. Dies ist das, was die effektive Kurve enger macht (mehr Quote-Reserve gegen das gleiche Base-Angebot). * `protocol_share` erhöht `LaunchState.state_data.protocol_fees_quote`. * `creator_share` erhöht `LaunchState.state_data.creator_fees_quote`. Bei `Sell` gilt die gleiche Aufteilung, aber die Gebühr wird aus dem ausgehenden `quote_out` abgezogen. Beide Zähler werden über `CollectFees` (Admin oder Creator, jeder zu ihrem eigenen Zähler) geleert. ## Präzision * Base-seitige Beträge: `u64`. * Quote-seitige Beträge: `u64`. * Zwischensummen / Produkte: `u128`. * Newton-Lösungen für „exakte Quote kaufen" und „exakte Quote verkaufen" iterieren in `u128` mit Festpunkt und einer konfigurierbaren maximalen Iterationszahl (Standard 10). Fehlermodus ist `NotConverged` — selten außerhalb von nahe-Graduierungs-Grenzfällen. ## Übergabe zu CPMM Wenn `Graduate` ausgelöst wird: ``` cpmm_quote_reserve = quote_vault − swept_protocol_fees − swept_creator_fees cpmm_base_reserve = base_vault // d. h. base_supply_max − base_sold cpmm_initial_price = cpmm_quote_reserve / cpmm_base_reserve ``` Für die quadratische Kurve ist `cpmm_initial_price` mechanisch `price(base_sold)` (es ist der Grenzpreis der Kurve zum Zeitpunkt der Übergabe). Der CPMM-Pool eröffnet genau zu diesem Preis, sodass ein Beobachter, der von der Kurven-UI zur CPMM-UI wechselt, keinen Sprung sieht. ## Nächste Schritte * [`products/launchlab/accounts`](/de/products/launchlab/accounts) — die `LaunchState`-Felder, die diese Parameter speichern. * [`products/launchlab/instructions`](/de/products/launchlab/instructions) — `Buy`, `Sell`, `Graduate` Account-Listen. * [`algorithms/constant-product`](/de/algorithms/constant-product) — die CPMM-Mathematik, die der Post-Graduierungs-Pool verwendet. Quellen: * [Raydium SDK v2 `LaunchLab` module](https://github.com/raydium-io/raydium-sdk-V2) * Raydium LaunchLab Programmquellcode