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

# Courbe de liaison LaunchLab

> Les formules de courbe supportées par LaunchLab, le coût d'achat et de vente sous forme fermée, la dérivation du seuil de graduation, et une démonstration numérique complète d'un lancement du premier achat à la graduation.

<Info>
  **Cette page est traduite automatiquement par IA. La version anglaise fait foi.**

  [Voir la version anglaise →](/products/launchlab/bonding-curve)
</Info>

<Info>
  LaunchLab supporte trois formes de courbe sélectionnées à l'`Initialize` : **constant-product** (la plus courante, la forme de réserve virtuelle de la courbe `x · y = k` standard), **linear-price**, et **fixed-price**. La formule du seuil de graduation est commune à tous les trois. Cette page détaille les mathématiques constant-product ; les formes linéaire et fixe sont résumées à la fin.
</Info>

## Paramètres stockés sur `LaunchState`

| Champ                                                        | Signification                                                                                                                                                                    |
| ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `curve_type`                                                 | `0` = constant-product (réserves virtuelles), `1` = fixed-price, `2` = linear-price.                                                                                             |
| `base_supply_max`                                            | Total de jetons de base que la courbe peut émettre.                                                                                                                              |
| `base_supply_graduation`                                     | Jetons de base qui doivent être vendus pour atteindre la graduation. Généralement `0.8 × base_supply_max` ; les 20 % restants deviennent la LP initiale du pool post-graduation. |
| `quote_reserve_target`                                       | Montant de citation qui déclenche la graduation. Dérivé à l'`Initialize` à partir des paramètres de courbe + `base_supply_graduation`.                                           |
| `virtual_base` / `virtual_quote`                             | Graines de réserve virtuelle pour la courbe constant-product.                                                                                                                    |
| `migrate_type`                                               | Sélectionne la cible de graduation : AMM v4 vs CPMM. Voir [`instructions`](/fr/products/launchlab/instructions).                                                                 |
| `fees.buy_numerator / buy_denominator`                       | Frais du côté achat, par exemple `100 / 10_000 = 1.00%`.                                                                                                                         |
| `fees.sell_numerator / sell_denominator`                     | Frais du côté vente. Souvent identiques aux frais d'achat.                                                                                                                       |
| `fees.protocol_share`, `fees.creator_share`, `fees.lp_share` | Répartition des frais ci-dessus, s'additionnant au dénominateur.                                                                                                                 |

Les noms de champs dans la structure Rust correspondent aux champs `PoolState` décrits dans [`accounts`](/fr/products/launchlab/accounts) ; les unités ci-dessus sont conceptuelles.

## Courbe constant-product avec réserves virtuelles (`curve_type = 0`)

La courbe par défaut et la plus utilisée. Tous les lancements de type Pump utilisent cette forme. La courbe prétend qu'il existe une **réserve de citation virtuelle** `V_q` et une **réserve de base virtuelle** `V_b` dès le début (stockées sous `virtual_quote` et `virtual_base` sur `PoolState`), donc le pool effectif ressemble à un CPMM avec ces réserves. Les achats suivent les mathématiques `x · y = k` :

```
(V_q + real_quote_in_after_fee) × (V_b + real_base_remaining − base_out) = V_q × V_b
```

résolu pour `base_out` :

```
base_out = (V_b + real_base_remaining) × quote_in_after_fee / (V_q + real_quote_in_after_fee)
```

Prix effectif au base-vendu `s` :

```
price(s) = (V_q + real_quote_in(s)) / (V_b + real_base_remaining(s))
```

L'invariant `x · y = k` identique que LaunchLab applique avant la graduation est alors littéralement la courbe CPMM (ou AMM v4) post-graduation, donc la transmission de graduation est mécaniquement transparente : le prix marginal à `base_sold = base_supply_graduation` égale le prix auquel le pool post-graduation s'ouvre avec `(quote_vault, base_vault_remaining)` comme réserves.

## Courbe à prix fixe (`curve_type = 1`)

Une courbe à prix plat. Chaque achat/vente se fait à un prix constant, configurable à l'`Initialize` :

```
price(s) = virtual_quote / virtual_base    (constant pour tout s)
```

Utile pour les lancements équitables où l'équipe souhaite une tarification uniforme pour tous les participants indépendamment de quand ils achètent. La graduation se déclenche quand `base_supply_graduation` a été vendu (la relation de coût linéaire rend `quote_reserve_target` simple à dériver).

## Courbe de prix linéaire (`curve_type = 2`)

Le prix augmente linéairement avec `base_sold` :

```
price(s) = a · s     (a = pente, dérivée de virtual_base / virtual_quote)
```

Coût intégré :

```
cost(s_0, s_1) = a · (s_1² − s_0²) / 2
```

Quadratique en `base_sold` — les premiers acheteurs paient presque zéro, les derniers acheteurs paient beaucoup plus, le prix marginal augmentant toujours à une pente fixe. L'implémentation on-chain vit dans `curve/linear_price.rs`.

## Comparaison des formes de courbe

```
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
```

## Seuil de graduation

`quote_reserve_target` est calculé à l'`Initialize` comme la citation requise pour conduire `base_sold` de 0 à `base_supply_graduation` :

```
quote_reserve_target = cost(0, base_supply_graduation) × (1 + buy_fee_rate)
                                                         ^^^^^^^^^^^^^^^^^
                                                         approximatif ; la forme
                                                         exacte correspond aux
                                                         arrondis de frais utilisés
                                                         sur Buy.
```

Un lancement se diplôme dès que `quote_vault.balance ≥ quote_reserve_target`. Comme les achats arrivent à des tailles discrètes, le solde réel à la graduation peut légèrement dépasser la cible — l'excédent devient de la liquidité supplémentaire du côté citation dans le pool CPMM résultant.

## Exemple travaillé — un lancement quadratique

Paramètres :

* `base_supply_max        = 1_000_000_000` (1 milliard de jetons de base, 6 décimales)
* `base_supply_graduation = 800_000_000`   (80 % vendus déclenchent la graduation)
* `k                      = 40` (échelle de prix)
* Frais : 1 % achat, 1 % vente, répartition `lp:creator:protocol = 60:20:20`.

**Prix initial** (`s = 0`) : `0` (la quadratique pure commence à zéro).

**Prix à 50 % vendu** (`s = 500_000_000`) :

```
price = 40 × (500e6 / 1e9)² = 40 × 0.25 = 10  (citation par base, 6 décimales)
```

**Prix à la graduation** (`s = 800_000_000`) :

```
price = 40 × (800e6 / 1e9)² = 40 × 0.64 = 25.6
```

**Citation requise pour atteindre la graduation** (coût intégré) :

```
cost(0, 800_000_000) = (40 / (3 × 1e18)) × ((800e6)³ − 0)
                     = (40 / 3e18) × 5.12e26
                     ≈ 6.827e9
```

Donc ≈ 6.827 unités natives de citation (dans la menthe de citation 6-décimale configurée, par exemple \~6 827 USDC si la citation est USDC).

**Frais appliqués par-dessus** :

```
quote_reserve_target ≈ 6.827e9 × 1.01 ≈ 6.895e9  (6 895 USDC)
```

**Premier achat** de `10 USDC` :

* État virtuel : `s = 0`, `quote_vault = 0`.
* Soustraire les frais : `quote_after_fee = 10 × 0.99 = 9.9`.
* Résoudre `(40 / (3e18)) × s³ = 9.9` ⇒ `s ≈ 6.22e6` jetons de base achetés.
* Frais 1% (`0.1 USDC`) répartis : lp `0.06`, creator `0.02`, protocol `0.02`. La part lp reste dans `quote_vault` ; les deux autres routent vers leurs compteurs de cumul respectifs.

**Achat à 75 % vendu** (approchant la graduation) :

Les mêmes 10 USDC achètent beaucoup moins de base maintenant parce que la courbe est raide. Une résolution Newton à `s₀ = 750e6` avec `quote_in_after_fee = 9.9` donne approximativement `∆s ≈ 0.4e6` — une réduction \~15× de base par USDC comparée au premier achat.

## Mécanique des frais pendant la phase de courbe

À chaque `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` est laissé dans `quote_vault`. C'est ce qui rend la courbe effective plus serrée (plus de réserve de citation contre le même approvisionnement en base).
* `protocol_share` incrémente `LaunchState.state_data.protocol_fees_quote`.
* `creator_share` incrémente `LaunchState.state_data.creator_fees_quote`.

Sur `Sell` la même répartition s'applique mais les frais sont prélevés sur la `quote_out` sortante.

Les deux compteurs sont balayés via `CollectFees` (admin ou creator, chacun sur son propre compteur).

## Précision

* Montants du côté base : `u64`.
* Montants du côté citation : `u64`.
* Cubes / produits intermédiaires : `u128`.
* Les résolutions Newton pour « acheter citation exacte » et « vendre citation exacte » itèrent en `u128` à point fixe avec un nombre d'itérations max configurable (par défaut 10). Le mode d'échec est `NotConverged` — rare en dehors des cas limites proches de la graduation.

## Transmission au CPMM

Quand `Graduate` se déclenche :

```
cpmm_quote_reserve = quote_vault − swept_protocol_fees − swept_creator_fees
cpmm_base_reserve  = base_vault                       // c.-à-d. base_supply_max − base_sold
cpmm_initial_price = cpmm_quote_reserve / cpmm_base_reserve
```

Pour la courbe quadratique, `cpmm_initial_price` est mécaniquement `price(base_sold)` (c'est le prix de courbe marginal au moment de la transmission). Le pool CPMM s'ouvre exactement à ce prix, donc un observateur passant de l'interface de courbe à l'interface CPMM ne voit aucun saut.

## Où aller ensuite

* [`products/launchlab/accounts`](/fr/products/launchlab/accounts) — les champs `LaunchState` stockant ces paramètres.
* [`products/launchlab/instructions`](/fr/products/launchlab/instructions) — listes de comptes `Buy`, `Sell`, `Graduate`.
* [`algorithms/constant-product`](/fr/algorithms/constant-product) — les mathématiques CPMM que le pool post-graduation utilise.

Sources :

* [Raydium SDK v2 `LaunchLab` module](https://github.com/raydium-io/raydium-sdk-V2)
* Raydium LaunchLab program source