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

# Courbes de liaison (Bonding curves)

> Les mathématiques des courbes d'émission de jetons — variantes CPMM quadratiques, linéaires et à réserves virtuelles — dérivations du coût, du produit et du prix au comptant, et les mathématiques du seuil de graduation utilisées par LaunchLab.

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

  [Voir la version anglaise →](/algorithms/bonding-curves)
</Info>

## Qu'est-ce qu'une courbe de liaison

Une **courbe de liaison** est une fonction de prix déterministe `p(s)` qui relie le prix d'un jeton à la quantité actuellement en circulation (`s` pour « supply sold »). Les acheteurs font leurs achats en envoyant de la garantie au contrat ; le contrat émet de nouvelles unités de jetons au prix marginal dicté par la courbe. Les vendeurs retournent les unités de jetons et reçoivent le remboursement intégré.

Deux propriétés clés par rapport à un pool CPMM :

* **Pas de contrepartie nécessaire.** Le contrat émetteur est le teneur de marché ; la liquidité existe de jure.
* **Prix monotone.** Le prix augmente à chaque achat net et diminue à chaque vente nette.

Les courbes de liaison sont le mécanisme de lancement standard quand l'entité émettrice ne souhaite pas pré-amorcer un pool AMM avec de la garantie.

## Formules de tarification génériques

Pour toute fonction de prix continue `p(s)` :

**Prix au comptant** à l'offre `s` :

```
p(s) = the curve formula
```

**Coût pour acheter** l'offre de `s_0` à `s_1` (avec `s_1 > s_0`) :

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

où `P(s) = ∫ p(s) ds` est la primitive de la courbe. Géométriquement, `cost` est l'aire sous `p` entre `s_0` et `s_1`.

**Produit de la vente** de l'offre de `s_1` à `s_0` :

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

(Symétrie : acheter et vendre sur le même intervalle échange la même garantie — modulo les frais.)

**Prix moyen** pour l'achat :

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

## Familles de courbes courantes

### Linéaire

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

Le prix augmente proportionnellement avec l'offre. Utilisé pour les lancements « réguliers » où l'émetteur souhaite une majoration prévisible et modérée sur la durée de vie.

### Quadratique

```
p(s) = k · s²                      // or  k · (s / S_max)² for a normalized form
```

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

Le prix augmente quadratiquement. Les premiers acheteurs obtiennent un prix proche de zéro (région de démarrage plate) ; les derniers acheteurs paient une prime plus raide. C'est le type de courbe par défaut de LaunchLab (`curve_type = 0`).

### CPMM à réserves virtuelles (style Pump)

La courbe est un CPMM standard avec une réserve de devis imaginaire initiale `V_q` :

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

Prix au comptant :

```
p(s) = effective_y / effective_x
     = V_q · S_max / (S_max − s)² · ... (derivable via implicit differentiation)
```

Coût pour passer de `s_0` à `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))
```

Cette variante a la propriété élégante qu'à la graduation (où `s = S_graduate`), le prix marginal égale le prix d'ouverture du pool CPMM en aval amorcé avec les réserves `(S_max − S_graduate, V_q + cost(0, S_graduate))`. La transition est transparente. LaunchLab l'expose en tant que `curve_type = 1`.

## Implémentation discrète

Sur la chaîne, `s` et `cost` sont tous deux des entiers (unités de plus petite dénomination). L'intégrale continue `cost(s_0, s_1)` est calculée directement à partir de la forme fermée chaque fois qu'elle existe (linéaire, quadratique). Pour les courbes sans inverse en forme fermée (quadratique, étant donné `cost`, trouvez `s_1`), l'itération de Newton est utilisée :

```
# Solve quadratic: (k/3)·s_1³ = (k/3)·s_0³ + cost
# Initialize with 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 limite les itérations à \~10 et effectue un revert avec `NotConverged` si le résidu est encore au-dessus de la tolérance. En pratique, cela ne se déclenche qu'aux extrémités du domaine ; les swaps en production convergent en 2–3 itérations.

## Intégration des frais

Les frais sont appliqués en plus du coût de la courbe, pas à l'intérieur. À l'achat :

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

À la vente :

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

La partie LP du frais est conservée dans `quote_vault` et rend effectivement la courbe plus raide pour les acheteurs ultérieurs — la réserve augmente sans émettre plus d'offre. Les portions de protocole et de créateur sont suivies dans des compteurs séparés pour un balayage ultérieur.

## Seuil de graduation

Une courbe « se diplôme » quand elle a reçu suffisamment de garantie pour amorcer un pool AMM externe à un prix correspondant au prix de courbe actuel. Pour une courbe quadratique avec les paramètres `(k, S_max, S_graduate)` :

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

Une fois que `quote_vault ≥ quote_to_graduate`, l'instruction `Graduate` crée un pool CPMM avec :

```
cpmm_base_reserve  = S_max − S_graduate        // unsold curve supply
cpmm_quote_reserve = quote_vault − accrued_fee_counters
cpmm_initial_price = cpmm_quote_reserve / cpmm_base_reserve
```

Pour la courbe à réserves virtuelles, par construction :

```
cpmm_initial_price == p(S_graduate)           // exact equality
```

Pour la quadratique, l'égalité est approximative ; la « perte » est absorbée par l'arrondi de `S_graduate` (typiquement `0.8 · S_max`) et la garantie excédentaire de l'achat final franchissant le seuil.

## Impermanence vs un pool CPMM

Un lancement de courbe de liaison pure n'a **aucune impermanence** au sens Uniswap : il n'y a pas d'« autre côté » du marché à rééquilibrer. La courbe émet l'offre à la demande, et le seul « LP » est le contrat lui-même.

Après la graduation, le pool CPMM résultant se comporte comme n'importe quel autre pool CPMM — si le LP n'a pas été brûlé, il est sujet aux dynamiques habituelles de perte impermanente. C'est pourquoi la politique de **brûlage** post-graduation est dominante dans les lancements publics : elle maintient le pool permanent et élimine les chocs de prix entraînés par les retraits de LP.

## Exemple concret

Courbe : quadratique, `k = 40`, `S_max = 1e9`, `S_graduate = 0.8 · S_max = 8e8`. Frais d'achat 1 %.

### Prix à `s = 5e8`

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

10 unités de devis par unité de base.

### Coût du premier achat de 1e6 base

```
cost(0, 1e6) = (40/3) · (1e6)³
             = (40/3) · 1e18
             ≈ 1.333e19     (smallest quote units)
```

Avec frais de 1 % :

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

### Seuil de graduation

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

### Prix à la graduation

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

### Réserves CPMM post-graduation

```
cpmm_base  = 1e9 − 8e8 = 2e8
cpmm_quote ≈ 6.827e27  (less fee-counter deductions)
cpmm_price ≈ 3.41e19 per base — which matches p(8e8) after units are accounted for
```

(Unités : les décimales doivent être suivies avec soin ; l'exemple est illustratif.)

## Pointeurs

* [`/fr/products/launchlab/bonding-curve`](/fr/products/launchlab/bonding-curve) — l'implémentation sur la chaîne de LaunchLab de ces formules.
* [`/fr/products/launchlab/instructions`](/fr/products/launchlab/instructions) — spécifications au niveau des comptes pour `Buy`, `Sell`, `Graduate`.
* [`/fr/algorithms/constant-product`](/fr/algorithms/constant-product) — ce que le CPMM post-graduation fait avec les réserves.

Sources :

* Code source du programme Raydium LaunchLab (implémentations de courbes quadratiques + réserves virtuelles).
* Document technique Bancor (courbes de liaison linéaires, historique).
* Post-mortems publics Pump.fun (variante à réserves virtuelles).