> ## 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. # 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 →](/products/launchlab/bonding-curve) 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`](/es/products/launchlab/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`](/es/products/launchlab/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`](/es/products/launchlab/accounts) — los campos `LaunchState` que almacenan estos parámetros. * [`products/launchlab/instructions`](/es/products/launchlab/instructions) — listas de cuentas de `Buy`, `Sell`, `Graduate`. * [`algorithms/constant-product`](/es/algorithms/constant-product) — la matemática CPMM que el pool post-graduación usa. Fuentes: * [Módulo `LaunchLab` del Raydium SDK v2](https://github.com/raydium-io/raydium-sdk-V2) * Fuente del programa Raydium LaunchLab