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

# Integrasi agregator

> Cara menemukan pool Raydium, memberikan kutipan di seluruh CPMM / CLMM / AMM v4, dan merutekan swap atomik melalui set program yang tepat. Ditulis untuk agregator DEX dan UI swap dompet.

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

  [Lihat versi bahasa Inggris →](/integration-guides/aggregator)
</Info>

<Info>
  Tugas agregator adalah memberikan pengguna harga terbaik yang mungkin di seluruh banyak pool, kemungkinan membagi satu input di beberapa rute pool, dan menjalankannya secara atomik. Halaman ini mendokumentasikan bagian spesifik Raydium dari tugas tersebut: penemuan, kutipan, dan perakitan transaksi.
</Info>

## Penemuan

### Inventaris pool

Anda memerlukan daftar lengkap pool Raydium aktif untuk setiap produk. Tiga pilihan:

1. **REST API** (paling sederhana): `GET https://api-v3.raydium.io/pools/info/list?poolType=all&pageSize=1000&page=1` mengembalikan pool dalam batch 1000. Paginate hingga Anda memiliki semuanya. Cache selama 1–5 menit.
2. **Pemindaian on-chain**: `getProgramAccounts` pada ID program CPMM, CLMM, dan AMM v4, disaring berdasarkan diskriminator akun status. Menghasilkan \~setiap pool aktif dengan \~10 detik waktu RPC. Berguna ketika API sedang down atau rate-limited.
3. **Hibrida**: gunakan API sebagai sumber utama; jalankan pemindaian on-chain harian sebagai pemeriksaan kewarasan. Tim berkomitmen untuk menjaga API tetap komprehensif, tetapi pool yang dibuat melalui CPI langsung (tanpa frontend) kadang-kadang dapat tertinggal.

### Pencarian pasangan mint

Untuk pasangan `(mintA, mintB)` tertentu, gunakan `GET /pools/info/mint?mint1=...&mint2=...&poolType=all&sort=liquidity`. Mengembalikan setiap pool pada tingkat biaya dan jenis produk apa pun. Hingga \~10 hasil per pasangan adalah umum pada mint yang banyak lalu lintas; urutkan berdasarkan TVL dan ambil beberapa teratas untuk perutean.

## Kutipan

Matematika kutipan berbeda per produk. Gunakan fungsi matematika murni SDK sehingga Anda tidak perlu mengimplementasikan ulang:

<Warning>
  Ketiga produk **tidak** berbagi satu tanda tangan. `computeAmountOut` hanya ada di
  `raydium.liquidity` (AMM v4) dan sebagai `PoolUtils.computeAmountOut(Format)` untuk CLMM; setara CPMM
  disebut `computeSwapAmount` dan mengambil parameter berbeda. Tulis ketiga panggilan
  secara eksplisit daripada parameterisasi atas produk.
</Warning>

```ts theme={null}
// CPMM — computeSwapAmount, dan `pool` harus CpmmComputeData dari getPoolInfoFromRpc
const { computePoolInfo } = await raydium.cpmm.getPoolInfoFromRpc(cpmmPoolId);   // base58 string
const cpmmQuote = raydium.cpmm.computeSwapAmount({
  pool: computePoolInfo,
  amountIn,
  outputMint: mintOut,
  slippage: 0,        // compute exact expected; layer slippage at route level
});
// -> { allTrade, amountIn, amountOut, minAmountOut, fee, executionPrice, priceImpact, swapResult }

// CLMM — crosses ticks; deterministic but more expensive.
// `poolInfo` harus ComputeClmmPoolInfo (the `computePoolInfo` dari
// clmm.getPoolInfoFromRpc), dan keduanya `tickarrayBitmapExtension` dan
// `blockTimestamp` diperlukan.
const { amountOut: clmmOut, remainingAccounts } = PoolUtils.computeAmountOutFormat({
  poolInfo:  computeClmmPoolInfo,
  tickarrayBitmapExtension,
  tickArrayCache,
  amountIn,
  tokenOut:  mintOutToken,
  slippage:  0,
  epochInfo: await raydium.fetchEpochInfo(),
  blockTimestamp: Math.floor(Date.now() / 1000),
});
// -> { amountOut, minAmountOut, fee, priceImpact, remainingAccounts, ... }

// AMM v4 — amountIn adalah BN, slippage adalah angka, dan return adalah BN biasa
const ammV4Quote = raydium.liquidity.computeAmountOut({
  poolInfo: ammV4Pool,       // needs baseReserve / quoteReserve / version / status spliced in
  amountIn,
  mintIn,
  mintOut,
  slippage: 0,
});
// -> { amountOut, minAmountOut, currentPrice, executionPrice, priceImpact, fee }
```

Untuk perbandingan agregator gunakan `amountOut` (pre-slippage) dari masing-masing.

### Kesegaran cache

Status pool menjadi usang dengan cepat. Target kesegaran yang direkomendasikan:

| Jenis pool | Frekuensi re-fetch | Alasan |
| - | - | - |
| CPMM dengan `<$100k` TVL | `<10s` | Cadangan bergerak pada setiap perdagangan. |
| CPMM dengan `>$10M` TVL | 30–60s | Cadangan dominan; perdagangan kecil adalah kebisingan. |
| CLMM | `<30s` | Batas tick; satu perdagangan besar dapat mengonfigurasi ulang likuiditas. |
| AMM v4 | `<30s` | Pergerakan sisi OpenBook tidak ditangkap dalam vault. |

Untuk agregator yang mengambil kutipan pada latensi interaktif, berlangganan pembaruan akun WebSocket (`accountSubscribe`) pada setiap status pool yang relevan. Itu membalik model dari polling ke push.

### Penyesuaian Token-2022

Jika ada mint dalam rute yang memiliki biaya transfer Token-2022, matematika kutipan harus menyesuaikan input dan output per [`algorithms/token-2022-transfer-fees`](/id/algorithms/token-2022-transfer-fees). SDK menangani ini jika `poolInfo.mintA.extensions.transferFeeConfig` diisi. Konfirmasi dengan melihat bidang `.extensions` sebelum mempercayai kutipan.

## Perutean

### Rute pool tunggal

Sebagian besar rute adalah pool tunggal. Pilih pool yang `amountOut` tertinggi. Jika beberapa dekat, tie-break berdasarkan tingkat biaya (lebih rendah lebih baik), kemudian berdasarkan TVL (lebih banyak lebih aman).

### Perutean terpisah

Untuk perdagangan besar di mana satu pool memiliki dampak harga >5%, pisahkan di seluruh pool. Algoritma greedy sederhana:

```
remaining = amountIn
routes    = []
while remaining > 0:
    best_pool, best_size = argmax over pools of:
        marginal_out_per_in(pool, current_size_toward_pool + epsilon)
    size = min(remaining, best_pool.max_size_at_target_impact)
    routes.append((best_pool, size))
    remaining -= size
```

Ini menghasilkan vektor perutean `[(pool_A, 0.6), (pool_B, 0.3), (pool_C, 0.1)]` yang meminimalkan dampak agregat. Solusi optimasi cembung yang tepat (misalnya menyamakan harga marginal di seluruh pool) berada dalam \~1% dari hasil greedy dalam praktik.

### Rute multi-hop

`USDC → RAY → SOL` melalui dua pool terpisah adalah umum ketika tidak ada pool `USDC-SOL` langsung yang memberikan kutipan yang baik (jarang). Terapkan batas slippage per-hop; setiap hop memberlakukan `minAmountOut` sendiri. Lihat [`algorithms/slippage-and-price-impact`](/id/algorithms/slippage-and-price-impact).

Multi-hop di seluruh pool yang sama (misalnya dua hop CLMM pada `SOL-USDC`) selalu suboptimal vs satu hop — jangan hasilkan rute seperti itu.

## Perakitan transaksi

### Single-hop, single-pool

Untuk satu pool, panggil builder swap jenis pool itu sendiri — `raydium.liquidity.swap`, `raydium.cpmm.swap` atau `raydium.clmm.swap`. `raydium.tradeV2.swap` adalah executor rute *multi-hop* dan mengambil bentuk yang sama sekali berbeda (`{ swapInfo, swapPoolKeys, routeProgram, ownerInfo, txVersion }`); tidak ada `raydium.trade`.

```ts theme={null}
const { execute } = await raydium.liquidity.swap({
  poolKeys:        poolInfo,
  amountIn,
  amountOut:       quote.minAmountOut,
  fixedSide:       "in",
  inputMint:       mintIn,
  txVersion:       TxVersion.V0,
  computeBudgetConfig: {
    units:         250_000,
    microLamports: priorityFee,
  },
});
```

### Terpisah dan multi-hop

Komposisi ATA + instruksi secara manual. Pola:

```
[1] ComputeBudget set_compute_unit_limit
[2] ComputeBudget set_compute_unit_price
[3] createATA (if needed, once per mint the user doesn't hold)
[4..N] SwapInstruction for each (pool, size) in routes
[N+1] CloseAccount (if you wrap/unwrap SOL)
```

Semuanya dalam satu transaksi untuk atomisitas. Untuk split 3-pool pada V0 dengan tabel pencarian alamat, ini biasanya cocok dalam \~1100 byte. Untuk 4+ pool, batas ukuran transaksi memaksa multi-tx atau konsolidasi di mint hub.

### Atomisitas

Agregator harus menjamin atomisitas: baik rute penuh mendarat atau tidak sama sekali. Instruksi swap Raydium revert pada `ExceededSlippage`, jadi rute multi-pool di mana satu hop gagal menyebabkan seluruh transaksi revert. Gratis.

Satu-satunya pengecualian: jika rute Anda melewati Raydium + DEX pihak ketiga, pastikan DEX itu juga memiliki model revert-on-slippage. Beberapa program mengabaikan batas slippage (jarang).

## Jebakan

### 1. Kutipan usang

Antara pengguna melihat "Anda menerima 125.43 RAY" dan transaksi mendarat, cadangan dapat bergeser. Re-fetch status pool segera sebelum pengiriman; re-quote; jika kutipan baru >1% lebih buruk, jeda dan re-konfirmasi dengan pengguna.

### 2. Daftar hitam pool

Beberapa pool Raydium adalah token scam dengan biaya transfer yang ditetapkan ke 99% atau dengan ekstensi non-transferable. REST API menandai ini (lihat bidang `tags`); lewati pool apa pun yang ditandai `scam` atau `honeypot`. Menjalankan pemeriksaan keamanan Anda sendiri di atas tag Raydium adalah bijaksana.

### 3. Persyaratan status observasi pada CLMM

CLMM `SwapV2` mengambil akun `observation_state`. SDK mengisinya untuk Anda; instruksi yang dibangun tangan sering lupa, yang menyebabkan program revert dengan `AccountNotFound`. Selalu sertakan.

### 4. Tabel pencarian alamat

Raydium memelihara tabel pencarian publik untuk akun yang paling sering digunakan (mint utama, ID program, AmmConfigs). Agregator harus mengonsumsi ini — menghemat \~100 byte per transaksi dan memungkinkan rute yang lebih besar untuk cocok di V0. Menarik alamat LUT:

```ts theme={null}
const raydiumLUTs = await raydium.getRaydiumLutAddresses();
```

### 5. Menangani kemacetan

Selama jendela volume tinggi, transaksi dapat duduk di mempool selama beberapa blok. Retry agresif pada TX expiry (bukan pada revert — revert bersifat deterministik) direkomendasikan. Opsi `sendAndConfirm` SDK melakukan retry dasar; agregator produksi melapisi logika mereka sendiri (bundle Jito, broadcast multi-RPC) di atas.

## Daftar periksa

Sebelum go live, verifikasi:

* [ ] Penemuan pool mencakup CPMM + CLMM + AMM v4 secara komprehensif.
* [ ] Kutipan cocok dengan kutipan UI Raydium sendiri dalam 1 basis poin pada beberapa perdagangan uji.
* [ ] Perutean terpisah dimulai untuk perdagangan >5% dampak pada pool tunggal apa pun.
* [ ] Biaya prioritas diukur terhadap biaya program pool terbaru (lihat [`integration-guides/priority-fee-tuning`](/id/integration-guides/priority-fee-tuning)).
* [ ] Biaya transfer Token-2022 dihitung dan ditampilkan kepada pengguna.
* [ ] Transaksi revert dengan bersih ketika slippage terlampaui.
* [ ] Logika retry membedakan tx expiry (retry) dari revert (jangan retry).

## Penunjuk

* [`integration-guides/routing-and-mev`](/id/integration-guides/routing-and-mev) — ketahanan sandwich, bundle.
* [`integration-guides/priority-fee-tuning`](/id/integration-guides/priority-fee-tuning) — ukuran instruksi compute-budget.
* [`sdk-api/rest-api`](/id/sdk-api/rest-api) — endpoint daftar pool.

Sumber:

* [Modul `trade` Raydium SDK v2](https://github.com/raydium-io/raydium-sdk-V2)


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