Programma's ontwikkelen in Rust
Solana-programma's worden voornamelijk ontwikkeld met de programmeertaal Rust. Deze pagina richt zich op het schrijven van Solana-programma's in Rust zonder gebruik te maken van het Anchor framework, een aanpak die vaak wordt aangeduid als het schrijven van "native Rust"-programma's.
Native Rust-ontwikkeling geeft ontwikkelaars directe controle over hun Solana-programma's. Deze aanpak vereist echter meer handmatige configuratie en standaardcode in vergelijking met het gebruik van het Anchor-framework. Deze methode wordt aanbevolen voor ontwikkelaars die:
- Gedetailleerde controle zoeken over programmalogica en optimalisaties
- De onderliggende concepten willen leren voordat ze overstappen naar frameworks van hoger niveau
Voor beginners raden we aan om te starten met het Anchor-framework. Zie de Anchor sectie voor meer informatie.
Vereisten
Voor gedetailleerde installatie-instructies, bezoek de installatiepagina.
Voordat je begint, zorg ervoor dat je het volgende hebt geïnstalleerd:
- Rust: De programmeertaal voor het bouwen van Solana-programma's.
- Solana CLI: Command-line tool voor Solana-ontwikkeling.
Aan de slag
Het onderstaande voorbeeld behandelt de basisstappen om je eerste Solana-programma geschreven in Rust te maken. We zullen een minimaal programma maken dat "Hello, world!" afdrukt in het programmalogboek.
Een nieuw programma maken
Maak eerst een nieuw Rust-project met het standaard cargo new
commando met de
--lib
vlag.
$cargo new hello_world --lib
Navigeer naar de projectmap. Je zou de standaard src/lib.rs
en Cargo.toml
bestanden moeten zien
$cd hello_world
Werk het edition
veld in Cargo.toml
bij naar 2021
. Anders kun je een
foutmelding krijgen bij het bouwen van het programma.
Voeg de solana-program dependency toe
Voeg vervolgens de solana-program
dependency toe. Dit is de minimale
dependency die nodig is om een Solana-programma te bouwen.
$cargo add solana-program@2.2.0
Voeg het crate-type toe
Voeg vervolgens het volgende fragment toe aan Cargo.toml
.
[lib]crate-type = ["cdylib", "lib"]
Als je deze configuratie niet opneemt, wordt de target/deploy
map niet
gegenereerd wanneer je het programma bouwt.
Je Cargo.toml
bestand zou er als volgt uit moeten zien:
[package]name = "hello_world"version = "0.1.0"edition = "2021"[lib]crate-type = ["cdylib", "lib"][dependencies]solana-program = "2.2.0"
Voeg de programmacode toe
Vervang vervolgens de inhoud van src/lib.rs
met de volgende code. Dit is een
minimaal Solana-programma dat "Hello, world!" naar het programmalogboek print
wanneer het programma wordt aangeroepen.
De msg!
macro wordt in Solana-programma's gebruikt om een bericht naar het
programmalogboek te printen.
use solana_program::{account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, msg, pubkey::Pubkey,};entrypoint!(process_instruction);pub fn process_instruction(_program_id: &Pubkey,_accounts: &[AccountInfo],_instruction_data: &[u8],) -> ProgramResult {msg!("Hello, world!");Ok(())}
Bouw het programma
Bouw vervolgens het programma met het cargo build-sbf
commando.
$cargo build-sbf
Dit commando genereert een target/deploy
map met twee belangrijke bestanden:
- Een
.so
bestand (bijv.hello_world.so
): Dit is het gecompileerde Solana-programma dat naar het netwerk wordt gedeployed als een "smart contract". - Een keypair bestand (bijv.
hello_world-keypair.json
): De publieke sleutel van deze keypair wordt gebruikt als programma-ID bij het deployen van het programma.
Om de programma-ID te bekijken, voer je het volgende commando uit in je terminal. Dit commando print de publieke sleutel van de keypair op het opgegeven bestandspad:
$solana address -k ./target/deploy/hello_world-keypair.json
Voorbeelduitvoer:
$ cargo build-sbf
$ cargo build-sbf --sbf-out-dir=./dist/program
BuildOptions {bpf_sdk: "/home/runner/.local/share/solana/install/releases/1.18.4/solana-release/bin/sdk/bpf",dump: false,features: "",no_default_features: false,debug: false,jobs: 16,arch: "sbf",out_dir: "./dist/program",}...To deploy this program:$ solana program deploy dist/program/helloworld.soThe program address will default to this keypair (override with --program-id):dist/program/helloworld-keypair.json
Testafhankelijkheden toevoegen
Test vervolgens het programma met behulp van de litesvm
crate. Voeg de
volgende afhankelijkheden toe aan Cargo.toml
.
[dev-dependencies]solana-program-test = "~1.18.4"solana-sdk = "~1.18.4"
[features]test-sbf = []
Test het programma
Voeg de volgende test toe aan src/lib.rs
, onder de programmacode. Dit is een
testmodule die het hello world programma aanroept.
#[cfg(test)]mod test {use super::*;use solana_program::instruction::{AccountMeta, Instruction};use solana_program_test::*;use solana_sdk::{signature::Signer, transaction::Transaction};#[tokio::test]async fn test_transaction() {let program_id = Pubkey::new_unique();let (mut banks_client, payer, recent_blockhash) = ProgramTest::new("helloworld",program_id,processor!(process_instruction),).start().await;let instruction = Instruction::new_with_bincode(program_id,&[0],vec![],);let mut transaction = Transaction::new_with_payer(&[instruction],Some(&payer.pubkey()),);transaction.sign(&[&payer], recent_blockhash);banks_client.process_transaction(transaction).await.unwrap();}}
Voer de test uit met het cargo test
commando. Het programmalogboek zal "Hello,
world!" weergeven.
$ cargo test-sbf
Voorbeelduitvoer:
BuildOptions {bpf_sdk: "/home/runner/.local/share/solana/install/releases/1.18.4/solana-release/bin/sdk/bpf",dump: false,features: "test-sbf",no_default_features: false,debug: false,jobs: 16,arch: "sbf",out_dir: "target/deploy",}...Running test test::test_transaction...Program log: Hello, world!test test::test_transaction ... ok
Implementeer het programma
Implementeer vervolgens het programma. Bij lokale ontwikkeling kunnen we de
solana-test-validator
gebruiken.
Configureer eerst de Solana CLI om de lokale Solana cluster te gebruiken.
$ solana config set --url localhost
Voorbeelduitvoer:
Config File: /home/runner/.config/solana/cli/config.ymlRPC URL: http://localhost:8899WebSocket URL: ws://localhost:8900 (computed)Keypair Path: /home/runner/.config/solana/id.jsonCommitment: confirmed
Open een nieuwe terminal en voer het solana-test-validators
commando uit om de
lokale validator te starten.
$ solana-test-validator
Terwijl de testvalidator draait, voer het solana program deploy
commando uit
in een aparte terminal om het programma te implementeren op de lokale validator.
$ solana program deploy dist/program/helloworld.so
Voorbeelduitvoer:
Program Id: 4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMzSignature:5osMiNMiDZGM7L1e2tPHxU8wdB8gwG8fDnXLg5G7SbhwFz4dHshYgAijk4wSQL5cXiu8z1MMou5kLadAQuHp7ybH
Je kunt de programma-ID en transactiehandtekening bekijken op Solana Explorer.
Let op dat de cluster op Solana Explorer ook localhost moet zijn. De optie
"Custom RPC URL" op Solana Explorer staat standaard op
http://localhost:8899
.
Maak een voorbeeldclient
Vervolgens laten we zien hoe je het programma kunt aanroepen met een Rust-client.
Maak eerst een examples
map en een client.rs
bestand.
$mkdir -p examples && touch examples/client.rs
Voeg het volgende toe aan Cargo.toml
.
[[example]]name = "client"path = "examples/client.rs"
Voeg de afhankelijkheden solana-client
en tokio
toe.
$cargo add solana-client@2.2.0 --dev$cargo add tokio --dev
Voeg de client toe
Voeg de volgende code toe aan examples/client.rs
. Dit is een Rust-clientscript
dat een nieuwe keypair financiert om transactiekosten te betalen en vervolgens
het hello world-programma aanroept.
use solana_client::rpc_client::RpcClient;use solana_sdk::{commitment_config::CommitmentConfig,instruction::Instruction,pubkey::Pubkey,signature::{Keypair, Signer},transaction::Transaction,};use std::str::FromStr;#[tokio::main]async fn main() {// Program ID (replace with your actual program ID)let program_id = Pubkey::from_str("4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMz").unwrap();// Connect to the Solana devnetlet rpc_url = String::from("http://localhost:8899");let client = RpcClient::new_with_commitment(rpc_url, CommitmentConfig::confirmed());// Generate a new keypair for the payerlet payer = Keypair::new();// Request airdroplet airdrop_amount = 1_000_000_000; // 1 SOLlet signature = client.request_airdrop(&payer.pubkey(), airdrop_amount).expect("Failed to request airdrop");// Wait for airdrop confirmationloop {let confirmed = client.confirm_transaction(&signature).unwrap();if confirmed {break;}}// Create the instructionlet instruction = Instruction::new_with_borsh(program_id,&(), // Empty instruction datavec![], // No accounts needed);// Add the instruction to new transactionlet mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));transaction.sign(&[&payer], client.get_latest_blockhash().unwrap());// Send and confirm the transactionmatch client.send_and_confirm_transaction(&transaction) {Ok(signature) => println!("Transaction Signature: {}", signature),Err(err) => eprintln!("Error sending transaction: {}", err),}}
Vervang de programma-ID
Voordat je de clientcode uitvoert, vervang je de programma-ID in het codefragment door die van jouw programma.
Je kunt je programma-ID krijgen door het volgende commando uit te voeren.
$solana address -k ./target/deploy/hello_world-keypair.json
Roep het programma aan
Voer het clientscript uit met het volgende commando.
$cargo run --example client
Voorbeelduitvoer:
Transaction Signature: 54TWxKi3Jsi3UTeZbhLGUFX6JQH7TspRJjRRFZ8NFnwG5BXM9udxiX77bAACjKAS9fGnVeEazrXL4SfKrW7xZFYV
Je kunt de transactiehandtekening inspecteren op Solana Explorer (lokale cluster) om "Hello, world!" in het programmalogboek te zien.
Het programma bijwerken
Solana-programma's kunnen worden bijgewerkt door opnieuw te implementeren naar
dezelfde programma-ID. Werk het programma in src/lib.rs
bij om "Hello,
Solana!" af te drukken in plaats van "Hello, world!".
pub fn process_instruction(_program_id: &Pubkey,_accounts: &[AccountInfo],_instruction_data: &[u8],) -> ProgramResult {-msg!("Hello, world!");+msg!("Hello, Solana!");Ok(())}
Voer het commando cargo build-sbf
uit om een bijgewerkt .so
bestand te
genereren.
$cargo build-sbf
Test het bijgewerkte programma door het commando cargo test
uit te voeren.
$cargo test -- --no-capture
Je zou "Hello, Solana!" in het programmalogboek moeten zien.
running 1 testLogs: ["Program 5y8bHrnwfq2dLDgLn3WoTHb9dDuyorj9gyapW6aeyrpV invoke [1]","Program log: Hello, Solana!","Program 5y8bHrnwfq2dLDgLn3WoTHb9dDuyorj9gyapW6aeyrpV consumed 211 of 200000 compute units","Program 5y8bHrnwfq2dLDgLn3WoTHb9dDuyorj9gyapW6aeyrpV success",]test test::test_hello_world ... oktest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.08s
Het programma opnieuw implementeren
Implementeer het programma opnieuw met hetzelfde solana program deploy
commando.
$solana program deploy ./target/deploy/hello_world.so
Voer de clientcode opnieuw uit en inspecteer de transactiehandtekening op Solana Explorer om "Hello, Solana!" in het programmalogboek te zien.
$cargo run --example client
Het programma sluiten
Je kunt je Solana-programma sluiten om de SOL die aan het account is toegewezen terug te vorderen. Het sluiten van een programma is onomkeerbaar, dus dit moet met voorzichtigheid worden gedaan.
Om een programma te sluiten, gebruik je het commando
solana program close <PROGRAM_ID>
. Bijvoorbeeld:
$solana program close 4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMz --bypass-warning
Voorbeelduitvoer:
Closed Program Id 4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMz, 0.1350588 SOLreclaimed
Merk op dat zodra een programma is gesloten, de programma-ID niet opnieuw kan worden gebruikt. Een poging om een programma te implementeren met een eerder gesloten programma-ID zal resulteren in een fout.
Error: Program 4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMz has been closed, usea new Program Id
Een gesloten programma opnieuw implementeren
Als je een programma met dezelfde broncode opnieuw moet implementeren na het sluiten van een programma, moet je een nieuwe programma-ID genereren. Om een nieuwe keypair voor het programma te genereren, voer je het volgende commando uit:
$solana-keygen new -o ./target/deploy/hello_world-keypair.json --force
Als alternatief kun je het bestaande keypair-bestand (bijv.
./target/deploy/hello_world-keypair.json
) verwijderen en cargo build-sbf
opnieuw uitvoeren, wat een nieuw keypair-bestand zal genereren.
Is this page helpful?