Frais CPMM

​

Deux frais indépendants, quatre destinations

1. Frais de trading — prélevés à AmmConfig.trade_fee_rate et répartis entre trois destinations :
   • Part LP — reste dans le vault et augmente k. Réclamée implicitement en brûlant les tokens LP.
   • Part protocole — accumulée dans PoolState.protocol_fees_token* ; collectée par le protocol_owner via CollectProtocolFee.
   • Part fonds — accumulée dans PoolState.fund_fees_token* ; collectée par le fund_owner via CollectFundFee.
2. Frais créateur (optionnel, par pool) — prélevés à AmmConfig.creator_fee_rate indépendamment du frais de trading et accumulés dans PoolState.creator_fees_token*. Le créateur peut les collecter via CollectCreatorFee, ou n’importe quel payeur peut déclencher le chemin CollectCreatorFeePermissionless avec destinations contraintes. Actif uniquement si le pool a été créé avec enable_creator_fee = true.

​

Taux et unités

• trade_fee_rate est une fraction du volume de swap. 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 de swap, prélevée séparément du frais de trading. 1000 ⇒ 0,10 % du côté pertinent.
• protocol_fee_rate et fund_fee_rate sont des fractions du frais de trading, non du volume. 120_000 ⇒ 12 % du frais de trading.

​

La répartition, en code

// Paraphrasé de raydium-cp-swap/programs/cp-swap/src/curve/{calculator,fees}.rs.
// Le code réel se divise sur `is_creator_fee_on_input` ; les deux branches préservent
// l'invariant que creator_fee est son propre taux, jamais une part 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 du côté input
    pub amount_out_after_fees: u64,   // output moins tout frais créateur prélevé du côté output
    pub trade_fee:    u64,            // → répartis en buckets LP / protocole / fonds ci-dessous
    pub protocol_fee: u64,            // part du trade_fee
    pub fund_fee:     u64,            // part du 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 que nous arrondissions une fois sur le frais combiné,
    // puis nous divisons proportionnellement — c'est purement une astuce d'arrondi/efficacité.
    // La répartition honore les taux exactement : 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 route le frais créateur vers le côté output,
    // trade_fee est prélevé sur input comme un taux unique, et creator_fee
    // est calculé contre 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).
• Le frais créateur est prélevé sur input ou output selon PoolState.creator_fee_on (voir section suivante). Le taux reste inchangé de toute 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 hors des soldes bruts est faux. Si vous construisez un quoteur hors de getTokenAccountBalance, vous surévaluerez systématiquement le prix que le pool honorera. Soustrayez toujours les frais accumulés, ou simulez via SwapBaseInput / l’API.
• CollectProtocolFee ne déplace pas le prix. Il déplace les tokens hors du vault et met à zéro les compteurs protocol_fees_token*, 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.-à-d., via Withdraw) — il n’y a pas de CollectLpFee.

​

Interaction avec les frais de transfert Token-2022

1. Le frais de transfert du mint d’input sur amount_in (à l’autorité de frais du mint).
2. Le trade_fee du pool sur le reste (réparti comme ci-dessus).
3. Le 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és 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 le niveau de frais. Le taux lui-même est AmmConfig.creator_fee_rate, la même valeur sur chaque pool lié à cette config. Chaque pool décide alors s’il faut le facturer (enable_creator_fee) et de quel côté du swap le facturer (creator_fee_on). Quand enable_creator_fee = false, le taux de frais créateur effectif du pool est zéro indépendamment de la valeur de config (voir PoolState::adjust_creator_fee_rate dans la source).
• Indépendant du frais de trading. Le frais créateur ne réduit jamais les parts LP / protocole / fonds — c’est son propre taux, appliqué séparément, accumulé dans ses propres compteurs.
• Balayé via CollectCreatorFee ou CollectCreatorFeePermissionless. Le chemin original nécessite que PoolState.pool_creator signe. Le chemin sans permission permet à n’importe quel payeur de déclencher la collection mais fixe les deux destinations aux ATA canoniques du créateur.
• Ne peut pas être réactivé ou réacheminé après la création. Un pool initialisé avec enable_creator_fee = false ne facturera jamais un 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 niveau de frais

• Déplacer un pool d’un AmmConfig à un autre.
• Rétroactivement réévaluer les 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 actuellement 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 du *frais de trading* (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 trading fixe de 0,25 % avec une répartition LP/protocole différente et pas de frais de fonds.
• CLMM les frais sont par niveau d’espacement de tick, 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 du frais de trading se branche dans la courbe.
• products/cpmm/instructions — les listes de comptes d’instruction Collect*.
• algorithms/token-2022-transfer-fees — comment combiner correctement un frais de trading 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