Taxas CPMM

​

Duas taxas independentes, quatro destinos

1. Taxa de negociação — cobrada em AmmConfig.trade_fee_rate e dividida entre três destinos:
   • Participação de LP — permanece no vault e aumenta k. Reivindicada implicitamente ao queimar tokens LP.
   • Participação do protocolo — acumulada em PoolState.protocol_fees_token*; coletada pelo protocol_owner via CollectProtocolFee.
   • Participação do fundo — acumulada em PoolState.fund_fees_token*; coletada pelo fund_owner via CollectFundFee.
2. Taxa de criador (opcional, por pool) — cobrada em AmmConfig.creator_fee_rate independentemente da taxa de negociação e acumulada em PoolState.creator_fees_token*. O criador pode coletá-la através de CollectCreatorFee, ou qualquer pagador pode disparar o caminho restrito a destino CollectCreatorFeePermissionless. 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

// Parafraseado de raydium-cp-swap/programs/cp-swap/src/curve/{calculator,fees}.rs.
// O código real se ramifica em `is_creator_fee_on_input`; ambas as ramificações preservam o
// invariante de que creator_fee é sua própria taxa, nunca uma fatia de trade_fee.

const FEE_RATE_DENOMINATOR_VALUE: u64 = 1_000_000;

pub struct FeeBreakdown {
    pub amount_in_after_fees: u64,    // entrada menos todas as taxas cobradas no lado da entrada
    pub amount_out_after_fees: u64,   // saída menos qualquer taxa de criador cobrada no lado da saída
    pub trade_fee:    u64,            // → dividida em buckets de LP / protocolo / fundo abaixo
    pub protocol_fee: u64,            // participação de trade_fee
    pub fund_fee:     u64,            // participação de trade_fee
    pub creator_fee:  u64,            // bucket independente (lado da entrada ou saída)
}

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 */) {
    // As duas taxas são somadas para que arredondemos uma vez na taxa combinada, depois dividimos
    // proporcionalmente — isso é puramente um truque de arredondamento/eficiência. A divisão
    // honra as taxas exatamente: 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) {
    // Quando creator_fee_on roteia a taxa de criador para o lado da saída,
    // trade_fee é cobrada na entrada como uma taxa única, e creator_fee
    // é computada contra a saída da curva.
    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 subcobre.
• As subdivisões de trade_fee (protocolo, fundo) arredondam para baixo para que sua soma nunca exceda trade_fee; o restante é a participação de LP.
• lp_share = trade_fee − protocol_fee − fund_fee (creator_fee não é subtraída aqui porque é seu próprio bucket).
• A taxa de criador é cobrada da entrada ou saída dependendo de PoolState.creator_fee_on (veja próxima seção). A taxa permanece inalterada 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 fora de saldos brutos está errado. Se você construir um cotador fora de getTokenAccountBalance, você consistentemente superestimará 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 vault e zera os contadores protocol_fees_token*, então 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 vault. 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 restante (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 de criador

• Habilitada 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 controlados) podem passar enable_creator_fee = true e escolher creator_fee_on.
• Taxa compartilhada com o nível de taxa. A taxa em si é AmmConfig.creator_fee_rate, o mesmo valor em todos os pools vinculados a essa configuração. Cada pool então decide se cobrar (enable_creator_fee) e qual lado do swap cobrar (creator_fee_on). Quando enable_creator_fee = false, a taxa de criador efetiva do pool é zero independentemente do valor da configuração (veja PoolState::adjust_creator_fee_rate na fonte).
• Independente da taxa de negociação. A taxa de criador nunca reduz as participações de LP / protocolo / fundo — é sua própria taxa, aplicada separadamente, acumulada em seus próprios contadores.
• Varrida via CollectCreatorFee ou CollectCreatorFeePermissionless. O caminho original requer que PoolState.pool_creator assine. O caminho sem permissão permite que qualquer pagador dispare a coleta, mas fixa ambos os destinos aos ATAs canônicos do criador.
• Não pode ser reabilitada ou redirecionada após a criação. Um pool inicializado com enable_creator_fee = false nunca cobrará uma taxa de criador; um inicializado com um creator_fee_on particular não pode mudar de lado.

​

Fluxo operacional de coleta

​

Alterando um nível de taxa

• Mover um pool de um AmmConfig para outro.
• Reprojetar 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: taxas acumuladas atuais em cada 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: taxas efetivas hoje.
// trade_fee_rate, creator_fee_rate são frações do volume (denominador 1e6).
// protocol_fee_rate, fund_fee_rate são frações da *taxa de negociação* (mesmo denominador).
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 nível de espaçamento de tick, acumuladas por posição (não por pool), e reivindicadas via DecreaseLiquidity ou CollectFees.

​

Próximos passos

• products/cpmm/math — onde a dedução de taxa de negociação se conecta à curva.
• products/cpmm/instructions — as listas de contas de 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