Python para Solana

Python é uma linguagem off-chain de primeira classe para Solana. As equipes o usam para bots, serviços de back-end, notebooks de pesquisa, ETL e automação de operações em nós RPC do Agave 4.1.1.

Ele não é executado dentro do tempo de execução do Sealevel. Os programas on-chain permanecem Rust (geralmente Anchor 0.32.1), construídos e implantados com Solana CLI 3.0.10. Python se comunica com esses programas por meio de JSON-RPC, websockets e clientes IDL.

Esta página é o guarda-chuva da seção. Os artigos irmãos cobrem o par SDK, construção de transações, AnchorPy, leituras, bots, análises e hábitos de produção.

Resumo

• Idéia principal: Use Python para ler o estado de Solana, criar e assinar transações, chamar programas Anchor via IDL e canalizar dados da cadeia para pilhas de análise - sempre como um cliente do cluster, nunca como bytecode do programa.
• Por que é importante: Muitas equipes de quantificação, dados e plataformas já disponibilizam Python. solders + solana-py + AnchorPy permitem que eles integrem Solana sem reescrever serviços em TypeScript, enquanto ainda emparelham com front-ends @solana/kit 7.0.0 quando carteiras e navegadores são a superfície do produto.
• Conceitos principais: soldas, solana-py (solana), AnchorPy, VersionedTransaction, blockhash, simulação/preflight, AsyncClient, getProgramAccounts/filtros, API DAS, pandas/Polares, Python vs Kit.
• Quando usar Python: Bots de criação de mercado e arb, back-ends de custódia ou retransmissão, ETL adjacente ao indexador, métricas de tesouraria e protocolo, scripts de pesquisa e operações que refletem fluxos de trabalho CLI.
• Limitações/Compensações: Sem execução na cadeia; o adaptador de carteira e o UX do navegador são mais fracos que o kit TS; limites públicos de taxas de RPC punem bots ingênuos; gerenciamento de chaves e expiração do blockhash são problemas de produção que você possui.
• Tópicos relacionados: Python para Solana Basics, soldas e solana-py, Construindo transações em Python, AnchorPy, Leitura de dados da cadeia, Análise de dados.

Fundações

A fonte do programa Solana é Rust 1.91.1 visando sBPF. Python nunca entra nesse caminho de compilação. Seu processo é um tempo de execução de host normal que:

1. Conecta-se ao RPC (HTTP e WebSocket opcional).
2. Desserializa contas e meta de transação.
3. Constrói instruções e mensagens com tipos de soldas.
4. Assina com pares de chaves que você controla (ou retorna txs não assinados para carteiras de usuários).
5. Envia e confirma os níveis de compromisso do cluster.

Essa separação é todo o modelo. O estado durável do aplicativo reside nas contas. Os programas as modificam. Python observa, programa e às vezes sinaliza.

A pilha padrão do Python é:

Fixe URLs RPC e IDs de programas por ambiente. Os scripts de desenvolvimento não devem apontar silenciosamente para mainnet-beta. Para trabalho local, combine Solana CLI 3.0.10 (solana-test-validator ou fluxos de trabalho de equipe Surfpool/LiteSVM para programas) com um venv Python para código de cliente.

O dinheiro é sempre inteiro: lamports e unidades básicas de token. Nunca use floats para saldos, taxas ou PnL que devam corresponder à cadeia.

Mecânica e interações

soldas e solana-py

soldas é o tipo e a camada de serialização. Ele espelha os primitivos Solana com desempenho Rust em toda a fronteira do Python. Prefira construtores de soldas para instruções, metas de contas e empacotamento de mensagens, em vez de formatos de fios enrolados manualmente.

solana-py (caminho de importação solana) é a camada de rede. Use-o para:

• get_latest_blockhash, get_balance, get_account_info
• simulate_transaction e send_transaction
• get_signatures_for_address, get_transaction
• Websockets assíncronos para notificações de contas e assinaturas

O solana-py moderno espera tipos de soldas. Trate-os como uma pilha, não como SDKs concorrentes. Detalhes e receitas de copiar e colar estão em solders & solana-py.

Construindo e enviando transações

O caminho feliz para uma transação construída em Python:1. Elaborar instruções (transferência de programa do sistema, token SPL, programa anchor ix, orçamento de cálculo). 2. Busque um blockhash recente do RPC. 3. Crie uma mensagem com pagador de taxas e lista ix (Message.new_with_blockhash ou APIs de mensagens versionadas). 4. Entre em um VersionedTransaction (ou legado somente quando uma dependência o forçar). 5. Simular (preflight ou simulação explícita) e inspecionar logs/CU. 6. Enviar com política de compromisso e nova tentativa; atualize o blockhash ao expirar.

Taxas de prioridade e limites de computação são instruções comuns (solda ajudantes de orçamento de computação). Coloque-os no início da mensagem. Os bots de longa duração devem tratar a vida útil do blockhash e as regras de assinatura duplicada como preocupações centrais do circuito de controle, e não como casos extremos.

Os padrões de composição completos estão em Building Transactions in Python.

Programas AnchorPy e Anchor

Se o programa on-chain for Anchor 0.32.1, envie o IDL de anchor build e carregue-o com AnchorPy. Isso lhe dá:

• Construtores de instruções com discriminadores correspondentes ao programa
• Clientes de conta para fetch / decodificação
• Provider ligação de cliente RPC, carteira e opções padrão

Fluxo de trabalho:

1. Construa e implante o programa (Rust + Anchor + CLI).
2. Versione o IDL JSON com o ID do programa para cada cluster.
3. Em Python: Provider + Program.at(...) ou Idl.from_json explícito.
4. Ligue para program.rpc["instruction_name"](...) ou crie instruções para lotes personalizados.

Gere novamente clientes quando o IDL for alterado. Discriminadores incompatíveis ou ordem de conta falham na simulação ou no tempo de execução. AnchorPy fica em soldas/solana-py; você ainda possui blockhash, simulação e confirmação. Consulte AnchorPy.

Lendo dados da cadeia

As leituras dominam a maioria dos serviços Python de produção.

RPC principal

• Bytes e lamports da conta: get_account_info (bruto ou jsonParsed quando compatível)
• Saldo nativo: get_balance
• Participações SPL: get_token_accounts_by_owner (e variantes jsonParsed)
• História: get_signatures_for_address então get_transaction
• Varreduras: get_program_accounts com filtros memcmp em discriminadores ou campos fixos

DAS (Padrão de Ativos Digitais)

Os portfólios NFT e cNFT geralmente precisam de um endpoint DAS do provedor (getAsset, pesquisa, provas). Use httpx ou clientes HTTP semelhantes quando solana-py não encapsula o método; mantenha URLs DAS e chaves de API fora do git.

Hábitos de leitura de produção

• Prefira clientes assíncronos sob carga simultânea
• Encadernado get_program_accounts com filtros; não despeje programas inteiros em RPC público
• Para análises pesadas, use indexadores ou exportações de armazém em vez de raspar a rede principal ao vivo
• Decodifique layouts de conta com soldas, ajudantes Borsh ou tipos de conta AnchorPy - não divisões de string ad-hoc

Aprofundamentos: Lendo dados da cadeia.

Pipelines de análise

A vantagem comparativa do Python é a pilha de dados: pandas, Polars, NumPy, notebooks e ferramentas de ML.

Fluxo típico:

1. Colete assinaturas ou instantâneos de contas (RPC, buffer de websocket ou despejo de indexador).
2. Normalize as linhas: assinatura, slot, taxa, sucesso, ID do programa, campos analisados.
3. Carregue em Polares (lotes grandes) ou pandas (cadernos exploratórios).
4. Junte-se a tabelas fora da cadeia (usuários, campanhas, pontuações de risco).
5. Publique métricas, alertas ou recursos de treinamento.

Trate o tempo da cadeia (slots, tempos de bloco) com cuidado; as chaves de junção geralmente são pubkey, assinatura ou mint. Lamports permanecem inteiros até a apresentação. Padrões e enquadramento: Análise de dados.

Alinhamento de operações com CLI e validadores

Os scripts Python devem concordar com a forma como os operadores usam Solana CLI 3.0.10: mesmo URL RPC, mesmo formato JSON de par de chaves (Keypair.from_bytes na matriz secreta de 64 bytes), mesmo cluster (devnet/mainnet-beta/local). A semântica RPC do Agave 4.1.1 (compromisso, meta de simulação, relatórios de unidade de computação) é o que seu cliente deve lidar - não um "Python Solana" separado.

Considerações e aplicações avançadas

Quando Python vs TypeScript (@solana/kit 7.0.0)

Muitas organizações executam ambos: Kit no aplicativo voltado para o usuário; Python para dados de mercado, risco, rebalanceamento e operações. O formato de transferência é o mesmo - transações com versão e JSON RPC. Não invente uma segunda interface de programa por idioma; compartilhe IDs de programas, versões de IDL e documentos de layout de contas.

Padrões de arquitetura que envelhecem bem

• Carteira quente + política: bots possuem chaves com saldo baixo; cold ou multisig para movimentos de tesouraria.
• Construa não assinado, assine em outro lugar: backends preparam mensagens; Sinal de HSMs ou carteiras de usuários.
• Simule sempre caminhos de dinheiro: a simulação detecta contas perdidas, estouros de CU e PDAs ruins antes das taxas.
• Confirme com propósito: processed para UX ágil não é liquidação para contabilidade; escolha compromisso por risco.
• Estratégias idempotentes: novas tentativas não devem gastar o dobro; use IDs de pedidos do lado do cliente e exclusividade na cadeia onde os programas permitirem.
• Observabilidade: slot de log, idade do blockhash, taxa de prioridade, logs de simulação e status de assinatura em cada classe de falha.

Bots e automação (visualização do escopo)

A negociação e a automação unem leituras de RPC, construtores de transações e limites de risco em um ciclo de controle. Isso se baseia nos mesmos fundamentos desta visão geral; as páginas da seção para negociação e práticas recomendadas cobrem ritmo, taxas de prioridade e tratamento de falhas sem transformar o Python em uma caixa preta de estratégia.

Híbrido com Anchor e programas nativos

Python não se importa se o programa é Anchor, nativo solana-program ou Pinocchio. Você precisa do ID do programa, metas da conta e bytes de instrução corretos. AnchorPy reduz esse custo para Anchor IDLs. Para programas nativos, construa manualmente com soldas ou mantenha pequenos codecs compartilhados com testes Rust.

Equívocos comuns

• "Python pode ser executado on-chain se eu usar a biblioteca correta." Não. Somente programas sBPF são executados no SVM. Python é sempre um cliente.
• "soldas e solana-py são alternativas." São complementares: tipos vs RPC. As pilhas modernas usam ambos.
• "Se funcionar em exemplos web3.js, a porta Python é um para um." Nomes de campos, formatos de transação e APIs assíncronas são diferentes. Siga as APIs de mensagens de solda de ponta a ponta.
• "AnchorPy substitui contas compreensivas e discriminadores." Gera conveniência nas mesmas regras de transferência; IDLs ruins ainda produzem txs ruins.
• "RPC público gratuito é adequado para bots de produção." Limites de taxa e vizinhos barulhentos quebram loops sensíveis à latência. Faça um orçamento de um fornecedor.
• "skip_preflight me acelera com segurança." Ele pode ocultar falhas que você teria detectado de graça. Use-o apenas com os olhos abertos.
• "Floats são aceitáveis ​​para valores de USDC em pandas." Prefira unidades base inteiras por meio de cálculo; formato para exibição por último.
• "getProgramAccounts é uma análise gratuita." As varreduras não filtradas são pesadas; os provedores os restringem ou rejeitam. Prefira filtros ou indexadores.
• "TypeScript é sempre melhor para Solana." Kit ganha para carteiras e web. Python vence em dados e muitas propriedades de back-end. Escolha pela superfície, não pela moda.
• "Um par de chaves mainnet em um notebook é adequado para demonstrações." Vazamento de notebooks. Use segredos de ambiente e chaves dedicadas de baixo privilégio.

Perguntas frequentes