Saltar para o conteúdo 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 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

CampoSignificado
curve_type0 = constant-product (reservas virtuais), 1 = fixed-price, 2 = linear-price.
base_supply_maxTotal de tokens base que a curva pode cunhar.
base_supply_graduationTokens 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_targetQuantidade de quote que dispara a graduação. Derivada em Initialize a partir dos parâmetros da curva + base_supply_graduation.
virtual_base / virtual_quoteSementes de reserva virtual para a curva constant-product.
migrate_typeSeleciona o alvo de graduação: AMM v4 vs CPMM. Veja instructions.
fees.buy_numerator / buy_denominatorTaxa buy, p.ex. 100 / 10_000 = 1.00%.
fees.sell_numerator / sell_denominatorTaxa sell. Frequentemente igual à buy.
fees.protocol_share, fees.creator_share, fees.lp_shareDivisã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

Fontes: