Como Usar getAccountInfo

​

Casos de Uso Comuns

• Verificando Saldo SOL: Determine o saldo SOL nativo de qualquer conta.
• Verificando Existência da Conta: Verifique se uma conta com uma determinada chave pública foi inicializada (ou seja, possui lamports ou dados).
• Inspecionando Contas de Programas: Recupere os dados armazenados em uma conta pertencente a um programa, o que é crucial para entender o estado de um programa.
• Identificando o Proprietário da Conta: Descubra qual programa é o proprietário de uma conta. Isso ajuda a determinar como os dados da conta devem ser interpretados ou se é uma conta pertencente ao sistema.
• Verificando se uma Conta é Executável: Identifique se uma conta contém um programa implantado.

​

Parâmetros

1. publicKey (string, obrigatório): A chave pública codificada em base-58 da conta a ser consultada.
2. config (objeto, opcional): Um objeto de configuração com os seguintes campos:
   • commitment (string, opcional): Especifica o nível de compromisso a ser usado para a consulta. O padrão é finalized.
     • finalized: O nó consultará o bloco mais recente confirmado pela supermaioria do cluster como tendo atingido o bloqueio máximo.
     • confirmed: O nó consultará o bloco mais recente que foi votado por uma supermaioria do cluster.
     • processed: O nó consultará seu bloco mais recente. Note que o bloco pode não estar completo.
   • encoding (string, opcional): A codificação para dados da conta. O padrão é base64.
     • base58 (lento)
     • base64
     • base64+zstd (se os dados estiverem comprimidos)
     • jsonParsed: Se os dados da conta forem um estado de programa conhecido (por exemplo, contas de token, contas de staking), o nó tentará analisá-lo em uma estrutura JSON. Para contas de programas genéricos, geralmente retorna para binário (base64).
   • dataSlice (objeto, opcional): Limita os dados da conta retornados a um segmento específico. Disponível apenas para as codificações base58, base64 ou base64+zstd.
     • offset (número): O número de bytes do início dos dados da conta para começar o segmento.
     • length (número): O número de bytes a serem retornados.
   • minContextSlot (número, opcional): O slot mínimo em que a solicitação pode ser avaliada.

​

Resposta

• context (objeto): Contém metadados sobre a solicitação.
  • slot (número): O slot em que a informação foi recuperada.
  • apiVersion (string, opcional): A versão da API RPC.
• value (objeto | null): Se a conta não existir, isso será null. Caso contrário, é um objeto que contém:
  • lamports (número): O número de lamports (1 SOL = 1.000.000.000 lamports) possuídos pela conta.
  • owner (string): A chave pública codificada em base-58 do programa que possui esta conta.
  • data (array | objeto | string): Os dados armazenados na conta. O formato depende do parâmetro encoding usado na solicitação.
    • Para base64 (padrão), base58, base64+zstd: Isso geralmente é um array [encoded_string, encoding_format], por exemplo, ["string_data", "base64"].
    • Para jsonParsed: Isso pode ser um objeto JSON se os dados forem analisáveis pelo nó RPC (por exemplo, para contas de Token SPL). Caso contrário, pode retornar a ["", "base64"] ou similar se os dados não forem reconhecidos como um layout padrão.
  • executable (booleano): true se a conta contiver um programa, false caso contrário.
  • rentEpoch (número): A próxima época em que esta conta deve aluguel.
  • space (número, opcional): O comprimento dos dados em bytes. (Nota: Os documentos oficiais do Solana listam space, enquanto alguns provedores de RPC podem incluí-lo. Representa o espaço total alocado para os dados da conta). Para mais detalhes sobre dados de conta e desserialização, consulte nosso guia detalhado.

​

Exemplo: Obtendo Informações da Conta

curl https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY -X POST -H "Content-Type: application/json" -d \
'{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getAccountInfo",
  "params": [
    "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin",
    {
      "encoding": "jsonParsed"
    }
  ]
}'

const { Connection, PublicKey } = require('@solana/web3.js');

async function getAccountDetails() {
  const rpcUrl = 'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY'; // Replace YOUR_API_KEY
  const connection = new Connection(rpcUrl, 'confirmed');
  const accountPubKey = new PublicKey('9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin');

  try {
    const accountInfo = await connection.getAccountInfo(accountPubKey);

    if (accountInfo === null) {
      console.log('Account not found.');
      return;
    }

    console.log('Account Info:');
    console.log(`   Lamports: ${accountInfo.lamports}`);
    console.log(`   Owner: ${accountInfo.owner.toBase58()}`);
    console.log(`   Executable: ${accountInfo.executable}`);
    console.log(`   Rent Epoch: ${accountInfo.rentEpoch}`);
    // Data is a Buffer, you might need to deserialize it based on the account type
    // console.log(`   Data: ${accountInfo.data.toString()}`); 
  } catch (error) {
    console.error('Error fetching account info:', error);
  }
}

getAccountDetails();

import { address, createSolanaRpc } from "@solana/kit";

const rpc_url = "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY";
const rpc = createSolanaRpc(rpc_url);

const publicKey = address("vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg");
const accountInfo = await rpc.getAccountInfo(publicKey).send();

console.log("Account Info:", accountInfo);

use solana_client::nonblocking::rpc_client::RpcClient;
use solana_sdk::{commitment_config::CommitmentConfig, pubkey::Pubkey};
use anyhow::Result;
use std::str::FromStr;

#[tokio::main]
async fn main() -> Result<()> {
    let client = RpcClient::new_with_commitment(
        String::from("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY"),
        CommitmentConfig::confirmed()
    );
    let pubkey = Pubkey::from_str("vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg")?;
    let account = client.get_account(&pubkey).await?;

    println!("{:#?}", account);

    Ok(())
}

​

Dicas para Desenvolvedores

• Desempenho: Para aplicativos que exigem verificações frequentes de várias contas, considere usar getMultipleAccounts para agrupar solicitações e reduzir idas e voltas.
• Desserialização de Dados: O campo data geralmente requer desserialização com base nas estruturas de dados do programa proprietário. Ferramentas e bibliotecas específicas para o programa (por exemplo, biblioteca de Token SPL para contas de token) geralmente são necessárias. Nosso post no blog sobre desserialização de dados de conta fornece técnicas e exemplos úteis.
• Limites de Taxa: Esteja atento aos limites de taxa do nó RPC, especialmente ao consultar um grande número de contas ou fazer solicitações frequentes.
• Gestão de Custos: getAccountInfo é geralmente uma consulta de baixo custo, mas a sondagem frequente pode se acumular. Otimize seus padrões de consulta.
• Use jsonParsed com Sabedoria: Embora jsonParsed possa ser conveniente, pode não suportar todos os tipos de conta, e sua saída pode mudar se um programa atualizar suas estruturas de dados. Para aplicativos críticos, analisar dados binários com um layout conhecido oferece mais estabilidade.
• Considere dataSlice: Se você só precisar de uma pequena parte dos dados de uma conta, use dataSlice para reduzir a quantidade de dados transferidos e potencialmente diminuir os custos de consulta.

​

Métodos Relacionados