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 →

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.
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 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 — die LaunchState-Felder, die diese Parameter speichern.
• products/launchlab/instructions — Buy, Sell, Graduate Account-Listen.
• algorithms/constant-product — die CPMM-Mathematik, die der Post-Graduierungs-Pool verwendet.

Quellen:

• Raydium SDK v2 LaunchLab module
• Raydium LaunchLab Programmquellcode