Cómo usar getAccountInfo

​

Casos de uso comunes

• Consultar el saldo de SOL: Determina el saldo nativo de SOL de cualquier cuenta.
• Verificar la existencia de una cuenta: Comprueba si se inicializó una cuenta con una clave pública determinada (es decir, si tiene lamports o datos).
• Inspeccionar cuentas de programas: Recupera los datos almacenados en una cuenta que pertenece a un programa. Esto es fundamental para comprender el estado de un programa.
• Identificar al propietario de una cuenta: Averigua qué programa es el propietario de una cuenta. Esto ayuda a determinar cómo interpretar los datos de la cuenta o si se trata de una cuenta propiedad del sistema.
• Comprobar si una cuenta es ejecutable: Identifica si una cuenta contiene un programa desplegado.

​

Parámetros

1. publicKey (string, obligatorio): La clave pública de la cuenta que se consultará, codificada en base 58.
2. config (object, opcional): Un objeto de configuración con los siguientes campos:
   • commitment (string, opcional): Especifica el nivel de compromiso que se usará para la consulta. El valor predeterminado es finalized.
     • finalized: El nodo consultará el bloque más reciente que la supermayoría del clúster haya confirmado que alcanzó el bloqueo máximo.
     • confirmed: El nodo consultará el bloque más reciente por el que haya votado una supermayoría del clúster.
     • processed: El nodo consultará su bloque más reciente. Ten en cuenta que es posible que el bloque no esté completo.
   • encoding (string, opcional): La codificación de los datos de la cuenta. El valor predeterminado es base64.
     • base58 (lento)
     • base64
     • base64+zstd (si los datos están comprimidos)
     • jsonParsed: Si los datos de la cuenta corresponden a un estado de programa conocido (por ejemplo, cuentas de tokens o cuentas de participación), el nodo intentará analizarlos como una estructura JSON. Para las cuentas de programas genéricas, normalmente se utilizarán datos binarios (base64).
   • dataSlice (object, opcional): Limita los datos de la cuenta devueltos a una sección específica. Solo está disponible para las codificaciones base58, base64 o base64+zstd.
     • offset (number): La cantidad de bytes desde el inicio de los datos de la cuenta donde comenzará la sección.
     • length (number): La cantidad de bytes que se devolverán.
   • minContextSlot (number, opcional): El slot mínimo en el que se puede evaluar la solicitud.

​

Respuesta

• context (object): Contiene metadatos sobre la solicitud.
  • slot (number): El slot en el que se recuperó la información.
  • apiVersion (string, opcional): La versión de la API RPC.
• value (object | null): Si la cuenta no existe, el valor será null. De lo contrario, será un objeto que contiene:
  • lamports (number): La cantidad de lamports (1 SOL = 1,000,000,000 lamports) que posee la cuenta.
  • owner (string): La clave pública codificada en base 58 del programa que posee esta cuenta.
  • data (array | object | string): Los datos almacenados en la cuenta. El formato depende del parámetro encoding utilizado en la solicitud.
    • Para base64 (valor predeterminado), base58, base64+zstd: Normalmente, es un array [encoded_string, encoding_format]; por ejemplo, ["string_data", "base64"].
    • Para jsonParsed: Puede ser un objeto JSON si el nodo RPC puede analizar los datos (por ejemplo, para cuentas de tokens SPL). De lo contrario, puede usar de forma predeterminada ["", "base64"] o un valor similar si los datos no se reconocen como un diseño estándar.
  • executable (boolean): true si la cuenta contiene un programa; de lo contrario, false.
  • rentEpoch (number): La siguiente época en la que esta cuenta deberá pagar alquiler.
  • space (number, opcional): La longitud de los datos en bytes. (Nota: La documentación oficial de Solana incluye space y algunos proveedores de RPC también podrían incluirlo. Representa el espacio total asignado a los datos de la cuenta). Para obtener más información sobre los datos de cuentas y la deserialización, consulta nuestra guía detallada.

​

Ejemplo: Obtener información de una cuenta

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(())
}

​

Consejos para desarrolladores

• Rendimiento: Para aplicaciones que necesitan consultar varias cuentas con frecuencia, considera usar getMultipleAccounts para agrupar las solicitudes y reducir los viajes de ida y vuelta.
• Deserialización de datos: El campo data suele requerir deserialización según las estructuras de datos del programa propietario. Por lo general, se necesitan herramientas y bibliotecas específicas del programa (por ejemplo, la biblioteca SPL Token para cuentas de tokens). Nuestra publicación sobre la deserialización de datos de cuentas ofrece técnicas y ejemplos útiles.
• Límites de frecuencia: Ten en cuenta los límites de frecuencia del nodo RPC, especialmente al consultar una gran cantidad de cuentas o enviar solicitudes frecuentes.
• Administración de costos: getAccountInfo suele ser una consulta de bajo costo, pero las consultas periódicas frecuentes pueden acumular costos. Optimiza tus patrones de consulta.
• Usa jsonParsed con cuidado: Aunque jsonParsed puede ser conveniente, es posible que no admita todos los tipos de cuenta y su resultado puede cambiar si un programa actualiza sus estructuras de datos. Para aplicaciones críticas, analizar datos binarios con un diseño conocido ofrece mayor estabilidad.
• Considera dataSlice: Si solo necesitas una pequeña parte de los datos de una cuenta, usa dataSlice para reducir la cantidad de datos transferidos y, posiblemente, disminuir los costos de consulta.

​

Métodos relacionados