Buku Panduan Solana

Development Lokal

Memulai Validator Lokal

Menguji kode program anda secara lokal bisa jauh lebih andal daripada pengujian di devnet, dan bisa membantu anda menguji sebelum mencobanya di devnet.

Anda bisa mengatur validator pengujian lokal anda dengan menginstal solana tool suite dan menjalankannya.

solana-test-validator

Keuntungan menggunakan validator uji lokal meliputi:

  • Tidak ada batas kecepatan RPC
  • Tidak ada batasan airdrop
  • Penyebaran program on-chain langsung (--bpf-program ...)
  • Mengkloning akun dari cluster publik, termasuk program (--clone ...)
  • Retensi riwayat transaksi yang dapat dikonfigurasi (--limit-ledger-size ...)
  • Panjang zaman yang dapat dikonfigurasi (--slots-per-epoch ...)
  • Lompat ke slot arbitrer (--warp-slot ...)

Menghubungkan Ke Environment

Saat anda mengerjakan pengembangan Solana, anda harus terhubung ke titik akhir API RPC tertentu. Solana memiliki 3 alamat environment:

  • mainnet-beta https://api.mainnet-beta.solana.com
  • devnet https://api.devnet.solana.com
  • testnet https://api.testnet.solana.com
Press </> button to view full source
import { clusterApiUrl, Connection } from "@solana/web3.js";

(async () => {
  const connection = new Connection(clusterApiUrl("mainnet-beta"), "confirmed");
})();

from solana.rpc.api import Client

client = Client("https://api.mainnet-beta.solana.com")

#include "solana.hpp"

using namespace many::solana;

int main() {
    Connection connection("https://api.mainnet-beta.solana.com");
    return 0;
}

use solana_client::rpc_client::RpcClient;
use solana_sdk::commitment_config::CommitmentConfig;

fn main() {
    let rpc_url = String::from("https://api.mainnet-beta.solana.com");
    let client = RpcClient::new_with_commitment(rpc_url, CommitmentConfig::confirmed());
}

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

Terakhir, anda juga dapat terhubung ke cluster pribadi, baik satu lokal atau berjalan dari jarak jauh sebagai berikut:

Press </> button to view full source
import { Connection } from "@solana/web3.js";

(async () => {
  // This will connect you to your local validator
  const connection = new Connection("http://127.0.0.1:8899", "confirmed");
})();

from solana.rpc.api import Client

client = Client("http://127.0.0.1:8899")

#include "solana.hpp"

using namespace many::solana;

int main() {
    Connection connection("http://127.0.0.1:8899");
    return 0;
}

use solana_client::rpc_client::RpcClient;
use solana_sdk::commitment_config::CommitmentConfig;

fn main() {
    let rpc_url = String::from("http://127.0.0.1:8899");
    let client = RpcClient::new_with_commitment(rpc_url, CommitmentConfig::confirmed());
}

solana config set --url http://privaterpc.com

Subskripsi Event

Soket web menyediakan antarmuka pub/sub dimana anda bisa mendengarkan event tertentu. Alih-alih melakukan ping ke titik akhir HTTP biasa pada suatu interval untuk mendapatkan pembaruan yang sering, Anda dapat menerima pembaruan tersebut hanya ketika itu terjadi.

Web3 Solana Connectionopen in new window di bawah tenda menghasilkan titik akhir websocket dan mendaftarkan klien websocket saat anda membuat instansi Connection baru. (see source code hereopen in new window).

Kelas Connection mengekspos metode pub/sub - semuanya dimulai dengan on, seperti pemancar peristiwa. Saat anda memanggil metode pendengar ini, itu mendaftarkan langganan baru ke klien websocket dari instansi Connection itu. Contoh metode pub/sub yang kami gunakan di bawah ini adalah onAccountChangeopen in new window. Panggilan balik akan memberikan data status yang diperbarui melalui argumen (see AccountChangeCallbackopen in new window as an example).

Press </> button to view full source
import { clusterApiUrl, Connection, Keypair } from "@solana/web3.js";

(async () => {
  // Establish new connect to devnet - websocket client connected to devnet will also be registered here
  const connection = new Connection(clusterApiUrl("devnet"), "confirmed");

  // Create a test wallet to listen to
  const wallet = Keypair.generate();

  // Register a callback to listen to the wallet (ws subscription)
  connection.onAccountChange(
    wallet.publicKey(),
    (updatedAccountInfo, context) =>
      console.log("Updated account info: ", updatedAccountInfo),
    "confirmed"
  );
})();

import asyncio
from solders.keypair import Keypair
from solana.rpc.websocket_api import connect

async def main():
    async with connect("wss://api.devnet.solana.com") as websocket:
        # Create a Test Wallet
        wallet = Keypair()
        # Subscribe to the Test wallet to listen for events
        await websocket.account_subscribe(wallet.pubkey())
        # Capture response from account subscription 
        first_resp = await websocket.recv()
        print("Subscription successful with id {}, listening for events \n".format(first_resp.result))
        updated_account_info = await websocket.recv()
        print(updated_account_info)
        
asyncio.run(main())

// clang++ on_account_change.cpp -o on_account_change -std=c++17 -lssl -lcrypto -lsodium

#include "solana.hpp"

using namespace many::solana;

int main() {
  Connection connection("https://api.devnet.solana.com");

  auto key_pair = Keypair::generate();

  int subscriptionId = connection.on_account_change(key_pair.public_key, [&](Result<Account> result) {
    Account account = result.unwrap();
    std::cout << "owner = " << account.owner.to_base58() << std::endl;
    std::cout << "lamports = " << account.lamports << std::endl;
    std::cout << "data = " << account.data << std::endl;
    std::cout << "executable = " << (account.executable ? "true" : "false") << std::endl;
  });

  sleep(1);

  std::string tx_hash = connection.request_airdrop(key_pair.public_key).unwrap();
  std::cout << "tx hash = " << tx_hash << std::endl;

  for (int i = 0; i < 10; i++) {
    connection.poll();
    sleep(1);
  }

  connection.remove_account_listener(subscriptionId);

  return 0;
}

use solana_client::pubsub_client::PubsubClient;
use solana_client::rpc_config::RpcAccountInfoConfig;
use solana_sdk::commitment_config::CommitmentConfig;
use solana_sdk::signature::{Keypair, Signer};

fn main() {
    let wallet = Keypair::new();
    let pubkey = Signer::pubkey(&wallet);
    let ws_url = String::from("wss://api.devnet.solana.com/");
    println!("{}", ws_url);
    if let Ok(subscription) = PubsubClient::account_subscribe(
        &ws_url,
        &pubkey,
        Some(RpcAccountInfoConfig {
            encoding: None,
            data_slice: None,
            commitment: Some(CommitmentConfig::confirmed()),
        }),
    ) {
        let (mut ws_client, receiver) = subscription;
        println!("Subscription successful, listening for events");
        let handle = std::thread::spawn(move || loop {
            println!("Waiting for a message");
            match receiver.recv() {
                Ok(message) => println!("{:?}", message),
                Err(err) => {
                    println!("Connection broke with {:}", err);
                    break;
                }
            }
        });
        handle.join().unwrap();
        ws_client.shutdown().unwrap()
    } else {
        println!("Errooooor");
    }
}

Mendapatkan Tes SOL

Saat anda bekerja secara lokal, anda memerlukan beberapa SOL untuk mengirim transaksi. Di lingkungan non-mainnet anda dapat menerima SOL dengan mengirimkannya ke alamat anda.

Press </> button to view full source
import { Connection, Keypair, LAMPORTS_PER_SOL } from "@solana/web3.js";

(async () => {
  const keypair = Keypair.generate();

  const connection = new Connection("http://127.0.0.1:8899", "confirmed");

  const signature = await connection.requestAirdrop(
    keypair.publicKey,
    LAMPORTS_PER_SOL
  );
  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
  await connection.confirmTransaction({
      blockhash,
      lastValidBlockHeight,
      signature
    });
})();

from solders.keypair import Keypair
from solana.rpc.api import Client

wallet = Keypair()

client = Client("https://api.devnet.solana.com")

#Input Airdrop amount in LAMPORTS
client.request_airdrop(wallet.pubkey(), 1000000000)

#Airdrops 1 SOL

// clang++ request_airdrop.cpp -o request_airdrop -std=c++17 -lssl -lcrypto -lsodium

#include "solana.hpp"

using namespace many::solana;

int main() {
  Connection connection("https://api.devnet.solana.com");

  auto key_pair = Keypair::generate();

  std::string tx_hash = connection.request_airdrop(key_pair.public_key).unwrap();

  std::cout << "tx hash = " << tx_hash << std::endl;

  return 0;
}

use solana_client::rpc_client::RpcClient;
use solana_sdk::commitment_config::CommitmentConfig;
use solana_sdk::native_token::LAMPORTS_PER_SOL;
use solana_sdk::signature::{Keypair, Signer};

fn main() {
    let wallet = Keypair::new();
    let pubkey = Signer::pubkey(&wallet);
    let rpc_url = String::from("https://api.devnet.solana.com");
    let client = RpcClient::new_with_commitment(rpc_url, CommitmentConfig::confirmed());
    match client.request_airdrop(&pubkey, LAMPORTS_PER_SOL) {
        Ok(sig) => loop {
            if let Ok(confirmed) = client.confirm_transaction(&sig) {
                if confirmed {
                    println!("Transaction: {} Status: {}", sig, confirmed);
                    break;
                }
            }
        },
        Err(_) => println!("Error requesting airdrop"),
    };
}

solana airdrop 1

# Return
# "1 SOL"

Menggunakan Akun dan Program Mainnet

Seringkali, pengujian lokal bergantung pada program dan akun yang hanya tersedia di mainnet. Solana CLI mengizinkan keduanya:

  • Mengunduh Program dan Akun
  • Memuat Program dan Akun ke validator lokal

Cara memuat akun dari mainnet

Dimungkinkan untuk mengunduh akun mint token SRM ke file:

Press </> button to view full source
# solana account -u <source cluster> --output <output format> --output-file <destination file name/path> <address of account to fetch>
solana account -u m --output json-compact --output-file SRM_token.json SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt

Memuatnya ke localnet anda kemudian dilakukan dengan meneruskan file akun dan alamat ujuan (pada cluster lokal) saat memulai validator:

Press </> button to view full source
# solana-test-validator --account <address to load the account to> <path to account file> --reset
solana-test-validator --account SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt SRM_token.json --reset

Cara memuat program dari mainnet

Demikian pula, dimungkinkan untuk mengunduh program OpenBook Dex v3:

Press </> button to view full source
# solana program dump -u <source cluster> <address of account to fetch> <destination file name/path>
solana program dump -u m 9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin OpenBook_dex_v3.so

Memuatnya ke localnet anda kemudian dilakukan dengan meneruskan file program dan alamat tujuan (pada cluster lokal) saat memulai validator:

Press </> button to view full source
# solana-test-validator --bpf-program <address to load the program to> <path to program file> --reset
solana-test-validator --bpf-program 9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin OpenBook_dex_v3.so --reset
Last Updated:
Contributors: Partially Sorted, akangaziz