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.

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

​

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.
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 ; 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 — 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
• Raydium LaunchLab program source