Cómo Usar la API de Solana: Guía Completa para Desarrolladores

¿Qué pasaría si pudieras construir aplicaciones blockchain que procesaran 65,000 transacciones por segundo con una finalidad de 400 milisegundos? La API de Solana lo hace posible, ofreciendo una interfaz JSON-RPC que te permite consultar cuentas, enviar transacciones y suscribirte a actualizaciones en tiempo real sin tener que gestionar tu propia infraestructura de validadores.

El desarrollo tradicional de blockchain te obliga a elegir entre velocidad y descentralización. Los 15 TPS de Ethereum crean cuellos de botella durante la congestión de la red. Las soluciones de Capa 2 añaden complejidad. Solana elimina esta disyuntiva a través de su consenso de prueba de historial (Proof of History) combinado con prueba de participación (Proof of Stake), ofreciendo un rendimiento de Web2 con garantías de Web3. Construyes aplicaciones que se sienten instantáneas mientras mantienes la resistencia a la censura.

Tabla de Contenidos:

• Comprendiendo la Arquitectura de Solana
• Configurando Tu Entorno de Desarrollo
• Métodos Principales de la API RPC
• Construyendo Transacciones con Web3.js
• Mejores Prácticas de Seguridad
• Conclusión

Comprendiendo la Arquitectura de Solana

Solana utiliza una arquitectura única centrada en la Biblioteca de Programas de Solana (SPL) y un tiempo de ejecución de alto rendimiento. Comprender estos fundamentos te ayuda a escribir llamadas a la API eficientes.

Prueba de Historial (PoH)

PoH crea una marca de tiempo criptográfica para cada transacción antes del consenso. Esto elimina la necesidad de que los nodos se pongan de acuerdo sobre la hora, reduciendo la latencia drásticamente. Cuando envías una transacción a través de la API, se le asigna una marca de tiempo inmediatamente y entra en la cola del líder para su procesamiento.

Cuentas y Programas

A diferencia del modelo basado en cuentas de Ethereum con almacenamiento de código, Solana separa el código (programas) de los datos (cuentas). Los programas no tienen estado; solo contienen lógica ejecutable. Las cuentas almacenan datos y especifican qué programa las posee. Esta arquitectura permite el procesamiento paralelo de transacciones, ya que las cuentas no superpuestas pueden ejecutarse simultáneamente.

Cada cuenta tiene una dirección única de 32 bytes derivada de una clave pública Ed25519. Las cuentas pagan alquiler en lamports (1 SOL = 10^9 lamports) para permanecer en la cadena. Las cuentas exentas de alquiler, aquellas que tienen al menos 2 años de alquiler, persisten indefinidamente sin decaer.

Niveles de Compromiso

Solana ofrece tres niveles de confirmación:

• Processed (Procesado): Transacción procesada por el líder actual pero no confirmada. Respuesta más rápida, menor certeza.
• Confirmed (Confirmado): Transacción confirmada por el clúster. ~5-10 segundos en promedio.
• Finalized (Finalizado): Transacción raíz y no se puede revertir. ~12-15 segundos.

Especifica los niveles de compromiso en las llamadas a la API para equilibrar la velocidad con las garantías de finalidad.

Configurando Tu Entorno de Desarrollo

Necesitas tres componentes: la CLI de Solana para la gestión y despliegue de claves, un punto final RPC para el acceso a la blockchain y el SDK de JavaScript para la integración de aplicaciones.

Instalando la CLI de Solana

Instala la herramienta CLI oficial:

sh -c "$(curl -sSfL https://release.solana.com/stable/install)"

Verifica la instalación:

solana --version

Configura tu entorno para Devnet (pruebas) o Mainnet (producción):

# Para desarrollo
solana config set --url https://api.devnet.solana.com

# Para producción
solana config set --url https://api.mainnet-beta.solana.com

Creando una Cartera

Genera un nuevo par de claves para firmar transacciones:

solana-keygen new --outfile ~/.config/solana/id.json

La CLI muestra tu dirección pública y una frase semilla de 12 palabras. Almacena la frase semilla de forma segura, ya que recupera tu cartera. El archivo JSON contiene tu clave privada; protégela con permisos de archivo (chmod 600).

Verifica tu saldo:

solana balance

Financia tu cartera de Devnet con SOL gratis:

solana airdrop 2

Los airdrops de Devnet proporcionan 2 SOL por solicitud, limitado a una solicitud cada 10 segundos. Mainnet requiere la compra de SOL a través de exchanges.

Eligiendo un Proveedor RPC

Aunque Solana proporciona puntos finales RPC públicos, las aplicaciones de producción necesitan infraestructura dedicada. Las opciones incluyen:

• Helius: https://mainnet.helius-rpc.com/?api-key=TU_CLAVE
• QuickNode: https://solana-mainnet.g.alchemy.com/v2/TU_CLAVE
• Chainstack: Nodos dedicados de grado empresarial

Los niveles gratuitos suelen permitir 100,000 solicitudes al mes. Los planes de pago ofrecen límites más altos, conexiones garantizadas para el aterrizaje de transacciones y APIs de tarifas prioritarias.

Instalando Web3.js

El SDK de JavaScript de Solana tiene dos versiones principales. La versión 2.0 representa una reescritura completa con patrones de programación funcional, capacidad de eliminación de código no utilizado (tree-shakability) y cero dependencias.

Instala la versión 2.0:

npm install @solana/web3.js@2 @solana-program/system @solana-program/compute-budget

Para compatibilidad con la versión 1.x:

npm install @solana/web3.js

ConsejoApidogSolana

Métodos Principales de la API RPC de Solana

La API JSON-RPC de Solana proporciona puntos finales HTTP para consultas y puntos finales WebSocket para suscripciones. Todas las solicitudes siguen la especificación JSON-RPC 2.0.

Operaciones de Cuenta

Obtener información de la cuenta y saldo:

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getAccountInfo",
    "params": [
      "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36zEGQp",
      {"encoding": "base58"}
    ]
  }'

Obtener múltiples cuentas eficientemente:

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type": "application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getMultipleAccounts",
    "params": [
      [
        "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36zEGQp",
        "4fYNw3dojWGPgVMtUU7ziPwq1r2VMGrhCrKZC9EQTbkV"
      ],
      {"encoding": "base64"}
    ]
  }'

Consultas de Bloques y Transacciones

Obtener el hash del último bloque para la construcción de transacciones:

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getLatestBlockhash",
    "params": [{"commitment": "confirmed"}]
  }'

Consultar el estado de la transacción:

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getSignatureStatuses",
    "params": [
      [
        "5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpEz7CmGVZxhEHppBrGK"
      ],
      {"searchTransactionHistory": true}
    ]
  }'

Suscripciones WebSocket

Monitorizar cambios en la cuenta en tiempo real:

import { createSolanaRpcSubscriptions } from "@solana/web3.js";

const rpcSubscriptions = createSolanaRpcSubscriptions(
  "wss://api.devnet.solana.com"
);

const abortController = new AbortController();

await rpcSubscriptions.accountNotifications(
  "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36zEGQp",
  { commitment: "confirmed" },
  (notification) => {
    console.log("Account changed:", notification);
  },
  { abortSignal: abortController.signal }
);

// Stop listening after 60 seconds
setTimeout(() => abortController.abort(), 60000);

Las conexiones WebSocket requieren pings periódicos cada 30-60 segundos para permanecer activas. Implementa una lógica de reconexión para aplicaciones de producción.

Consejo ProApidogSolana

Construyendo Transacciones con Web3.js

Las transacciones de Solana consisten en una o más instrucciones dirigidas a programas específicos. Cada instrucción especifica el programa, las cuentas con las que interactúa y los datos serializados.

Creando una Transacción de Transferencia

Transfiere SOL entre cuentas usando el SDK versión 2.0:

import {
  airdropFactory,
  createKeyPairSignerFromBytes,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  generateKeyPairSigner,
  lamports,
  sendAndConfirmTransactionFactory,
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayer,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  signTransactionMessageWithSigners,
  getSignatureFromTransaction,
} from "@solana/web3.js";
import { getTransferSolInstruction } from "@solana-program/system";

const LAMPORTS_PER_SOL = BigInt(1_000_000_000);

// Setup RPC connections
const rpc = createSolanaRpc("https://api.devnet.solana.com");
const rpcSubscriptions = createSolanaRpcSubscriptions("wss://api.devnet.solana.com");
const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });

// Generate sender and recipient
const sender = await generateKeyPairSigner();
const recipient = await generateKeyPairSigner();

// Fund sender with airdrop
await airdropFactory({ rpc, rpcSubscriptions })({
  recipientAddress: sender.address,
  lamports: lamports(2n * LAMPORTS_PER_SOL),
  commitment: "confirmed",
});

// Get latest blockhash
const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

// Build transaction using pipe
const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }),
  (msg) => setTransactionMessageFeePayer(sender.address, msg),
  (msg) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, msg),
  (msg) => appendTransactionMessageInstruction(
    getTransferSolInstruction({
      amount: lamports(LAMPORTS_PER_SOL / BigInt(2)),
      destination: recipient.address,
      source: sender,
    }),
    msg
  )
);

// Sign and send
const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
console.log("Transaction signed");

await sendAndConfirmTransaction(signedTransaction, {
  commitment: "confirmed",
  maxRetries: 0n,
  skipPreflight: true,
});

console.log("Confirmed:", getSignatureFromTransaction(signedTransaction));

La función pipe crea una cadena funcional donde cada paso transforma el mensaje de la transacción. Este patrón elimina el estado mutable y hace que la construcción de transacciones sea declarativa.

Optimizando con Tarifas de Prioridad

Durante la congestión de la red, las tarifas de prioridad aseguran la inclusión de la transacción. Obtén las tarifas recomendadas de la API de Helius:

import { getBase64EncodedWireTransaction } from "@solana/web3.js";

const base64Transaction = getBase64EncodedWireTransaction(signedTransaction);

const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_KEY", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: "priority-fee-request",
    method: "getPriorityFeeEstimate",
    params: [{
      transaction: base64Transaction,
      options: { recommended: true }
    }]
  })
});

const { result } = await response.json();
const priorityFee = result.priorityFeeEstimate;

// Add priority fee instruction
import { getSetComputeUnitPriceInstruction } from "@solana-program/compute-budget";

const optimizedMessage = pipe(
  transactionMessage,
  (msg) => appendTransactionMessageInstruction(
    getSetComputeUnitPriceInstruction({ microLamports: priorityFee }),
    msg
  )
);

Las tarifas de prioridad se especifican en microlamports por unidad de computación. Tarifas más altas aumentan la prioridad de la transacción durante la congestión.

Manejo de Errores

Solana devuelve códigos de error específicos para fallos comunes:

import { isSolanaError, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE } from "@solana/web3.js";

try {
  await sendAndConfirmTransaction(signedTransaction);
} catch (error) {
  if (isSolanaError(error)) {
    switch (error.contextErrorCode) {
      case SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE:
        console.error("Preflight failed:", error.message);
        break;
      default:
        console.error("Solana error:", error);
    }
  }
}

Los errores comunes incluyen fondos insuficientes (0x1), blockhash inválido (caducado) y cuenta en uso (conflictos de transacción).

Mejores Prácticas de Seguridad

El alto rendimiento de Solana introduce consideraciones de seguridad únicas. Implementa estas medidas para proteger tu aplicación y a tus usuarios.

Gestión de Claves

Nunca subas claves privadas al control de versiones. Usa variables de entorno:

# .env
SOLANA_PRIVATE_KEY="[1,2,3,...]"

Carga las claves de forma segura en tu aplicación:

import { createKeyPairSignerFromBytes } from "@solana/web3.js";
import { getBase58Encoder } from "@solana/codecs";

const secretKey = JSON.parse(process.env.SOLANA_PRIVATE_KEY);
const signer = await createKeyPairSignerFromBytes(
  new Uint8Array(secretKey)
);

Para aplicaciones de navegador, integra adaptadores de cartera (Phantom, Solflare) en lugar de manejar las claves privadas directamente. Los usuarios firman las transacciones a través de la extensión de su cartera, manteniendo las claves seguras.

Simulación de Transacciones

Siempre simula las transacciones antes de enviarlas para detectar errores temprano:

const simulationResult = await rpc.simulateTransaction(signedTransaction).send();

if (simulationResult.value.err) {
  console.error("Simulation failed:", simulationResult.value.err);
  // Handle error without wasting fees
}

La simulación ejecuta la transacción contra el estado actual sin confirmar cambios. Revela errores lógicos, cuentas insuficientes y violaciones del presupuesto de cómputo.

Protección contra Repeticiones

Las transacciones de Solana incluyen un blockhash reciente que caduca después de ~90 segundos. Esto previene ataques de repetición, es decir, enviar la misma transacción varias veces. Para operaciones idempotentes, genera datos de instrucción o cuentas únicos por transacción.

Limitación de Tasa (Rate Limiting)

Los puntos finales RPC públicos implementan una estricta limitación de tasa (típicamente 100 solicitudes cada 10 segundos). Implementa un retroceso exponencial:

async function withRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.status === 429) {
        await new Promise(r => setTimeout(r, 1000 * Math.pow(2, i)));
        continue;
      }
      throw error;
    }
  }
}

Para producción, usa nodos RPC dedicados o niveles de proveedor de pago con límites más altos.

Verificación de Programas

Antes de interactuar con programas de terceros, verifica su código fuente en exploradores como SolanaFM o Solscan. Busca insignias verificadas que indiquen que el bytecode desplegado coincide con los repositorios de código abierto. Los programas no verificados pueden contener lógica maliciosa que agota los fondos del usuario.

Conclusión

La API de Solana ofrece el rendimiento que exigen las aplicaciones modernas: finalidad en menos de un segundo, alto rendimiento y tarifas predecibles. Puedes consultar estados de cuentas a través de JSON-RPC, suscribirte a actualizaciones en tiempo real mediante WebSocket y construir transacciones utilizando el SDK funcional Web3.js 2.0. La arquitectura basada en cuentas permite la ejecución paralela, mientras que los niveles de compromiso te permiten elegir tu equilibrio entre seguridad y velocidad.

Empieza con Devnet para experimentar sin riesgo financiero. Usa tarifas de prioridad durante la congestión de Mainnet. Implementa la simulación y una gestión adecuada de las claves antes de desplegar aplicaciones orientadas al usuario. El ecosistema de Solana proporciona las herramientas; la lógica de tu aplicación determina el valor.

Empieza con Apidog hoy mismo: importa tus puntos finales de la API de Solana en segundos y comienza a realizar pruebas sin configuración alguna.