CPMM fees

​

Two independent fees, four destinations

1. Trade fee — charged at AmmConfig.trade_fee_rate and split between three destinations:
   • LP share — stays in the vault and grows k. Claimed implicitly by burning LP tokens.
   • Protocol share — accrued to PoolState.protocol_fees_token*; swept by the protocol_owner via CollectProtocolFee.
   • Fund share — accrued to PoolState.fund_fees_token*; swept by the fund_owner via CollectFundFee.
2. Creator fee (optional, per-pool) — charged at AmmConfig.creator_fee_rate independently of the trade fee and accrued to PoolState.creator_fees_token*. The creator can sweep it through CollectCreatorFee, or any payer can trigger the destination-constrained CollectCreatorFeePermissionless path. Active only when the pool was created with enable_creator_fee = true. Since the 2026-09-19 upgrade the accrued creator fee is split once more at collection time: a configurable share is moved into the pool’s protocol bucket and only the remainder reaches the creator — see Protocol share of the creator fee.

​

Rates and units

• trade_fee_rate is a fraction of swap volume. 2500 ⇒ 0.25% of the relevant side (input or output, depending on creator_fee_on — see “Which side of the trade the fees are taken from” below).
• creator_fee_rate is a fraction of swap volume, taken separately from the trade fee. 1000 ⇒ 0.10% of the relevant side.
• protocol_fee_rate and fund_fee_rate are fractions of the trade fee, not of volume. 120_000 ⇒ 12% of the trade fee.
• creator_fee_share_rate is a fraction of the accrued creator fee, not of volume and not of the trade fee. 200_000 ⇒ 20% of whatever sits in creator_fees_token* at the moment it is collected. 0 (the default) leaves the whole creator fee with the creator.

​

The split, in code

// 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)
}

• The total fee on input rounds up so the pool never undercharges.
• The sub-splits of trade_fee (protocol, fund) round down so their sum never exceeds trade_fee; the remainder is the LP share.
• lp_share = trade_fee − protocol_fee − fund_fee (creator_fee is not subtracted here because it is its own bucket).
• The creator fee is taken from input or output depending on PoolState.creator_fee_on (see next section). The rate is unchanged either way.

​

Which side of the trade the fees are taken from

​

How “accrued” fees interact with the curve

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)

• Quoting off raw balances is wrong. If you build a quoter off getTokenAccountBalance, you will consistently overstate the price the pool will honor. Always subtract accrued fees, or simulate via SwapBaseInput / the API.
• CollectProtocolFee does not move the price. It moves tokens out of the vault and zeros the protocol_fees_token* counters, so curve_x and curve_y are unchanged.
• LP fees do not accrue to a counter. They are implicit in the vault balance. LP’s entitlement to accumulated LP fees is exercised by burning LP tokens (i.e., via Withdraw) — there is no CollectLpFee.

​

Interaction with Token-2022 transfer fees

1. The input mint’s transfer fee on amount_in (to the mint’s fee authority).
2. The pool’s trade_fee on the remainder (split per above).
3. The output mint’s transfer fee on amount_out (to the mint’s fee authority).

​

Creator fee

• Enabled at pool creation. Initialize sets enable_creator_fee = false by default; pools created via InitializeWithPermission (used by LaunchLab graduations and other gated paths) can pass enable_creator_fee = true and choose creator_fee_on.
• Rate is shared with the fee tier. The rate itself is AmmConfig.creator_fee_rate, the same value across every pool bound to that config. Each pool then decides whether to charge it (enable_creator_fee) and which side of the swap to charge it on (creator_fee_on). When enable_creator_fee = false, the pool’s effective creator-fee rate is zero regardless of the config value (see PoolState::adjust_creator_fee_rate in the source).
• Independent of trade fee. The creator fee never reduces the LP / protocol / fund shares — it is its own rate, applied separately, accrued in its own counters.
• Swept via CollectCreatorFee or CollectCreatorFeePermissionless. The original path requires PoolState.pool_creator to sign. The permissionless path lets any payer trigger collection but fixes both destinations to the creator’s canonical ATAs. Both paths settle the protocol’s share first — see the next section.
• Cannot be re-enabled or re-routed after creation. A pool initialized with enable_creator_fee = false will never charge a creator fee; one initialized with a particular creator_fee_on cannot switch sides.

​

Protocol share of the creator fee

​

Where the rate comes from

1. CreatorFeeShare PDA — seeds ["creator_fee_share", creator, amm_config]. When this account exists and is owned by CPMM, its share_rate wins. It lets the protocol negotiate a per-creator rate on a given fee tier without touching the tier itself.
2. AmmConfig.creator_fee_share_rate — the default for every creator on that fee tier. Used whenever the PDA does not exist.

​

What the split does

// programs/cp-swap/src/states/creator_fee_share.rs
shared_amount  = floor(creator_fee * share_rate / 1_000_000);   // to the protocol
creator_amount = creator_fee - shared_amount;                   // to the creator

• creator_amount_{0,1} is transferred out of the vaults to the creator’s token accounts.
• shared_amount_{0,1} is added to protocol_fees_token_{0,1} and stays in the vault until the protocol owner sweeps it with CollectProtocolFee. There is no separate instruction and no separate counter for it.
• creator_fees_token_{0,1} are zeroed, exactly as before.

• Rounding favours the creator. The protocol share floors, so dust stays with the creator — the same direction as protocol_fee and fund_fee, which also carve a share out of an already-accrued fee.
• Value is conserved. creator_amount + shared_amount == creator_fee for every rate and every fee, including u64::MAX.
• share_rate = 0 is a no-op. Both the default config value and the absence of a CreatorFeeShare PDA leave the whole creator fee with the creator, which is the pre-upgrade behaviour.

​

What it means for integrators

• LPs and quoting are unaffected. The shared amount moves between two counters that are both already excluded from the curve’s view of the vault (vault_amount_without_fee), so curve_x and curve_y do not move across a collection. k is untouched.
• A creator-fee estimator that reads creator_fees_token* now overstates the payout. Multiply by (1 − share_rate / 1_000_000) using the rate that actually applies to that (creator, amm_config) pair, not the config default.
• protocol_fees_token* grows outside of swaps. A monitor that reconciles protocol accrual against swap volume will see jumps at each creator-fee collection. Protocol accrual is no longer trade_fee × protocol_fee_rate alone.
• The rate can change between accrual and collection. It is read at collection time, so fees that accrued under one rate settle at whatever rate is in force when someone calls Collect*.

​

Collection operational flow

​

Changing a fee tier

• Move a pool from one AmmConfig to another.
• Retroactively reprice already-accrued fees.
• Collect fees without the protocol_owner / fund_owner signer.

​

Reading fees from a running pool

// Off-chain: current accrued fees in each bucket.
// The SDK exports the layout, not a `PoolState` class, and the fee fields are
// named ...MintA / ...MintB — there are no ...Token0 / ...Token1 fields.
import { CpmmPoolInfoLayout } from "@raydium-io/raydium-sdk-v2";

const pool = await connection.getAccountInfo(poolStatePda);
const decoded = CpmmPoolInfoLayout.decode(pool!.data);   // no .slice(8) — the
                                                          // layout includes the discriminator
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(),
);
// What the creator actually receives is this minus the protocol share, resolved at
// collection time from the (creator, ammConfig) CreatorFeeShare PDA if it exists and
// from AmmConfig.creator_fee_share_rate otherwise. See "Protocol share of the creator
// fee" above.

// 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());
// `configId` on the decoded pool is the config account's PublicKey, not an index.
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)",
);

​

Comparison with CLMM and AMM v4

• AMM v4 uses a fixed 0.25% trade fee with a different LP/protocol split and no fund fee.
• CLMM fees are per-tick-spacing tier, accrued per-position (not per-pool), and claimed via DecreaseLiquidity or CollectFees.

​

Where to go next

• products/cpmm/math — where the trade-fee deduction plugs into the curve.
• products/cpmm/instructions — the Collect* instruction account lists, including the creator_fee_share account both creator paths now require.
• algorithms/token-2022-transfer-fees — how to combine a pool trade fee with a mint transfer fee correctly.

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