Phí CPMM

​

Hai phí độc lập, bốn điểm đến

1. Phí giao dịch — được tính theo AmmConfig.trade_fee_rate và chia thành ba điểm đến:
   • Phần LP — nằm trong vault và làm tăng k. Được yêu cầu ngầm bằng cách đốt token LP.
   • Phần giao thức — tích lũy vào PoolState.protocol_fees_token*; được quét bởi protocol_owner thông qua CollectProtocolFee.
   • Phần quỹ — tích lũy vào PoolState.fund_fees_token*; được quét bởi fund_owner thông qua CollectFundFee.
2. Phí tạo pool (tùy chọn, theo pool) — được tính theo AmmConfig.creator_fee_rate độc lập với phí giao dịch và tích lũy vào PoolState.creator_fees_token*. Người tạo pool có thể quét nó thông qua CollectCreatorFee, hoặc bất kỳ người thanh toán nào có thể kích hoạt đường dẫn CollectCreatorFeePermissionless bị ràng buộc bởi điểm đến. Chỉ hoạt động khi pool được tạo với enable_creator_fee = true. Kể từ bản nâng cấp 2026-09-19, phí tạo pool tích lũy được chia một lần nữa tại thời điểm thu thập: một phần có thể cấu hình được chuyển vào bucket giao thức của pool và chỉ phần còn lại đến người tạo pool — xem Phần giao thức của phí tạo pool.

​

Tỷ lệ và đơn vị

• trade_fee_rate là một phần của khối lượng swap. 2500 ⇒ 0,25% của phía liên quan (đầu vào hoặc đầu ra, tùy thuộc vào creator_fee_on — xem “Phía nào của giao dịch mà phí được lấy từ” bên dưới).
• creator_fee_rate là một phần của khối lượng swap, được lấy riêng biệt từ phí giao dịch. 1000 ⇒ 0,10% của phía liên quan.
• protocol_fee_rate và fund_fee_rate là các phần của phí giao dịch, không phải của khối lượng. 120_000 ⇒ 12% của phí giao dịch.
• creator_fee_share_rate là một phần của phí tạo pool tích lũy, không phải của khối lượng và không phải của phí giao dịch. 200_000 ⇒ 20% của bất kỳ gì nằm trong creator_fees_token* tại thời điểm nó được thu thập. 0 (mặc định) để lại toàn bộ phí tạo pool cho người tạo pool.

​

Phần chia, trong mã

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

• Tổng phí trên đầu vào làm tròn lên để pool không bao giờ tính phí thấp hơn.
• Các phần chia của trade_fee (giao thức, quỹ) làm tròn xuống để tổng của chúng không bao giờ vượt quá trade_fee; phần còn lại là phần LP.
• lp_share = trade_fee − protocol_fee − fund_fee (creator_fee không được trừ ở đây vì nó là bucket riêng của nó).
• Phí tạo pool được lấy từ đầu vào hoặc đầu ra tùy thuộc vào PoolState.creator_fee_on (xem phần tiếp theo). Tỷ lệ không thay đổi bằng cách nào.

​

Phía nào của giao dịch mà phí được lấy từ

​

Cách phí “tích lũy” tương tác với đường cong

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)

• Báo giá từ raw balances là sai. Nếu bạn xây dựng một quoter từ getTokenAccountBalance, bạn sẽ liên tục phóng đại giá mà pool sẽ danh dự. Luôn trừ phí tích lũy, hoặc mô phỏng thông qua SwapBaseInput / API.
• CollectProtocolFee không di chuyển giá. Nó di chuyển token ra khỏi vault và đặt lại các bộ đếm protocol_fees_token*, vì vậy curve_x và curve_y không thay đổi.
• Phí LP không tích lũy vào bộ đếm. Chúng ngầm trong vault balance. Quyền của LP đối với phí LP tích lũy được thực hiện bằng cách đốt token LP (tức là thông qua Withdraw) — không có CollectLpFee.

​

Tương tác với phí chuyển Token-2022

1. Phí chuyển mint đầu vào trên amount_in (cho cơ quan phí của mint).
2. Phí trade_fee của pool trên phần còn lại (chia như trên).
3. Phí chuyển mint đầu ra trên amount_out (cho cơ quan phí của mint).

​

Phí tạo pool

• Bật tại tạo pool. Initialize đặt enable_creator_fee = false theo mặc định; các pool được tạo thông qua InitializeWithPermission (được sử dụng bởi các tốt nghiệp LaunchLab và các đường dẫn được gated khác) có thể chuyển enable_creator_fee = true và chọn creator_fee_on.
• Tỷ lệ được chia sẻ với tầng phí. Tỷ lệ chính nó là AmmConfig.creator_fee_rate, cùng một giá trị trên mỗi pool được ràng buộc với cấu hình đó. Mỗi pool sau đó quyết định có tính phí nó (enable_creator_fee) và phía nào của swap để tính phí nó (creator_fee_on). Khi enable_creator_fee = false, tỷ lệ phí tạo pool hiệu quả của pool là zero bất kể giá trị cấu hình (xem PoolState::adjust_creator_fee_rate trong nguồn).
• Độc lập với phí giao dịch. Phí tạo pool không bao giờ giảm phần LP / giao thức / quỹ — nó là tỷ lệ riêng của nó, được áp dụng riêng biệt, tích lũy trong các bộ đếm riêng của nó.
• Được quét thông qua CollectCreatorFee hoặc CollectCreatorFeePermissionless. Đường dẫn gốc yêu cầu PoolState.pool_creator ký. Đường dẫn không cần phép cho phép bất kỳ người thanh toán nào kích hoạt bộ sưu tập nhưng sửa cả hai điểm đến thành ATA chính tắc của người tạo pool. Cả hai đường dẫn đều giải quyết phần giao thức trước — xem phần tiếp theo.
• Không thể được bật lại hoặc định tuyến lại sau khi tạo. Một pool được khởi tạo với enable_creator_fee = false sẽ không bao giờ tính phí tạo pool; một pool được khởi tạo với một creator_fee_on cụ thể không thể chuyển đổi phía.

​

Phần giao thức của phí tạo pool

​

Tỷ lệ đến từ đâu

1. PDA CreatorFeeShare — seeds ["creator_fee_share", creator, amm_config]. Khi tài khoản này tồn tại và được sở hữu bởi CPMM, share_rate của nó thắng. Nó cho phép giao thức thương lượng tỷ lệ cho mỗi người tạo pool trên một tầng phí nhất định mà không cần chạm vào tầng đó.
2. AmmConfig.creator_fee_share_rate — mặc định cho mỗi người tạo pool trên tầng phí đó. Được sử dụng bất cứ khi nào PDA không tồn tại.

​

Phần chia làm gì

// 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} được chuyển ra khỏi vault đến các tài khoản token của người tạo pool.
• shared_amount_{0,1} được thêm vào protocol_fees_token_{0,1} và nằm trong vault cho đến khi chủ sở hữu giao thức quét nó bằng CollectProtocolFee. Không có lệnh riêng biệt và không có bộ đếm riêng biệt cho nó.
• creator_fees_token_{0,1} được đặt lại về 0, chính xác như trước đây.

• Làm tròn ưu tiên người tạo pool. Phần giao thức làm tròn xuống, vì vậy bụi nằm với người tạo pool — cùng hướng với protocol_fee và fund_fee, cũng cắt một phần từ một phí đã tích lũy.
• Giá trị được bảo toàn. creator_amount + shared_amount == creator_fee cho mỗi tỷ lệ và mỗi phí, bao gồm u64::MAX.
• share_rate = 0 là không hoạt động. Cả giá trị cấu hình mặc định và sự vắng mặt của PDA CreatorFeeShare để lại toàn bộ phí tạo pool với người tạo pool, đó là hành vi trước nâng cấp.

​

Điều đó có nghĩa gì đối với các nhà tích hợp

• LP và báo giá không bị ảnh hưởng. Số tiền được chia sẻ di chuyển giữa hai bộ đếm cả hai đã bị loại trừ khỏi chế độ xem vault của đường cong (vault_amount_without_fee), vì vậy curve_x và curve_y không di chuyển trên một bộ sưu tập. k không bị chạm.
• Một công cụ ước tính phí tạo pool đọc creator_fees_token* bây giờ phóng đại khoản thanh toán. Nhân với (1 − share_rate / 1_000_000) sử dụng tỷ lệ thực sự áp dụng cho cặp (creator, amm_config) đó, không phải mặc định cấu hình.
• protocol_fees_token* phát triển bên ngoài swap. Một monitor điều hòa accrual giao thức so với khối lượng swap sẽ thấy bước nhảy ở mỗi bộ sưu tập phí tạo pool. Accrual giao thức không còn là trade_fee × protocol_fee_rate một mình.
• Tỷ lệ có thể thay đổi giữa accrual và collection. Nó được đọc tại thời điểm thu thập, vì vậy phí tích lũy theo một tỷ lệ giải quyết ở bất kỳ tỷ lệ nào có hiệu lực khi ai đó gọi Collect*.

​

Luồng hoạt động thu thập

​

Thay đổi tầng phí

• Di chuyển pool từ một AmmConfig sang AmmConfig khác.
• Định giá lại các phí đã tích lũy.
• Thu thập phí mà không có người ký protocol_owner / fund_owner.

​

Đọc phí từ một pool đang chạy

// 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)",
);

​

So sánh với CLMM và AMM v4

• AMM v4 sử dụng phí giao dịch cố định 0,25% với phần chia LP/giao thức khác và không có phí quỹ.
• CLMM phí là theo tầng khoảng tick, tích lũy theo vị trí (không phải theo pool), và được yêu cầu thông qua DecreaseLiquidity hoặc CollectFees.

​

Tiếp theo đi đâu

• products/cpmm/math — nơi phần trừ phí giao dịch cắm vào đường cong.
• products/cpmm/instructions — danh sách tài khoản lệnh Collect*, bao gồm tài khoản creator_fee_share mà cả hai đường dẫn người tạo pool bây giờ yêu cầu.
• algorithms/token-2022-transfer-fees — cách kết hợp phí giao dịch pool với phí chuyển mint một cách chính xác.

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