> ## 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.

# Curvas de bonificação

> A matemática por trás de curvas de emissão de tokens — variantes CPMM quadráticas, lineares e com reservas virtuais — derivações para custo / receita / preço spot, e a matemática do limite de graduação usada pelo LaunchLab.

<Info>
  **Esta página foi traduzida automaticamente por IA. A versão em inglês é a fonte oficial.**

  [Ver versão em inglês →](/algorithms/bonding-curves)
</Info>

## O que é uma curva de bonificação

Uma **curva de bonificação** é uma função de preço determinística `p(s)` que relaciona o preço de um token à quantidade atualmente em circulação (`s` de "supply sold"). Compradores adquirem enviando colateral para o contrato; o contrato emite novas unidades de token ao preço marginal ditado pela curva. Vendedores devolvem unidades de token e recebem o reembolso integrado.

Duas propriedades-chave em comparação com um pool CPMM:

* **Sem contraparte necessária.** O contrato emissor é o criador de mercado; liquidez existe por direito.
* **Preço monotônico.** O preço sobe a cada compra líquida e cai a cada venda líquida.

Curvas de bonificação são o mecanismo de lançamento padrão quando a entidade emissora não quer pré-semear um pool AMM com colateral.

## Fórmulas de preço genéricas

Para qualquer função de preço contínua `p(s)`:

**Preço spot** na oferta `s`:

```
p(s) = the curve formula
```

**Custo para comprar** oferta de `s_0` para `s_1` (com `s_1 > s_0`):

```
cost(s_0, s_1) = ∫_{s_0}^{s_1} p(s) ds = P(s_1) − P(s_0)
```

onde `P(s) = ∫ p(s) ds` é a antiderivada da curva. Geometricamente, `cost` é a área sob `p` entre `s_0` e `s_1`.

**Receita de venda** da oferta de volta de `s_1` para `s_0`:

```
proceeds(s_1, s_0) = cost(s_0, s_1)
```

(Simetria: comprar e vender no mesmo intervalo troca o mesmo colateral — módulo taxas.)

**Preço médio** para a compra:

```
avg = cost(s_0, s_1) / (s_1 − s_0)
```

## Famílias de curvas comuns

### Linear

```
p(s) = a + b · s
```

```
P(s)            = a·s + (b/2)·s²
cost(s_0, s_1)  = a·(s_1 − s_0) + (b/2)·(s_1² − s_0²)
```

O preço sobe proporcionalmente com a oferta. Usado para lançamentos "estáveis" onde o emissor quer um markup previsível e moderado ao longo do tempo de vida.

### Quadrática

```
p(s) = k · s²                      // ou  k · (s / S_max)² para uma forma normalizada
```

```
P(s)            = (k / 3) · s³
cost(s_0, s_1)  = (k / 3) · (s_1³ − s_0³)
```

O preço sobe quadraticamente. Compradores iniciais recebem um preço próximo a zero (região inicial plana); compradores tardios pagam um prêmio mais acentuado. Este é o tipo de curva que LaunchLab usa por padrão (`curve_type = 0`).

### CPMM com reservas virtuais (estilo Pump)

A curva é um CPMM padrão com uma pretensa reserva de cotação inicial `V_q`:

```
effective_y = V_q + collateral_received
effective_x = S_max − s
(effective_x) · (effective_y) = V_q · S_max      // invariant
```

Preço spot:

```
p(s) = effective_y / effective_x
     = V_q · S_max / (S_max − s)² · ... (derivável via diferenciação implícita)
```

Custo para se mover de `s_0` para `s_1`:

```
cost(s_0, s_1) = V_q · S_max / (S_max − s_1) − V_q · S_max / (S_max − s_0)
              = V_q · (s_1 − s_0) · S_max / ((S_max − s_0) · (S_max − s_1))
```

Esta variante tem a propriedade elegante de que na graduação (onde `s = S_graduate`), o preço marginal é igual ao preço de abertura do pool CPMM a jusante semeado com reservas `(S_max − S_graduate, V_q + cost(0, S_graduate))`. A transição é perfeita. LaunchLab expõe isto como `curve_type = 1`.

## Implementação discreta

On-chain, `s` e `cost` são ambos inteiros (unidades da menor denominação). O integral contínuo `cost(s_0, s_1)` é calculado diretamente a partir da forma fechada sempre que existe (linear, quadrática). Para curvas sem inversa de forma fechada (quadrática, dado `cost`, encontre `s_1`), iteração de Newton é usada:

```
# Resolver quadrática: (k/3)·s_1³ = (k/3)·s_0³ + cost
# Inicializar com s_guess ≈ cbrt(3·cost/k + s_0³)
for i in 0..MAX_ITER:
    f    = (k/3)·s_guess³ − (k/3)·s_0³ − cost
    f'   = k·s_guess²
    step = f / f'
    s_guess -= step
    if |step| < precision_floor: break
```

LaunchLab limita iterações a \~10 e reverte com `NotConverged` se o resíduo ainda estiver acima da tolerância. Na prática, isto só dispara perto das extremidades do domínio; swaps de produção convergem em 2–3 iterações.

## Integração de taxas

As taxas são aplicadas no topo do custo da curva, não dentro dela. Na compra:

```
cost_curve  = cost(base_sold, base_sold + base_out)
fee         = ceil(cost_curve · buy_numerator / buy_denominator)
quote_in    = cost_curve + fee
```

Na venda:

```
proceeds_curve = cost(base_sold − base_in, base_sold)
fee            = ceil(proceeds_curve · sell_numerator / sell_denominator)
quote_out      = proceeds_curve − fee
```

A porção LP da taxa é retida em `quote_vault` e efetivamente torna a curva mais rígida para compradores posteriores — a reserva cresce sem emitir mais oferta. As porções do protocolo e do criador são rastreadas em contadores separados para varredura posterior.

## Limite de graduação

Uma curva "gradua" quando recebeu colateral suficiente para semear um pool AMM externo a um preço que corresponde ao preço atual da curva. Para uma curva quadrática com parâmetros `(k, S_max, S_graduate)`:

```
quote_to_graduate = cost(0, S_graduate) · (1 + buy_fee_rate)
                  = (k / 3) · S_graduate³ · (1 + f_buy)
```

Uma vez que `quote_vault ≥ quote_to_graduate`, a instrução `Graduate` cria um pool CPMM com:

```
cpmm_base_reserve  = S_max − S_graduate        // unsold curve supply
cpmm_quote_reserve = quote_vault − accrued_fee_counters
cpmm_initial_price = cpmm_quote_reserve / cpmm_base_reserve
```

Para a curva de reservas virtuais, por construção:

```
cpmm_initial_price == p(S_graduate)           // igualdade exata
```

Para a quadrática, a igualdade é aproximada; o "erro" é absorvido no arredondamento de `S_graduate` (tipicamente `0.8 · S_max`) e no colateral excedente da compra final que ultrapassa o limite.

## Impermanência versus um pool CPMM

Um lançamento de curva de bonificação pura tem **nenhuma impermanência** no sentido Uniswap: não há "outro lado" do mercado para rebalancear. A curva emite oferta sob demanda, e o único "LP" é o próprio contrato.

Após graduação, o pool CPMM resultante se comporta como qualquer outro pool CPMM — se o LP não foi queimado, está sujeito à dinâmica usual de perda impermanente. É por isso que a política de **queimar** pós-graduação é dominante em lançamentos públicos: mantém o pool permanente e remove qualquer choque de preço causado por retirada de LP.

## Exemplo trabalhado

Curva: quadrática, `k = 40`, `S_max = 1e9`, `S_graduate = 0.8 · S_max = 8e8`. Taxa de compra 1%.

### Preço em `s = 5e8`

```
p(5e8) = 40 · (5e8 / 1e9)² = 40 · 0.25 = 10
```

10 unidades de cotação por unidade de base.

### Custo da primeira compra de 1e6 base

```
cost(0, 1e6) = (40/3) · (1e6)³
             = (40/3) · 1e18
             ≈ 1.333e19     (unidades menores de cotação)
```

Com taxa de 1%:

```
quote_in = 1.333e19 · 1.01 ≈ 1.347e19
```

### Limite de graduação

```
cost(0, 8e8) = (40/3) · (8e8)³
             = (40/3) · 5.12e26
             ≈ 6.827e27
quote_to_graduate ≈ 6.827e27 · 1.01 ≈ 6.895e27
```

### Preço na graduação

```
p(8e8) = 40 · 0.64 = 25.6
```

### Reservas CPMM pós-graduação

```
cpmm_base  = 1e9 − 8e8 = 2e8
cpmm_quote ≈ 6.827e27  (menos deduções de contador de taxas)
cpmm_price ≈ 3.41e19 por base — o que corresponde a p(8e8) após contabilizar unidades
```

(Unidades: decimais precisam ser rastreados cuidadosamente; o exemplo é ilustrativo.)

## Referências

* [`/pt/products/launchlab/bonding-curve`](/pt/products/launchlab/bonding-curve) — a implementação LaunchLab on-chain destas fórmulas.
* [`/pt/products/launchlab/instructions`](/pt/products/launchlab/instructions) — especificações de nível de conta para `Buy`, `Sell`, `Graduate`.
* [`/pt/algorithms/constant-product`](/pt/algorithms/constant-product) — o que o CPMM pós-graduação faz com as reservas.

Fontes:

* Código-fonte do programa Raydium LaunchLab (implementações de curva quadrática + reservas virtuais).
* Banco Branco (curvas de bonificação lineares, históricas).
* Posts post-mortem públicos do Pump.fun (variante de reservas virtuais).