> ## 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.

# Biaya CPMM

> Bagaimana CPMM mengenakan biaya perdagangan dan biaya kreator terpisah, membagi biaya perdagangan antara LP, kas protokol, dan multisig dana, membagi bagian yang dapat dikonfigurasi dari biaya kreator ke protokol pada saat pengumpulan, dan siapa yang mengumpulkan apa, kapan.

<Info>
  **Halaman ini diterjemahkan secara otomatis oleh AI. Versi bahasa Inggris adalah acuan resmi.**

  [Lihat versi bahasa Inggris →](/products/cpmm/fees)
</Info>

## Dua biaya independen, empat tujuan

CPMM mengenakan **dua biaya dengan tarif terpisah** pada setiap swap:

1. **Biaya perdagangan** — dikenakan pada `AmmConfig.trade_fee_rate` dan dibagi antara tiga tujuan:
   * **Bagian LP** — tetap di vault dan menambah `k`. Diklaim secara implisit dengan membakar token LP.
   * **Bagian protokol** — terakumulasi ke `PoolState.protocol_fees_token*`; disapu oleh `protocol_owner` melalui `CollectProtocolFee`.
   * **Bagian dana** — terakumulasi ke `PoolState.fund_fees_token*`; disapu oleh `fund_owner` melalui `CollectFundFee`.
2. **Biaya kreator** (opsional, per-pool) — dikenakan pada `AmmConfig.creator_fee_rate` **secara independen** dari biaya perdagangan dan terakumulasi ke `PoolState.creator_fees_token*`. Kreator dapat menyapunya melalui `CollectCreatorFee`, atau pembayar apa pun dapat memicu jalur `CollectCreatorFeePermissionless` yang dibatasi tujuan. Aktif hanya ketika pool dibuat dengan `enable_creator_fee = true`. **Sejak upgrade 2026-09-19, biaya kreator yang terakumulasi dibagi sekali lagi pada saat pengumpulan**: bagian yang dapat dikonfigurasi dipindahkan ke bucket protokol pool dan hanya sisanya yang mencapai kreator — lihat [Bagian protokol dari biaya kreator](#protocol-share-of-the-creator-fee).

Biaya kreator **bukan** bagian dari biaya perdagangan. Kedua tarif ditambahkan bersama ketika biaya diambil dari input swap, tetapi masing-masing tetap menjadi bucket tersendiri — bagian protokol dan dana yang diambil pada swap selalu berasal dari `trade_fee` saja, tidak pernah dari `creator_fee`. Pool dengan `creator_fee_rate = 1000` (0,10%) dan `trade_fee_rate = 2500` (0,25%) mengenakan total 0,35% dari input pada swap dengan creator-fee-on-input, di mana bucket kreator mendapat 0,10% dan bucket biaya perdagangan mendapat 0,25%.

Bagian protokol dari biaya kreator berjalan sebaliknya dan mudah dikacaukan dengan di atas: biaya tersebut diambil dari **bucket kreator**, bukan dari biaya perdagangan, dan bukan pada swap — biaya tersebut diterapkan ketika `CollectCreatorFee` atau `CollectCreatorFeePermissionless` menyelesaikan saldo yang terakumulasi. Matematika swap tidak berubah karenanya.

Tarif biaya perdagangan (`trade_fee_rate`, `protocol_fee_rate`, `fund_fee_rate`), `creator_fee_rate` dan default `creator_fee_share_rate` semuanya berada di `AmmConfig`. Flag `enable_creator_fee` per-pool dan mode `creator_fee_on` (sisi perdagangan mana biaya kreator diambil) berada di `PoolState`. Override per-kreator dari share rate berada di PDA `CreatorFeeShare` tersendiri. Lihat [`products/cpmm/accounts`](/id/products/cpmm/accounts).

## Tarif dan unit

Semua tarif adalah `u64` yang dinyatakan dalam unit `1 / FEE_RATE_DENOMINATOR` di mana `FEE_RATE_DENOMINATOR = 1_000_000`.

* **`trade_fee_rate`** adalah fraksi dari **volume swap**. `2500` ⇒ 0,25% dari sisi yang relevan (input atau output, tergantung pada `creator_fee_on` — lihat "Sisi perdagangan mana biaya diambil" di bawah).
* **`creator_fee_rate`** adalah fraksi dari **volume swap**, diambil **secara terpisah** dari biaya perdagangan. `1000` ⇒ 0,10% dari sisi yang relevan.
* **`protocol_fee_rate`** dan **`fund_fee_rate`** adalah fraksi dari **biaya perdagangan**, bukan dari volume. `120_000` ⇒ 12% dari biaya perdagangan.
* **`creator_fee_share_rate`** adalah fraksi dari **biaya kreator yang terakumulasi**, bukan dari volume dan bukan dari biaya perdagangan. `200_000` ⇒ 20% dari apa pun yang berada di `creator_fees_token*` pada saat dikumpulkan. `0` (default) membiarkan seluruh biaya kreator bersama kreator.

Parameter default untuk `AmmConfig[index=0]` (pool "standar" 0,25%) di mainnet, sebagai referensi:

| Bidang | Nilai | Persentase Efektif |
| - | - | - |
| `trade_fee_rate` | `2500` | 0,25% dari volume (bucket biaya perdagangan) |
| `protocol_fee_rate` | `120000` | 12% dari biaya perdagangan ≈ **0,030% dari volume** |
| `fund_fee_rate` | `40000` | 4% dari biaya perdagangan ≈ **0,010% dari volume** |
| `creator_fee_rate` | `0` (default) | 0% (bucket terpisah) |
| `creator_fee_share_rate` | `0` (default) | 0% dari bucket kreator (kreator menyimpan semuanya) |
| → Bagian LP efektif | | **0,210% dari volume** |

Jadi pada swap \$1.000 terhadap `AmmConfig[0]` dengan `enable_creator_fee = false`: total biaya perdagangan \$2,50, di mana \$2,10 tetap bersama LP, \$0,30 ke protokol, \$0,10 ke dana. Bucket kreator adalah 0 karena biaya kreator dinonaktifkan.

Jika pool yang sama memiliki `enable_creator_fee = true` dan `creator_fee_rate = 1000` (0,10%), pengguna membayar tambahan \$1,00 ke bucket kreator — diambil dari sisi perdagangan yang sama yang dikonfigurasi oleh `creator_fee_on` — untuk total \$3,50 biaya. Bucket biaya perdagangan dan pembagian protokol/dana-nya tidak berubah.

Konfirmasi nilai mainnet saat ini terhadap `GET https://api-v3.raydium.io/main/cpmm-config` — tarif dapat diubah admin dan harus dibaca segar daripada dikodekan.

## Pembagian, dalam kode

```rust theme={null}
// Diparafrasekan dari raydium-cp-swap/programs/cp-swap/src/curve/{calculator,fees}.rs.
// Kode aktual bercabang pada `is_creator_fee_on_input`; kedua cabang mempertahankan
// invarian bahwa creator_fee adalah tarifnya sendiri, tidak pernah bagian dari 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)
}
```

Catatan:

* Total biaya pada input dibulatkan **ke atas** sehingga pool tidak pernah mengenakan biaya kurang.
* Sub-pembagian `trade_fee` (protokol, dana) dibulatkan **ke bawah** sehingga jumlahnya tidak pernah melebihi `trade_fee`; sisanya adalah bagian LP.
* `lp_share = trade_fee − protocol_fee − fund_fee` (creator\_fee **tidak** dikurangi di sini karena merupakan bucket tersendiri).
* Biaya kreator diambil dari input atau output tergantung pada `PoolState.creator_fee_on` (lihat bagian berikutnya). Tarifnya tidak berubah.

## Sisi perdagangan mana biaya diambil

CPMM memiliki pengaturan `creator_fee_on` per-pool (`BothToken` / `OnlyToken0` / `OnlyToken1`) yang menentukan apakah biaya kreator diambil dari sisi **input** atau sisi **output** dari swap tertentu. Helper runtime `is_creator_fee_on_input(direction)` menyederhanakan itu menjadi boolean per swap:

| `creator_fee_on` | Swap `0 → 1` | Swap `1 → 0` |
| - | - | - |
| `BothToken` (`0`) | sisi input | sisi input |
| `OnlyToken0` (`1`) | sisi input | sisi output |
| `OnlyToken1` (`2`) | sisi output | sisi input |

Ketika biaya kreator berada di sisi **input**, baik biaya perdagangan maupun biaya kreator dikurangi dari `amount_in` sebelum kurva berjalan. Matematika quote: ambil `trade_rate + creator_rate` gabungan dari input.

Ketika biaya kreator berada di sisi **output**, hanya biaya perdagangan yang dikurangi dari `amount_in`; kurva menghasilkan output tanpa biaya, kemudian biaya kreator dikurangi dari output itu. Matematika quote: ambil `trade_rate` dari input; ambil `creator_rate` dari output.

Biaya perdagangan itu sendiri selalu diambil dari sisi input (pola Uniswap-V2 standar). Hanya biaya kreator yang dapat mendarat di output.

## Bagaimana biaya "terakumulasi" berinteraksi dengan kurva

Nuansa penting: **biaya protokol, dana, dan kreator tetap secara fisik di vault** sampai instruksi `Collect*` masing-masing dipanggil. Tetapi mereka dikecualikan dari pandangan kurva tentang saldo vault.

Gambaran konkret setelah satu swap:

```
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)
```

Program menggunakan `curve_x` (dan `curve_y` analog) ketika menegakkan `k' ≥ k`. Ini adalah bagaimana biaya non-LP mencapai tujuan mereka **tanpa** menginflasi bagian LP dari pool.

Konsekuensi yang harus Anda rancang:

* **Quoting dari saldo mentah salah.** Jika Anda membangun quoter dari `getTokenAccountBalance`, Anda akan secara konsisten menyatakan harga yang akan dihormati pool. Selalu kurangi biaya terakumulasi, atau simulasikan melalui `SwapBaseInput` / API.
* **`CollectProtocolFee` tidak menggerakkan harga.** Ini memindahkan token keluar dari vault *dan* menolkan counter `protocol_fees_token*`, jadi `curve_x` dan `curve_y` tidak berubah.
* **Biaya LP tidak terakumulasi ke counter.** Mereka implisit dalam saldo vault. Hak LP atas biaya LP yang terakumulasi dilakukan dengan membakar token LP (yaitu, melalui `Withdraw`) — tidak ada `CollectLpFee`.

## Interaksi dengan biaya transfer Token-2022

Biaya transfer Token-2022 diterapkan oleh **mint**, bukan oleh CPMM. Mereka bertindak pada setiap transfer token — swap, deposit, penarikan, dan penyapuan `Collect*`. Matematika biaya perdagangan CPMM dihitung terhadap jumlah yang **benar-benar mendarat di vault**, yaitu, bersih dari biaya transfer mint input (jika ada).

Jadi dalam kasus terburuk pengguna membayar tiga pajak berbeda pada swap input-exact:

1. Biaya transfer mint input pada `amount_in` (ke otoritas biaya mint).
2. Biaya `trade_fee` pool pada sisanya (dibagi per di atas).
3. Biaya transfer mint output pada `amount_out` (ke otoritas biaya mint).

Quoter SDK memperhitungkan ketiga-tiganya sehingga `minimum_amount_out` dinyatakan dalam apa yang benar-benar diterima pengguna. Jika Anda menulis quoter Anda sendiri, cerminkan perilaku itu, atau pemeriksaan slippage Anda akan secara sistematis terlalu murah hati.

Lihat [`algorithms/token-2022-transfer-fees`](/id/algorithms/token-2022-transfer-fees) untuk derivasi terperinci.

## Biaya kreator

Biaya kreator bersifat opsional dan per-pool. **Tarif** berada di `AmmConfig.creator_fee_rate`; **flag enable** dan **sisi** (`creator_fee_on`) berada di `PoolState`:

* **Diaktifkan saat pembuatan pool.** `Initialize` menetapkan `enable_creator_fee = false` secara default; pool yang dibuat melalui `InitializeWithPermission` (digunakan oleh kelulusan LaunchLab dan jalur gated lainnya) dapat melewatkan `enable_creator_fee = true` dan memilih `creator_fee_on`.
* **Tarif dibagikan dengan tier biaya.** Tarifnya sendiri adalah `AmmConfig.creator_fee_rate`, nilai yang sama di setiap pool yang terikat pada config itu. Setiap pool kemudian memutuskan apakah akan mengenakan biaya (`enable_creator_fee`) dan sisi swap mana untuk mengenakan biaya (`creator_fee_on`). Ketika `enable_creator_fee = false`, tarif biaya kreator efektif pool adalah nol terlepas dari nilai config (lihat `PoolState::adjust_creator_fee_rate` dalam sumber).
* **Independen dari biaya perdagangan.** Biaya kreator tidak pernah mengurangi bagian LP / protokol / dana — biaya tersebut adalah tarifnya sendiri, diterapkan secara terpisah, terakumulasi di counter tersendiri.
* **Disapu melalui `CollectCreatorFee` atau `CollectCreatorFeePermissionless`.** Jalur asli memerlukan `PoolState.pool_creator` untuk menandatangani. Jalur tanpa izin membiarkan pembayar apa pun memicu pengumpulan tetapi memperbaiki kedua tujuan ke ATA kanonik kreator. Kedua jalur menyelesaikan bagian protokol terlebih dahulu — lihat bagian berikutnya.
* **Tidak dapat diaktifkan kembali atau dialihkan setelah pembuatan.** Pool yang diinisialisasi dengan `enable_creator_fee = false` tidak akan pernah mengenakan biaya kreator; yang diinisialisasi dengan `creator_fee_on` tertentu tidak dapat beralih sisi.

Biaya kreator adalah mekanisme di balik pola "Burn & Earn" Raydium: token LP dikunci di bawah program [LP Lock](/reference/program-addresses) sehingga kreator tidak dapat menarik likuiditas, tetapi biaya kreator yang terakumulasi masih dapat dikumpulkan tanpa batas.

## Bagian protokol dari biaya kreator

Sejak upgrade 2026-09-19, protokol dapat mempertahankan bagian yang dapat dikonfigurasi dari biaya kreator. Tidak ada yang berubah tentang swap: biaya kreator masih dikenakan pada `creator_fee_rate` dan masih terakumulasi penuh ke `creator_fees_token{0,1}`. Pembagian terjadi **sekali, pada saat pengumpulan**, di dalam `CollectCreatorFee` dan `CollectCreatorFeePermissionless`.

### Dari mana tarifnya berasal

Dua sumber, dalam urutan prioritas:

1. **PDA `CreatorFeeShare`** — seeds `["creator_fee_share", creator, amm_config]`. Ketika akun ini ada dan dimiliki oleh CPMM, `share_rate`-nya menang. Ini memungkinkan protokol untuk menegosiasikan tarif per-kreator pada tier biaya tertentu tanpa menyentuh tier itu sendiri.
2. **`AmmConfig.creator_fee_share_rate`** — default untuk setiap kreator pada tier biaya itu. Digunakan setiap kali PDA tidak ada.

Keduanya adalah `u64` di atas `FEE_RATE_DENOMINATOR = 1_000_000` yang sama, dan keduanya dibatasi pada denominator. Instruksi pengumpulan **selalu mengambil akun `creator_fee_share`**, bahkan ketika belum pernah dibuat — program memeriksa apakah kosong dan kembali ke config. Melewatkan alamat yang salah gagal pada constraint PDA, bukan fallback.

### Apa yang dilakukan pembagian

```rust theme={null}
// 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
```

Diterapkan secara independen ke `creator_fees_token_0` dan `creator_fees_token_1`, kemudian:

* `creator_amount_{0,1}` ditransfer keluar dari vault ke akun token kreator.
* `shared_amount_{0,1}` **ditambahkan ke `protocol_fees_token_{0,1}`** dan tetap di vault sampai pemilik protokol menyapunya dengan `CollectProtocolFee`. Tidak ada instruksi terpisah dan tidak ada counter terpisah untuk itu.
* `creator_fees_token_{0,1}` dinolkan, persis seperti sebelumnya.

Tiga properti yang patut diandalkan:

* **Pembulatan menguntungkan kreator.** Bagian protokol lantai, jadi debu tetap bersama kreator — arah yang sama dengan `protocol_fee` dan `fund_fee`, yang juga mengukir bagian dari biaya yang sudah terakumulasi.
* **Nilai dikonservasi.** `creator_amount + shared_amount == creator_fee` untuk setiap tarif dan setiap biaya, termasuk `u64::MAX`.
* **`share_rate = 0` adalah no-op.** Baik nilai config default maupun ketiadaan PDA `CreatorFeeShare` membiarkan seluruh biaya kreator bersama kreator, yang merupakan perilaku pra-upgrade.

### Apa artinya bagi integrator

* **LP dan quoting tidak terpengaruh.** Jumlah bersama bergerak antara dua counter yang *keduanya* sudah dikecualikan dari pandangan kurva tentang vault (`vault_amount_without_fee`), jadi `curve_x` dan `curve_y` tidak bergerak di seluruh pengumpulan. `k` tidak tersentuh.
* **Estimator biaya kreator yang membaca `creator_fees_token*` sekarang menyatakan pembayaran berlebihan.** Kalikan dengan `(1 − share_rate / 1_000_000)` menggunakan tarif yang benar-benar berlaku untuk pasangan `(creator, amm_config)` itu, bukan default config.
* **`protocol_fees_token*` tumbuh di luar swap.** Monitor yang merekonsiliasi akrual protokol terhadap volume swap akan melihat lompatan pada setiap pengumpulan biaya kreator. Akrual protokol tidak lagi `trade_fee × protocol_fee_rate` saja.
* **Tarifnya dapat berubah antara akrual dan pengumpulan.** Tarifnya dibaca pada saat pengumpulan, jadi biaya yang terakumulasi di bawah satu tarif menyelesaikan pada tarif apa pun yang berlaku ketika seseorang memanggil `Collect*`.

Akun `CreatorFeeShare` dibuat dan ditutup oleh admin atau otoritas share biaya kreator khusus melalui [`CreateCreatorFeeShare` / `CloseCreatorFeeShare`](/id/products/cpmm/instructions#createcreatorfeeshare); menutupnya mengembalikan pasangan ke `AmmConfig.creator_fee_share_rate`. Tata letak akun di [`products/cpmm/accounts`](/id/products/cpmm/accounts#creatorfeeshare), alamat di [`reference/program-addresses`](/id/reference/program-addresses#cpmm-creator-fee-share-authority).

## Alur operasional pengumpulan

| Penandatangan | Instruksi | Counter sumber dinolkan | Frekuensi tipikal |
| - | - | - | - |
| `amm_config.protocol_owner` | `CollectProtocolFee` | `protocol_fees_token{0,1}` | Mingguan atau programatik |
| `amm_config.fund_owner` | `CollectFundFee` | `fund_fees_token{0,1}` | Mingguan atau programatik |
| `pool_state.pool_creator` | `CollectCreatorFee` | `creator_fees_token{0,1}` — minus bagian protokol, yang dipindahkan ke `protocol_fees_token{0,1}` | Kapan saja |
| Pembayar apa pun; kreator tidak menandatangani | `CollectCreatorFeePermissionless` | `creator_fees_token{0,1}` — pembagian yang sama seperti di atas | Kapan saja; ATA kreator adalah tujuan tetap |
| `admin` atau otoritas share biaya kreator | `CreateCreatorFeeShare` / `CloseCreatorFeeShare` | — (menetapkan atau menghapus share rate untuk satu pasangan `(creator, amm_config)`) | Sesuai permintaan |

Pemilik protokol dan dana adalah multisig Raydium di mainnet; lihat [`security/admin-and-multisig`](/id/security/admin-and-multisig). Pada jalur kreator asli, penandatangan kreator adalah akun yang dicatat di `PoolState`. Pada jalur tanpa izin, pemanggil membayar untuk membuat ATA kreator yang hilang. Program membatasi `creator` ke `pool_state.pool_creator` dan menurunkan setiap tujuan dari kreator itu ditambah mint vault dan program token yang sesuai, jadi pemanggil tidak dapat mengalihkan dana.

## Mengubah tier biaya

Tarif biaya dapat diubah oleh admin melalui `UpdateAmmConfig` (lihat [`products/cpmm/instructions`](/id/products/cpmm/instructions)). Perubahan berlaku pada **swap berikutnya** untuk setiap pool yang terikat pada `AmmConfig` itu — tidak ada migrasi, karena pool memuat config setiap swap.

Apa yang tidak dapat dilakukan admin:

* Pindahkan pool dari satu `AmmConfig` ke yang lain.
* Harga ulang biaya yang sudah terakumulasi secara retroaktif.
* Kumpulkan biaya tanpa penandatangan `protocol_owner` / `fund_owner`.

## Membaca biaya dari pool yang berjalan

```ts theme={null}
// 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)",
);
```

<Note>
  **Selesaikan share rate on-chain, bukan dari config yang di-cache.** `creator_fee_share_rate` adalah bidang `AmmConfig` yang baru ditambahkan, jadi bacanya dari akun daripada mengasumsikan payload config REST membawanya, dan periksa apakah PDA `CreatorFeeShare` ada di `["creator_fee_share", creator, ammConfig]` sebelum mengutip pembayaran kreator. PDA yang tidak ada adalah kasus umum dan berarti default config berlaku.
</Note>

## Perbandingan dengan CLMM dan AMM v4

Lihat [`reference/fee-comparison`](/id/reference/fee-comparison) untuk matriks berdampingan. Ringkasan:

* **AMM v4** menggunakan biaya perdagangan tetap 0,25% dengan pembagian LP/protokol yang berbeda dan tidak ada biaya dana.
* **CLMM** biaya adalah per-tick-spacing tier, terakumulasi per-posisi (bukan per-pool), dan diklaim melalui `DecreaseLiquidity` atau `CollectFees`.

## Ke mana selanjutnya

* [`products/cpmm/math`](/id/products/cpmm/math) — di mana pengurangan biaya perdagangan terhubung ke kurva.
* [`products/cpmm/instructions`](/id/products/cpmm/instructions) — daftar akun instruksi `Collect*`, termasuk akun `creator_fee_share` yang sekarang diperlukan oleh kedua jalur kreator.
* [`algorithms/token-2022-transfer-fees`](/id/algorithms/token-2022-transfer-fees) — cara menggabungkan biaya perdagangan pool dengan biaya transfer mint dengan benar.

Sumber:

* [`raydium-io/raydium-cp-swap` — `states/config.rs`, `states/pool.rs`, `states/curve.rs`](https://github.com/raydium-io/raydium-cp-swap)
* [Raydium API — `GET /main/cpmm-config`](https://api-v3.raydium.io/main/cpmm-config)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.