> ## 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.

# Bonding Curves

> Die Mathematik hinter Token-Emissionskurven — quadratisch, linear und Virtual-Reserves-CPMM-Varianten — Herleitungen für Kosten / Einnahmen / Spotpreis und die Graduierungsschwellwert-Mathematik von LaunchLab.

<Info>
  **Diese Seite wurde mit KI automatisch übersetzt. Maßgeblich ist stets die englische Version.**

  [Englische Version ansehen →](/algorithms/bonding-curves)
</Info>

## Was eine Bonding Curve ist

Eine **Bonding Curve** ist eine deterministische Preisfunktion `p(s)`, die den Preis eines Tokens zur momentan im Umlauf befindlichen Menge (`s` für „Supply Sold") in Beziehung setzt. Käufer erwerben durch Überweisung von Collateral zum Vertrag; der Vertrag gibt neue Token-Einheiten zum Grenzpreis der Kurve aus. Verkäufer geben Token-Einheiten zurück und erhalten die integrierte Rückerstattung.

Zwei Schlüsseleigenschaften im Vergleich zu einem CPMM-Pool:

* **Keine Gegenpartei erforderlich.** Der ausgebende Vertrag ist der Market Maker; Liquidität existiert per Dekret.
* **Monotoner Preis.** Der Preis steigt bei jedem Netto-Kauf und sinkt bei jedem Netto-Verkauf.

Bonding Curves sind der Standard-Startmechanismus, wenn die ausgebende Entität einen AMM-Pool nicht mit Collateral vorfinanzieren möchte.

## Generische Preisformeln

Für jede kontinuierliche Preisfunktion `p(s)`:

**Spotpreis** bei Supply `s`:

```
p(s) = die Kurvenformel
```

**Kosten zum Kauf** von Supply von `s_0` zu `s_1` (mit `s_1 > s_0`):

```
cost(s_0, s_1) = ∫_{s_0}^{s_1} p(s) ds = P(s_1) − P(s_0)
```

wobei `P(s) = ∫ p(s) ds` die Stammfunktion der Kurve ist. Geometrisch ist `cost` die Fläche unter `p` zwischen `s_0` und `s_1`.

**Einnahmen aus dem Verkauf** von Supply zurück von `s_1` zu `s_0`:

```
proceeds(s_1, s_0) = cost(s_0, s_1)
```

(Symmetrie: Kauf und Verkauf über dasselbe Intervall tauschen dasselbe Collateral aus — modulo Gebühren.)

**Durchschnittspreis** für den Kauf:

```
avg = cost(s_0, s_1) / (s_1 − s_0)
```

## Häufige Kurvenfamilien

### Linear

```
p(s) = a + b · s
```

```
P(s)            = a·s + (b/2)·s²
cost(s_0, s_1)  = a·(s_1 − s_0) + (b/2)·(s_1² − s_0²)
```

Der Preis steigt proportional zur Supply. Wird für „stabile" Launches verwendet, bei denen der Emittent einen vorhersehbaren, moderaten Aufschlag über die Lebensdauer hinweg wünscht.

### Quadratisch

```
p(s) = k · s²                      // oder  k · (s / S_max)² für eine normalisierte Form
```

```
P(s)            = (k / 3) · s³
cost(s_0, s_1)  = (k / 3) · (s_1³ − s_0³)
```

Der Preis steigt quadratisch. Frühe Käufer erhalten einen nahezu Null-Preis (flache Startregion); späte Käufer zahlen einen steileren Aufschlag. Dies ist der Standard-Kurventyp von LaunchLab (`curve_type = 0`).

### Virtual-Reserves CPMM (Pump-Stil)

Die Kurve ist ein Standard-CPMM mit einer vorgetäuschten initialen Quote-Reserve `V_q`:

```
effective_y = V_q + collateral_received
effective_x = S_max − s
(effective_x) · (effective_y) = V_q · S_max      // Invariante
```

Spotpreis:

```
p(s) = effective_y / effective_x
     = V_q · S_max / (S_max − s)² · ... (ableitbar durch implizite Differentiation)
```

Kosten zur Bewegung von `s_0` zu `s_1`:

```
cost(s_0, s_1) = V_q · S_max / (S_max − s_1) − V_q · S_max / (S_max − s_0)
              = V_q · (s_1 − s_0) · S_max / ((S_max − s_0) · (S_max − s_1))
```

Diese Variante hat die elegante Eigenschaft, dass bei der Graduierung (wo `s = S_graduate`) der Grenzpreis gleich dem Eröffnungspreis des nachgelagerten CPMM-Pools ist, der mit Reserves `(S_max − S_graduate, V_q + cost(0, S_graduate))` gefüllt wird. Die Übergabe ist nahtlos. LaunchLab stellt dies als `curve_type = 1` bereit.

## Diskrete Implementierung

On-Chain sind sowohl `s` als auch `cost` ganzzahlig (Einheiten der kleinsten Denomination). Das kontinuierliche Integral `cost(s_0, s_1)` wird direkt aus der geschlossenen Form berechnet, wenn eine existiert (linear, quadratisch). Für Kurven ohne geschlossene Inverse (quadratisch, gegeben `cost`, finde `s_1`), wird Newton-Iteration verwendet:

```
# Löse quadratisch: (k/3)·s_1³ = (k/3)·s_0³ + cost
# Initialisiere mit s_guess ≈ cbrt(3·cost/k + s_0³)
for i in 0..MAX_ITER:
    f    = (k/3)·s_guess³ − (k/3)·s_0³ − cost
    f'   = k·s_guess²
    step = f / f'
    s_guess -= step
    if |step| < precision_floor: break
```

LaunchLab begrenzt Iterationen auf etwa 10 und bricht mit `NotConverged` ab, falls der Residuum noch über der Toleranz liegt. In der Praxis wird dies nur an extremen Punkte der Domäne ausgelöst; typische Swaps konvergieren in 2–3 Iterationen.

## Gebührenintegration

Gebühren werden auf den Kurvenwert aufgelegt, nicht in ihn integriert. Beim Kauf:

```
cost_curve  = cost(base_sold, base_sold + base_out)
fee         = ceil(cost_curve · buy_numerator / buy_denominator)
quote_in    = cost_curve + fee
```

Beim Verkauf:

```
proceeds_curve = cost(base_sold − base_in, base_sold)
fee            = ceil(proceeds_curve · sell_numerator / sell_denominator)
quote_out      = proceeds_curve − fee
```

Der LP-Anteil der Gebühr wird in `quote_vault` eingezogen und macht die Kurve für spätere Käufer effektiv steifer — die Reserve wächst, ohne mehr Supply auszugeben. Die Protokoll- und Creator-Anteile werden in separaten Zählern nachverfolgt zur späteren Erfassung.

## Graduierungsschwellwert

Eine Kurve „graduiert", wenn sie genug Collateral erhalten hat, um einen externen AMM-Pool mit einem Preis zu finanzieren, der dem aktuellen Kurvenprice entspricht. Für eine quadratische Kurve mit Parametern `(k, S_max, S_graduate)`:

```
quote_to_graduate = cost(0, S_graduate) · (1 + buy_fee_rate)
                  = (k / 3) · S_graduate³ · (1 + f_buy)
```

Sobald `quote_vault ≥ quote_to_graduate` gilt, erstellt die `Graduate`-Anweisung einen CPMM-Pool mit:

```
cpmm_base_reserve  = S_max − S_graduate        // unverkaufte Kurven-Supply
cpmm_quote_reserve = quote_vault − accrued_fee_counters
cpmm_initial_price = cpmm_quote_reserve / cpmm_base_reserve
```

Für die Virtual-Reserves-Kurve ist per Konstruktion:

```
cpmm_initial_price == p(S_graduate)           // exakte Gleichheit
```

Für die quadratische Kurve ist die Gleichheit näherungsweise; die „Restmenge" wird durch das Runden von `S_graduate` (typischerweise `0.8 · S_max`) und das Überschuss-Collateral des letzten schwellwert-überschreitenden Kaufs absorbiert.

## Unbestständigkeit vs ein CPMM-Pool

Ein reiner Bonding-Curve-Launch hat **keine Unbestständigkeit** im Uniswap-Sinne: es gibt keine „andere Seite" des Marktes zum Rebalancieren. Die Kurve gibt Supply nach Bedarf aus, und der einzige „LP" ist der Vertrag selbst.

Nach der Graduierung verhält sich der resultierende CPMM-Pool wie jeder andere CPMM-Pool — falls der LP nicht gebrannt wurde, unterliegen sie den üblichen Impermanent-Loss-Dynamiken. Deshalb ist die **Burn**-Policy nach der Graduierung dominierend in öffentlichen Launches: sie halten den Pool permanent und entfernen etwaige LP-Auszahlungsgesteuerte Preisschocks.

## Bearbeitetes Beispiel

Kurve: quadratisch, `k = 40`, `S_max = 1e9`, `S_graduate = 0.8 · S_max = 8e8`. Kaufgebühr 1%.

### Preis bei `s = 5e8`

```
p(5e8) = 40 · (5e8 / 1e9)² = 40 · 0.25 = 10
```

10 Quote-Einheiten pro Base-Einheit.

### Kosten des ersten Kaufs von 1e6 Base

```
cost(0, 1e6) = (40/3) · (1e6)³
             = (40/3) · 1e18
             ≈ 1.333e19     (kleinste Quote-Einheiten)
```

Mit 1% Gebühr:

```
quote_in = 1.333e19 · 1.01 ≈ 1.347e19
```

### Graduierungsschwellwert

```
cost(0, 8e8) = (40/3) · (8e8)³
             = (40/3) · 5.12e26
             ≈ 6.827e27
quote_to_graduate ≈ 6.827e27 · 1.01 ≈ 6.895e27
```

### Preis bei Graduierung

```
p(8e8) = 40 · 0.64 = 25.6
```

### Post-Graduierungs-CPMM-Reserves

```
cpmm_base  = 1e9 − 8e8 = 2e8
cpmm_quote ≈ 6.827e27  (minus Gebührenzähler-Abzüge)
cpmm_price ≈ 3.41e19 pro Base — was p(8e8) entspricht, wenn Einheiten berücksichtigt werden
```

(Einheiten: Dezimalstellen müssen sorgfältig nachverfolgt werden; das Beispiel ist illustrativ.)

## Verweise

* [`products/launchlab/bonding-curve`](/de/products/launchlab/bonding-curve) — die On-Chain-Implementierung dieser Formeln von LaunchLab.
* [`products/launchlab/instructions`](/de/products/launchlab/instructions) — `Buy`, `Sell`, `Graduate` Spezifikationen auf Kontoebene.
* [`algorithms/constant-product`](/de/algorithms/constant-product) — was der Post-Graduierungs-CPMM mit den Reserves macht.

Quellen:

* Raydium LaunchLab-Programmquelle (quadratische + Virtual-Reserves-Kurven-Implementierungen).
* Bancor White Paper (lineare Bonding Curves, historisch).
* Pump.fun öffentliche Post-Mortems (Virtual-Reserves-Variante).