solders y solana-py

solders proporciona primitivas de Solana rápidas y tipadas en Python; solana-py (importa solana) envuelve JSON-RPC, ayudantes de transacciones y suscripciones de websocket. Juntos, son la pila Python fuera de la cadena predeterminada contra los nodos RPC de Agave 4.1.1.

Receta

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

pip install solders solana
 
from solders.pubkey import Pubkey
from solders.keypair import Keypair
from solana.rpc.api import Client
 
client = Client("https://api.devnet.solana.com")
payer = Keypair()
balance = client.get_balance(payer.pubkey()).value

Cuándo usar esto:

• Crear bots o backends que lean el estado de la cadena y envíen transacciones.
• Necesitar rendimiento de grado Rust para serialización y manejo de claves en Python.
• Evitar herramientas pesadas de JavaScript cuando tu equipo ya ejecuta servicios en Python.
• Prototipar scripts de operaciones que reflejen los flujos de trabajo de Solana CLI 3.0.10.

Ejemplo de Trabajo

import asyncio
from solders.keypair import Keypair
from solders.pubkey import Pubkey
from solders.system_program import TransferParams, transfer
from solders.hash import Hash
from solders.message import Message
from solders.transaction import VersionedTransaction
from solana.rpc.async_api import AsyncClient
from solana.rpc.types import TxOpts
 
RPC = "https://api.devnet.solana.com"
RECIPIENT = Pubkey.from_string("11111111111111111111111111111111")
 
async def main():
    payer = Keypair()
    async with AsyncClient(RPC) as client:
        bh_resp = await client.get_latest_blockhash()
        blockhash = Hash.from_string(str(bh_resp.value.blockhash))
 
        ix = transfer(
            TransferParams(
                from_pubkey=payer.pubkey(),
                to_pubkey=RECIPIENT,
                lamports=1_000,
            )
        )
        msg = Message.new_with_blockhash([ix], payer.pubkey(), blockhash)
        tx = VersionedTransaction(msg, [payer])
 
        sim = await client.simulate_transaction(tx)
        if sim.value.err:
            raise RuntimeError(sim.value.err)
 
        sig = await client.send_transaction(
            tx,
            opts=TxOpts(skip_preflight=True, preflight_commitment="confirmed"),
        )
        print("signature:", sig.value)
 
asyncio.run(main())

Lo que esto demuestra:

• solders construye instrucciones, mensajes y transacciones versionadas.
• AsyncClient recupera blockhashes y envía transacciones.
• La simulación detecta fallos antes de gastar tarifas.
• VersionedTransaction es el predeterminado moderno en los clústeres de Agave 4.x.

Inmersión Profunda

Cómo Funciona

• solders se enlaza a implementaciones de Rust de tipos de Solana (Pubkey, Keypair, Instruction, sysvars).
• solana-py implementa JSON-RPC 2.0 sobre HTTP/WebSocket con tipos compatibles con solders.
• La serialización cruza el límite Python/Rust para rutas críticas como la firma y el empaquetado de mensajes.
• Ninguno de los paquetes compila programas en cadena; empareja con Anchor 0.32.1 para el trabajo de programas.

Responsabilidades del Paquete

Notas de Python

# Los tipos de solders son inmutables - reconstruir en lugar de mutar
from solders.instruction import Instruction, AccountMeta
 
# Preferir codificaciones explícitas en llamadas RPC
client.get_account_info(pubkey, encoding="base64")
 
# Asíncrono para lecturas concurrentes en bots
async with AsyncClient(RPC) as client:
    await asyncio.gather(
        client.get_balance(pk1),
        client.get_balance(pk2),
    )

Trampas

• Mezclar ejemplos de web3.js con solders - los nombres de los campos y las formas de las transacciones difieren. Solución: seguir las APIs de mensajes de solders de principio a fin.
• Matemáticas de lamports con punto flotante - 0.1 * 1e9 introduce errores de redondeo. Solución: solo enteros de lamports.
• Blockhashes obsoletos en bucles largos - las transacciones expiran después de ~60-90s. Solución: actualizar el blockhash en cada intento.
• get_program_accounts sin límites - puede agotar la memoria de tu proceso. Solución: filtros memcmp e indexadores externos.
• Compromiso predeterminado finalized - demasiado lento para bots. Solución: usar confirmed o processed explícitamente por llamada.

Alternativas

Preguntas Frecuentes

Relacionado

• Conceptos Básicos de Python para Solana - introducción a la sección
• Construcción de Transacciones en Python - firma y envío
• AnchorPy - clientes IDL de Anchor
• Conceptos Básicos de RPC - conceptos de JSON-RPC

Versiones de la Pila: Esta página fue escrita 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.