CPMM-Gebühren

​

Zwei unabhängige Gebühren, vier Ziele

1. Handelsgebühr — erhoben mit AmmConfig.trade_fee_rate und aufgeteilt auf drei Ziele:
   • LP-Anteil — bleibt im Vault und vergrößert k. Wird implizit durch das Verbrennen von LP-Token beansprucht.
   • Protokoll-Anteil — aufgelaufen zu PoolState.protocol_fees_token*; eingezogen durch den protocol_owner via CollectProtocolFee.
   • Fund-Anteil — aufgelaufen zu PoolState.fund_fees_token*; eingezogen durch den fund_owner via CollectFundFee.
2. Creator-Gebühr (optional, pro Pool) — erhoben mit AmmConfig.creator_fee_rate unabhängig von der Handelsgebühr und aufgelaufen zu PoolState.creator_fees_token*. Der Creator kann sie über CollectCreatorFee einziehen, oder jeder Zahler kann den zielgebundenen CollectCreatorFeePermissionless-Pfad auslösen. Aktiv nur, wenn der Pool mit enable_creator_fee = true erstellt wurde.

​

Sätze und Einheiten

• trade_fee_rate ist ein Bruchteil des Swap-Volumens. 2500 ⇒ 0,25% der relevanten Seite (Input oder Output, abhängig von creator_fee_on — siehe „Von welcher Seite des Trades die Gebühren erhoben werden” unten).
• creator_fee_rate ist ein Bruchteil des Swap-Volumens, erhoben separat von der Handelsgebühr. 1000 ⇒ 0,10% der relevanten Seite.
• protocol_fee_rate und fund_fee_rate sind Bruchteile der Handelsgebühr, nicht des Volumens. 120_000 ⇒ 12% der Handelsgebühr.

​

Die Aufteilung im 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)
}

• Die Gesamtgebühr auf Input rundet auf, damit der Pool nie unterberechnet.
• Die Unteraufteilungen von trade_fee (Protokoll, Fund) runden ab, damit ihre Summe trade_fee nie übersteigt; der Rest ist der LP-Anteil.
• lp_share = trade_fee − protocol_fee − fund_fee (creator_fee wird hier nicht subtrahiert, da es sein eigener Bucket ist).
• Die Creator-Gebühr wird je nach PoolState.creator_fee_on vom Input oder Output erhoben (siehe nächster Abschnitt). Der Satz bleibt in beiden Fällen unverändert.

​

Von welcher Seite des Trades die Gebühren erhoben werden

​

Wie „aufgelaufene” Gebühren mit der Kurve interagieren

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 von rohen Salden ist falsch. Wenn Sie einen Quoter von getTokenAccountBalance erstellen, werden Sie den Preis, den der Pool ehrt, konsistent überzeichnen. Subtrahieren Sie immer aufgelaufene Gebühren, oder simulieren Sie via SwapBaseInput / die API.
• CollectProtocolFee bewegt den Preis nicht. Es bewegt Token aus dem Vault und setzt die protocol_fees_token*-Zähler auf Null, sodass curve_x und curve_y unverändert bleiben.
• LP-Gebühren fallen nicht auf einem Zähler an. Sie sind implizit im Vault-Saldo. Die Berechtigung des LP auf aufgelaufene LP-Gebühren wird durch das Verbrennen von LP-Token ausgeübt (d. h. via Withdraw) — es gibt kein CollectLpFee.

​

Interaktion mit Token-2022-Transfergebühren

1. Die Transfergebühr des Input-Mints auf amount_in (an die Gebührenautorität des Mints).
2. Die trade_fee des Pools auf den Rest (aufgeteilt wie oben).
3. Die Transfergebühr des Output-Mints auf amount_out (an die Gebührenautorität des Mints).

​

Creator-Gebühr

• Aktiviert bei Pool-Erstellung. Initialize setzt enable_creator_fee = false standardmäßig; Pools, die über InitializeWithPermission erstellt werden (verwendet von LaunchLab-Graduierungen und anderen gated Pfaden), können enable_creator_fee = true übergeben und creator_fee_on wählen.
• Satz wird mit dem Gebühren-Tier geteilt. Der Satz selbst ist AmmConfig.creator_fee_rate, der gleiche Wert über jeden Pool, der an diese Config gebunden ist. Jeder Pool entscheidet dann, ob er ihn erhebt (enable_creator_fee) und von welcher Seite des Swaps er ihn erhebt (creator_fee_on). Wenn enable_creator_fee = false, ist der effektive Creator-Gebühren-Satz des Pools unabhängig vom Config-Wert null (siehe PoolState::adjust_creator_fee_rate in der Quelle).
• Unabhängig von der Handelsgebühr. Die Creator-Gebühr reduziert niemals die LP-/Protokoll-/Fund-Anteile — sie ist ihr eigener Satz, separat angewendet, in ihren eigenen Zählern aufgelaufen.
• Eingezogen via CollectCreatorFee oder CollectCreatorFeePermissionless. Der ursprüngliche Pfad erfordert, dass PoolState.pool_creator signiert. Der erlaubnislose Pfad lässt jeden Zahler die Einziehung auslösen, aber fixiert beide Ziele auf die kanonischen ATAs des Creators.
• Kann nach der Erstellung nicht erneut aktiviert oder umgeleitet werden. Ein Pool, der mit enable_creator_fee = false initialisiert wurde, wird niemals eine Creator-Gebühr erheben; einer, der mit einem bestimmten creator_fee_on initialisiert wurde, kann nicht die Seiten wechseln.

​

Einzugs-Operationsablauf

​

Ändern eines Gebühren-Tiers

• Einen Pool von einer AmmConfig zu einer anderen verschieben.
• Bereits aufgelaufene Gebühren rückwirkend neu bewerten.
• Gebühren ohne den protocol_owner / fund_owner-Unterzeichner einziehen.

​

Gebühren aus einem laufenden Pool lesen

// Off-chain: current accrued fees in each 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: 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());
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)",
);

​

Vergleich mit CLMM und AMM v4

• AMM v4 verwendet eine feste 0,25%-Handelsgebühr mit einer anderen LP-/Protokoll-Aufteilung und keine Fund-Gebühr.
• CLMM-Gebühren sind pro-Tick-Spacing-Tier, aufgelaufen pro-Position (nicht pro-Pool), und beansprucht via DecreaseLiquidity oder CollectFees.

​

Nächste Schritte

• products/cpmm/math — wo die Handelsgebühren-Abzug in die Kurve passt.
• products/cpmm/instructions — die Collect*-Anweisungs-Kontolisten.
• algorithms/token-2022-transfer-fees — wie man eine Pool-Handelsgebühr mit einer Mint-Transfergebühr korrekt kombiniert.

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