Saltar al contenido principal

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.

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

CampoSignificado
curve_type0 = constant-product (reservas virtuales), 1 = fixed-price, 2 = linear-price.
base_supply_maxTotal de tokens base que la curva puede acuñar.
base_supply_graduationTokens 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_targetCantidad de quote que desencadena la graduación. Se deriva en Initialize de los parámetros de la curva + base_supply_graduation.
virtual_base / virtual_quoteSemillas de reserva virtual para la curva constant-product.
migrate_typeSelecciona el destino de graduación: AMM v4 vs CPMM. Ver instructions.
fees.buy_numerator / buy_denominatorTarifa del lado de compra, ej. 100 / 10_000 = 1.00%.
fees.sell_numerator / sell_denominatorTarifa del lado de venta. A menudo igual a la de compra.
fees.protocol_share, fees.creator_share, fees.lp_shareDivisió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

Fuentes: