Desarrollando programas en Rust
Los programas de Solana se desarrollan principalmente utilizando el lenguaje de programación Rust. Esta página se centra en escribir programas de Solana en Rust sin utilizar el framework Anchor, un enfoque que a menudo se conoce como escribir programas "Rust nativo".
El desarrollo en Rust nativo proporciona a los desarrolladores un control directo sobre sus programas de Solana. Sin embargo, este enfoque requiere más configuración manual y código repetitivo en comparación con el uso del framework Anchor. Este método es recomendado para desarrolladores que:
- Buscan un control granular sobre la lógica del programa y las optimizaciones
- Quieren aprender los conceptos subyacentes antes de pasar a frameworks de más alto nivel
Para principiantes, recomendamos comenzar con el framework Anchor. Consulta la sección Anchor para más información.
Requisitos previos
Para instrucciones detalladas de instalación, visita la página de instalación.
Antes de comenzar, asegúrate de tener instalado lo siguiente:
- Rust: El lenguaje de programación para construir programas de Solana.
- Solana CLI: Herramienta de línea de comandos para el desarrollo en Solana.
Primeros pasos
El ejemplo a continuación cubre los pasos básicos para crear tu primer programa de Solana escrito en Rust. Crearemos un programa mínimo que imprime "Hello, world!" en el registro del programa.
Crear un nuevo programa
Primero, crea un nuevo proyecto de Rust utilizando el comando estándar
cargo new
con la bandera --lib
.
$cargo new hello_world --lib
Navega al directorio del proyecto. Deberías ver los archivos predeterminados
src/lib.rs
y Cargo.toml
$cd hello_world
Actualiza el campo edition
en Cargo.toml
a 2021
. De lo contrario,
podrías encontrar un error al compilar el programa.
Añadir la dependencia solana-program
A continuación, añade la dependencia solana-program
. Esta es la dependencia
mínima requerida para construir un programa de Solana.
$cargo add solana-program@2.2.0
Añadir el crate-type
A continuación, añade el siguiente fragmento a Cargo.toml
.
[lib]crate-type = ["cdylib", "lib"]
Si no incluyes esta configuración, el directorio target/deploy
no se
generará cuando construyas el programa.
Tu archivo Cargo.toml
debería verse así:
[package]name = "hello_world"version = "0.1.0"edition = "2021"[lib]crate-type = ["cdylib", "lib"][dependencies]solana-program = "2.2.0"
Añadir el código del programa
A continuación, reemplaza el contenido de src/lib.rs
con el siguiente código.
Este es un programa mínimo de Solana que imprime "Hello, world!" en el registro
del programa cuando el programa es invocado.
La macro msg!
se utiliza en los programas de Solana para imprimir un mensaje
en el registro del programa.
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(())}
Construir el programa
A continuación, construye el programa usando el comando cargo build-sbf
.
$cargo build-sbf
Este comando genera un directorio target/deploy
que contiene dos archivos
importantes:
- Un archivo
.so
(p. ej.,hello_world.so
): Este es el programa de Solana compilado que será desplegado en la red como un "contrato inteligente". - Un archivo keypair (p. ej.,
hello_world-keypair.json
): La clave pública de este keypair se utiliza como ID del programa al desplegarlo.
Para ver el ID del programa, ejecuta el siguiente comando en tu terminal. Este comando imprime la clave pública del keypair en la ruta de archivo especificada:
$solana address -k ./target/deploy/hello_world-keypair.json
Ejemplo de salida:
4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMz
Añadir dependencias de prueba
A continuación, prueba el programa usando el crate litesvm
. Añade las
siguientes dependencias a Cargo.toml
.
$cargo add litesvm --dev$cargo add solana-sdk@2.2.0 --dev
Probar el programa
Añade la siguiente prueba a src/lib.rs
, debajo del código del programa. Este
es un módulo de prueba que invoca el programa hello world.
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(())}#[cfg(test)]mod test {use litesvm::LiteSVM;use solana_sdk::{instruction::Instruction,message::Message,signature::{Keypair, Signer},transaction::Transaction,};#[test]fn test_hello_world() {// Create a new LiteSVM instancelet mut svm = LiteSVM::new();// Create a keypair for the transaction payerlet payer = Keypair::new();// Airdrop some lamports to the payersvm.airdrop(&payer.pubkey(), 1_000_000_000).unwrap();// Load our programlet program_keypair = Keypair::new();let program_id = program_keypair.pubkey();svm.add_program_from_file(program_id, "target/deploy/hello_world.so").unwrap();// Create instruction with no accounts and no datalet instruction = Instruction {program_id,accounts: vec![],data: vec![],};// Create transactionlet message = Message::new(&[instruction], Some(&payer.pubkey()));let transaction = Transaction::new(&[&payer], message, svm.latest_blockhash());// Send transaction and verify it succeedslet result = svm.send_transaction(transaction);assert!(result.is_ok(), "Transaction should succeed");let logs = result.unwrap().logs;println!("Logs: {logs:#?}");}}
Ejecuta la prueba usando el comando cargo test
. El registro del programa
mostrará "Hello, world!".
$cargo test -- --no-capture
Ejemplo de salida:
running 1 testLogs: ["Program 9528phXNvdWp5kkR4rgpoeZvR8ZWT5THVywK95YRprkk invoke [1]","Program log: Hello, world!","Program 9528phXNvdWp5kkR4rgpoeZvR8ZWT5THVywK95YRprkk consumed 211 of 200000 compute units","Program 9528phXNvdWp5kkR4rgpoeZvR8ZWT5THVywK95YRprkk success",]test test::test_hello_world ... oktest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.05s
Desplegar el programa
A continuación, despliega el programa. Cuando desarrollamos localmente, podemos
usar el solana-test-validator
.
Primero, configura la CLI de Solana para usar el cluster local de Solana.
$solana config set -ul
Ejemplo de salida:
Config File: /.config/solana/cli/config.ymlRPC URL: http://localhost:8899WebSocket URL: ws://localhost:8900/ (computed)Keypair Path: /.config/solana/id.jsonCommitment: confirmed
Abre una nueva terminal y ejecuta el comando solana-test-validators
para
iniciar el validator local.
$solana-test-validator
Mientras el validator de prueba está en ejecución, ejecuta el comando
solana program deploy
en una terminal separada para desplegar el programa en
el validator local.
$solana program deploy ./target/deploy/hello_world.so
Ejemplo de salida:
Program Id: 4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMzSignature:5osMiNMiDZGM7L1e2tPHxU8wdB8gwG8fDnXLg5G7SbhwFz4dHshYgAijk4wSQL5cXiu8z1MMou5kLadAQuHp7ybH
Puedes inspeccionar el ID del programa y la firma de la transacción en Solana Explorer.
Ten en cuenta que el clúster en Solana Explorer también debe ser localhost. La
opción "Custom RPC URL" en Solana Explorer tiene por defecto
http://localhost:8899
.
Crear cliente de ejemplo
A continuación, demostraremos cómo invocar el programa utilizando un cliente Rust.
Primero crea un directorio examples
y un archivo client.rs
.
$mkdir -p examples && touch examples/client.rs
Añade lo siguiente a Cargo.toml
.
[[example]]name = "client"path = "examples/client.rs"
Añade las dependencias solana-client
y tokio
.
$cargo add solana-client@2.2.0 --dev$cargo add tokio --dev
Añadir el cliente
Añade el siguiente código a examples/client.rs
. Este es un script cliente en
Rust que financia un nuevo keypair para pagar las tarifas de transacción y luego
invoca el programa hello world.
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),}}
Reemplazar el ID del programa
Antes de ejecutar el código del cliente, reemplaza el ID del programa en el fragmento de código con el de tu programa.
Puedes obtener el ID de tu programa ejecutando el siguiente comando.
$solana address -k ./target/deploy/hello_world-keypair.json
Invocar el programa
Ejecuta el script del cliente con el siguiente comando.
$cargo run --example client
Ejemplo de salida:
Transaction Signature: 54TWxKi3Jsi3UTeZbhLGUFX6JQH7TspRJjRRFZ8NFnwG5BXM9udxiX77bAACjKAS9fGnVeEazrXL4SfKrW7xZFYV
Puedes inspeccionar la firma de la transacción en Solana Explorer (clúster local) para ver "Hello, world!" en el registro del programa.
Actualizar el programa
Los programas de Solana pueden actualizarse mediante la reimplementación al
mismo ID de programa. Actualiza el programa en src/lib.rs
para que imprima
"Hello, Solana!" en lugar de "Hello, world!".
pub fn process_instruction(_program_id: &Pubkey,_accounts: &[AccountInfo],_instruction_data: &[u8],) -> ProgramResult {-msg!("Hello, world!");+msg!("Hello, Solana!");Ok(())}
Ejecuta el comando cargo build-sbf
para generar un archivo .so
actualizado.
$cargo build-sbf
Prueba el programa actualizado ejecutando el comando cargo test
.
$cargo test -- --no-capture
Deberías ver "Hello, Solana!" en el registro del programa.
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
Reimplementar el programa
Reimplementa el programa usando el mismo comando solana program deploy
.
$solana program deploy ./target/deploy/hello_world.so
Ejecuta el código del cliente nuevamente e inspecciona la firma de la transacción en Solana Explorer para ver "Hello, Solana!" en el registro del programa.
$cargo run --example client
Cerrar el programa
Puedes cerrar tu programa de Solana para recuperar el SOL asignado a la cuenta. Cerrar un programa es irreversible, por lo que debe hacerse con precaución.
Para cerrar un programa, utiliza el comando solana program close <PROGRAM_ID>
.
Por ejemplo:
$solana program close 4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMz --bypass-warning
Ejemplo de salida:
Closed Program Id 4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMz, 0.1350588 SOLreclaimed
Ten en cuenta que una vez que un programa se cierra, su ID de programa no puede reutilizarse. Intentar desplegar un programa con un ID de programa previamente cerrado resultará en un error.
Error: Program 4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMz has been closed, usea new Program Id
Redesplegar un programa cerrado
Si necesitas redesplegar un programa con el mismo código fuente después de cerrar un programa, debes generar un nuevo ID de programa. Para generar un nuevo keypair para el programa, ejecuta el siguiente comando:
$solana-keygen new -o ./target/deploy/hello_world-keypair.json --force
Alternativamente, puedes eliminar el archivo keypair existente (por ejemplo
./target/deploy/hello_world-keypair.json
) y ejecutar cargo build-sbf
de
nuevo, lo que generará un nuevo archivo keypair.
Is this page helpful?