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 →

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.
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; 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 — os campos LaunchState armazenando estes parâmetros.
• products/launchlab/instructions — listas de contas Buy, Sell, Graduate.
• algorithms/constant-product — a matemática CPMM que o pool pós-graduação usa.

Fontes:

• Raydium SDK v2 módulo LaunchLab
• Fonte do programa Raydium LaunchLab