Panduan Anchor Framework Solana

Anchor Framework Solana membantu pengembang membangun program dengan validasi akun terstruktur, definisi instruksi, antarmuka yang dihasilkan, dan pemeriksaan keamanan yang dapat digunakan kembali.

Catatan versi: Versi Anchor, Rust, Solana CLI, dan klien JavaScript berubah secara independen. Verifikasi kompatibilitas saat ini di dokumentasi resmi Anchor sebelum menginstal atau menerapkan.

Artikel ini hanya untuk tujuan edukasi dan bukan merupakan saran keuangan atau investasi. Investasi mata uang kripto mengandung risiko yang signifikan. Selalu lakukan riset Anda sendiri sebelum membuat keputusan investasi.

📌 CATATAN: Panduan ini menggunakan Anchor v0.29.x dan Solana CLI v1.18.x+, berlaku per 2024. Anchor Framework berkembang pesat. Jalankan anchor --version untuk memverifikasi versi yang Anda instal sebelum mengikuti instruksi ini.

Daftar Isi

1. Apa Itu Anchor Framework Solana?
2. Model Akun Solana
3. Komponen Inti dari Anchor Framework Solana
4. Prasyarat
5. Cara Menginstal Anchor Framework
6. Membangun dan Menerapkan Program Anchor Pertama Anda
7. Menguji Program Anchor
8. Anchor vs Alternatif
9. Keamanan Anchor Framework
10. Pemecahan Masalah Kesalahan Umum Anchor
11. Anchor Framework dan Ekosistem Pengembang Solana
12. Pertanyaan Umum
13. Kesimpulan

Apa Itu Anchor Framework Solana?

Anchor Framework Solana adalah kerangka kerja pengembangan sumber terbuka yang menghilangkan boilerplate dan kompleksitas validasi akun dalam penulisan program Solana (setara dengan kontrak pintar secara on-chain) dalam Rust mentah.

Solana adalah blockchain Lapisan 1 berkinerja tinggi yang memproses sekitar 65.000 transaksi per detik dalam kondisi optimal (per 2024), dengan finalitas sub-detik dan biaya biasanya di bawah $0,001. Solana mencapai throughput ini sebagian melalui mekanisme konsensus unik yang disebut Proof of History (PoH), yang menciptakan jam kriptografi yang mengurutkan transaksi tanpa overhead komunikasi dari protokol konsensus tradisional.

Membangun di atas Solana tanpa kerangka kerja berarti menulis kode Rust tingkat rendah yang sangat panjang untuk setiap program. Pengembang harus memvalidasi kepemilikan akun secara manual, menserialisasi data, menangani kesalahan, dan mengelola hubungan akun untuk setiap transaksi tunggal. Bagi insinyur yang berasal dari backend Web2 atau pengembangan Ethereum, hambatan pembelajaran ini cukup terjal untuk menghentikan sebagian besar proyek sebelum dimulai.

Anchor mengubah hal itu. Bayangkan Anchor sebagai Ruby on Rails bagi pengembangan Solana: sebuah kerangka kerja yang berpendirian (opinionated) yang menangani infrastruktur dasar sehingga Anda dapat fokus pada logika program Anda daripada infrastruktur di bawahnya. Anchor dibuat oleh Armani Ferrante dan dikelola oleh Coral XYZ. Anda dapat menemukan kode sumber dan rilisnya di repositori GitHub Anchor (coral-xyz/anchor).. Versi stabil saat ini adalah v0.29.x.

Anchor memungkinkan pengembang untuk membangun aplikasi terdesentralisasi (dApps). dApp adalah aplikasi yang logika back-end-nya berjalan di blockchain melalui program Solana, bukan di server terpusat. Program tersebut adalah back end dApp; klien TypeScript yang dihasilkan Anchor adalah cara front end Anda memanggilnya. Kategori dApp yang dibangun dengan Anchor meliputi protokol Keuangan Terdesentralisasi (DeFi), platform Token Non-Fungible (NFT), organisasi otonom terdesentralisasi (DAO), dan game Web3.

Di akhir panduan ini, Anda akan memahami arsitektur inti Anchor, memiliki lingkungan pengembangan yang berfungsi, telah menerapkan program ke devnet Solana (jaringan pengujian dengan SOL gratis tanpa nilai), dan memiliki konteks yang cukup untuk mengevaluasi apakah Anchor sesuai untuk proyek Anda. Untuk melihat langsung perbandingan Anchor dengan perkakas Ethereum dan pengembangan Rust asli, lihat perbandingan Anchor dengan Hardhat Ethereum dan pengembangan Rust asli.

Apa yang akan Anda pelajari:

• Apa itu Solana dan mengapa arsitekturnya membuat Anchor diperlukan
• Apa fungsi IDL, makro, dan PDA masing-masing, dan bagaimana program saling memanggil
• Cara menginstal lingkungan pengembangan Anchor lengkap
• Cara menulis dan menerapkan program Anchor pertama Anda
• Kerentanan keamanan yang harus dihindari sebelum meluncurkan ke mainnet
• Cara memecahkan masalah kesalahan Anchor yang paling umum

Model Akun Solana: Fondasi yang Perlu Anda Pahami Terlebih Dahulu

Model akun Solana adalah fondasi arsitektur yang membuat Anchor diperlukan. Model ini benar-benar berbeda dari apa pun yang Anda temui dalam pengembangan Ethereum atau Web2. Sebelum abstraksi Anchor dapat dipahami, Anda perlu memahami masalah yang diselesaikannya.

Apa Itu Solana

Solana adalah jaringan blockchain Lapisan 1 yang dirancang untuk throughput tinggi dan biaya transaksi rendah. Tidak seperti Ethereum, yang memproses sekitar 15 hingga 30 transaksi per detik di mainnet, Solana memproses sekitar 65.000 transaksi per detik dalam kondisi optimal (per 2024). Biaya transaksi biasanya di bawah $0,001. Kombinasi kecepatan dan biaya ini membuat Solana sangat cocok untuk aplikasi yang memerlukan banyak transaksi kecil dan sering: sistem perdagangan DeFi, platform Minting NFT, dan game on-chain.

SOL adalah token asli Solana. SOL digunakan untuk membayar biaya transaksi dan untuk sewa (rent) yang harus dipertahankan oleh akun on-chain agar tetap hidup di jaringan. Setiap program yang Anda terapkan dan setiap akun yang dibuat program Anda memerlukan SOL untuk ada secara on-chain. Di devnet (jaringan uji gratis Solana), Anda mendapatkan airdrop SOL tanpa biaya.

Keunggulan kecepatan ini ada karena keputusan arsitektur yang membuat pengembangan Solana lebih sulit daripada pengembangan Ethereum pada tingkat dasar. Anchor menangani bagian-bagian sulit tersebut secara tepat.

Bagaimana Solana Menyimpan Program dan Data

Di Solana, "akun" bukanlah akun pengguna atau akun wallet dalam pengertian sehari-hari. Akun adalah unit penyimpanan di blockchain: wadah berbeda yang dapat menampung data, saldo SOL, atau kode program yang dapat dieksekusi.

Perbedaan arsitektur inti: di Solana, program (kode yang dapat dieksekusi) dan data (state) berada di akun yang terpisah. Program bersifat stateless. Akun program hanya berisi bytecode yang dikompilasi. Data berada di akun data terpisah yang dibaca dan ditulis oleh program.

Di Ethereum, kontrak pintar seperti apartemen mandiri: kode dan perabotan tinggal di ruang yang sama. Di Solana, sebuah program lebih seperti sebuah perusahaan dengan departemen terpisah: logika yang dapat dieksekusi tinggal di satu akun, dan data yang dibaca serta ditulisnya tinggal di akun-akun lain sepenuhnya.

Setiap akun Solana memiliki tiga properti: pemilik (program yang mengontrolnya), alamat Kunci Publik (identifikasi on-chain), dan saldo lamport (unit terkecil SOL, di mana 1 SOL setara dengan 1 miliar lamport). Akun data juga menyimpan data program yang telah diserialisasi.

Konsekuensi praktisnya: saat Anda memanggil program Solana, Anda harus secara eksplisit memberikan setiap akun yang akan dibaca atau ditulis oleh program tersebut. Anda harus membuktikan kepemilikan. Anda harus menyatakan akun mana yang dapat diubah (mutable). Anda harus memverifikasi akun mana yang merupakan penanda tangan (signer). Dalam Rust mentah, manajemen akun ini memerlukan ratusan baris kode validasi per program.

Manajemen akun secara eksplisit inilah yang menjadi masalah yang dirancang untuk diselesaikan oleh sistem batasan (constraint system) Anchor.

Komponen Utama dari Kerangka Kerja Solana Anchor: IDL, Makro, PDA, dan CPI

Anchor menyediakan empat mekanisme yang saling terhubung yang secara bersama-sama menghilangkan sebagian besar kompleksitas dalam pengembangan Solana mentah. Memahami masing-masing secara berurutan adalah prasyarat untuk menulis program pertama Anda.

IDL (Interface Definition Language): Kontrak Komunikasi Anchor

Anchor secara otomatis menghasilkan file JSON yang disebut Interface Definition Language (IDL) setiap kali Anda menjalankan anchor build. Anggap saja ini sebagai spesifikasi OpenAPI untuk program on-chain Anda: deskripsi yang dapat dibaca mesin dari setiap instruksi yang diterima program Anda, setiap akun yang diperlukan instruksi tersebut, dan setiap tipe data yang terlibat.

IDL bagi Anchor sama seperti ABI (Application Binary Interface) bagi kontrak Solidity di Ethereum. Jika Anda pernah membangun di Ethereum, Anda sudah tahu bagaimana ABI memungkinkan kode front-end memanggil fungsi kontrak dengan keamanan tipe (type safety). IDL Anchor melakukan hal yang sama untuk program Solana, dan itu dihasilkan secara otomatis dari kode Rust Anda. Anda tidak pernah menulisnya secara manual.

File IDL disimpan di target/idl/nama_program_anda.json setelah anchor build. Di sampingnya, Anchor menghasilkan target/types/nama_program_anda.ts, sebuah file tipe TypeScript yang diimpor oleh front-end atau skrip pengujian Anda untuk mendapatkan akses yang sepenuhnya bertipe ke instruksi program Anda.

IDL yang disingkat terlihat seperti ini:

{
  "version": "0.1.0",
  "name": "balance_tracker",
  "instructions": [
    {
      "name": "initialize",
      "accounts": [
        { "name": "balanceAccount", "isMut": true, "isSigner": false },
        { "name": "user",           "isMut": true, "isSigner": true  },
        { "name": "systemProgram",  "isMut": false, "isSigner": false }
      ],
      "args": []
    },
    {
      "name": "deposit",
      "accounts": [
        { "name": "balanceAccount", "isMut": true, "isSigner": false },
        { "name": "user",           "isMut": false, "isSigner": true }
      ],
      "args": [{ "name": "amount", "type": "u64" }]
    }
  ]
}

Klien TypeScript membaca IDL ini dan memberikan Anda panggilan metode yang sepenuhnya bertipe (program.methods.initialize() dan program.methods.deposit(amount)) tanpa penulisan antarmuka manual apa pun. Keahlian TypeScript Anda dapat diterapkan secara langsung di sini.

Makro Anchor: Bagaimana Anchor Menghilangkan Boilerplate

Anchor menyediakan serangkaian makro Rust, yang merupakan generator kode yang menulis logika validasi berulang untuk Anda. Makro dalam Rust adalah anotasi yang berkembang menjadi kode pada saat kompilasi. Makro Anchor menghasilkan kode validasi akun, serialisasi, dan penanganan kesalahan yang seharusnya Anda tulis secara manual.

Tiga makro membentuk inti dari setiap program Anchor:

#[program] menandai modul yang berisi fungsi penangan instruksi Anda. Anchor memperlakukan setiap fungsi publik dalam modul ini sebagai instruksi yang dapat dipanggil.

#[derive(Accounts)] menghasilkan kode validasi akun dari definisi struct Rust. Anda menyatakan akun mana yang dibutuhkan instruksi, dan Anchor menghasilkan kode untuk memverifikasi kepemilikan dan mutabilitas, ditambah tipe dari setiap akun, secara otomatis.

#[account] menandai struct sebagai tipe data akun yang dikelola Anchor dan menambahkan diskriminator 8-byte yang memungkinkan Anchor membedakan tipe akun Anda dari tipe akun lainnya.

Berikut adalah tampilan makro ini dalam konteks:

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(
        init,           // Anchor membuat akun ini (memvalidasi bahwa akun belum ada)
        payer = user,   // Akun 'user' mendanai Deposit bebas sewa (rent-exemption)
        space = 8 + 8   // diskriminator 8-byte + 8 byte untuk kolom total u64
    )]
    pub balance_account: Account<'info, BalanceAccount>,

    #[account(mut)]          // Menyatakan saldo lamport akun ini akan berubah
    pub user: Signer<'info>, // Tipe Signer: Anchor memverifikasi akun ini menandatangani transaksi

    pub system_program: Program<'info, System>,
}

Batasan Akun (Account Constraints): Bagaimana Anchor Memvalidasi Akun Secara Otomatis

Setiap atribut di dalam #[account(...)] adalah batasan Anchor. Batasan adalah aturan validasi yang berjalan secara otomatis sebelum logika instruksi Anda dijalankan. Ini adalah alasan utama mengapa program Anchor memerlukan jauh lebih sedikit kode validasi manual daripada program Rust mentah.

Batasan yang paling umum adalah:

#[derive(Accounts)]
pub struct ExampleAccounts<'info> {
    #[account(init, payer = user, space = 8 + 8)]
    // init: membuat akun; dibatalkan jika akun sudah ada
    pub new_account: Account<'info, MyData>,

    #[account(mut)]
    // mut: menyatakan data atau saldo lamport akun ini akan berubah
    pub existing_account: Account<'info, MyData>,

    #[account(seeds = [b"vault", user.key().as_ref()], bump)]
    // seeds + bump: menurunkan alamat PDA dan memverifikasi bump kanonik
    pub pda_account: Account<'info, VaultData>,

    #[account(constraint = user_account.authority == user.key())]
    // constraint: mengevaluasi ekspresi boolean; gagal jika salah
    pub user_account: Account<'info, UserData>,

pub user: Signer<'info>,
// Signer: memverifikasi bahwa akun telah menandatangani transaksi

}

Tanpa batasan, Anda harus menulis masing-masing pemeriksaan ini secara manual di dalam badan instruksi Anda. Dengan batasan, Anchor memberlakukannya sebelum logika instruksi Anda berjalan. Ini merupakan peningkatan produktivitas sekaligus fitur keamanan, karena batasan lebih sulit dilupakan daripada pemeriksaan manual yang tersembunyi di dalam kode instruksi.

### Program Derived Addresses (PDA): Penyimpanan On-Chain Deterministik

Program Derived Address (PDA) adalah salah satu konsep yang lebih rumit dalam pengembangan Solana. Rencanakan untuk membaca bagian ini dua kali. PDA membuka salah satu pola Solana yang paling kuat, dan Anchor membuatnya jauh lebih mudah dikelola daripada Rust mentah.

PDA adalah alamat akun yang diturunkan secara deterministik dari sekumpulan seed dan ID program. Tidak seperti alamat dompet normal, PDA tidak memiliki Kunci Pribadi yang sesuai. Tidak ada pengguna individu yang dapat menandatangani untuk PDA. Hanya program pemilik yang dapat mengotorisasi transaksi yang melibatkannya.

Bayangkan PDA seperti kotak simpanan aman yang hanya bisa dibuka oleh Bank (program). Tidak ada nasabah yang memiliki kuncinya; Bank mengontrol akses secara terprogram. Hal ini membuat PDA ideal untuk brankas yang dikendalikan program, akun escrow, dan penyimpanan khusus pengguna di mana program, bukan pengguna, yang harus memiliki otoritas.

Dalam Rust mentah, menurunkan PDA memerlukan pemanggilan `Pubkey::find_program_address(&seeds, &program_id)` dan memverifikasi hasilnya secara manual. Anchor menangani ini dengan batasan `seeds`:

#[derive(Accounts)]
pub struct CreateVault<'info> {
    #[account(
        init,
        payer = authority,
        space = 8 + 32,
        seeds = [b"vault", authority.key().as_ref()], // Seed menentukan alamat PDA
        bump                 // Anchor menemukan dan menyimpan seed bump kanonik
    )]
    pub vault: Account<'info, Vault>,   // Akun PDA, tanpa kunci pribadi

    #[account(mut)]
    pub authority: Signer<'info>,

    pub system_program: Program<'info, System>,
}

Kendala seeds memberitahu Anchor cara menurunkan alamat PDA. Field bump menyimpan seed bump kanonik, bilangan bulat kecil yang memastikan alamat yang diturunkan keluar dari kurva eliptik dan tidak memiliki Kunci Pribadi. Di Anchor v0.29.x, bump kanonik diturunkan dan diverifikasi secara otomatis.

PDA bersifat deterministik: dengan seeds dan ID program yang sama, mereka selalu menghasilkan alamat yang sama. Properti ini memungkinkan klien menghitung alamat PDA secara Off-Chain untuk mengambil data, sementara program mengontrol akses tulis.

Pemanggilan Lintas Program (CPI): Cara Program Berkomunikasi Satu Sama Lain

Pemanggilan Lintas Program (CPI) adalah mekanisme Solana agar satu program dapat memanggil instruksi program lain. Ini adalah padanan On-Chain dari memanggil fungsi pustaka bersama. CPI memungkinkan komposisi: protokol DeFi Anda dapat memanggil program SPL Token untuk mentransfer token, kontrak tata kelola Anda dapat memanggil program Staking, dan seterusnya.

Solana Program Library (SPL) adalah padanan Solana untuk pustaka standar program On-Chain. SPL Token setara dengan ERC-20 pada Ethereum, tetapi diimplementasikan sebagai program On-Chain bersama daripada templat kontrak yang di-deploy secara independen oleh setiap proyek. Saat program Anchor Anda perlu melakukan Mint atau mentransfer token, program tersebut memanggil SPL Token melalui CPI.

Anchor menyederhanakan panggilan CPI dengan crate anchor-spl dan CpiContext:

use anchor_spl::token::{self, Transfer, Token};

pub fn withdraw(ctx: Context<Withdraw>, amount: u64) -> Result<()> {
    let cpi_accounts = Transfer {
        from: ctx.accounts.vault_token_account.to_account_info(), // Akun token sumber
        to: ctx.accounts.user_token_account.to_account_info(),   // Akun token tujuan
        authority: ctx.accounts.vault.to_account_info(),         // PDA menandatangani untuk vault
    };
    let cpi_ctx = CpiContext::new(ctx.accounts.token_program.to_account_info(), cpi_accounts);
    token::transfer(cpi_ctx, amount)?;  // Memanggil instruksi transfer SPL Token
    Ok(())
}

Tanpa Anchor, merakit informasi akun, membangun instruksi, dan memanggil `invoke_signed` memerlukan sekitar 30 baris. Bantuan CPI Anchor mengurangi ini menjadi panggilan fungsi yang tertulis dengan baik dan dapat dibaca.

Anda akan mempraktikkan konsep-konsep ini dalam [tutorial program langkah demi langkah](#building-and-deploying-your-first-anchor-program-a-complete-walkthrough).

---

## Prasyarat: Apa yang Anda Butuhkan Sebelum Menginstal Kerangka Kerja Anchor

Empat alat diperlukan sebelum Anda dapat membangun dengan Kerangka Kerja Anchor di Solana.

**Alat yang diperlukan:**

1. **Rust dan Cargo** (melalui rustup), versi 1.70.0 atau lebih baru direkomendasikan
2. **Solana CLI** (v1.18.x atau lebih baru), alat baris perintah resmi untuk berinteraksi dengan jaringan Solana; menangani manajemen wallet, permintaan Airdrop, dan konfigurasi kluster
3. **Node.js** (v18 atau lebih baru) plus Yarn atau npm, diperlukan untuk klien TypeScript dan tes Anchor
4. **Anchor Version Manager (avm)**, yang menginstal dan mengelola versi Anchor CLI; selalu instal Anchor melalui avm daripada langsung melalui Cargo

**Tentang Rust:** Program Anchor ditulis dalam Rust. Rust diperlukan. Tidak ada jalan pintas untuk ini. Konon, makro Anchor mengabstraksi pola Rust yang paling menyakitkan: validasi dan serialisasi akun, ditambah propagasi kesalahan. Anda tidak perlu mahir Rust untuk membangun program pertama Anda.

Apa yang Anda butuhkan untuk memulai: struct, fungsi, kepemilikan dasar, dan batasan trait di tingkat permukaan. Apa yang dapat Anda tunda nanti: lifetime, async Rust, dan detail peminjam (borrow checker). Keterampilan TypeScript atau JavaScript Anda berlaku langsung untuk kode sisi klien Anchor. Tes, interaksi front-end, dan panggilan klien yang dihasilkan IDL semuanya menggunakan TypeScript. Anda tidak perlu menjadi ahli Rust untuk membangun dengan Anchor, sama seperti Anda tidak perlu menjadi ahli Ruby untuk membangun dengan Ruby on Rails. Tetapi Anda akan menemukan Rust, dan keakraban dasar sangat membantu.

Jika abstraksi Anchor pada pola Rust menarik bagi Anda, [bagian komponen inti menjelaskan apa yang diabstraksi Anchor dari Rust](#core-components-of-the-solana-anchor-framework-idl-macros-pdas-and-cpi) secara detail.

**Tentang Solana CLI vs. Anchor CLI:** Ini adalah dua alat terpisah dengan tanggung jawab yang berbeda. CLI `solana` menangani interaksi jaringan: memeriksa Saldo, meminta Airdrop, dan beralih antara devnet dan Mainnet. CLI `anchor` menangani siklus hidup program Anda: menginisialisasi proyek, membangun program, menjalankan tes, dan melakukan deployment. Keduanya diperlukan.

---

## Cara Menginstal Kerangka Kerja Anchor: Pengaturan Langkah demi Langkah

📌 **CATATAN:** Semua perintah di bawah ini divalidasi untuk Anchor v0.29.x dan Solana CLI v1.18.x per 2024. Jalankan `anchor --version` setelah instalasi untuk mengonfirmasi versi Anda. Jika membaca ini setelah publikasi, verifikasi versi saat ini di [repositori GitHub Anchor (coral-xyz/anchor)](https://github.com/coral-xyz/anchor).

**Langkah 1: Instal Rust melalui rustup**

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# Ikuti petunjuk di layar dan pilih instalasi default
source "$HOME/.cargo/env"
rustc --version
# Seharusnya mencetak: rustc 1.70.0 atau lebih baru

Langkah 2: Instal Solana CLI

sh -c "$(curl -sSfL https://release.solana.com/stable/install)"
# Ikuti instruksi PATH dari output penginstal
solana --version
# Seharusnya mencetak: solana-cli 1.18.x atau lebih baru

Saat Anda melakukan deployment program Anchor ke Solana, program tersebut disimpan On-Chain dan dieksekusi oleh node validator jaringan kapan pun transaksi memanggilnya. Solana CLI adalah cara Anda berinteraksi dengan validator tersebut dari terminal Anda.

Langkah 3: Konfigurasi Solana CLI ke devnet dan buat Kunci Pribadi

solana config set --url devnet
solana-keygen new
# Membuat keypair lokal (Kunci Pribadi pengembangan Anda)
# Simpan path output. Anchor menggunakan keypair ini untuk menandatangani deployment

💡 TIPS: Simpan path file keypair Anda. Anchor membaca keypair ini dari konfigurasi Anchor.toml Anda untuk menandatangani transaksi deployment di devnet.

Langkah 4: Minta Airdrop SOL devnet

solana airdrop 2
solana balance
# Konfirmasikan Saldo menunjukkan 2 SOL

Langkah 5: Instal avm (Anchor Version Manager) dan Anchor

cargo install --git https://github.com/coral-xyz/avm avm --locked --force
avm install latest
avm use latest
anchor --version
# Seharusnya mencetak: anchor-cli 0.29.x

📌 CATATAN: Selalu instal Anchor melalui avm daripada langsung melalui cargo install anchor-cli. avm memungkinkan Anda beralih antar versi Anchor tanpa menginstal ulang. Ini penting ketika proyek dikunci ke versi tertentu atau saat Anda memperbarui proyek yang ada.

Langkah 6: Inisialisasi proyek pertama Anda

anchor init my-first-program
cd my-first-program

Struktur proyek Anda setelah anchor init:

my-first-program/
├── Anchor.toml
├── programs/
│   └── my-first-program/
│       └── src/
│           └── lib.rs
├── tests/
│   └── my-first-program.ts
└── app/

💡 TIPS: Perintah anchor init membuat program contoh yang berfungsi di lib.rs. Jalankan anchor test segera untuk mengonfirmasi lingkungan Anda berfungsi sebelum menulis kode Anda sendiri.

Membangun dan Melakukan Deployment Program Anchor Pertama Anda: Panduan Lengkap

Bagian ini membawa Anda dari proyek kosong ke program yang di-deploy di devnet Solana. Contohnya adalah pelacak Saldo: sebuah program yang menginisialisasi Saldo tersimpan ke nol dan kemudian menerima instruksi Deposit untuk meningkatkannya. Ini mendemonstrasikan siklus hidup akun penuh dan secara fungsional identik dengan program penghitung tetapi menggunakan nama variabel asli.

Menulis Program Pelacak Saldo

File programs/my-first-program/src/lib.rs Anda sudah berisi kerangka dari anchor init. Ganti isinya dengan yang berikut:

// Program Pelacak Saldo Anchor v0.29.x
use anchor_lang::prelude::*;

declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkgHH5WfZCnQ");

#[program]
pub mod balance_tracker {
    use super::*;

    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
        ctx.accounts.balance_account.total = 0;  // Saldo awal adalah nol
        Ok(())
    }

    pub fn deposit(ctx: Context<Deposit>, amount: u64) -> Result<()> {
        ctx.accounts.balance_account.total += amount;  // Menambah saldo yang tersimpan
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(
        init,
        payer = user,
        space = 8 + 8   // 8-byte Anchor discriminator + 8 bytes untuk u64
    )]
    pub balance_account: Account<'info, BalanceAccount>,

    #[account(mut)]
    pub user: Signer<'info>,

    pub system_program: Program<'info, System>,
}

#[derive(Accounts)]
pub struct Deposit<'info> {
    #[account(mut)]
    pub balance_account: Account<'info, BalanceAccount>,
    pub user: Signer<'info>,
}

#[account]
pub struct BalanceAccount {
    pub total: u64,
}

Tiga pola dalam kode ini penting sebelum Anda lanjut. Pertama, #[derive(Accounts)] menghasilkan logika validasi akun sepenuhnya. Anchor membaca definisi struct Anda dan menulis pemeriksaan kepemilikan, pemeriksaan mutabilitas, dan verifikasi penandatangan. Anda menyatakan niat; Anchor yang menegakkannya. Kedua, space = 8 + 8 mengalokasikan byte yang tepat yang dibutuhkan akun: 8 byte untuk diskriminator Anchor (tag unik yang mengidentifikasi tipe akun dan mencegah serangan kebingungan akun) ditambah 8 byte untuk total u64. Ketiga, Signer<'info> adalah tipe bawaan Anchor yang memverifikasi bahwa akun tersebut menandatangani transaksi. Tanpa itu, akun apa pun bisa memanggil instruksi deposit Anda.

Menguji Program Anda dengan Mocha dan TypeScript

Mocha adalah test runner JavaScript; Chai menyediakan sintaks asersi. Keduanya sudah terpasang saat Anda menjalankan anchor init. Buka tests/my-first-program.ts dan ganti isinya:

import * as anchor from "@coral-xyz/anchor";
import { Program } from "@coral-xyz/anchor";
import { MyFirstProgram } from "../target/types/my_first_program";
import { assert } from "chai";

describe("balance-tracker", () => {
  const provider = anchor.AnchorProvider.env();
  anchor.setProvider(provider);

  const program = anchor.workspace.MyFirstProgram as Program<MyFirstProgram>;
  const balanceAccount = anchor.web3.Keypair.generate();

  it("Initializes a balance account with total = 0", async () => {
    await program.methods
      .initialize()
      .accounts({
        balanceAccount: balanceAccount.publicKey,
        user: provider.wallet.publicKey,
        systemProgram: anchor.web3.SystemProgram.programId,
      })
      .signers([balanceAccount])
      .rpc();

    const account = await program.account.balanceAccount.fetch(
      balanceAccount.publicKey
    );
    assert.equal(account.total.toNumber(), 0, "Saldo awal harus 0");
  });

  it("Deposits 500 and updates the stored balance", async () => {
    await program.methods
      .deposit(new anchor.BN(500))
      .accounts({
        balanceAccount: balanceAccount.publicKey,
        user: provider.wallet.publicKey,
      })
      .rpc();

    const account = await program.account.balanceAccount.fetch(
      balanceAccount.publicKey
    );
    assert.equal(account.total.toNumber(), 500, "Saldo harus 500 setelah deposit");
  });
});

Paket npm @coral-xyz/anchor adalah library klien TypeScript Anchor. Tipe Program<MyFirstProgram> dihasilkan secara otomatis dari IDL saat anchor build dijalankan. Inilah nilai praktis IDL dalam tindakan: kode TypeScript Anda mendapatkan keamanan tipe penuh atas antarmuka program Rust Anda tanpa penulisan antarmuka manual apa pun.

Program ini juga merupakan back-end dari sebuah dApp. Klien TypeScript yang ditampilkan di atas adalah cara aplikasi front-end akan memanggilnya. Tambahkan UI React atau Next.js di atas panggilan metode ini dan Anda memiliki aplikasi terdesentralisasi yang lengkap yang berjalan di Solana.

Membangun dan Menerapkan ke Devnet

Jalankan tiga perintah ini secara berurutan dari root proyek Anda:

anchor build
# Output: target/deploy/my_first_program.so, target/idl/my_first_program.json, target/types/my_first_program.ts

anchor test
# Memulai validator lokal, menerapkan, menjalankan pengujian Mocha, mematikan

anchor deploy --provider.cluster devnet
# Output mencakup ID Program Anda: ABC123...xyz789

💡 TIP: Salin ID Program Anda dari output deploy. Perbarui nilai declare_id!("...") di lib.rs dengan ID tersebut, lalu jalankan anchor build lagi untuk menyematkan alamat yang benar dalam program terkompilasi Anda. Perbarui juga bagian [programs.devnet] di Anchor.toml.

📌 CATATAN: Anda sedang melakukan deployment ke devnet, jaringan pengujian Solana. Ini tidak memakan biaya SOL asli. Airdrop devnet Anda dari bagian penyiapan mencakup biaya deployment.

Anda kini telah menulis dan menguji program Solana, lalu menerapkannya menggunakan Anchor Framework. Program tersebut berada di devnet pada ID Program Anda dan dieksekusi setiap kali ada transaksi yang memanggilnya.

Menguji Program Anchor: Alur Kerja anchor test

anchor test adalah perintah tunggal yang memulai validator Solana lokal, menerapkan program Anda ke sana, menjalankan seluruh rangkaian pengujian Mocha Anda, dan mematikan validator setelah selesai. Anda tidak perlu mengelola validator secara manual.

Urutan alur kerja pengujian:

1. anchor test membaca Anchor.toml Anda untuk konfigurasi
2. Ia memulai proses validator lokal di latar belakang
3. Ia membangun dan menerapkan program Anda ke validator tersebut
4. Ia menjalankan semua file pengujian TypeScript di direktori tests/ Anda menggunakan Mocha
5. Ia mencetak hasil lulus/gagal dan mematikan validator

Struktur file pengujian: Setiap file pengujian mengimpor dari @coral-xyz/anchor, menyiapkan provider (yang terhubung ke validator lokal), dan mereferensikan program Anda melalui objek workspace yang dihasilkan IDL. Blok describe dan it adalah sintaks standar Mocha.

Mengambil data akun: Setelah memanggil instruksi, ambil akun On-Chain untuk menegaskan statusnya:

const account = await program.account.balanceAccount.fetch(
  balanceAccount.publicKey
);
assert.equal(account.total.toNumber(), 0);

Menguji kasus kesalahan: Uji bahwa input yang tidak valid gagal dengan benar. Program yang diuji dengan baik mencakup pengujian negatif:

it("Rejects deposit from an unsigned account", async () => {
  const badActor = anchor.web3.Keypair.generate();
  try {
    await program.methods
      .deposit(new anchor.BN(100))
      .accounts({
        balanceAccount: balanceAccount.publicKey,
        user: badActor.publicKey,
      })
      .rpc();
    assert.fail("Transaksi seharusnya ditolak");
  } catch (err) {
    assert.ok(err, "Anchor menolak transaksi yang tidak ditandatangani");
  }
});

Localnet vs. devnet: Gunakan anchor test (localnet) untuk semua pengembangan aktif. Localnet bersifat instan dan gratis, serta diatur ulang di setiap sesi. Terapkan ke devnet hanya jika Anda ingin membagikan URL persisten atau menguji terhadap kondisi jaringan yang sebenarnya.

Mocha adalah test runner (struktur blok describe dan it). Chai menyediakan sintaks asersi (assert.equal, assert.ok, expect). Keduanya telah dikonfigurasi sebelumnya di setiap proyek anchor init dan tidak memerlukan instalasi terpisah.

Anchor vs. Alternatif: Memilih Jalur Pengembangan Solana Anda

Ada tiga jalur pengembangan untuk membangun di Solana: Anchor Framework, Rust asli tanpa framework, dan Seahorse. Solana sendiri adalah salah satu dari beberapa blockchain yang layak dievaluasi untuk proyek Anda. Tabel di bawah ini menyajikan perbedaan utama tanpa keberpihakan.

Tabel 1: Pendekatan Pengembangan Solana

Tabel 2: Perangkat Solana vs. Ethereum

Kapan memilih Anchor daripada Rust murni: Untuk banyak kasus penggunaan pengembangan aplikasi Solana, termasuk protokol DeFi, platform NFT, sistem pembatasan token, DAO, dan game on-chain, Anchor adalah titik awal yang umum. Pengurangan boilerplate sangat signifikan: sebuah program yang membutuhkan 300 baris dalam Rust mentah mungkin membutuhkan 80 baris dengan Anchor. Pengembangan Rust murni masuk akal ketika sebuah program membutuhkan kontrol yang tepat atas konsumsi unit komputasi, ketika abstraksi Anchor bertentangan dengan arsitektur yang tidak biasa, atau ketika tim memiliki keahlian Rust yang mendalam dan membutuhkan fleksibilitas maksimum.

Kerangka Kerja Seahorse: Seahorse memungkinkan pengembang menulis program Solana dalam Python, yang kemudian dikompilasi oleh Seahorse menjadi Rust yang kompatibel dengan Anchor di baliknya. Ini menurunkan hambatan bahasa bagi pengembang Python yang ingin bereksperimen dengan Solana tanpa mempelajari Rust. Konsekuensinya adalah kematangan: Seahorse adalah proyek komunitas dengan basis pengguna yang jauh lebih kecil daripada Anchor dan tidak direkomendasikan untuk aplikasi produksi per 2024. Untuk membuat prototipe, ini adalah pilihan yang masuk akal; untuk produksi, Anchor tetap menjadi standar de facto.

Ethereum vs. Solana: Ethereum menawarkan ekosistem pengembang kontrak pintar terbesar, riwayat audit keamanan terdalam, dan dukungan perangkat terlengkap. Solana menawarkan throughput yang jauh lebih tinggi dan biaya yang lebih rendah, membuatnya lebih cocok untuk aplikasi di mana frekuensi dan biaya transaksi adalah kendala utama. Platform ini melayani profil aplikasi yang berbeda. Pengembang yang membangun infrastruktur perdagangan frekuensi tinggi atau game transaksi mikro mungkin memilih Solana; pengembang yang membangun sistem tata kelola atau standar token yang membutuhkan kompatibilitas ekosistem maksimum mungkin memilih Ethereum. Untuk sebagian besar aplikasi Solana produksi, Anchor adalah titik awal yang umum, yang dikonfirmasi oleh protokol utama termasuk Raydium, Marinade Finance, dan Metaplex yang memilih Anchor sebagai fondasi mereka.

Keamanan Kerangka Kerja Anchor: Lima Kerentanan yang Wajib Diketahui Setiap Pengembang Solana

⚠️ PERINGATAN: Kerentanan keamanan dalam program Solana dapat mengakibatkan kerugian dana pengguna yang permanen dan tidak dapat diubah. Sebelum menerapkan program apa pun ke mainnet, jalankan melalui alat analisis statis seperti Soteria dan pertimbangkan audit keamanan profesional. Ekosistem Solana telah mengalami eksploitasi signifikan dari kerentanan yang persis dijelaskan di bawah ini. Tinjauan keamanan bukanlah pilihan bagi program produksi. Untuk bacaan lebih mendalam, konsultasikan dokumentasi resmi Anchor.

Sistem batasan Anchor, atribut #[account(...)] dalam struct akun Anda, adalah garis pertahanan keamanan pertama Anda. Ini secara otomatis menegakkan pemeriksaan kepemilikan, izin mutabilitas, dan verifikasi tipe yang seharusnya Anda tulis secara manual dalam Rust mentah. Tetapi batasan hanya melindungi apa yang Anda deklarasikan. Kerentanan di bawah ini muncul dari apa yang lupa dideklarasikan oleh pengembang.

Hilangnya Pemeriksaan Penanda Tangan (Signer Check)

Akun apa pun dapat memanggil instruksi Anda jika pemanggil tidak diwajibkan untuk menandatangani transaksi. Ini memungkinkan wallet apa pun untuk memanggil instruksi yang seharusnya dibatasi.

// VULNERABLE: AccountInfo tidak memverifikasi bahwa pemanggil menandatangani transaksi
#[derive(Accounts)]
pub struct Deposit<'info> {
    #[account(mut)]
    pub balance_account: Account<'info, BalanceAccount>,
    pub user: AccountInfo<'info>,  // Tidak ada verifikasi tanda tangan
}

// AMAN: Signer<'info> menggagalkan transaksi jika akun tidak menandatangani
#[derive(Accounts)]
pub struct Deposit<'info> {
    #[account(mut)]
    pub balance_account: Account<'info, BalanceAccount>,
    pub user: Signer<'info>,  // Transaksi dibatalkan jika pengguna tidak menandatangani
}

Gunakan Signer<'info> untuk akun apa pun yang seharusnya mengotorisasi instruksi.

Hilangnya Pemeriksaan Kepemilikan (Substitusi Akun)

Penyerang dapat mengganti akun yang dibuat secara berbahaya yang memiliki tata letak data yang sama dengan akun yang Anda harapkan tetapi dimiliki oleh program yang berbeda.

// VULNERABLE: AccountInfo tidak memverifikasi pemilik program akun
pub balance_account: AccountInfo<'info>,  // Menerima akun apa pun

// AMAN: Account<'info, T> memverifikasi bahwa akun dimiliki oleh program Anda
pub balance_account: Account<'info, BalanceAccount>,  // Pemeriksaan kepemilikan otomatis

Selalu gunakan wrapper Account<'info, T> berjenis Anchor daripada AccountInfo<'info> mentah untuk akun yang berisi data yang dikontrol program.

Serangan Inisialisasi Ulang

Jika instruksi initialize dapat dijalankan lebih dari sekali pada akun yang sama, penyerang dapat mengatur ulang status yang seharusnya permanen.

// VULNERABLE: init_if_needed secara diam-diam menerima akun yang sudah diinisialisasi
#[account(init_if_needed, payer = user, space = 8 + 8)]
pub balance_account: Account<'info, BalanceAccount>,

// AMAN: init menggagalkan jika akun sudah ada
#[account(init, payer = user, space = 8 + 8)]
pub balance_account: Account<'info, BalanceAccount>,

Gunakan init (bukan init_if_needed) untuk akun yang hanya boleh dibuat sekali. Jika init_if_needed benar-benar diperlukan, tambahkan bendera inisialisasi eksplisit dan periksa dalam logika instruksi Anda.

Integer Overflow dan Underflow

Aritmatika Rust panik pada overflow dalam build debug tetapi membungkus secara diam-diam dalam build rilis, yang dapat merusak saldo keuangan tanpa menimbulkan kesalahan.

// VULNERABLE: aritmatika langsung membungkus diam-diam dalam mode rilis
pub fn deposit(ctx: Context<Deposit>, amount: u64) -> Result<()> {
    ctx.accounts.balance_account.total += amount;
    Ok(())
}

// AMAN: checked_add mengembalikan Err alih-alih membungkus saat overflow
pub fn deposit(ctx: Context<Deposit>, amount: u64) -> Result<()> {
    ctx.accounts.balance_account.total = ctx.accounts.balance_account.total
        .checked_add(amount)
        .ok_or(error!(ErrorCode::Overflow))?;
    Ok(())
}

Gunakan checked_add, checked_sub, dan checked_mul untuk semua aritmatika pada nilai keuangan. Tentukan enum ErrorCode kustom dengan varian Overflow untuk pesan kesalahan yang jelas.

Kanonisasi Bump PDA

Menggunakan bump seed non-kanonik dapat menghasilkan alamat PDA yang valid tetapi tidak terduga, yang memungkinkan serangan spoofing alamat.

// RENTAN: bump manual tidak dijamin bersifat kanonik
#[account(seeds = [b"vault", user.key().as_ref()], bump = ctx.accounts.vault.bump)]
pub vault: Account<'info, Vault>,

// AMAN: abaikan nilai bump eksplisit. Anchor v0.29.x menurunkan dan memverifikasi
// bump kanonik secara otomatis
#[account(
    seeds = [b"vault", user.key().as_ref()],
    bump,
)]
pub vault: Account<'info, Vault>,

Di Anchor v0.29.x, abaikan nilai bump eksplisit dan biarkan Anchor menurunkan bump kanonik tersebut. Jika Anda menyimpan bump di data akun, isi selama init menggunakan ctx.bumps.vault.

Untuk pesan kesalahan yang Anda temui saat menerapkan pola keamanan ini, lihat bagian pemecahan masalah.

Pemecahan Masalah Kesalahan Umum Anchor

Kesalahan di bawah ini mewakili masalah paling umum yang dihadapi pengembang saat membangun dengan Anchor Framework. Setiap entri menyertakan pesan kesalahan yang tepat, penyebab, dan perbaikannya.

📌 CATATAN: Ketidakcocokan versi menyebabkan sebagian besar kegagalan anchor build. Periksa tabel ini terlebih dahulu sebelum menyelidiki penyebab lainnya.

Kesalahan 1: AccountNotInitialized

AnchorError caused by account: balance_account.
Error Code: AccountNotInitialized.
Error Number: 3012.

Penyebab: Program Anda mencoba membaca akun data yang belum ada On-Chain. Instruksi initialize belum dipanggil.

Perbaikan: Panggil instruksi initialize Anda sebelum instruksi apa pun yang membaca dari akun tersebut. Dalam pengujian, pastikan blok it inisialisasi berjalan sebelum blok pengujian deposit.

Kesalahan 2: Ketidakcocokan Tipe pada anchor build

error[E0308]: mismatched types
expected struct `anchor_lang::prelude::AccountInfo`
found struct `anchor_lang::accounts::signer::Signer`

Penyebab: Kode Anda menggunakan sintaks batasan akun dari Anchor v0.26.x atau yang lebih lama, yang telah berubah di v0.29.x.

Perbaikan: Periksa dokumentasi resmi Anchor) untuk sintaks batasan v0.29.x. Jalankan avm use 0.29.0 untuk memastikan versi CLI Anda cocok dengan dependensi Cargo.toml Anda.

Kesalahan 3: Ketidakcocokan Versi CLI Anchor/Solana

Error: RPC response error -32002: Transaction simulation failed

Penyebab: Versi CLI Anchor dan versi CLI Solana Anda tidak kompatibel.

Perbaikan:

avm use 0.29.0
solana --version     # Pastikan Solana CLI adalah 1.18.x atau versi lebih baru

Kesalahan 4: Ketidakcocokan declare_id! Setelah Penerapan Ulang

Error: Program Id mismatch

Penyebab: Anda menerapkan ulang ke alamat baru tetapi declare_id!() di lib.rs masih memegang ID Program lama.

Perbaikan:

anchor keys sync
anchor build

Kesalahan 5: Dana Tidak Mencukupi di Devnet

Error: Transaction simulation failed: insufficient funds

Penyebab: Saldo devnet wallet Anda tidak memiliki cukup SOL untuk membayar biaya penerapan atau transaksi.

Perbaikan:

solana airdrop 2
solana balance

Kesalahan 6: Biner Program Melebihi Batas Ukuran

Error: account data too small for instruction

Penyebab: Biner program yang Anda kompilasi melebihi batas ukuran program Solana untuk program yang dapat ditingkatkan (upgradeable).

Perbaikan: Tambahkan optimasi rilis ke Cargo.toml Anda:

[profile.release]
opt-level = "z"
lto = true

Hapus dependensi yang tidak digunakan dan bendera fitur dari Cargo.toml dan Anchor.toml Anda.

Jika Anda mengalami kesalahan versi, kembalilah ke panduan instalasi dan verifikasi bahwa versi alat Anda cocok dengan tabel kompatibilitas di atas.

Anchor Framework dan Ekosistem Pengembang Solana

Anchor Framework mendukung mayoritas program produksi yang diterapkan di Mainnet Solana, termasuk protokol dalam Keuangan Terdesentralisasi (DeFi), infrastruktur NFT, dan tata kelola on-chain.

Protokol produksi yang dibangun dengan Anchor:

• Raydium: Protokol Automated Market Maker (AMM) dan likuiditas
• Marinade Finance: Protokol staking cair untuk SOL
• Metaplex: Standar NFT, metadata token, dan rangkaian alat
• Drift Protocol: Bursa perpetual terdesentralisasi
• Kamino Finance: Protokol likuiditas dan peminjaman
• Jito: Staking yang sadar MEV dan infrastruktur validator

Protokol DeFi mewakili kategori dominan dari program yang diterapkan dengan Anchor. Bursa terdesentralisasi, platform peminjaman, dan agregator imbal hasil semuanya bergantung pada throughput Solana (sekitar 65.000 transaksi per detik dalam kondisi optimal, per 2024) dan biaya rendah (biasanya di bawah $0,001 per transaksi) untuk operasi inti mereka. Pertumbuhan instrumen keuangan on-chain dan tokenisasi Aset Dunia Nyata di Solana mencerminkan kematangan infrastruktur ini.

Menurut Laporan Pengembang Electric Capital (tersedia di electriccapital.com untuk angka saat ini), basis pengembang aktif Solana tumbuh dari tahun ke tahun sepanjang 2023 dan memasuki 2024. Peningkatan adopsi pengembang umumnya berkontribusi pada kesehatan ekosistem blockchain, meskipun hal ini tidak boleh ditafsirkan sebagai nasihat investasi.

SOL berfungsi sebagai mata uang biaya jaringan Solana. Setiap transaksi yang memanggil program on-chain membutuhkan sejumlah kecil SOL (dapat diperdagangkan di bursa mata uang kripto utama termasuk Coinbase dan Binance). Untuk data pasar SOL saat ini, lihat harga SOL dan data pasar saat ini di CoinGecko.)

Semakin banyak pengembang yang membangun dengan Anchor berarti semakin banyak program yang diterapkan, yang berarti semakin banyak penggunaan aktif jaringan Solana. Hubungan ini adalah pengamatan tentang dinamika ekosistem, bukan sinyal investasi.

Pertanyaan yang Sering Diajukan Tentang Solana Anchor Framework

Bahasa pemrograman apa yang digunakan Solana?

Program Solana ditulis dalam Rust. Runtime-nya juga mendukung C dan C++, tetapi Rust adalah standar untuk pengembangan produksi. Untuk kode sisi klien, termasuk pengujian, interaksi front-end, dan skrip yang memanggil program Anda, TypeScript dan JavaScript digunakan melalui paket npm @coral-xyz/anchor. Anchor Framework mencakup kedua lapisan: Rust untuk logika program dan TypeScript untuk segala sesuatu yang berinteraksi dengannya.

Apakah Rust diperlukan untuk menggunakan Anchor Framework?

Ya. Program Anchor ditulis dalam Rust, dan tidak ada cara lain. Meskipun demikian, makro Anchor mengabstraksi bagian paling intensif Rust dari pengembangan Solana: validasi akun dan propagasi kesalahan. Seorang pengembang dengan keakraban dasar Rust (struct, fungsi, trait, ownership dasar) dapat membangun dan menerapkan program Anchor yang berfungsi. Keahlian mendalam Rust dalam lifetime, pola asinkron, dan generik tingkat lanjut tidak diperlukan untuk memulai. Keterampilan TypeScript atau JavaScript Anda berlaku langsung pada sisi klien dari setiap proyek Anchor.

Apa itu Program Derived Address (PDA) dalam istilah sederhana?

Program Derived Address (PDA) adalah alamat akun yang dikendalikan oleh program, bukan oleh pengguna dengan kunci pribadi. Karena PDA tidak memiliki kunci pribadi, hanya program pemilik yang dapat mengotorisasi transaksi yang melibatkannya. Dengan seed dan ID program yang sama, sebuah PDA selalu merujuk ke alamat yang sama, yang memungkinkan klien menemukan akun yang dikendalikan program tanpa menyimpan alamatnya secara terpisah. Anchor menangani derivasi PDA secara otomatis melalui batasan seeds dalam struktur akun Anda. PDA umumnya digunakan untuk brankas yang dikendalikan program, akun escrow, dan penyimpanan data per pengguna.

Bisakah Anda membuat NFT dengan Anchor Framework?

Ya. Mayoritas infrastruktur NFT Solana dibangun di atas Anchor. Standar Metaplex, yang mendefinisikan metadata token, struktur koleksi, dan royalti untuk NFT Solana, adalah program berbasis Anchor itu sendiri. Platform NFT apa pun di Solana berinteraksi dengan program Metaplex melalui Cross-Program Invocation (CPI) menggunakan crate anchor-spl, yang menyediakan wrapper yang aman secara tipe untuk instruksi Token SPL.

Apakah Anchor Framework dipelihara secara aktif?

Ya. Anchor dikelola oleh Coral XYZ dan merupakan standar de facto untuk pengembangan program Solana per tahun 2024. Versi stabil saat ini adalah v0.29.x. Repositori GitHub Anchor (coral-xyz/anchor) menerima rilis reguler yang mengikuti pembaruan runtime Solana. Protokol produksi utama, termasuk Raydium, Marinade Finance, dan Metaplex, terus dibangun di atas Anchor, mengonfirmasi kesiapannya untuk produksi.

Bagaimana perbandingan Anchor dengan Hardhat milik Ethereum?

Anchor dan Hardhat melayani peran yang serupa pada Blockchain masing-masing: keduanya menyediakan scaffolding proyek, lingkungan pengujian, dan peralatan deployment. Perbedaannya dimulai dengan arsitektur dasarnya. Hardhat menargetkan model kontrak stateful Ethereum, di mana sebuah Kontrak Pintar menyimpan logika dan state-nya. Anchor menargetkan model program stateless Solana, di mana program dan data berada di akun yang terpisah. Bahasanya pun berbeda: proyek Hardhat menggunakan Solidity untuk kontrak dan JavaScript atau TypeScript untuk pengujian; proyek Anchor menggunakan Rust untuk program dan TypeScript untuk pengujian. Biaya transaksi juga berbeda secara substansial: transaksi Solana biasanya berbiaya di bawah $0,001, sementara biaya gas Ethereum bervariasi dan dapat mencapai $1 hingga $50 atau lebih per transaksi. Untuk perbandingan lengkap secara berdampingan, lihat tabel perbandingan Anchor vs. Alternatif.

Berapa lama waktu yang dibutuhkan untuk mempelajari Framework Anchor?

Seorang pengembang dengan pengalaman TypeScript atau JavaScript dan tanpa pengetahuan Rust sebelumnya biasanya dapat membangun dan men-deploy program Anchor dasar ke devnet dalam satu hingga dua hari menggunakan panduan terstruktur. Beralih dari program dasar ke protokol DeFi produksi membutuhkan waktu berminggu-minggu hingga berbulan-bulan, tergantung pada kompleksitas program dan kedalaman Rust. Kurva pembelajaran Rust adalah variabel utamanya. Pengembang yang menginvestasikan waktu pada dasar-dasar Rust bersama dengan Anchor akan melihat kemajuan yang lebih cepat pada program-program non-trivial.

Apa itu Solana Program Library (SPL)?

Solana Program Library (SPL) adalah kumpulan program yang sudah di-deploy dan diaudit di Solana untuk operasi umum. Program SPL Token adalah padanan Solana untuk standar ERC-20, yang diimplementasikan sebagai program On-Chain bersama, bukan sebagai templat kontrak yang di-deploy oleh setiap proyek secara independen. Anchor berintegrasi dengan SPL melalui crate anchor-spl, yang menyediakan wrapper tipe-aman untuk instruksi SPL Token termasuk transfer, mint_to, dan burn. SPL juga merupakan fondasi untuk metadata token NFT melalui program Metaplex.

Apa itu Proof of History (PoH) di Solana?

Proof of History (PoH) adalah mekanisme pencatatan waktu kriptografis yang digunakan Solana untuk mengurutkan transaksi sebelum mencapai validator untuk konsensus. Alih-alih mengharuskan validator berkomunikasi untuk menyepakati urutan transaksi, PoH menyematkan urutan stempel waktu yang dapat diverifikasi langsung ke dalam Blockchain. Ini mengurangi beban koordinasi protokol konsensus tradisional dan merupakan salah satu alasan Solana mencapai sekitar 65.000 transaksi per detik dalam kondisi optimal per tahun 2024.

Apakah Solana bagus untuk pengembangan Kontrak Pintar?

Solana sangat cocok untuk aplikasi di mana throughput transaksi dan biaya menjadi kendala utama: protokol DeFi frekuensi tinggi, marketplace NFT dengan banyak transaksi kecil, dan game On-Chain. Model akunnya memerlukan pembelajaran lebih awal dibandingkan Ethereum, tetapi Framework Anchor mengurangi hambatan tersebut secara signifikan. Apakah Solana merupakan pilihan yang tepat tergantung pada profil aplikasi Anda. Ethereum menawarkan ekosistem yang lebih besar dan riwayat audit keamanan yang lebih mapan, sementara Solana menawarkan biaya yang lebih rendah dan throughput yang lebih tinggi untuk kasus penggunaan yang diuntungkan oleh keduanya.

Kesimpulan: Apakah Framework Anchor Tepat untuk Proyek Solana Anda?

Untuk banyak alur kerja pengembangan aplikasi Solana, Framework Anchor adalah titik awal yang umum, sementara Rust asli tetap relevan ketika kontrol tingkat rendah diperlukan.

Anchor mengurangi boilerplate pengembangan Rust mentah secara substansial. Program yang membutuhkan ratusan baris dalam kode asli Solana hanya membutuhkan sebagian kecil dari itu dengan sistem makro Anchor. Anchor menegakkan keamanan akun melalui sistem kendalanya, menangkap kesalahan kepemilikan dan otorisasi pada waktu kompilasi atau runtime daripada saat produksi. Dan Anchor menghasilkan klien TypeScript secara otomatis dari IDL, memberikan pengembang JavaScript antarmuka yang diketik dan familier untuk program mereka tanpa menulis Rust di sisi klien.

Pengembangan Rust asli layak dipertimbangkan hanya jika program Anda memerlukan kontrol presisi atas konsumsi unit komputasi atau ketika abstraksi Anchor benar-benar berbenturan dengan arsitektur yang tidak biasa. Untuk sebagian besar program, termasuk protokol DeFi, platform NFT, DAO, dan sistem token-gating, Anchor adalah tempat Anda harus memulai.

Langkah selanjutnya:

1. Deploy program pelacak Saldo dari panduan ini ke devnet menggunakan anchor deploy --provider.cluster devnet
2. Jelajahi dokumentasi resmi Anchor di anchor-lang.com untuk referensi API lengkap dan fitur-fitur lanjutan
3. Telusuri repositori contoh GitHub Anchor untuk program pola produksi
4. Bergabunglah dengan Discord Anchor atau Solana Stack Exchange untuk dukungan komunitas saat Anda menemui masalah

Program yang Anda deploy dalam panduan ini adalah nyata: program tersebut hidup di devnet Solana, menerima transaksi, dan menyimpan state On-Chain. Itulah fondasi tempat setiap aplikasi produksi Solana dibangun.

Panduan Teknis Solana Terkait

• Alamat kontrak Solana dan ID Program
• Standar Token Solana
• Token SPL Solana

Pengembang yang melacak SOL bersama dengan peralatan ekosistem dapat berkonsultasi dengan halaman harga SOL sebagai referensi pasar terpisah; ini tidak memvalidasi keamanan program atau kesiapan deployment.