Blog

Cara Menggunakan Solana API: Panduan Lengkap untuk Developer

Ashley Goolam

Ashley Goolam

6 February 2026

Cara Menggunakan Solana API: Panduan Lengkap untuk Developer

Apidog untuk Perusahaan

Penerapan On-Premises

SSO & RBAC

Sesuai SOC 2

Jelajahi Apidog Enterprise

Bagaimana jika Anda bisa membangun aplikasi blockchain yang memproses 65.000 transaksi per detik dengan finalitas 400 milidetik? API Solana memungkinkan hal ini, menawarkan antarmuka JSON-RPC yang memungkinkan Anda mengkueri akun, mengirim transaksi, dan berlangganan pembaruan real-time tanpa harus mengelola infrastruktur validator sendiri.

Pengembangan blockchain tradisional memaksa Anda untuk memilih antara kecepatan dan desentralisasi. 15 TPS Ethereum menciptakan kemacetan selama kongesti jaringan. Solusi Layer 2 menambah kompleksitas. Solana menghilangkan pertukaran ini melalui konsensus proof-of-history yang dikombinasikan dengan proof-of-stake, menghadirkan kinerja Web2 dengan jaminan Web3. Anda membangun aplikasi yang terasa instan sambil mempertahankan ketahanan terhadap sensor.

Daftar Isi:

💡
Saat membangun aplikasi Solana, mengelola beberapa titik akhir RPC dan men-debug kegagalan transaksi menjadi rumit. Apidog menyediakan pengujian API visual, dokumentasi otomatis, dan fitur kolaborasi tim yang dirancang khusus untuk pengembangan blockchain. Coba Apidog gratis untuk menyederhanakan alur kerja Solana Anda—tidak memerlukan kartu kredit.
button

Memahami Arsitektur Solana

Solana menggunakan arsitektur unik yang berpusat pada Solana Program Library (SPL) dan runtime ber throughput tinggi. Memahami dasar-dasar ini membantu Anda menulis panggilan API yang efisien.

Proof of History (PoH)

PoH membuat stempel waktu kriptografis untuk setiap transaksi sebelum konsensus. Ini menghilangkan kebutuhan node untuk menyepakati waktu, mengurangi latensi secara dramatis. Ketika Anda mengirim transaksi melalui API, ia langsung diberi stempel waktu dan memasuki antrian pemimpin untuk diproses.

Akun dan Program

Berbeda dengan model berbasis akun Ethereum dengan penyimpanan kode, Solana memisahkan kode (program) dari data (akun). Program bersifat stateless—mereka hanya berisi logika yang dapat dieksekusi. Akun menyimpan data dan menentukan program mana yang memilikinya. Arsitektur ini memungkinkan pemrosesan transaksi paralel karena akun yang tidak tumpang tindih dapat dieksekusi secara bersamaan.

Setiap akun memiliki alamat 32-byte unik yang berasal dari kunci publik Ed25519. Akun membayar sewa dalam lamports (1 SOL = 10^9 lamports) untuk tetap berada di rantai. Akun yang bebas sewa—yaitu yang memiliki setidaknya 2 tahun sewa—bertahan tanpa batas waktu tanpa dekomposisi.

Tingkat Komitmen

Solana menyediakan tiga tingkat konfirmasi:

Tentukan tingkat komitmen dalam panggilan API untuk menyeimbangkan kecepatan dengan jaminan finalitas.

API Solana

Menyiapkan Lingkungan Pengembangan Anda

Anda memerlukan tiga komponen: Solana CLI untuk manajemen kunci dan deployment, titik akhir RPC untuk akses blockchain, dan SDK JavaScript untuk integrasi aplikasi.

Menginstal Solana CLI

Instal alat CLI resmi:

sh -c "$(curl -sSfL https://release.solana.com/stable/install)"

Verifikasi instalasi:

solana --version

Konfigurasi lingkungan Anda untuk Devnet (pengujian) atau Mainnet (produksi):

# Untuk pengembangan
solana config set --url https://api.devnet.solana.com

# Untuk produksi
solana config set --url https://api.mainnet-beta.solana.com

Membuat Dompet

Hasilkan pasangan kunci baru untuk menandatangani transaksi:

solana-keygen new --outfile ~/.config/solana/id.json

CLI mengeluarkan alamat publik Anda dan frase benih 12 kata. Simpan frase benih dengan aman—ini memulihkan dompet Anda. File JSON berisi kunci pribadi Anda; lindungi dengan izin file (chmod 600).

Periksa saldo Anda:

solana balance

Danai dompet Devnet Anda dengan SOL gratis:

solana airdrop 2

Airdrop Devnet menyediakan 2 SOL per permintaan, terbatas satu permintaan per 10 detik. Mainnet memerlukan pembelian SOL melalui bursa.

Memilih Penyedia RPC

Meskipun Solana menyediakan titik akhir RPC publik, aplikasi produksi memerlukan infrastruktur khusus. Pilihan meliputi:

Tingkat gratis biasanya mengizinkan 100.000 permintaan per bulan. Paket berbayar menawarkan batas yang lebih tinggi, koneksi yang di-stake untuk pendaratan transaksi, dan API biaya prioritas.

Menginstal Web3.js

Solana's JavaScript SDK memiliki dua versi utama. Versi 2.0 merupakan penulisan ulang lengkap dengan pola pemrograman fungsional, tree-shakability, dan tanpa dependensi.

Instal versi 2.0:

npm install @solana/web3.js@2 @solana-program/system @solana-program/compute-budget

Untuk kompatibilitas versi 1.x:

npm install @solana/web3.js
TipsApidogSolana

Metode API RPC Solana Inti

JSON-RPC Solana API menyediakan titik akhir HTTP untuk kueri dan titik akhir WebSocket untuk langganan. Semua permintaan mengikuti spesifikasi JSON-RPC 2.0.

Metode API RPC Solana Inti

Operasi Akun

Dapatkan informasi akun dan saldo:

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getAccountInfo",
    "params": [
      "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36zEGQp",
      {"encoding": "base58"}
    ]
  }'

Ambil beberapa akun secara efisien:

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getMultipleAccounts",
    "params": [
      [
        "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36zEGQp",
        "4fYNw3dojWGPgVMtUU7ziPwq1r2VMGrhCrKZC9EQTbkV"
      ],
      {"encoding": "base64"}
    ]
  }'

Kueri Blok dan Transaksi

Dapatkan blockhash terbaru untuk pembuatan transaksi:

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getLatestBlockhash",
    "params": [{"commitment": "confirmed"}]
  }'

Kueri status transaksi:

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getSignatureStatuses",
    "params": [
      [
        "5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpEz7CmGVZxhEHppBrGK"
      ],
      {"searchTransactionHistory": true}
    ]
  }'

Langganan WebSocket

Pantau perubahan akun secara real-time:

import { createSolanaRpcSubscriptions } from "@solana/web3.js";

const rpcSubscriptions = createSolanaRpcSubscriptions(
  "wss://api.devnet.solana.com"
);

const abortController = new AbortController();

await rpcSubscriptions.accountNotifications(
  "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36zEGQp",
  { commitment: "confirmed" },
  (notification) => {
    console.log("Account changed:", notification);
  },
  { abortSignal: abortController.signal }
);

// Hentikan mendengarkan setelah 60 detik
setTimeout(() => abortController.abort(), 60000);

Koneksi WebSocket memerlukan ping berkala setiap 30-60 detik agar tetap aktif. Terapkan logika penyambungan ulang untuk aplikasi produksi.

Kiat ProApidogSolana

Membangun Transaksi dengan Web3.js

Transaksi Solana terdiri dari satu atau lebih instruksi yang menargetkan program tertentu. Setiap instruksi menentukan program, akun yang berinteraksi dengannya, dan data yang diserialisasi.

Membuat Transaksi Transfer

Transfer SOL antar akun menggunakan SDK versi 2.0:

import {
  airdropFactory,
  createKeyPairSignerFromBytes,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  generateKeyPairSigner,
  lamports,
  sendAndConfirmTransactionFactory,
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayer,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  signTransactionMessageWithSigners,
  getSignatureFromTransaction,
} from "@solana/web3.js";
import { getTransferSolInstruction } from "@solana-program/system";

const LAMPORTS_PER_SOL = BigInt(1_000_000_000);

// Menyiapkan koneksi RPC
const rpc = createSolanaRpc("https://api.devnet.solana.com");
const rpcSubscriptions = createSolanaRpcSubscriptions("wss://api.devnet.solana.com");
const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });

// Menghasilkan pengirim dan penerima
const sender = await generateKeyPairSigner();
const recipient = await generateKeyPairSigner();

// Mendanai pengirim dengan airdrop
await airdropFactory({ rpc, rpcSubscriptions })({
  recipientAddress: sender.address,
  lamports: lamports(2n * LAMPORTS_PER_SOL),
  commitment: "confirmed",
});

// Dapatkan blockhash terbaru
const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

// Membangun transaksi menggunakan pipe
const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }),
  (msg) => setTransactionMessageFeePayer(sender.address, msg),
  (msg) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, msg),
  (msg) => appendTransactionMessageInstruction(
    getTransferSolInstruction({
      amount: lamports(LAMPORTS_PER_SOL / BigInt(2)),
      destination: recipient.address,
      source: sender,
    }),
    msg
  )
);

// Menandatangani dan mengirim
const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
console.log("Transaksi ditandatangani");

await sendAndConfirmTransaction(signedTransaction, {
  commitment: "confirmed",
  maxRetries: 0n,
  skipPreflight: true,
});

console.log("Dikonfirmasi:", getSignatureFromTransaction(signedTransaction));

Fungsi pipe membuat rantai fungsional di mana setiap langkah mengubah pesan transaksi. Pola ini menghilangkan keadaan mutable dan membuat konstruksi transaksi deklaratif.

Mengoptimalkan dengan Biaya Prioritas

Selama kongesti jaringan, biaya prioritas memastikan penyertaan transaksi. Ambil biaya yang direkomendasikan dari API Helius:

import { getBase64EncodedWireTransaction } from "@solana/web3.js";

const base64Transaction = getBase64EncodedWireTransaction(signedTransaction);

const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_KEY", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: "priority-fee-request",
    method: "getPriorityFeeEstimate",
    params: [{
      transaction: base64Transaction,
      options: { recommended: true }
    }]
  })
});

const { result } = await response.json();
const priorityFee = result.priorityFeeEstimate;

// Tambahkan instruksi biaya prioritas
import { getSetComputeUnitPriceInstruction } from "@solana-program/compute-budget";

const optimizedMessage = pipe(
  transactionMessage,
  (msg) => appendTransactionMessageInstruction(
    getSetComputeUnitPriceInstruction({ microLamports: priorityFee }),
    msg
  )
);

Biaya prioritas ditentukan dalam mikro-lamports per unit komputasi. Biaya yang lebih tinggi meningkatkan prioritas transaksi selama kongesti.

Menangani Kesalahan

Solana mengembalikan kode kesalahan spesifik untuk kegagalan umum:

import { isSolanaError, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE } from "@solana/web3.js";

try {
  await sendAndConfirmTransaction(signedTransaction);
} catch (error) {
  if (isSolanaError(error)) {
    switch (error.contextErrorCode) {
      case SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE:
        console.error("Pra-penerbangan gagal:", error.message);
        break;
      default:
        console.error("Kesalahan Solana:", error);
    }
  }
}

Kesalahan umum termasuk dana tidak mencukupi (0x1), blockhash tidak valid (kadaluarsa), dan akun sedang digunakan (konflik transaksi).

Praktik Keamanan Terbaik

Throughput tinggi Solana memperkenalkan pertimbangan keamanan yang unik. Terapkan langkah-langkah ini untuk melindungi aplikasi dan pengguna Anda.

Manajemen Kunci

Jangan pernah menyerahkan kunci pribadi ke kontrol versi. Gunakan variabel lingkungan:

# .env
SOLANA_PRIVATE_KEY="[1,2,3,...]"

Muat kunci dengan aman di aplikasi Anda:

import { createKeyPairSignerFromBytes } from "@solana/web3.js";
import { getBase58Encoder } from "@solana/codecs";

const secretKey = JSON.parse(process.env.SOLANA_PRIVATE_KEY);
const signer = await createKeyPairSignerFromBytes(
  new Uint8Array(secretKey)
);

Untuk aplikasi browser, integrasikan adapter dompet (Phantom, Solflare) daripada menangani kunci pribadi secara langsung. Pengguna menandatangani transaksi melalui ekstensi dompet mereka, menjaga kunci tetap aman.

Simulasi Transaksi

Selalu simulasikan transaksi sebelum pengiriman untuk menangkap kesalahan lebih awal:

const simulationResult = await rpc.simulateTransaction(signedTransaction).send();

if (simulationResult.value.err) {
  console.error("Simulasi gagal:", simulationResult.value.err);
  // Tangani kesalahan tanpa membuang biaya
}

Simulasi mengeksekusi transaksi terhadap keadaan saat ini tanpa melakukan perubahan. Ini mengungkapkan kesalahan logika, akun yang tidak memadai, dan pelanggaran anggaran komputasi.

Perlindungan Pemutaran Ulang

Transaksi Solana mencakup blockhash terbaru yang kedaluwarsa setelah ~90 detik. Ini mencegah serangan pemutaran ulang—mengirimkan transaksi yang sama beberapa kali. Untuk operasi idempoten, hasilkan data instruksi atau akun unik per transaksi.

Pembatasan Tingkat Permintaan (Rate Limiting)

Titik akhir RPC publik menerapkan pembatasan tingkat permintaan yang ketat (biasanya 100 permintaan per 10 detik). Terapkan backoff eksponensial:

async function withRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.status === 429) {
        await new Promise(r => setTimeout(r, 1000 * Math.pow(2, i)));
        continue;
      }
      throw error;
    }
  }
}

Untuk produksi, gunakan node RPC khusus atau tingkat penyedia berbayar dengan batas yang lebih tinggi.

Verifikasi Program

Sebelum berinteraksi dengan program pihak ketiga, verifikasi kode sumbernya di penjelajah seperti SolanaFM atau Solscan. Cari lencana terverifikasi yang menunjukkan bytecode yang diterapkan cocok dengan repositori open-source. Program yang tidak terverifikasi mungkin berisi logika berbahaya yang menguras dana pengguna.

Kesimpulan

API Solana menghadirkan kinerja yang dibutuhkan aplikasi modern—finalitas di bawah satu detik, throughput tinggi, dan biaya yang dapat diprediksi. Anda mengkueri status akun melalui JSON-RPC, berlangganan pembaruan real-time melalui WebSocket, dan membangun transaksi menggunakan SDK Web3.js 2.0 fungsional. Arsitektur berbasis akun memungkinkan eksekusi paralel sementara tingkat komitmen memungkinkan Anda memilih pertukaran keamanan-kecepatan Anda.

Mulailah dengan Devnet untuk bereksperimen tanpa risiko finansial. Gunakan biaya prioritas selama kongesti Mainnet. Terapkan simulasi dan manajemen kunci yang tepat sebelum menyebarkan aplikasi yang menghadap pengguna. Ekosistem Solana menyediakan alatnya; logika aplikasi Anda menentukan nilainya.

Mulailah dengan Apidog hari ini—impor titik akhir API Solana Anda dalam hitungan detik dan mulai pengujian tanpa konfigurasi.

button

Mengembangkan API dengan Apidog

Apidog adalah alat pengembangan API yang membantu Anda mengembangkan API dengan lebih mudah dan efisien.

Daftar gratisUnduh
Cara Menggunakan Solana API: Panduan Lengkap untuk Developer