> ## 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 vinculação do LaunchLab > As fórmulas de curva que o LaunchLab suporta, custo de compra e venda em forma fechada, derivação do limiar de graduação e um passo a passo numérico de um lançamento desde a primeira compra até a graduação. **Esta página foi traduzida automaticamente por IA. A versão em inglês é a fonte oficial.** [Ver versão em inglês →](/products/launchlab/bonding-curve) O LaunchLab suporta três formas de curva selecionadas em `Initialize`: **constant-product** (a mais comum, forma de reserva virtual da curva padrão `x · y = k`), **linear-price** e **fixed-price**. A fórmula do limiar de graduação é compartilhada entre as três. Esta página detalha a matemática constant-product; as formas linear e fixa são resumidas ao final. ## Parâmetros armazenados em `LaunchState` | Campo | Significado | | ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `curve_type` | `0` = constant-product (reservas virtuais), `1` = fixed-price, `2` = linear-price. | | `base_supply_max` | Total de tokens base que a curva pode cunhar. | | `base_supply_graduation` | Tokens base que devem ser vendidos para atingir a graduação. Geralmente `0.8 × base_supply_max`; os 20% restantes se tornam o LP inicial do pool pós-graduação. | | `quote_reserve_target` | Quantidade de quote que dispara a graduação. Derivada em `Initialize` a partir dos parâmetros da curva + `base_supply_graduation`. | | `virtual_base` / `virtual_quote` | Sementes de reserva virtual para a curva constant-product. | | `migrate_type` | Seleciona o alvo de graduação: AMM v4 vs CPMM. Veja [`instructions`](/pt/products/launchlab/instructions). | | `fees.buy_numerator / buy_denominator` | Taxa buy, p.ex. `100 / 10_000 = 1.00%`. | | `fees.sell_numerator / sell_denominator` | Taxa sell. Frequentemente igual à buy. | | `fees.protocol_share`, `fees.creator_share`, `fees.lp_share` | Divisão da acima, somando ao denominador. | Os nomes dos campos na struct Rust correspondem aos campos `PoolState` descritos em [`accounts`](/pt/products/launchlab/accounts); as unidades acima são conceituais. ## Curva constant-product com reservas virtuais (`curve_type = 0`) A curva padrão e mais usada. Todos os lançamentos estilo Pump usam esta forma. A curva finge que há uma **reserva virtual de quote** `V_q` e uma **reserva virtual de base** `V_b` desde o início (armazenadas como `virtual_quote` e `virtual_base` em `PoolState`), então o pool efetivo se parece com um CPMM com essas reservas. As compras seguem a matemática `x · y = k`: ``` (V_q + real_quote_in_after_fee) × (V_b + real_base_remaining − base_out) = V_q × V_b ``` resolvido para `base_out`: ``` base_out = (V_b + real_base_remaining) × quote_in_after_fee / (V_q + real_quote_in_after_fee) ``` Preço efetivo no base vendido `s`: ``` price(s) = (V_q + real_quote_in(s)) / (V_b + real_base_remaining(s)) ``` O mesmo invariante `x · y = k` que o LaunchLab aplica pré-graduação é então literalmente a curva CPMM (ou AMM v4) pós-graduação, então a transição de graduação é mecanicamente perfeita: o preço marginal em `base_sold = base_supply_graduation` é igual ao preço que o pool pós-graduação abre com `(quote_vault, base_vault_remaining)` como suas reservas. ## Curva de preço fixo (`curve_type = 1`) Uma curva de preço plano. Toda compra/venda acontece a um preço constante, configurável em `Initialize`: ``` price(s) = virtual_quote / virtual_base (constante para todo s) ``` Útil para lançamentos justos nos quais a equipe deseja precificação uniforme para todos os participantes independentemente de quando compram. A graduação é disparada quando `base_supply_graduation` foi vendido (a relação de custo linear torna `quote_reserve_target` simples de derivar). ## Curva de preço linear (`curve_type = 2`) O preço aumenta linearmente com `base_sold`: ``` price(s) = a · s (a = inclinação, derivada de virtual_base / virtual_quote) ``` Custo integrado: ``` cost(s_0, s_1) = a · (s_1² − s_0²) / 2 ``` Quadrático em `base_sold` — compradores iniciais pagam próximo de zero, compradores tardios pagam substancialmente mais, com o preço marginal sempre crescendo em uma inclinação fixa. A implementação on-chain vive em `curve/linear_price.rs`. ## Comparação de formas de curva ``` price │ linear (cauda íngreme) linear (curve_type = 2) │ ╱ │ ╱ │ ╱ const-product (curve_type = 0) │ ╱ ╱ │ ╱ ╱ │ ╱ ╱ │ ╱ ╱ │╱_____╱_______________________ fixed-price (curve_type = 1) └──────────────────────────────── base_sold 0 S_grad S_max ``` ## Limiar de graduação `quote_reserve_target` é calculado em `Initialize` como o quote necessário para levar `base_sold` de 0 a `base_supply_graduation`: ``` quote_reserve_target = cost(0, base_supply_graduation) × (1 + buy_fee_rate) ^^^^^^^^^^^^^^^^^ aproximado; forma exata corresponde ao arredondamento de taxa usado em Buy. ``` Um lançamento se forma assim que `quote_vault.balance ≥ quote_reserve_target`. Como as compras vêm em tamanhos discretos, o saldo real na graduação pode exceder ligeiramente o alvo — o excedente se torna liquidez adicional do lado quote no pool CPMM resultante. ## Exemplo prático — um lançamento quadrático Parâmetros: * `base_supply_max = 1_000_000_000` (1 bilhão de tokens base, 6 decimais) * `base_supply_graduation = 800_000_000` (80% vendidos dispara graduação) * `k = 40` (escala de preço) * Taxas: 1% buy, 1% sell, divididas `lp:creator:protocol = 60:20:20`. **Preço inicial** (`s = 0`): `0` (quadrático puro começa em zero). **Preço em 50% vendido** (`s = 500_000_000`): ``` price = 40 × (500e6 / 1e9)² = 40 × 0.25 = 10 (quote por base, 6 decimais) ``` **Preço na graduação** (`s = 800_000_000`): ``` price = 40 × (800e6 / 1e9)² = 40 × 0.64 = 25.6 ``` **Quote necessário para atingir graduação** (custo integrado): ``` cost(0, 800_000_000) = (40 / (3 × 1e18)) × ((800e6)³ − 0) = (40 / 3e18) × 5.12e26 ≈ 6.827e9 ``` Então ≈ 6.827 unidades nativas de quote (em qualquer mint de quote com 6 decimais configurado, p.ex. \~6.827 USDC se o quote for USDC). **Taxa aplicada por cima**: ``` quote_reserve_target ≈ 6.827e9 × 1.01 ≈ 6.895e9 (6.895 USDC) ``` **Primeira compra** de `10 USDC`: * Estado virtual: `s = 0`, `quote_vault = 0`. * Subtrair taxa: `quote_after_fee = 10 × 0.99 = 9.9`. * Resolver `(40 / (3e18)) × s³ = 9.9` ⇒ `s ≈ 6.22e6` tokens base comprados. * Taxa de 1% (`0.1 USDC`) dividida: lp `0.06`, creator `0.02`, protocol `0.02`. A participação lp fica em `quote_vault`; as outras duas são roteadas para seus respectivos contadores. **Compra em 75% vendido** (aproximando-se da graduação): Os mesmos 10 USDC compram muito menos base agora porque a curva é íngreme. Uma solução Newton em `s₀ = 750e6` com `quote_in_after_fee = 9.9` fornece aproximadamente `∆s ≈ 0.4e6` — uma redução de \~15× em base por USDC comparado à primeira compra. ## Mecânica de taxas durante a fase de curva A 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` é deixado em `quote_vault`. Isto é o que torna a curva efetiva mais apertada (mais reserva de quote contra o mesmo suprimento de base). * `protocol_share` incrementa `LaunchState.state_data.protocol_fees_quote`. * `creator_share` incrementa `LaunchState.state_data.creator_fees_quote`. Em `Sell` a mesma divisão se aplica mas a taxa é retirada do `quote_out` de saída. Ambos os contadores são limpos via `CollectFees` (admin ou creator, cada um ao seu contador). ## Precisão * Quantidades lado base: `u64`. * Quantidades lado quote: `u64`. * Cubos / produtos intermediários: `u128`. * Soluções Newton para "comprar quote exato" e "vender quote exato" iteram em `u128` ponto fixo com contagem máxima de iterações configurável (padrão 10). O modo de falha é `NotConverged` — raro fora de casos extremos perto da graduação. ## Transição para CPMM Quando `Graduate` dispara: ``` cpmm_quote_reserve = quote_vault − swept_protocol_fees − swept_creator_fees cpmm_base_reserve = base_vault // i.e. base_supply_max − base_sold cpmm_initial_price = cpmm_quote_reserve / cpmm_base_reserve ``` Para a curva quadrática, `cpmm_initial_price` é mecanicamente `price(base_sold)` (é o preço marginal da curva no momento da transição). O pool CPMM abre exatamente a esse preço, então um observador que muda da UI da curva para a UI do CPMM não vê um salto. ## Próximos passos * [`products/launchlab/accounts`](/pt/products/launchlab/accounts) — os campos `LaunchState` armazenando estes parâmetros. * [`products/launchlab/instructions`](/pt/products/launchlab/instructions) — listas de contas `Buy`, `Sell`, `Graduate`. * [`algorithms/constant-product`](/pt/algorithms/constant-product) — a matemática CPMM que o pool pós-graduação usa. Fontes: * [Raydium SDK v2 módulo `LaunchLab`](https://github.com/raydium-io/raydium-sdk-V2) * Fonte do programa Raydium LaunchLab