Curva de bonificación de LaunchLab

Esta página fue traducida automáticamente por IA. La versión en inglés es la fuente autorizada.Ver versión en inglés →

LaunchLab soporta tres formas de curva seleccionadas en Initialize: constant-product (la más común, forma de reserva virtual del estándar x · y = k), linear-price y fixed-price. La fórmula del umbral de graduación se comparte entre las tres. Esta página detalla la matemática de constant-product; las formas lineal y fija se resumen al final.

Parámetros almacenados en `LaunchState`

Campo	Significado
`curve_type`	`0` = constant-product (reservas virtuales), `1` = fixed-price, `2` = linear-price.
`base_supply_max`	Total de tokens base que la curva puede acuñar.
`base_supply_graduation`	Tokens base que deben venderse para alcanzar la graduación. Generalmente `0.8 × base_supply_max`; el 20% restante se convierte en LP inicial del pool post-graduación.
`quote_reserve_target`	Cantidad de quote que dispara la graduación. Se deriva en `Initialize` a partir de los parámetros de la curva + `base_supply_graduation`.
`virtual_base` / `virtual_quote`	Semillas de reserva virtual para la curva constant-product.
`migrate_type`	Debe ser `CPSWAP` para nueva inicialización. Un valor AMM v4 almacenado es solo estado heredado. Ver `instructions`.
`fees.buy_numerator / buy_denominator`	Tarifa del lado de compra, p. ej. `100 / 10_000 = 1.00%`.
`fees.sell_numerator / sell_denominator`	Tarifa del lado de venta. A menudo igual a la de compra.
`fees.protocol_share`, `fees.creator_share`, `fees.lp_share`	División de lo anterior, sumando al denominador.

Los nombres de campo en la estructura Rust coinciden con los campos PoolState descritos en accounts; las unidades anteriores son conceptuales.

Curva constant-product con reservas virtuales (`curve_type = 0`)

La curva predeterminada y más utilizada. Todos los lanzamientos estilo Pump usan esta forma. La curva pretende que hay una reserva de quote virtual V_q y una reserva de base virtual V_b desde el inicio (almacenadas como virtual_quote y virtual_base en PoolState), por lo que el pool efectivo se parece a un CPMM con esas reservas. Las compras siguen la matemática x · y = k:

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

resuelto para base_out:

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

Precio efectivo en base vendida s:

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

El mismo invariante x · y = k que LaunchLab aplica pre-graduación es entonces la curva CPMM post-graduación, por lo que la transición es mecánicamente sin problemas: el precio marginal en base_sold = base_supply_graduation es igual al precio al que se abre el pool post-graduación con (quote_vault, base_vault_remaining) como sus reservas.

Curva de precio fijo (`curve_type = 1`)

Una curva de precio plano. Cada compra/venta ocurre a un precio constante, configurable en Initialize:

price(s) = virtual_quote / virtual_base    (constante para todo s)

Útil para lanzamientos justos donde el equipo quiere precios uniformes para todos los participantes independientemente de cuándo compren. La graduación se dispara cuando base_supply_graduation ha sido vendido (la relación de costo lineal hace que quote_reserve_target sea sencillo de derivar).

Curva de precio lineal (`curve_type = 2`)

El precio aumenta linealmente con base_sold:

price(s) = a · s     (a = pendiente, derivada de virtual_base / virtual_quote)

Costo integrado:

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

Cuadrático en base_sold — los compradores tempranos pagan casi cero, los compradores tardíos pagan sustancialmente más, con el precio marginal siempre aumentando a una pendiente fija. La implementación en cadena vive en curve/linear_price.rs.

Comparación de formas de curva

price
  │   linear (cola pronunciada)               linear (curve_type = 2)
  │       ╱
  │      ╱
  │     ╱            const-product (curve_type = 0)
  │    ╱            ╱
  │   ╱           ╱
  │  ╱         ╱
  │ ╱       ╱
  │╱_____╱_______________________  fixed-price (curve_type = 1)
  └──────────────────────────────── base_sold
  0                  S_grad         S_max

Umbral de graduación

quote_reserve_target se calcula en Initialize como el quote requerido para impulsar base_sold de 0 a base_supply_graduation:

quote_reserve_target = cost(0, base_supply_graduation) × (1 + buy_fee_rate)
                                                         ^^^^^^^^^^^^^^^^^
                                                         aproximado; la forma
                                                         exacta coincide con el
                                                         redondeo de tarifa usado en Buy.

Un lanzamiento se gradúa tan pronto como quote_vault.balance ≥ quote_reserve_target. Debido a que las compras vienen en tamaños discretos, el saldo real en la graduación puede exceder ligeramente el objetivo — el excedente se convierte en liquidez adicional del lado de quote en el pool CPMM resultante.

Ejemplo trabajado — un lanzamiento cuadrático

Parámetros:

base_supply_max = 1_000_000_000 (1 mil millones de tokens base, 6 decimales)
base_supply_graduation = 800_000_000 (80% vendido dispara la graduación)
k = 40 (escala de precio)
Tarifas: 1% compra, 1% venta, divididas lp:creator:protocol = 60:20:20.

Precio inicial (s = 0): 0 (cuadrático puro comienza en cero). Precio al 50% vendido (s = 500_000_000):

price = 40 × (500e6 / 1e9)² = 40 × 0.25 = 10  (quote por base, 6 decimales)

Precio en graduación (s = 800_000_000):

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

Quote requerido para alcanzar la graduación (costo integrado):

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

Entonces ≈ 6.827 unidades nativas de quote (en cualquier mint de quote de 6 decimales configurado, p. ej. ~6,827 USDC si el quote es USDC). Tarifa aplicada encima:

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

Primera compra de 10 USDC:

Estado virtual: s = 0, quote_vault = 0.
Restar tarifa: quote_after_fee = 10 × 0.99 = 9.9.
Resolver (40 / (3e18)) × s³ = 9.9 ⇒ s ≈ 6.22e6 tokens base comprados.
Tarifa del 1% (0.1 USDC) dividida: lp 0.06, creator 0.02, protocol 0.02. La parte de lp permanece en quote_vault; las otras dos se enrutan a sus contadores de acumulación respectivos.

Compra al 75% vendido (acercándose a la graduación): Los mismos 10 USDC compran mucho menos base ahora porque la curva es pronunciada. Una resolución de Newton en s₀ = 750e6 con quote_in_after_fee = 9.9 da aproximadamente ∆s ≈ 0.4e6 — una reducción de ~15× en base por USDC comparado con la primera compra.

Mecánica de tarifas durante la fase de curva

En cada 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 se deja en quote_vault. Esto es lo que hace que la curva efectiva sea más ajustada (más reserva de quote contra el mismo suministro de base).
protocol_share incrementa LaunchState.state_data.protocol_fees_quote.
creator_share incrementa LaunchState.state_data.creator_fees_quote.

En Sell se aplica la misma división pero la tarifa se toma del quote_out saliente. Ambos contadores se barren a través de CollectFees (admin o creator, cada uno a su propio contador).

Precisión

Cantidades del lado base: u64.
Cantidades del lado quote: u64.
Cubos / productos intermedios: u128.
Las resoluciones de Newton para “comprar quote exacto” y “vender quote exacto” iteran en u128 de punto fijo con un conteo máximo de iteraciones configurable (predeterminado 10). El modo de fallo es NotConverged — raro fuera de casos extremos cerca de la graduación.

Transición a CPMM

Cuando se dispara Graduate:

cpmm_quote_reserve = quote_vault − swept_protocol_fees − swept_creator_fees
cpmm_base_reserve  = base_vault                       // es decir, base_supply_max − base_sold
cpmm_initial_price = cpmm_quote_reserve / cpmm_base_reserve

Para la curva cuadrática, cpmm_initial_price es mecánicamente price(base_sold) (es el precio marginal de la curva en el momento de la transición). El pool CPMM se abre exactamente a ese precio, por lo que un observador que cambia de la UI de curva a la UI de CPMM no ve ningún salto.

Dónde ir a continuación

products/launchlab/accounts — los campos LaunchState que almacenan estos parámetros.
products/launchlab/instructions — listas de cuentas de Buy, Sell, Graduate.
algorithms/constant-product — la matemática CPMM que usa el pool post-graduación.

Fuentes:

Módulo LaunchLab del SDK de Raydium v2
Fuente del programa Raydium LaunchLab

LaunchLab

Flujo de lanzamiento de token

Tips & Gotchas

Curva de bonificación de LaunchLab

Parámetros almacenados en `LaunchState`

Curva constant-product con reservas virtuales (`curve_type = 0`)

Curva de precio fijo (`curve_type = 1`)

Curva de precio lineal (`curve_type = 2`)

Comparación de formas de curva

Umbral de graduación

Ejemplo trabajado — un lanzamiento cuadrático

Mecánica de tarifas durante la fase de curva

Precisión

Transición a CPMM

Dónde ir a continuación

​Parámetros almacenados en LaunchState

​Curva constant-product con reservas virtuales (curve_type = 0)

​Curva de precio fijo (curve_type = 1)

​Curva de precio lineal (curve_type = 2)

​Comparación de formas de curva

​Umbral de graduación

​Ejemplo trabajado — un lanzamiento cuadrático

​Mecánica de tarifas durante la fase de curva

​Precisión

​Transición a CPMM

​Dónde ir a continuación

Parámetros almacenados en `LaunchState`

Curva constant-product con reservas virtuales (`curve_type = 0`)

Curva de precio fijo (`curve_type = 1`)

Curva de precio lineal (`curve_type = 2`)

Comparación de formas de curva

Umbral de graduación

Ejemplo trabajado — un lanzamiento cuadrático

Mecánica de tarifas durante la fase de curva

Precisión

Transición a CPMM

Dónde ir a continuación