Taxas do CPMM

​

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 — permanece no vault e aumenta k. Reivindicada implicitamente ao queimar tokens de 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 e acumulada em PoolState.creator_fees_token*. O criador pode coletá-la via CollectCreatorFee, ou qualquer pagador pode ativar o caminho restrito a destino CollectCreatorFeePermissionless. Ativa apenas quando o pool foi criado com enable_creator_fee = true. Desde a atualização de 2026-09-13, a taxa do criador acumulada é dividida novamente no momento da coleta: uma parcela configurável é movida para o bucket de protocolo do pool e apenas o restante chega ao criador — veja Parcela do protocolo da taxa do criador.

​

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.
• creator_fee_share_rate é uma fração da taxa do criador acumulada, não do volume e não da taxa de negociação. 200_000 ⇒ 20% do que estiver em creator_fees_token* no momento em que é coletado. 0 (o padrão) deixa toda a taxa do criador com o criador.

​

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 do criador cobrada no lado da saída
    pub trade_fee:    u64,            // → dividida em buckets de LP / protocolo / fundo abaixo
    pub protocol_fee: u64,            // parcela de trade_fee
    pub fund_fee:     u64,            // parcela de trade_fee
    pub creator_fee:  u64,            // bucket independente (lado de 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 do 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 parcela de LP.
• lp_share = trade_fee − protocol_fee − fund_fee (creator_fee não é subtraído aqui porque é seu próprio bucket).
• A taxa do 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)

• Citar 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 queimando tokens de 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 do 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 fechados) 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 cada pool vinculado a essa configuração. Cada pool então decide se a cobra (enable_creator_fee) e qual lado do swap a cobra (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 do criador nunca reduz as parcelas 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 ative a coleta, mas fixa ambos os destinos aos ATAs canônicos do criador. Ambos os caminhos liquidam a parcela do protocolo primeiro — veja a próxima seção.
• 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.

​

Parcela do protocolo da taxa do criador

​

De onde vem a taxa

1. PDA CreatorFeeShare — seeds ["creator_fee_share", creator, amm_config]. Quando essa conta existe e é de propriedade do CPMM, sua share_rate vence. Permite que o protocolo negocie uma taxa por criador em um determinado nível de taxa sem tocar no nível em si.
2. AmmConfig.creator_fee_share_rate — o padrão para cada criador nesse nível de taxa. Usado sempre que o PDA não existe.

​

O que a divisão faz

// programs/cp-swap/src/states/creator_fee_share.rs
shared_amount  = floor(creator_fee * share_rate / 1_000_000);   // para o protocolo
creator_amount = creator_fee - shared_amount;                   // para o criador

• creator_amount_{0,1} é transferido para fora dos vaults para as contas de token do criador.
• shared_amount_{0,1} é adicionado a protocol_fees_token_{0,1} e permanece no vault até que o proprietário do protocolo o varra com CollectProtocolFee. Não há instrução separada e nenhum contador separado para isso.
• creator_fees_token_{0,1} são zerados, exatamente como antes.

• Arredondamento favorece o criador. A parcela do protocolo arredonda para baixo, então poeira fica com o criador — a mesma direção que protocol_fee e fund_fee, que também extraem uma parcela de uma taxa já acumulada.
• Valor é conservado. creator_amount + shared_amount == creator_fee para cada taxa e cada taxa, incluindo u64::MAX.
• share_rate = 0 é uma operação nula. Tanto o valor de configuração padrão quanto a ausência de um PDA CreatorFeeShare deixam toda a taxa do criador com o criador, que é o comportamento pré-atualização.

​

O que significa para integradores

• LPs e cotação não são afetados. O valor compartilhado se move entre dois contadores que ambos já são excluídos da visão da curva do vault (vault_amount_without_fee), então curve_x e curve_y não se movem em uma coleta. k não é tocado.
• Um estimador de taxa do criador que lê creator_fees_token* agora superestima o pagamento. Multiplique por (1 − share_rate / 1_000_000) usando a taxa que realmente se aplica a esse par (creator, amm_config), não o padrão de configuração.
• protocol_fees_token* cresce fora de swaps. Um monitor que reconcilia acúmulo de protocolo contra volume de swap verá saltos em cada coleta de taxa do criador. O acúmulo de protocolo não é mais apenas trade_fee × protocol_fee_rate.
• A taxa pode mudar entre acúmulo e coleta. É lida no momento da coleta, então taxas que se acumularam sob uma taxa liquidam com qualquer taxa que estiver em vigor quando alguém chamar Collect*.

​

Fluxo operacional de coleta

​

Alterando um nível de taxa

• Mover um pool de um AmmConfig para outro.
• Reprojetar retroativamente 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.
// O SDK exporta o layout, não uma classe `PoolState`, e os campos de taxa são
// nomeados ...MintA / ...MintB — não há campos ...Token0 / ...Token1.
import { CpmmPoolInfoLayout } from "@raydium-io/raydium-sdk-v2";

const pool = await connection.getAccountInfo(poolStatePda);
const decoded = CpmmPoolInfoLayout.decode(pool!.data);   // sem .slice(8) — o
                                                          // layout inclui o discriminador
console.log(
  "Protocol accrued:",
  decoded.protocolFeesMintA.toString(),
  decoded.protocolFeesMintB.toString(),
);
console.log(
  "Fund accrued:",
  decoded.fundFeesMintA.toString(),
  decoded.fundFeesMintB.toString(),
);
console.log(
  "Creator accrued:",
  decoded.creatorFeesMintA.toString(),
  decoded.creatorFeesMintB.toString(),
);
// O que o criador realmente recebe é isso menos a parcela do protocolo, resolvido no
// momento da coleta a partir do PDA CreatorFeeShare (creator, ammConfig) se existir e
// de AmmConfig.creator_fee_share_rate caso contrário. Veja "Parcela do protocolo da taxa do criador"
// acima.

// Off-chain: taxas efetivas hoje.
// trade_fee_rate, creator_fee_rate são frações de 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());
// `configId` no pool decodificado é a PublicKey da conta de configuração, não um índice.
const tier = config.data.find((t) => t.id === decoded.configId.toBase58());

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

​

Para onde ir a seguir

• 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*, incluindo a conta creator_fee_share que ambos os caminhos do criador agora exigem.
• 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