solana-program & solana-sdk

solana-program es la biblioteca estándar en cadena para programas nativos de Rust dirigidos a Agave 4.1.1 sBPF. solana-sdk (y sus crates de cliente divididos) potencian binarios de Rust fuera de cadena que construyen transacciones, las firman y se comunican con RPC. Juntos son la base de Anchor 0.32.1 y frameworks ligeros como Pinocchio.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

# En cadena (Cargo.toml)
[dependencies]
solana-program = "2.2"
 
# Binario cliente fuera de cadena
[dependencies]
solana-sdk = "2.2"

use solana_program::{
    account_info::AccountInfo,
    entrypoint,
    entrypoint::ProgramResult,
    pubkey::Pubkey,
};

Cuándo recurrir a esto:

• Escribir programas nativos en cadena sin las macros de Anchor.
• Construir CLIs, bots o bancos de pruebas de Rust fuera de cadena.
• Entender en qué se expande Anchor bajo el capó.
• Auditar la validación de cuentas de bajo nivel y los ayudantes de CPI.

Ejemplo de Trabajo

// programs/native_counter/src/lib.rs (en cadena)
use solana_program::{
    account_info::{next_account_info, AccountInfo},
    entrypoint,
    entrypoint::ProgramResult,
    msg,
    program_error::ProgramError,
    pubkey::Pubkey,
};
 
entrypoint!(process_instruction);
 
pub fn process_instruction(
    _program_id: &Pubkey,
    accounts: &[AccountInfo],
    _instruction_data: &[u8],
) -> ProgramResult {
    let iter = &mut accounts.iter();
    let payer = next_account_info(iter)?;
    if !payer.is_signer {
        return Err(ProgramError::MissingRequiredSignature);
    }
    msg!("payer: {}", payer.key);
    Ok(())
}

// client/src/main.rs (fuera de cadena)
use solana_sdk::{
    signature::{Keypair, Signer},
    system_instruction,
    transaction::Transaction,
};
use solana_client::rpc_client::RpcClient;
 
fn main() {
    let rpc = RpcClient::new("https://api.devnet.solana.com".to_string());
    let payer = Keypair::new();
    let ix = system_instruction::transfer(&payer.pubkey(), &payer.pubkey(), 1);
    let bh = rpc.get_latest_blockhash().unwrap();
    let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], bh);
    let _sig = rpc.send_and_confirm_transaction(&tx).unwrap();
}

Lo que esto demuestra:

• El punto de entrada en cadena recibe cuentas y datos de instrucción.
• Las comprobaciones de firma son manuales en código nativo.
• El SDK fuera de cadena compone instrucciones del sistema y firma transacciones.
• El cliente RPC es separado (solana-client) pero se empareja con tipos de solana-sdk.

Inmersión Profunda

Cómo Funciona

• solana-program es compatible con no_std para destinos sBPF a través de cargo build-sbf.
• solana-sdk tiene como objetivo el std completo de Rust para hosts que construyen y firman transacciones.
• Los crates se dividen en las líneas 2.x: importa solo lo que cada binario necesita para reducir el tiempo de compilación.
• anchor-lang de Anchor reexporta y envuelve muchos primitivos de solana-program.

Tabla de Crates de Rust (en cadena vs. fuera de cadena)

Tabla de TypeScript / NPM (paridad de cliente)

Notas de Rust

// Programas: evitar crates solo std en Cargo.toml
// Clientes: preferir solana_sdk::commitment_config::CommitmentConfig::confirmed()
 
// Importaciones de ejemplo de CPI
use solana_program::program::invoke;

Trampas

• Mezclar familias de crates 1.x y 2.x - Desajustes de tipos en el espacio de trabajo. Solución: una generación de SDK por repositorio, alineada con Agave 4.1.1.
• std en crates en cadena - Rompe cargo build-sbf. Solución: auditar cargo tree para dependencias prohibidas.
• Usar solana-sdk dentro de programas - Tira características incompatibles. Solución: solo solana-program en cadena.
• Tipos de pubkey duplicados en crates - Cambio de conversión. Solución: estandarizar importaciones por binario.
• Asumir que Anchor oculta la validación - El código nativo debe forzar el propietario/firmante manualmente.

Alternativas

Preguntas Frecuentes

Relacionado

• anchor-lang & anchor-spl - crates de framework
• Fundamentos de Programas Nativos - patrones nativos
• Fundamentos de Rust para Solana - introducción a Rust
• Fundamentos de @solana/kit - pila de cliente TS

Versiones de la pila: Esta página se escribió para Agave 4.1.1, Solana CLI 3.0.10, Anchor 0.32.1, anchor-lang 0.32.1, Rust 1.91.1, @solana/kit 7.0.0, Surfpool 0.12.0 y LiteSVM 0.6.x.