CPMM-Gebühren

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.

​

Zwei unabhängige Gebühren, vier Destinationen

1. Handelsgebühr — berechnet mit AmmConfig.trade_fee_rate und aufgeteilt auf drei Ziele:
   • LP-Anteil — verbleibt im Vault und lässt k wachsen. Wird implizit durch das Verbrennen von LP-Token beansprucht.
   • Protokoll-Anteil — auflaufend auf PoolState.protocol_fees_token*; eingezogen durch den protocol_owner via CollectProtocolFee.
   • Fund-Anteil — auflaufend auf PoolState.fund_fees_token*; eingezogen durch den fund_owner via CollectFundFee.
2. Creator-Gebühr (optional, pro Pool) — berechnet mit AmmConfig.creator_fee_rate unabhängig von der Handelsgebühr, auflaufend auf PoolState.creator_fees_token*, eingezogen durch pool_state.pool_creator via CollectCreatorFee. 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 (Eingabe oder Ausgabe, je nach creator_fee_on — siehe „Von welcher Seite des Handels die Gebühren genommen werden” unten).
• creator_fee_rate ist ein Bruchteil des Swap-Volumens, genommen 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 der Eingabe rundet auf, damit der Pool nie untergebührt wird.
• Die Unter-Aufteilungen von trade_fee (Protokoll, Fund) runden ab, damit ihre Summe trade_fee nicht ü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 von der Eingabe oder Ausgabe genommen, abhängig von PoolState.creator_fee_on (siehe nächster Abschnitt). Der Satz bleibt in beiden Fällen gleich.

​

Von welcher Seite des Handels die Gebühren genommen werden

​

Wie „auflaufende” 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 über rohe Salden ist falsch. Wenn Sie einen Quoter über getTokenAccountBalance bauen, werden Sie den Preis, den der Pool ehren wird, systematisch zu hoch veranschlagen. Subtrahieren Sie immer auflaufende Gebühren, oder simulieren Sie via SwapBaseInput / die API.
• CollectProtocolFee bewegt den Preis nicht. Es bewegt Token aus dem Vault und nullt die protocol_fees_token*-Zähler, daher sind curve_x und curve_y unverändert.
• LP-Gebühren laufen nicht auf einem Zähler auf. Sie sind implizit im Vault-Saldo. Der Anspruch des LP auf akkumulierte LP-Gebühren wird durch das Verbrennen von LP-Token ausgeübt (d.h. via Withdraw) — es gibt kein CollectLpFee.

​

Interaction mit Token-2022-Transfergebühren

1. Die Transfergebühr der Eingabe-Mint auf amount_in (zur Gebühren-Autorität der Mint).
2. Der trade_fee des Pools auf den Rest (aufgeteilt wie oben).
3. Die Transfergebühr der Ausgabe-Mint auf amount_out (zur Gebühren-Autorität der Mint).

​

Creator-Gebühr

• Bei Pool-Erstellung aktiviert. Initialize setzt enable_creator_fee = false standardmäßig; Pools, die via InitializeWithPermission erstellt werden (verwendet durch LaunchLab-Graduationen und andere gated Paths), 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 berechnet (enable_creator_fee) und von welcher Seite des Swaps er ihn berechnet (creator_fee_on). Wenn enable_creator_fee = false, ist der effektive Creator-Gebühren-Satz des Pools null, unabhängig vom Config-Wert (siehe PoolState::adjust_creator_fee_rate in der Quelle).
• Unabhängig von der Handelsgebühr. Die Creator-Gebühr reduziert nie die LP-/Protokoll-/Fund-Anteile — sie ist ihr eigener Satz, separat angewendet, in ihren eigenen Zählern auflaufend.
• Eingezogen via CollectCreatorFee, signiert durch PoolState.pool_creator.
• Kann nach der Erstellung nicht wieder aktiviert oder umgeleitet werden. Ein Pool, der mit enable_creator_fee = false initialisiert wurde, wird niemals eine Creator-Gebühr berechnen; einer, der mit einem bestimmten creator_fee_on initialisiert wurde, kann nicht die Seiten wechseln.

​

Eintreibungs-Operationsfluss

​

Ändern eines Gebühren-Tiers

• Einen Pool von einer AmmConfig zu einer anderen verschieben.
• Bereits auflaufende Gebühren rückwirkend neu bewerten.
• Gebühren ohne protocol_owner / fund_owner Signatur 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 nutzt eine feste 0,25%-Handelsgebühr mit einer unterschiedlichen LP-/Protokoll-Aufteilung und keine Fund-Gebühr.
• CLMM Gebühren sind pro Tick-Spacing-Tier, auflaufend pro Position (nicht pro Pool), und beansprucht via DecreaseLiquidity oder CollectFees.

​

Wo es weitergeht

• products/cpmm/math — wo die Handelsgebühren-Abzug in die Kurve pluggt.
• products/cpmm/instructions — die Collect* Instruction 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