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

​

Deux frais indépendants, quatre destinations

1. Frais de trade — prélevés au taux AmmConfig.trade_fee_rate et répartis entre trois destinations :
   • Part LP — reste dans le vault et augmente k. Réclamée implicitement par la destruction de tokens LP.
   • Part protocole — accumulée dans PoolState.protocol_fees_token* ; collectée par protocol_owner via CollectProtocolFee.
   • Part fonds — accumulée dans PoolState.fund_fees_token* ; collectée par fund_owner via CollectFundFee.
2. Frais créateur (optionnel, par pool) — prélevés au taux AmmConfig.creator_fee_rate indépendamment des frais de trade, accumulés dans PoolState.creator_fees_token*, collectés par pool_state.pool_creator via CollectCreatorFee. Actifs uniquement si le pool a été créé avec enable_creator_fee = true.

​

Taux et unités

• trade_fee_rate est une fraction du volume échangé. 2500 ⇒ 0,25 % du côté pertinent (input ou output, selon creator_fee_on — voir « De quel côté du trade les frais sont prélevés » ci-dessous).
• creator_fee_rate est une fraction du volume échangé, prélevée séparément des frais de trade. 1000 ⇒ 0,10 % du côté pertinent.
• protocol_fee_rate et fund_fee_rate sont des fractions des frais de trade, non du volume. 120_000 ⇒ 12 % des frais de trade.

​

La répartition, en code

// Paraphrasé à partir de raydium-cp-swap/programs/cp-swap/src/curve/{calculator,fees}.rs.
// Le code réel se divise selon `is_creator_fee_on_input` ; les deux branches préservent
// l'invariant que creator_fee est son propre taux, jamais une portion de trade_fee.

const FEE_RATE_DENOMINATOR_VALUE: u64 = 1_000_000;

pub struct FeeBreakdown {
    pub amount_in_after_fees: u64,    // input moins tous les frais prélevés sur le côté input
    pub amount_out_after_fees: u64,   // output moins les frais créateur prélevés sur le côté output
    pub trade_fee:    u64,            // → réparti en buckets LP / protocole / fonds ci-dessous
    pub protocol_fee: u64,            // part de trade_fee
    pub fund_fee:     u64,            // part de trade_fee
    pub creator_fee:  u64,            // bucket indépendant (côté input ou output)
}

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 */) {
    // Les deux taux s'ajoutent pour qu'on arrondisse une seule fois sur les frais
    // combinés, puis on les répartit proportionnellement — c'est purement une
    // optimisation d'arrondi. La répartition respecte exactement les taux :
    // 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) {
    // Quand creator_fee_on achemine les frais créateur vers le côté output,
    // trade_fee est prélevé sur input en tant que taux unique, et creator_fee
    // est calculé en fonction de l'output de la courbe.
    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)
}

• Le frais total sur input arrondit vers le haut pour que le pool ne sous-facture jamais.
• Les sous-répartitions de trade_fee (protocole, fonds) arrondissent vers le bas pour que leur somme ne dépasse jamais trade_fee ; le reste est la part LP.
• lp_share = trade_fee − protocol_fee − fund_fee (creator_fee n’est pas soustrait ici car c’est son propre bucket).
• Les frais créateur sont prélevés de l’input ou de l’output selon PoolState.creator_fee_on (voir la section suivante). Le taux reste inchangé de chaque façon.

​

De quel côté du trade les frais sont prélevés

​

Comment les frais « accumulés » interagissent avec la courbe

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)

• Citer basé sur les soldes bruts est incorrect. Si vous construisez un quoteur sur getTokenAccountBalance, vous suréstimérez systématiquement le prix que le pool honorera. Soustrayez toujours les frais accumulés, ou simulez via SwapBaseInput / l’API.
• CollectProtocolFee ne modifie pas le prix. Il retire les tokens du vault et remet les compteurs protocol_fees_token* à zéro, donc curve_x et curve_y restent inchangés.
• Les frais LP ne s’accumulent pas dans un compteur. Ils sont implicites dans le solde du vault. Le droit des LP aux frais LP accumulés est exercé en brûlant les tokens LP (c’est-à-dire via Withdraw) — il n’y a pas de CollectLpFee.

​

Interaction avec les frais de transfert Token-2022

1. Les frais de transfert du mint d’input sur amount_in (à l’autorité de frais du mint).
2. Les frais trade_fee du pool sur le reste (répartis comme ci-dessus).
3. Les frais de transfert du mint d’output sur amount_out (à l’autorité de frais du mint).

​

Frais créateur

• Activé à la création du pool. Initialize définit enable_creator_fee = false par défaut ; les pools créés via InitializeWithPermission (utilisé par les graduations LaunchLab et autres chemins contrôlés) peuvent passer enable_creator_fee = true et choisir creator_fee_on.
• Le taux est partagé avec l’échelon de frais. Le taux lui-même est AmmConfig.creator_fee_rate, la même valeur sur tous les pools liés à cette config. Chaque pool décide ensuite s’il doit l’appliquer (enable_creator_fee) et de quel côté du swap l’appliquer (creator_fee_on). Quand enable_creator_fee = false, le taux créateur effectif du pool est zéro quel que soit la valeur de la config (voir PoolState::adjust_creator_fee_rate dans le code source).
• Indépendant des frais de trade. Les frais créateur ne réduisent jamais les parts LP / protocole / fonds — c’est son propre taux, appliqué séparément, accumulé dans ses propres compteurs.
• Collectés via CollectCreatorFee, signé par PoolState.pool_creator.
• Ne peuvent pas être réactivés ou redéployés après la création. Un pool initialisé avec enable_creator_fee = false ne facturera jamais de frais créateur ; un initialisé avec un creator_fee_on particulier ne peut pas changer de côté.

​

Flux opérationnel de collection

​

Modification d’un échelon de frais

• Déplacer un pool d’un AmmConfig à un autre.
• Rétablir le prix rétroactivement des frais déjà accumulés.
• Collecter les frais sans le signataire protocol_owner / fund_owner.

​

Lecture des frais d’un pool en cours d’exécution

// Off-chain : frais actuels accumulés dans chaque 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 : taux effectifs aujourd'hui.
// trade_fee_rate, creator_fee_rate sont des fractions du volume (dénominateur 1e6).
// protocol_fee_rate, fund_fee_rate sont des fractions des *frais de trade* (même dénominateur).
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)",
);

​

Comparaison avec CLMM et AMM v4

• AMM v4 utilise un frais de trade fixe de 0,25 % avec une répartition LP/protocole différente et pas de frais de fonds.
• CLMM les frais sont par échelon de tick-spacing, accumulés par position (non par pool), et réclamés via DecreaseLiquidity ou CollectFees.

​

Où aller ensuite

• products/cpmm/math — où la déduction des frais de trade s’insère dans la courbe.
• products/cpmm/instructions — les listes de comptes des instructions Collect*.
• algorithms/token-2022-transfer-fees — comment combiner correctement un frais de trade de pool avec un frais de transfert de mint.

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