Curva de ligação do LaunchLab

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 do 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 no 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`	Deve ser `CPSWAP` para nova inicialização. Um valor AMM v4 armazenado é apenas estado legado. Veja `instructions`.
`fees.buy_numerator / buy_denominator`	Taxa do lado da compra, ex. `100 / 10_000 = 1.00%`.
`fees.sell_numerator / sell_denominator`	Taxa do lado da venda. Geralmente igual à compra.
`fees.protocol_share`, `fees.creator_share`, `fees.lp_share`	Divisão da taxa 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 simula que existe uma reserva de quote virtual V_q e uma reserva de base virtual 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 em base vendida 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 a curva CPMM pós-graduação, então a transição é mecanicamente perfeita: o preço marginal em base_sold = base_supply_graduation é igual ao preço em que o pool pós-graduação abre com (quote_vault, base_vault_remaining) como suas reservas.

Curva fixed-price (`curve_type = 1`)

Uma curva de preço fixo. 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 onde o time quer preços uniformes 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 linear-price (`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 a zero, compradores tardios pagam substancialmente mais, com o preço marginal sempre subindo em uma inclinação fixa. A implementação on-chain fica 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 chegam em tamanhos discretos, o saldo real na graduação pode exceder ligeiramente o alvo — o excedente se torna liquidez extra do lado do quote no pool CPMM resultante.

Exemplo trabalhado — 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% vendido dispara graduação)
k = 40 (escala de preço)
Taxas: 1% compra, 1% venda, divisão 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, ex. ~6.827 USDC se o quote for USDC). Taxa aplicada no topo:

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 parte lp fica em quote_vault; as outras duas vão para seus contadores de acúmulo respectivos.

Compra em 75% vendido (aproximando-se da graduação): Os mesmos 10 USDC compram muito menos base agora porque a curva é íngreme. Uma resolução Newton em s₀ = 750e6 com quote_in_after_fee = 9.9 dá 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

Em 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 fica 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 é tirada do quote_out de saída. Ambos os contadores são varridos via CollectFees (admin ou creator, cada um para seu próprio contador).

Precisão

Quantidades do lado base: u64.
Quantidades do lado quote: u64.
Cubos / produtos intermediários: u128.
Resoluções Newton para “comprar quote exato” e “vender quote exato” iteram em u128 ponto fixo com uma contagem máxima de iterações configurável (padrão 10). O modo de falha é NotConverged — raro fora de casos extremos próximos à 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                       // ex. 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 nesse preço, então um observador mudando da UI da curva para a UI do CPMM não vê nenhum salto.

Próximos passos

products/launchlab/accounts — os campos LaunchState armazenando esses 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 LaunchLab module
Raydium LaunchLab program source

LaunchLab

Token launch flow

Tips & Gotchas

Curva de ligação do LaunchLab

Parâmetros armazenados em `LaunchState`

Curva constant-product com reservas virtuais (`curve_type = 0`)

Curva fixed-price (`curve_type = 1`)

Curva linear-price (`curve_type = 2`)

Comparação de formas de curva

Limiar de graduação

Exemplo trabalhado — um lançamento quadrático

Mecânica de taxas durante a fase de curva

Precisão

Transição para CPMM

Próximos passos

​Parâmetros armazenados em LaunchState

​Curva constant-product com reservas virtuais (curve_type = 0)

​Curva fixed-price (curve_type = 1)

​Curva linear-price (curve_type = 2)

​Comparação de formas de curva

​Limiar de graduação

​Exemplo trabalhado — um lançamento quadrático

​Mecânica de taxas durante a fase de curva

​Precisão

​Transição para CPMM

​Próximos passos

Parâmetros armazenados em `LaunchState`

Curva constant-product com reservas virtuais (`curve_type = 0`)

Curva fixed-price (`curve_type = 1`)

Curva linear-price (`curve_type = 2`)

Comparação de formas de curva

Limiar de graduação

Exemplo trabalhado — um lançamento quadrático

Mecânica de taxas durante a fase de curva

Precisão

Transição para CPMM

Próximos passos