Taxas do CPMM

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.

​

Duas taxas independentes, quatro destinos

1. Taxa de negociação — cobrada em AmmConfig.trade_fee_rate e dividida entre três destinos:
   • Parcela de LP — fica no cofre e aumenta k. Reivindicada implicitamente ao queimar tokens LP.
   • Parcela do protocolo — acumulada em PoolState.protocol_fees_token*; coletada pelo protocol_owner via CollectProtocolFee.
   • Parcela do fundo — acumulada em PoolState.fund_fees_token*; coletada pelo fund_owner via CollectFundFee.
2. Taxa do criador (opcional, por pool) — cobrada em AmmConfig.creator_fee_rate independentemente da taxa de negociação, acumulada em PoolState.creator_fees_token*, coletada por pool_state.pool_creator via CollectCreatorFee. Ativa apenas quando o pool foi criado com enable_creator_fee = true.

​

Taxas e unidades

• trade_fee_rate é uma fração do volume de swap. 2500 ⇒ 0,25% do lado relevante (entrada ou saída, dependendo de creator_fee_on — veja “Qual lado da negociação as taxas são cobradas” abaixo).
• creator_fee_rate é uma fração do volume de swap, cobrada separadamente da taxa de negociação. 1000 ⇒ 0,10% do lado relevante.
• protocol_fee_rate e fund_fee_rate são frações da taxa de negociação, não do volume. 120_000 ⇒ 12% da taxa de negociação.

​

A divisão, em código

// Paraphrased from raydium-cp-swap/programs/cp-swap/src/curve/{calculator,fees}.rs.
// The actual code branches on `is_creator_fee_on_input`; both branches preserve the
// invariant that creator_fee is its own rate, never a slice of trade_fee.

const FEE_RATE_DENOMINATOR_VALUE: u64 = 1_000_000;

pub struct FeeBreakdown {
    pub amount_in_after_fees: u64,    // input minus all fees taken on the input side
    pub amount_out_after_fees: u64,   // output minus any creator fee taken on the output side
    pub trade_fee:    u64,            // → split into LP / protocol / fund buckets below
    pub protocol_fee: u64,            // share of trade_fee
    pub fund_fee:     u64,            // share of trade_fee
    pub creator_fee:  u64,            // independent bucket (input or output side)
}

fn take_fees_on_input(
    amount_in: u64,
    trade_rate: u64,
    creator_rate: u64,
    protocol_rate: u64,
    fund_rate: u64,
) -> (u64 /* trade_fee */, u64 /* creator_fee */, u64 /* amount_in_after_fees */) {
    // The two rates are added so we round once on the combined fee, then split
    // proportionally — this is purely a rounding/efficiency trick. The split
    // honours the rates exactly: creator_fee/trade_fee == creator_rate/trade_rate.
    let total_fee = ((amount_in as u128) * ((trade_rate + creator_rate) as u128))
        .div_ceil(FEE_RATE_DENOMINATOR_VALUE as u128) as u64;

    let creator_fee = ((total_fee as u128) * (creator_rate as u128)
                       / ((trade_rate + creator_rate) as u128)) as u64;
    let trade_fee   = total_fee - creator_fee;

    (trade_fee, creator_fee, amount_in - total_fee)
}

fn take_creator_fee_on_output(amount_out_swapped: u64, creator_rate: u64) -> (u64, u64) {
    // When creator_fee_on routes the creator fee to the output side,
    // trade_fee is taken on input as a single rate, and creator_fee
    // is computed against the curve output.
    let creator_fee = ((amount_out_swapped as u128) * (creator_rate as u128))
        .div_ceil(FEE_RATE_DENOMINATOR_VALUE as u128) as u64;
    (amount_out_swapped - creator_fee, creator_fee)
}

fn split_trade_fee(
    trade_fee: u64,
    protocol_rate: u64,
    fund_rate: u64,
) -> (u64 /* protocol_fee */, u64 /* fund_fee */) {
    let protocol_fee = (trade_fee as u128 * protocol_rate as u128
                        / FEE_RATE_DENOMINATOR_VALUE as u128) as u64;
    let fund_fee     = (trade_fee as u128 * fund_rate as u128
                        / FEE_RATE_DENOMINATOR_VALUE as u128) as u64;
    (protocol_fee, fund_fee)
}

• A taxa total na entrada arredonda para cima para que o pool nunca subcodifique.
• As subdivisões de trade_fee (protocolo, fundo) arredondam para baixo para que sua soma nunca exceda trade_fee; o resto é a parcela de LP.
• lp_share = trade_fee − protocol_fee − fund_fee (creator_fee não é subtraído aqui porque é seu próprio balde).
• A taxa do criador é cobrada da entrada ou saída dependendo de PoolState.creator_fee_on (veja próxima seção). A taxa permanece a mesma de qualquer forma.

​

Qual lado da negociação as taxas são cobradas

​

Como as taxas “acumuladas” interagem com a curva

raw_vault_0_balance = getTokenAccountBalance(vault_0).amount
                    = lp_entitled + protocol_fees_token0
                      + fund_fees_token0 + creator_fees_token0

curve_x = raw_vault_0_balance − (protocol_fees_token0
                                  + fund_fees_token0
                                  + creator_fees_token0)

• Cotar com saldos brutos está errado. Se você construir um quoter em getTokenAccountBalance, você irá superestimar consistentemente o preço que o pool honrará. Sempre subtraia taxas acumuladas, ou simule via SwapBaseInput / a API.
• CollectProtocolFee não move o preço. Ele move tokens para fora do cofre e zera os contadores protocol_fees_token*, portanto curve_x e curve_y permanecem inalterados.
• As taxas de LP não se acumulam em um contador. Elas são implícitas no saldo do cofre. O direito de LP às taxas de LP acumuladas é exercido ao queimar tokens LP (ou seja, via Withdraw) — não há CollectLpFee.

​

Interação com taxas de transferência Token-2022

1. A taxa de transferência da mint de entrada em amount_in (para a autoridade de taxa da mint).
2. A trade_fee do pool no resto (dividida conforme acima).
3. A taxa de transferência da mint de saída em amount_out (para a autoridade de taxa da mint).

​

Taxa do criador

• Ativada na criação do pool. Initialize define enable_creator_fee = false por padrão; pools criados via InitializeWithPermission (usado por graduações de LaunchLab e outros caminhos monitorados) podem passar enable_creator_fee = true e escolher creator_fee_on.
• A taxa é compartilhada com a camada de taxa. A taxa em si é AmmConfig.creator_fee_rate, o mesmo valor em cada pool vinculado a essa config. Cada pool então decide se cobrar (enable_creator_fee) e qual lado da troca cobrar (creator_fee_on). Quando enable_creator_fee = false, a taxa efetiva do criador do pool é zero, independentemente do valor da config (veja PoolState::adjust_creator_fee_rate na fonte).
• Independente da taxa de negociação. A taxa do criador nunca reduz as parcelas LP / protocolo / fundo — é sua própria taxa, aplicada separadamente, acumulada em seus próprios contadores.
• Varrida via CollectCreatorFee, assinada por PoolState.pool_creator.
• Não pode ser reativada ou redirecionada após criação. Um pool inicializado com enable_creator_fee = false nunca cobará uma taxa de criador; um inicializado com um particular creator_fee_on não pode mudar de lado.

​

Fluxo operacional de coleta

​

Alterando uma camada de taxa

• Mover um pool de um AmmConfig para outro.
• Precificar retroativamente as taxas já acumuladas.
• Coletar taxas sem o signatário protocol_owner / fund_owner.

​

Lendo taxas de um pool em execução

// Off-chain: current accrued fees in each bucket
const pool = await connection.getAccountInfo(poolStatePda);
const decoded = PoolState.decode(pool.data);
console.log(
  "Protocol accrued:",
  decoded.protocolFeesToken0.toString(),
  decoded.protocolFeesToken1.toString(),
);
console.log(
  "Fund accrued:",
  decoded.fundFeesToken0.toString(),
  decoded.fundFeesToken1.toString(),
);
console.log(
  "Creator accrued:",
  decoded.creatorFeesToken0.toString(),
  decoded.creatorFeesToken1.toString(),
);

// Off-chain: effective rates today.
// trade_fee_rate, creator_fee_rate are fractions of volume (denominator 1e6).
// protocol_fee_rate, fund_fee_rate are fractions of the *trade fee* (same denominator).
const config = await fetch("https://api-v3.raydium.io/main/cpmm-config")
  .then((r) => r.json());
const tier = config.data.find((t) => t.index === decoded.ammConfigIndex);

const tradeFeeOfVolume   = tier.tradeFeeRate / 1_000_000;
const protocolOfTradeFee = tier.protocolFeeRate / 1_000_000;
const fundOfTradeFee     = tier.fundFeeRate / 1_000_000;
const lpOfTradeFee       = 1 - protocolOfTradeFee - fundOfTradeFee;

console.log("LP fee effective:",       (tradeFeeOfVolume * lpOfTradeFee * 100).toFixed(4), "%");
console.log("Protocol fee effective:", (tradeFeeOfVolume * protocolOfTradeFee * 100).toFixed(4), "%");
console.log("Fund fee effective:",     (tradeFeeOfVolume * fundOfTradeFee * 100).toFixed(4), "%");
console.log(
  "Creator fee effective:",
  decoded.enableCreatorFee
    ? ((tier.creatorFeeRate / 1_000_000) * 100).toFixed(4) + " %"
    : "0 % (disabled on this pool)",
);

​

Comparação com CLMM e AMM v4

• AMM v4 usa uma taxa de negociação fixa de 0,25% com uma divisão LP/protocolo diferente e sem taxa de fundo.
• CLMM as taxas são por camada de espaçamento de tick, acumuladas por posição (não por pool), e reivindicadas via DecreaseLiquidity ou CollectFees.

​

Para onde ir em seguida

• products/cpmm/math — onde a dedução da taxa de negociação se conecta à curva.
• products/cpmm/instructions — as listas de contas da instrução Collect*.
• algorithms/token-2022-transfer-fees — como combinar corretamente uma taxa de negociação de pool com uma taxa de transferência de mint.

• raydium-io/raydium-cp-swap — states/config.rs, states/pool.rs, states/curve.rs
• Raydium API — GET /main/cpmm-config