Noções Básicas de Python para Solana

9 exemplos para você começar a usar Python para Solana - 6 básicos e 3 intermediários. Abrange quando o Python faz sentido, leituras de RPC, construção de transações, AnchorPy e fluxos de trabalho de dados em clusters Agave 4.1.1.

Pré-requisitos

Crie um ambiente virtual e instale a pilha principal do Python:

 
python3 -m venv .venv
source .venv/bin/activate
pip install solders solana anchorpy httpx pandas polars
 

para devnet (corresponde aos padrões Solana CLI 3.0.10):

 
export SOLANA_RPC_URL=https://api.devnet.solana.com
 

Exemplos Básicos

1. Quando Python se encaixa

Python é a ferramenta certa para automação off-chain, não para programas on-chain.

 
# Good fits
USE_CASES = [
    "market-making and arbitrage bots",
    "backend APIs that build and relay transactions",
    "indexing, ETL, and analytics into pandas/Polars",
    "research notebooks and one-off ops scripts",
]
 
# Poor fit
ON_CHAIN = "Use Rust + Anchor 0.32.1 for programs deployed via cargo build-sbf"
 

• O código on-chain deve ser compilado para sBPF - Python não pode ser executado no tempo de execução Sealevel
• Python brilha onde I/O, agendamento e ferramentas de dados dominam
• Continue assinando chaves fora dos cadernos; use env vars ou um gerenciador de segredos

Relacionado: solders & solana-py - o par principal do SDK

2. Conecte-se ao RPC

solana-py expõe um cliente HTTP assíncrono para JSON-RPC.

 
from solana.rpc.async_api import AsyncClient
 
RPC = "https://api.devnet.solana.com"
 
async def main():
    async with AsyncClient(RPC) as client:
        slot = (await client.get_slot()).value
        print(f"Current slot: {slot}")
 
# asyncio.run(main())  # uncomment in a script
 

• Prefira AsyncClient para bots que pesquisam assinaturas ou distribuem leituras
• Fixar URL RPC por ambiente - nunca codificar mainnet em scripts de desenvolvimento
• Endpoints públicos com limite de taxa; use um provedor pago para bots de produção

Relacionado: Leitura de dados da cadeia - contas e tokens

3. Leia uma balança com tipos de solders

solders espelha primitivos Solana em Python com desempenho Rust.

 
from solders.pubkey import Pubkey
from solana.rpc.api import Client
 
SYSTEM_PROGRAM = Pubkey.from_string("11111111111111111111111111111111")
client = Client("https://api.devnet.solana.com")
 
resp = client.get_balance(SYSTEM_PROGRAM)
print(f"Lamports: {resp.value}")
 

• Os saldos são lamports (inteiros) - nunca use flutuadores para matemática de token
• Pubkey valida base58 na construção - detecta erros de digitação antecipadamente
• Os tipos solders interoperam com construtores de solicitação solana-py

4. Carregar um par de chaves do arquivo

Corresponda ao formato do par de chaves que Solana CLI 3.0.10 grava.

 
from solders.keypair import Keypair
 
kp = Keypair.from_bytes(bytes(open("/path/to/id.json", "rb").read()))
print(kp.pubkey())
 

• Caminho CLI padrão: ~/.config/solana/id.json (JSON da matriz secreta de 64 bytes)
• Nunca confirme arquivos de par de chaves - use segredos .gitignore e CI
• Para bots, prefira uma carteira quente dedicada de baixo saldo por estratégia

Relacionado: Construindo transações em Python - fluxos de assinatura

5. Crie uma instrução de transferência simples

Componha instruções com solders e, em seguida, conclua uma transação.

 
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 Transaction
 
payer = Keypair()  # replace with your keypair
dest = Pubkey.from_string("Recipient1111111111111111111111111111111")
ix = transfer(TransferParams(from_pubkey=payer.pubkey(), to_pubkey=dest, lamports=1_000_000))
blockhash = Hash.from_string("11111111111111111111111111111111")  # fetch fresh via RPC
msg = Message.new_with_blockhash([ix], payer.pubkey(), blockhash)
tx = Transaction.new_unsigned(msg)
tx.sign([payer], blockhash)
 

• Sempre busque um blockhash recente do RPC - o espaço reservado acima é apenas ilustrativo
• As transferências de programas do sistema são o caminho de envio ponta a ponta mais simples
• A simulação deve preceder os envios da mainnet (ver exemplos intermediários)

6. Simule antes de enviar

Detecte erros de conta e CU sem gastar taxas.

 
from solana.rpc.types import TxOpts
 
sig = client.send_transaction(tx, opts=TxOpts(skip_preflight=False, preflight_commitment="confirmed"))
print(sig.value)
 

• skip_preflight=False executa simulação dentro do nó RPC
• Analisar logs em caso de falha na depuração de contas ausentes ou erros de programa
• Os bots devem tentar novamente com um novo blockhash quando os relatórios de simulação expirarem

Relacionado: Trading & Bots - padrões de automação

Exemplos intermediários

7. Chame um programa anchor com AnchorPy

Carregue um IDL e invoque instruções com clientes digitados.

 
from anchorpy import Program, Provider, Wallet
from solana.rpc.async_api import AsyncClient
 
async def call_anchor():
    client = AsyncClient("https://api.devnet.solana.com")
    wallet = Wallet.local()  # uses ANCHOR_WALLET or default path
    provider = Provider(client, wallet)
    program = await Program.at("<PROGRAM_ID>", provider)
    # await program.rpc["initialize"](...)
 

• AnchorPy tem como alvo formas IDL Anchor 0.32.x - regenera IDL após alterações no programa
• Wallet.local() espelha o comportamento do Anchor TS para dev; use caminhos-chave explícitos em prod
• Mantenha o ID do programa e a versão IDL fixados por implantação

Relacionado: AnchorPy - guia completo do cliente

8. Paginar consultas de contas grandes

Evite respostas getProgramAccounts gigantes únicas.

 
from solana.rpc.types import MemcmpOpts
 
filters = [MemcmpOpts(offset=0, bytes="...")]  # program-specific discriminator
resp = client.get_program_accounts(
    Pubkey.from_string("<PROGRAM_ID>"),
    encoding="base64",
    filters=filters,
)
 

• Adicione filtros memcmp em discriminadores para reduzir cargas úteis
• Para análises, prefira um indexador ou exportação BigTable em vez de varreduras RPC brutas
• Respeite os limites de paginação do provedor - intervalo de lote por slot, quando disponível

Relacionado: Análise de dados - pipelines pandas/Polars

9. Log estruturado para bots

Torne a resposta a incidentes tratável quando as transações não ocorrerem.

 
import logging
 
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("solana-bot")
 
def on_send_failure(signature: str, err: Exception):
    log.error("send_failed sig=%s err=%s", signature, err)
 

• Slot de registro, idade do blockhash, taxa de prioridade e registros de simulação em caso de falha
• Correlacionar com Agave 4.1.1 RPC getSignatureStatuses para rastreamento de confirmação
• Envie logs para sua pilha de observabilidade - o stdout sozinho é frágil na produção

Relacionado: Python for Solana Best Practices - lista de verificação de produção

Versões Stack: Esta página foi 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 e LiteSVM 0.6.x.