Curva de vinculación de LaunchLab

Las fórmulas de curva que LaunchLab soporta, costo de compra y venta en forma cerrada, derivación del umbral de graduación, y un recorrido numérico detallado de un lanzamiento desde la primera compra hasta la graduación.

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 seleccionables 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 es compartida entre las tres. Esta página detalla la matemática 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. Normalmente 0.8 × base_supply_max; el 20% restante se convierte en el LP inicial del pool post-graduación.
quote_reserve_target	Cantidad de quote que desencadena la graduación. Se deriva en Initialize 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	Selecciona el destino de graduación: AMM v4 vs CPMM. Ver instructions.
fees.buy_numerator / buy_denominator	Tarifa del lado de compra, 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 descriptos en accounts; las unidades arriba son conceptuales.

​

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

La curva por defecto y más usada. Los lanzamientos estilo Pump usan esta forma. La curva simula que existe 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 ve como 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

despejando base_out:

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

Precio efectivo a 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 literalmente la curva CPMM (o AMM v4) post-graduación, por lo que la transición de graduación es mecánicamente sin fisuras: el precio marginal en base_sold = base_supply_graduation es igual al precio con el que abre el pool post-graduación usando (quote_vault, base_vault_remaining) como sus reservas.

​

Curva de precio fijo (curve_type = 1)

Una curva de precio plano. Cada compra/venta sucede 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 un precio uniforme para todos los participantes independientemente de cuándo compren. La graduación se desencadena cuando base_supply_graduation ha sido vendida (la relación de costo lineal hace que quote_reserve_target sea fácil 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 — compradores tempranos pagan casi cero, compradores tardíos pagan sustancialmente más, con el precio marginal siempre aumentando a una pendiente fija. La implementación on-chain 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 llevar 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. Dado que las compras vienen en tamaños discretos, el balance real en graduación puede exceder ligeramente el objetivo — el excedente se convierte en liquidez adicional del lado de quote en el pool CPMM resultante.

​

Ejemplo detallado — 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 desencadena graduación)
• k = 40 (escala de precio)
• Tarifas: 1% compra, 1% venta, dividido lp:creator:protocol = 60:20:20.

Precio inicial (s = 0): 0 (puro cuadrático 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 requerida para alcanzar graduación (costo integrado):

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

Así ≈ 6.827 unidades quote nativas (en cualquier mint 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 1% (0.1 USDC) dividida: lp 0.06, creator 0.02, protocol 0.02. La parte lp se queda en quote_vault; las otras dos se enrutan a sus contadores de acumulación respectivos.

Compra al 75% vendido (aproximá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 la curva efectiva más ajustada (más reserva de quote contra el mismo suministro base).
• protocol_share incrementa LaunchState.state_data.protocol_fees_quote.
• creator_share incrementa LaunchState.state_data.creator_fees_quote.

En Sell la misma división se aplica pero la tarifa se toma del quote_out saliente.

Ambos contadores se barren vía 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 exact quote” y “vender exact quote” iteran en u128 punto fijo con un máximo de iteraciones configurable (por defecto 10). El modo de falla es NotConverged — raro fuera de casos extremos cerca de la graduación.

​

Transición a CPMM

Cuando Graduate se dispara:

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 abre exactamente a ese precio, por lo que un observador que cambie de la UI de curva a la UI de CPMM no ve salto.

​

Dónde ir después

• 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 el pool post-graduación usa.

Fuentes:

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