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

# Matematika Stable AMM

> Pencarian biner dan interpolasi linier untuk mengutip harga dari tabel pencarian. Penerapan biaya identik dengan AMM v4. Akuntansi pool murni-AMM setelah pemisahan OpenBook.

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

  [Lihat versi bahasa Inggris →](/products/stable/math)
</Info>

## Kurva tabel pencarian

Stable AMM menggantikan formula x·y=k dengan **tabel pencarian sparse** dari tuple (x, y, price). Saat menentukan harga swap, program:

1. Menghitung rasio pool saat ini dari cadangan.
2. **Mencari secara biner** tabel untuk menemukan dua entri yang membatasi rasio tersebut.
3. **Menginterpolasi secara linier** di antara keduanya untuk mendapatkan harga perantara.
4. Menerapkan biaya dan mengembalikan kutipan.

Pendekatan ini menukar determinisme formula dengan **fleksibilitas admin** dalam pembentukan harga, dan cukup efisien untuk masuk dalam anggaran komputasi Solana.

## Tata letak tabel dan pencarian biner

`ModelDataInfo` menyimpan hingga 50.000 entri `DataElement`, diindeks oleh admin. Hanya `valid_data_count` pertama yang aktif. Setiap entri:

```
DataElement {
  x: u64,      // Koordinat X (jumlah sisi koin, diskalakan)
  y: u64,      // Koordinat Y (jumlah sisi pc, diskalakan)
  price: u64,  // price = x/y, diskalakan oleh multiplier
}
```

Untuk menemukan harga pada cadangan pool saat ini (x\_real, y\_real):

1. Hitung rasio: `target_ratio = (x_real * multiplier) / y_real`.
2. Cari secara biner entri di mana `(element.x * multiplier) / element.y` membatasi `target_ratio`.
3. Ketika bracket `[min_idx, max_idx]` ditemukan, interpolasi.

Kode pencarian biner program mencakup \~150 baris di `state.rs::ModelDataInfo::get_mininum_range_by_xy_real`. Invarian kunci: **entri harus diurutkan** (x naik, y turun, price naik) agar pencarian berfungsi.

## Interpolasi linier

Setelah dua titik tabel membatasi rasio, interpolasi menghitung harga perantara dan pasangan cadangan:

```
target = (x_real * multiplier) / y_real

[x1, y1, p1] = table[min_idx]
[x2, y2, p2] = table[max_idx]

// Interpolasi harga
p = p1 + (p2 - p1) * (target - ratio1) / (ratio2 - ratio1)

// Interpolasi cadangan
x = x1 + (x2 - x1) * (target - ratio1) / (ratio2 - ratio1)
y = y1 + (y2 - y1) * (target - ratio1) / (ratio2 - ratio1)
```

Hasilnya adalah kurva piecewise-linear yang menghubungkan titik tabel dengan mulus.

## Penskalaan: multiplier

Cadangan pool dan harga disimpan pada skala berbeda. Bidang `multiplier` pada `ModelDataInfo` memperhitungkan hal ini. Pola umum:

* Coin memiliki 6 desimal, PC memiliki 18 desimal.
* Multiplier = 10^6 (atau serupa).
* Entri tabel disimpan pada skala berkurang agar sesuai dengan batas u64.

Program menskalakan ulang saat membaca/menulis melalui:

```
real_value = table_value * ratio / multiplier
table_value = real_value * multiplier / ratio
```

## Penetapan harga swap: `SwapBaseIn` dan `SwapBaseOut`

### SwapBaseIn (input tepat)

Diberikan jumlah input `amount_in`:

1. Dapatkan rasio saat ini dari `(coin_vault, pc_vault)`.
2. Temukan entri tabel yang membatasi dan interpolasi untuk mendapatkan rasio ruang tabel.
3. Konversi input ke ruang tabel: `dx_table = amount_in * multiplier / ratio`.
4. Kueri tabel pada koordinat X baru untuk menemukan Y baru.
5. `dy_table = y_old - y_new`.
6. Konversi kembali: `dy_real = dy_table * ratio / multiplier`.
7. Terapkan biaya perdagangan: `dy_output = dy_real - (dy_real * trade_fee_numerator / trade_fee_denominator)`.
8. Kembalikan `dy_output`.

### SwapBaseOut (output tepat)

Simetris: diberikan `amount_out` yang diinginkan, selesaikan `amount_in` yang diperlukan.

Kedua jalur membaca cadangan efektif langsung dari vault pool. Pool tidak menyimpan pesanan terbuka OpenBook selama bertahun-tahun, jadi tidak ada yang perlu diselesaikan terlebih dahulu — saldo vault adalah seluruh ceritanya. (Upgrade [2026-06-22](/id/reference/changelog) menghapus kode pasar sisa.)

## Penerapan biaya

Identik dengan AMM v4: lihat [`products/amm-v4/math`](/id/products/amm-v4/math) untuk penurunan lengkap.

```
gross_fee = amount_in * (swap_fee_numerator / swap_fee_denominator)    // mis., 0,25%
lp_portion = gross_fee - (gross_fee * pnl_numerator / pnl_denominator) // mis., 0,22%
pnl_portion = gross_fee * (pnl_numerator / pnl_denominator)            // mis., 0,03%
```

`pnl_portion` masuk ke `need_take_pnl_*` dan disapu oleh admin melalui `WithdrawPnl`. `lp_portion` tetap di vault, menginflasi `k` dan menguntungkan pemegang token LP.

## Akuntansi aset pool

Formula secara historis menambahkan dana yang dipegang pool sebagai pesanan terbuka di akun OpenOrders OpenBook-nya. Istilah itu telah menjadi nol dalam praktik sejak pool berhenti memposting pesanan, dan upgrade 2026-06-22 menghapusnya sepenuhnya dari formula, meninggalkan perhitungan vault-only:

```
Lama: total aset = saldo vault + dana pesanan terbuka (native_coin_total / native_pc_total) − PnL tertunda (need_take_pnl)
Baru: total aset = saldo vault − PnL tertunda (need_take_pnl)
```

Ini adalah nilai yang diperlakukan matematika kurva sebagai cadangan efektif (bagian `need_take_pnl` yang terakumulasi tetapi belum disapu secara fisik berada di vault tetapi dikecualikan dari penetapan harga). Kode kutipan dan pengindeks yang sebelumnya membaca saldo OpenOrders harus menghapus istilah itu.

## MonitorStep (dihapus)

`MonitorStep` adalah **instruksi crank** yang menyelesaikan pengisian OpenBook yang tertunda, menghitung ulang `AmmInfo.target_orders`, dan memposting ulang grid pesanan batas yang berasal dari tabel pencarian. Pool berhenti memposting pesanan ke OpenBook bertahun-tahun yang lalu, jadi crank tidak memiliki apa pun untuk dilakukan; itu **dihapus dalam upgrade 2026-06-22**. Integrator tidak perlu melakukan crank pada pool Stable.

## Ringkasan: mengapa ini berfungsi

Desain tabel pencarian + interpolasi adalah **efisien dan fleksibel**:

* **Efisiensi:** Pencarian biner adalah O(log 50.000) ≈ 16 iterasi, masing-masing \~ 300–500 CU. Interpolasi adalah beberapa perkalian/pembagian. Total biaya kutipan adalah \~5k–15k CU, jauh lebih murah daripada menghitung ulang formula pada setiap swap.
* **Fleksibilitas:** Admin dapat mengkodekan kurva piecewise-linear apa pun. Pasangan stablecoin mendapat kepadatan tinggi sekitar 1:1; pasangan berjaminan mendapat kurva khusus.
* **Likuiditas mandiri:** Semua dana hidup di vault pool dan penetapan harga membacanya langsung — tidak ada crank, tidak ada buku pesanan eksternal, lebih sedikit akun per transaksi.

Untuk pendalaman logika interpolasi, lihat `raydium-stable/program/src/state.rs`, metode `get_data_by_x`, `get_data_by_y`, `get_dy_by_dx_base_in`, dll.

## Ke mana selanjutnya

* [Akun](/id/products/stable/accounts) — referensi bidang `ModelDataInfo` dan `DataElement`.
* [Instruksi](/id/products/stable/instructions) — set yang dapat dipanggil (swap, deposit, withdraw, `WithdrawPnl`) dan instruksi yang dihapus.
* [Biaya](/id/products/stable/fees) — penerapan biaya dan `WithdrawPnl`.
* [`products/amm-v4/math`](/id/products/amm-v4/math) — untuk logika penetapan harga pesanan inklusif biaya OpenBook.

Sumber:

* `raydium-stable/program/src/state.rs` (implementasi interpolasi dan pencarian biner)
* `raydium-stable/program/src/math.rs` (utilitas kalkulator)