Courbe de liaison LaunchLab

Cette page est traduite automatiquement par IA. La version anglaise fait foi.Voir la version anglaise →

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

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 des 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 le LP initial du pool post-graduation.
`quote_reserve_target`	Montant de quote qui déclenche la graduation. Dérivé à `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`	Doit être `CPSWAP` pour une nouvelle initialisation. Une valeur AMM v4 stockée est un état hérité uniquement. Voir `instructions`.
`fees.buy_numerator / buy_denominator`	Frais côté achat, par ex. `100 / 10_000 = 1.00%`.
`fees.sell_numerator / sell_denominator`	Frais côté vente. Souvent identiques aux frais d’achat.
`fees.protocol_share`, `fees.creator_share`, `fees.lp_share`	Répartition des frais ci-dessus, totalisant le dénominateur.

Les noms de champs dans la struct Rust correspondent aux champs PoolState décrits dans 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 style Pump utilisent cette forme. La courbe prétend qu’il existe une réserve de quote virtuelle V_q et une réserve de base virtuelle V_b dès le départ (stockées comme virtual_quote et virtual_base sur PoolState), de sorte que 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 à base-vendu s :

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

L’invariant x · y = k que LaunchLab applique avant la graduation est alors la courbe CPMM après la graduation, de sorte que la transition est mécaniquement transparente : le prix marginal à base_sold = base_supply_graduation est égal au prix auquel le pool post-graduation s’ouvre avec (quote_vault, base_vault_remaining) comme réserves.

Courbe fixed-price (`curve_type = 1`)

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

price(s) = virtual_quote / virtual_base    (constant pour tous les s)

Utile pour les lancements équitables où l’équipe souhaite un prix uniforme pour tous les participants, quel que soit le moment de leur achat. 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 linear-price (`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 près de zéro, les derniers acheteurs paient beaucoup plus, le prix marginal augmentant toujours à une pente fixe. L’implémentation on-chain se trouve dans curve/linear_price.rs.

Comparaison des formes de courbe

price
  │   linear (queue raide)               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é à Initialize comme le quote requis pour faire passer 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 en tailles discrètes, le solde réel à la graduation peut légèrement dépasser la cible — l’excédent devient une liquidité supplémentaire du côté quote dans le pool CPMM résultant.

Exemple détaillé — 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  (quote par base, 6 décimales)

Prix à la graduation (s = 800_000_000) :

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

Quote requis 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 quote (dans le jeton de quote configuré à 6 décimales, par ex. ~6 827 USDC si le quote est USDC). Frais appliqués en plus :

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.9e6 — 9,9 USDC en unités natives à 6 décimales, les mêmes unités que celles du 6.827e9 ci-dessus ⇒ s ≈ 9.06e7 jetons de base achetés.
Frais de 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 vont vers leurs compteurs d’accumulation respectifs.

Achat à 75% vendu (approchant la graduation) : Les mêmes 10 USDC achètent beaucoup moins de base maintenant car la courbe est raide. Une résolution à s₀ = 750e6 avec quote_in_after_fee = 9.9e6 donne ∆s ≈ 4.4e5 — une réduction de ~200× en base par USDC comparé 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 reste dans quote_vault. C’est ce qui rend la courbe effective plus serrée (plus de réserve de quote contre la même offre de 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 le quote_out sortant. Les deux compteurs sont balayés via CollectFees (admin ou créateur, chacun vers son propre compteur).

Précision

Montants côté base : u64.
Montants côté quote : u64.
Cubes / produits intermédiaires : u128.
« Acheter quote exact » et « vendre quote exact » s’inversent sous forme fermée — la courbe à produit constant algébriquement, la courbe à prix fixe par division, la courbe à prix linéaire par une racine carrée. Il n’y a pas de solveur de Newton dans le programme, pas de plafond d’itérations, et pas d’erreur NotConverged.

Transition vers 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 à produit constant — celle par défaut de LaunchLab et le seul type actif — cpmm_initial_price est exactement price(base_sold), le prix marginal de la courbe au moment de la transition, de sorte qu’un observateur passant de l’interface de courbe à l’interface CPMM ne voit aucun saut. Pour une courbe à prix quadratique, ce n’est pas le cas : la moyenne intégrée est supérieure au prix marginal (d’un facteur 4/3 dans l’exemple ci-dessus), et un saut à la transition est donc attendu.

Où aller ensuite

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

Sources :

Raydium SDK v2 LaunchLab module
Source du programme Raydium LaunchLab

LaunchLab

Flux de lancement de token

Tips & Gotchas

Courbe de liaison LaunchLab

Paramètres stockés sur `LaunchState`

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

Courbe fixed-price (`curve_type = 1`)

Courbe linear-price (`curve_type = 2`)

Comparaison des formes de courbe

Seuil de graduation

Exemple détaillé — un lancement quadratique

Mécanique des frais pendant la phase de courbe

Précision

Transition vers CPMM

Où aller ensuite

​Paramètres stockés sur LaunchState

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

​Courbe fixed-price (curve_type = 1)

​Courbe linear-price (curve_type = 2)

​Comparaison des formes de courbe

​Seuil de graduation

​Exemple détaillé — un lancement quadratique

​Mécanique des frais pendant la phase de courbe

​Précision

​Transition vers CPMM

​Où aller ensuite

Paramètres stockés sur `LaunchState`

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

Courbe fixed-price (`curve_type = 1`)

Courbe linear-price (`curve_type = 2`)

Comparaison des formes de courbe

Seuil de graduation

Exemple détaillé — un lancement quadratique

Mécanique des frais pendant la phase de courbe

Précision

Transition vers CPMM

Où aller ensuite