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

# Program dan Anchor

> Cara program Solana dikerahkan dan ditingkatkan, apa yang ditambahkan kerangka Anchor di atas model program asli Solana, dan cara membaca IDL Raydium untuk menghasilkan klien Anda sendiri.

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

  [Lihat versi bahasa Inggris →](/solana-fundamentals/programs-and-anchor)
</Info>

Program Raydium yang lebih baru (CPMM, CLMM, Farm v6, LaunchLab) ditulis dalam **Anchor** — kerangka Rust yang dibangun di atas model program asli Solana untuk memberikan validasi akun, penanganan kesalahan, dan IDL (deskripsi antarmuka). AMM v4 dan farm yang lebih lama mendahului Anchor. Memahami kedua paradigma ini membantu Anda membaca kode, menghasilkan klien dari IDL, dan men-debug kesalahan yang tidak terduga.

## Model penyebaran program

Setiap program Solana tinggal di sebuah `Pubkey`. Bytecode program disimpan dalam akun **executable** yang dimiliki oleh **BPF Upgradable Loader** (`BPFLoaderUpgradeab1e11111111111111111111111`).

Penyebaran program terdiri dari tiga akun:

1. **Akun Program**: akun metadata kecil di ID program. Pemilik: BPF Upgradable Loader.
2. **Akun ProgramData**: menyimpan bytecode sebenarnya. Diturunkan sebagai `[program_id, "programdata"]`.
3. **Akun Buffer** (sementara): menyimpan bytecode baru selama peningkatan. Dibuang setelah peningkatan.

Akun ProgramData memiliki **upgrade authority** — kunci yang dapat mengganti bytecode dengan versi baru. Upgrade authority Raydium adalah multisig di balik timelock 24 jam; lihat [`security/admin-and-multisig`](/id/security/admin-and-multisig).

### Memverifikasi program yang dikerahkan

Untuk mengonfirmasi apa yang ada di chain cocok dengan apa yang ada di sumber yang disetujui audit:

```bash theme={null}
# Dump program dari mainnet
solana program dump CPMMoo8L3F4NbTegBCKVNunggL7H1Zpdmwpwh8KMoZ0F cpmm-onchain.so

# Build dari sumber yang diketahui
cargo build-bpf --manifest-path raydium-cp-swap/programs/cp-amm/Cargo.toml
cp target/deploy/raydium_cp_swap.so cpmm-source.so

# Bandingkan
sha256sum cpmm-onchain.so cpmm-source.so
```

Hash yang cocok membuktikan Anda berinteraksi dengan sumber yang Anda pikir. Raydium menerbitkan instruksi build terverifikasi di catatan rilis.

## Anchor: kerangka di atas Solana

Program Solana mentah adalah fungsi Rust dengan tanda tangan ini:

```rust theme={null}
pub fn process_instruction(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    instruction_data: &[u8],
) -> ProgramResult {
    // Parsing instruction_data secara manual
    // Validasi akun secara manual
    // Deserialize data akun secara manual
    // Periksa flag signer/writable secara manual
    // ... kemudian lakukan pekerjaan sebenarnya
}
```

Anchor membungkus semua boilerplate dan memungkinkan Anda menulis:

```rust theme={null}
#[program]
pub mod cpmm {
    use super::*;

    pub fn swap_base_input(
        ctx: Context<Swap>,
        amount_in: u64,
        min_out: u64,
    ) -> Result<()> {
        // Hanya logika bisnis — ctx sudah tervalidasi
    }
}

#[derive(Accounts)]
pub struct Swap<'info> {
    pub payer: Signer<'info>,
    #[account(mut, seeds = [b"pool", config.key().as_ref(), ...], bump)]
    pub pool_state: AccountLoader<'info, PoolState>,
    #[account(mut)]
    pub input_vault: Box<Account<'info, TokenAccount>>,
    // ... lebih banyak akun
}
```

Anchor:

* Menghasilkan secara otomatis **discriminator** 8-byte deterministik untuk setiap instruksi dan tipe akun.
* Memvalidasi batasan akun (pemilik, seeds, writable, signer, mint-matches, token-program-matches) sebelum kode Anda berjalan.
* Menghasilkan **IDL** — berkas deskripsi antarmuka yang digunakan klien untuk memanggil program.
* Dilengkapi dengan perpustakaan klien Rust, TypeScript, dan Python.

### Discriminator 8-byte

Setiap akun Anchor dan setiap instruksi Anchor dimulai dengan discriminator 8-byte — 8 byte pertama dari SHA-256 dari string tetap:

```
Discriminator akun:      sha256("account:PoolState")[0..8]
Discriminator instruksi: sha256("global:swap_base_input")[0..8]
```

Ketika Anda memanggil instruksi Anchor, 8 byte pertama dari data instruksi adalah discriminator ini; Anchor mengirim ke penangan yang tepat dengan mencarinya.

Ketika Anda membaca akun Anchor, 8 byte pertama memberi tahu Anda jenisnya — penting untuk alat seperti `getProgramAccounts` yang menghitung semua akun dari tipe tertentu.

### Kesalahan

Program Anchor mendefinisikan kesalahan melalui `#[error_code]`:

```rust theme={null}
#[error_code]
pub enum ErrorCode {
    #[msg("Slippage tolerance exceeded")]
    SlippageExceeded,
    #[msg("Pool is disabled")]
    PoolDisabled,
    // ...
}
```

Anchor secara otomatis menetapkan kode numerik ini mulai dari 6000 (0x1770). Tabel kode kesalahan lengkap Raydium ada di [`reference/error-codes`](/id/reference/error-codes).

## IDL

Berkas Anchor **IDL** (Interface Description Language) adalah deskripsi JSON dari program: instruksi, akun, tipe, kesalahan, dan acara. Ini setara dengan ABI Ethereum.

Raydium menerbitkan IDL untuk semua program Anchor. Ambil secara langsung dari on-chain:

```bash theme={null}
anchor idl fetch CPMMoo8L3F4NbTegBCKVNunggL7H1Zpdmwpwh8KMoZ0F -o cpmm.idl.json
```

Atau dari sumber SDK: `src/raydium/*/idl/*.json`.

### Struktur IDL

```json theme={null}
{
  "version":      "0.1.0",
  "name":         "raydium_cp_swap",
  "instructions": [ { "name": "swap_base_input", "accounts": [ ... ], "args": [ ... ] }, ... ],
  "accounts":     [ { "name": "PoolState", "type": { ... } }, ... ],
  "types":        [ { "name": "AmmConfig", "type": { ... } }, ... ],
  "errors":       [ { "code": 6000, "name": "SlippageExceeded", "msg": "..." }, ... ],
  "events":       [ { "name": "SwapEvent", "fields": [ ... ] }, ... ]
}
```

### Menghasilkan klien dari IDL

CLI Anchor `anchor` menghasilkan tipe TypeScript dan Rust:

```bash theme={null}
anchor idl build -o target/idl/cpmm.json
# Tipe TypeScript yang dihasilkan secara otomatis oleh ts-client Anchor
# SDK Raydium sudah menyertakan ini
```

Alat pihak ketiga seperti [Kinobi](https://github.com/metaplex-foundation/kinobi) dapat menghasilkan klien Rust, Python, C, atau Go dari IDL.

### Ketika IDL adalah teman Anda

Jika Anda ingin membangun integrasi khusus yang tidak melalui SDK Raydium:

1. Ambil IDL (langsung dari on-chain atau dari sumber SDK).
2. Cari instruksi yang Anda inginkan (misalnya, `swap_base_input`).
3. Konstruksikan data instruksi: discriminator 8-byte + argumen yang dikodekan.
4. Lewatkan akun dalam urutan yang ditentukan IDL.

Lihat [`sdk-api/anchor-idl`](/id/sdk-api/anchor-idl) untuk contoh kerja.

## Program pra-Anchor: AMM v4 dan Farm v3/v5

Program ini mendahului Anchor. Mereka menggunakan:

* **Pengiriman instruksi manual**: tag `u8` dalam `instruction_data` dengan pernyataan `match`.
* **Validasi akun manual**: `if accounts[0].owner != &expected_program { ... }`.
* **Argumen instruksi yang diserialisasi Borsh**: tidak ada discriminator, hanya `instruction_data[1..]`.
* **Layout melalui `#[repr(C, packed)]`**: tata letak biner struct C.

SDK Raydium v2 dilengkapi dengan tata letak TypeScript untuk instruksi AMM v4 non-Anchor sehingga klien dapat mengenkode/mendekode tanpa Anchor:

```ts theme={null}
import { liquidityStateV4Layout, swapInstructionData }
  from "@raydium-io/raydium-sdk-v2";

const data = swapInstructionData.encode({
  instruction: 9,   // swap
  amountIn:    1_000_000n,
  minAmountOut: 950_000n,
});
```

Pola integrasi sama — Anda hanya tidak mendapatkan pembuatan otomatis yang didorong IDL Anchor.

## Mekanik peningkatan program

Hanya `upgrade_authority` ProgramData yang dapat meningkatkan. Langkah-langkahnya:

1. Kompilasi bytecode baru.
2. Tuliskan ke akun buffer (`solana program write-buffer`).
3. Kirim instruksi peningkatan: `BpfLoaderUpgradeable::Upgrade { buffer, program, authority }`.
4. Runtime secara atomik mengganti bytecode program dengan isi buffer.

Raydium membatasi ini di balik **timelock 24 jam** yang diimplementasikan dalam pengaturan multisig Squads. Transaksi peningkatan harus menunggu 24 jam setelah persetujuan multisig sebelum eksekusi. Ini melindungi dari peningkatan yang terburu-buru / dipaksa.

Lihat [`security/admin-and-multisig`](/id/security/admin-and-multisig).

### Membuat program tidak dapat diubah

Upgrade authority dapat diatur ke `None`, di mana program menjadi selamanya tidak dapat diubah. Raydium belum melakukan ini untuk produk apa pun — tim mempertahankan kemampuan untuk mendorong perbaikan keamanan. Trade-off: pengguna harus mempercayai proses multisig + timelock.

## Program dan sewa

Menyebarkan program mengkonsumsi lamport yang bebas sewa:

* Program 50 KB: \~0,35 SOL dalam sewa.
* Program 200 KB: \~1,4 SOL dalam sewa.

Menutup program (melalui `solana program close`) mengembalikan lamport. Program Raydium tetap aktif dan tidak dijadwalkan untuk ditutup.

## Program Anchor untuk debugging

### Output log

Makro `msg!` Anchor menulis ke log transaksi. Simulasikan transaksi untuk melihat log:

```ts theme={null}
const sim = await connection.simulateTransaction(tx);
console.log(sim.value.logs);
```

Log mencakup:

* Pemanggilan program (`Program CPMMoo8... invoke [1]`).
* Panggilan `msg!` dari kode program.
* Konsumsi unit komputasi (`consumed 137842 of 400000 compute units`).
* Keberhasilan atau kesalahan program.

### Kode kesalahan

Jika program Anchor melempar, log menampilkan:

```
Program CPMMoo8... failed: custom program error: 0x1770
```

0x1770 = 6000 desimal = kesalahan Anchor pertama (misalnya, `SlippageExceeded`). Referensi silang dengan array `errors` IDL.

Lihat [`reference/error-codes`](/id/reference/error-codes) untuk tabel kesalahan lengkap Raydium.

### Ketidakcocokan tata letak akun

Jika Anda melewatkan akun yang salah di slot yang salah, makro validasi akun Anchor mengembalikan kesalahan seperti:

```
AnchorError: AccountNotInitialized. Error Number: 3012
```

Nomor kesalahan di bawah 6000 adalah kesalahan bawaan Anchor (lihat enum `ErrorCode` Anchor); kesalahan ≥6000 adalah kode khusus program.

## Penunjuk

* [`solana-fundamentals/account-model`](/id/solana-fundamentals/account-model) — cara program memiliki akun.
* [`solana-fundamentals/pdas-and-cpis`](/id/solana-fundamentals/pdas-and-cpis) — PDA seperti yang dideklarasikan Anchor.
* [`sdk-api/anchor-idl`](/id/sdk-api/anchor-idl) — mengambil dan menggunakan IDL Raydium.
* [`reference/program-addresses`](/id/reference/program-addresses) — ID program.
* [`reference/error-codes`](/id/reference/error-codes) — referensi kode kesalahan.
* [`security/admin-and-multisig`](/id/security/admin-and-multisig) — kontrol upgrade-authority.

Sumber:

* [Buku Anchor](https://book.anchor-lang.com).
* [Penyebaran program Solana](https://docs.solana.com/cli/deploy-a-program).
* IDL Raydium (diterbitkan di SDK `src/raydium/*/idl/*.json`).