Optimización de RPC de Solana: prácticas recomendadas de rendimiento y costos

Optimizar el uso de RPC puede mejorar significativamente el rendimiento, reducir costos y optimizar la experiencia del usuario. Esta guía abarca técnicas comprobadas para interactuar de forma eficiente con RPC de Solana.

Inicio rápido

Transaction Optimization

Optimiza las unidades de cómputo, las comisiones de prioridad y el envío de transacciones

Data Retrieval

Patrones eficientes para obtener datos de cuentas y programas

Real-time Monitoring

Suscripciones WebSocket y optimización de la transmisión de datos

Best Practices

Pautas de rendimiento y administración de recursos

Optimización de transacciones

Administración de unidades de cómputo

1. Simula para determinar el uso real:

const testTransaction = new VersionedTransaction(/* your transaction */);
const simulation = await connection.simulateTransaction(testTransaction, {
  replaceRecentBlockhash: true,
  sigVerify: false
});
const unitsConsumed = simulation.value.unitsConsumed;

2. Establece límites adecuados con un margen:

const computeUnitLimit = Math.ceil(unitsConsumed * 1.1);
const computeUnitIx = ComputeBudgetProgram.setComputeUnitLimit({ 
  units: computeUnitLimit 
});
instructions.unshift(computeUnitIx); // Add at beginning

Optimización de comisiones de prioridad

1. Obtén estimaciones dinámicas de comisiones:

const response = await fetch(`https://mainnet.helius-rpc.com/?api-key=${API_KEY}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    method: 'getPriorityFeeEstimate',
    params: [{
      accountKeys: ['11111111111111111111111111111112'], // System Program
      options: { recommended: true }
    }]
  })
});
const { priorityFeeEstimate } = await response.json().result;

2. Aplica la comisión de prioridad:

const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({ 
  microLamports: priorityFeeEstimate 
});
instructions.unshift(priorityFeeIx);

Prácticas recomendadas para enviar transacciones

Standard Approach
With Confirmation

// Serialize and encode
const serializedTx = transaction.serialize();
const signature = await connection.sendRawTransaction(serializedTx, {
  skipPreflight: true, // Saves ~100ms
  maxRetries: 0 // Handle retries manually
});

// Send and confirm with custom logic
const signature = await connection.sendRawTransaction(serializedTx);

// Monitor confirmation
const confirmation = await connection.confirmTransaction({
  signature,
  blockhash: latestBlockhash.blockhash,
  lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
});

Optimización de la recuperación de datos

Métodos de paginación mejorados (V2)

Para consultas de datos a gran escala, usa los nuevos métodos V2 con paginación basada en cursores:

⚡ Performance Boost

getProgramAccountsV2 y getTokenAccountsByOwnerV2 ofrecen mejoras significativas de rendimiento para las aplicaciones que trabajan con grandes conjuntos de datos:

Límites configurables: de 1 a 10 000 cuentas por solicitud
Paginación basada en cursores: evita tiempos de espera agotados en consultas grandes
Actualizaciones incrementales: usa changedSinceSlot para la sincronización en tiempo real
Mejor uso de la memoria: transmite los datos en lugar de cargar todo a la vez

Ejemplo: consulta eficiente de cuentas de programas

// ❌ Old approach - could timeout with large datasets
const allAccounts = await connection.getProgramAccounts(programId, {
  encoding: 'base64',
  filters: [{ dataSize: 165 }]
});

// ✅ New approach - paginated with better performance
let allAccounts = [];
let paginationKey = null;

do {
  const response = await fetch(`https://mainnet.helius-rpc.com/?api-key=${API_KEY}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: '1',
      method: 'getProgramAccountsV2',
      params: [
        programId,
        {
          encoding: 'base64',
          filters: [{ dataSize: 165 }],
          limit: 5000,
          ...(paginationKey && { paginationKey })
        }
      ]
    })
  });
  
  const data = await response.json();
  allAccounts.push(...data.result.accounts);
  paginationKey = data.result.paginationKey;
} while (paginationKey);

Actualizaciones incrementales para aplicaciones en tiempo real:

// Get only accounts modified since a specific slot
const incrementalUpdate = await fetch(`https://mainnet.helius-rpc.com/?api-key=${API_KEY}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: '1',
    method: 'getProgramAccountsV2',
    params: [
      programId,
      {
        encoding: 'jsonParsed',
        limit: 1000,
        changedSinceSlot: lastProcessedSlot // Only get recent changes
      }
    ]
  })
});

Optimización de la recuperación de datos

Consultas eficientes de cuentas

Single Account
Multiple Accounts
Program Accounts

// Use dataSlice to reduce payload size
const accountInfo = await connection.getAccountInfo(pubkey, {
  encoding: 'base64',
  dataSlice: { offset: 0, length: 100 }, // Only get needed data
  commitment: 'confirmed'
});

// Batch multiple account queries
const accounts = await connection.getMultipleAccountsInfo([
  pubkey1, pubkey2, pubkey3
], {
  encoding: 'base64',
  commitment: 'confirmed'
});

// Use filters to reduce data transfer
const accounts = await connection.getProgramAccounts(programId, {
  filters: [
    { dataSize: 165 }, // Token account size
    { memcmp: { offset: 0, bytes: mintAddress }}
  ],
  encoding: 'jsonParsed'
});

Consultas de saldos de tokens

// Don't do this - requires N+1 RPC calls
const tokenAccounts = await connection.getTokenAccountsByOwner(owner, {
  programId: TOKEN_PROGRAM_ID
});
const balances = await Promise.all(
  tokenAccounts.value.map(acc => 
    connection.getTokenAccountBalance(acc.pubkey)
  )
);
// ~500ms + (100ms * N accounts)

// Single call with parsed data
const tokenAccounts = await connection.getTokenAccountsByOwner(owner, {
  programId: TOKEN_PROGRAM_ID
}, { encoding: 'jsonParsed' });

const balances = tokenAccounts.value.map(acc => ({
  mint: acc.account.data.parsed.info.mint,
  amount: acc.account.data.parsed.info.tokenAmount.uiAmount
}));
// ~500ms total - 95% reduction for large wallets

Historial de transacciones

Para obtener el historial completo de una dirección, usa getTransactionsForAddress, un método exclusivo de Helius que devuelve los datos completos de las transacciones, incluida la actividad de las cuentas de tokens asociadas, en una sola llamada:

// Avoid sequential transaction fetching
const signatures = await connection.getSignaturesForAddress(address, { limit: 100 });
const transactions = await Promise.all(
  signatures.map(sig => connection.getTransaction(sig.signature))
);
// ~1s + (200ms * 100 txs) = ~21s
// Also note: getSignaturesForAddress doesn't include token account transactions

// Use getTransactionsForAddress for full history including token accounts
const response = await fetch(`https://mainnet.helius-rpc.com/?api-key=${API_KEY}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getTransactionsForAddress',
    params: [
      address,
      {
        transactionDetails: 'full',
        limit: 100,
        filters: { tokenAccounts: 'balanceChanged' }
      }
    ]
  })
});
// ~100ms total - includes complete token history in one call

Historial de transferencias

Cuando solo necesites movimientos de tokens o SOL —pagos, actividad de portafolios o conciliación de saldos—, usa getTransfersByAddress (exclusivo de Helius; requiere un plan Developer o superior). Devuelve objetos de transferencia analizados y legibles, con los propietarios, acuñaciones, importes y decimales ya resueltos, por lo que puedes omitir por completo el análisis de transacciones:

// Parsed USDC transfers received by a wallet - no manual parsing needed
const response = await fetch(`https://mainnet.helius-rpc.com/?api-key=${API_KEY}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getTransfersByAddress',
    params: [
      address, // Wallet owner address, not a token account
      {
        mint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
        direction: 'in',
        limit: 100
      }
    ]
  })
});
// Each transfer includes parsed sender, recipient, amount, decimals, and uiAmount

Regla general: usa getTransactionsForAddress cuando necesites las cargas útiles completas de las transacciones o actividad que no sea de transferencias, y getTransfersByAddress cuando necesites registros de transferencias limpios para libros contables y seguimiento de pagos.

Monitoreo en tiempo real

Suscripciones a cuentas

// Avoid polling - wastes resources
setInterval(async () => {
  const accountInfo = await connection.getAccountInfo(pubkey);
  // Process updates...
}, 1000);

// Use WebSocket subscriptions for real-time updates
const subscriptionId = connection.onAccountChange(
  pubkey,
  (accountInfo, context) => {
    // Handle real-time updates
    console.log('Account updated:', accountInfo);
  },
  'confirmed',
  { encoding: 'base64', dataSlice: { offset: 0, length: 100 }}
);

Monitoreo de cuentas de programas

// Monitor specific program accounts with filters
connection.onProgramAccountChange(
  programId,
  (accountInfo, context) => {
    // Handle program account changes
  },
  'confirmed',
  {
    filters: [
      { dataSize: 1024 },
      { memcmp: { offset: 0, bytes: ACCOUNT_DISCRIMINATOR }}
    ],
    encoding: 'base64'
  }
);

Monitoreo de transacciones

// Subscribe to transaction logs for real-time monitoring
const ws = new WebSocket(`wss://mainnet.helius-rpc.com/?api-key=${API_KEY}`);

ws.on('open', () => {
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'logsSubscribe',
    params: [
      { mentions: [programId] },
      { commitment: 'confirmed' }
    ]
  }));
});

ws.on('message', (data) => {
  const message = JSON.parse(data);
  if (message.params) {
    const signature = message.params.result.value.signature;
    // Process transaction signature
  }
});

Patrones avanzados

Lógica inteligente de reintentos

class RetryManager {
  private backoff = new ExponentialBackoff({
    min: 100,
    max: 5000,
    factor: 2,
    jitter: 0.2
  });

  async executeWithRetry<T>(operation: () => Promise<T>): Promise<T> {
    while (true) {
      try {
        return await operation();
      } catch (error) {
        if (error.message.includes('429')) {
          // Rate limit - wait and retry
          await this.backoff.delay();
          continue;
        }
        throw error;
      }
    }
  }
}

Procesamiento eficiente en el uso de memoria

// Process large datasets in chunks
function chunk<T>(array: T[], size: number): T[][] {
  return Array.from({ length: Math.ceil(array.length / size) }, (_, i) =>
    array.slice(i * size, i * size + size)
  );
}

// Process program accounts in batches
const allAccounts = await connection.getProgramAccounts(programId, {
  dataSlice: { offset: 0, length: 32 }
});

const chunks = chunk(allAccounts, 100);
for (const batch of chunks) {
  const detailedAccounts = await connection.getMultipleAccountsInfo(
    batch.map(acc => acc.pubkey)
  );
  // Process batch...
}

Agrupación de conexiones

class ConnectionPool {
  private connections: Connection[] = [];
  private currentIndex = 0;

  constructor(rpcUrls: string[]) {
    this.connections = rpcUrls.map(url => new Connection(url));
  }

  getConnection(): Connection {
    const connection = this.connections[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.connections.length;
    return connection;
  }
}

const pool = new ConnectionPool([
  'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY',
  'https://mainnet-backup.helius-rpc.com/?api-key=YOUR_API_KEY'
]);

Monitoreo del rendimiento

Controla el uso de RPC

class RPCMonitor {
  private metrics = {
    calls: 0,
    errors: 0,
    totalLatency: 0
  };

  async monitoredCall<T>(operation: () => Promise<T>): Promise<T> {
    const start = Date.now();
    this.metrics.calls++;
    
    try {
      const result = await operation();
      this.metrics.totalLatency += Date.now() - start;
      return result;
    } catch (error) {
      this.metrics.errors++;
      throw error;
    }
  }

  getStats() {
    return {
      ...this.metrics,
      averageLatency: this.metrics.totalLatency / this.metrics.calls,
      errorRate: this.metrics.errors / this.metrics.calls
    };
  }
}

Prácticas recomendadas

Niveles de confirmación

processed
confirmed
finalized

Úsalo para: suscripciones WebSocket y actualizaciones en tiempo real
Latencia: ~400 ms
Confiabilidad: adecuada para la mayoría de las aplicaciones

Administración de recursos

Manejo de errores

// Implement robust error handling
async function robustRPCCall<T>(operation: () => Promise<T>): Promise<T> {
  try {
    return await operation();
  } catch (error) {
    if (error.code === -32602) {
      // Invalid params - fix request
      throw new Error('Invalid RPC parameters');
    } else if (error.code === -32005) {
      // Node behind - retry with different node
      throw new Error('Node synchronization issue');
    } else if (error.message.includes('429')) {
      // Rate limit - implement backoff
      throw new Error('Rate limited');
    }
    throw error;
  }
}

Errores comunes que debes evitar

Evita estos errores comunes:

Realizar sondeos en lugar de usar suscripciones WebSocket
Obtener todos los datos de una cuenta cuando solo se necesitan datos parciales
No usar operaciones por lotes para varias consultas
Ignorar los límites de solicitudes y no implementar una lógica de reintentos adecuada
Usar el nivel de confirmación finalized cuando confirmed es suficiente
No cerrar las suscripciones, lo que provoca fugas de memoria

Métodos relacionados

Las técnicas de optimización de esta guía hacen referencia a los siguientes métodos WebSocket y RPC:

getTransactionsForAddress

Historial completo de transacciones con filtrado, ordenamiento y compatibilidad con cuentas de tokens (exclusivo de Helius)

getTransfersByAddress

Historial analizado de transferencias de tokens y SOL para pagos y conciliaciones (exclusivo de Helius)

getTransaction

Recupera los detalles completos de una transacción mediante su firma

getProgramAccounts

Obtén todas las cuentas que pertenecen a un programa

getTokenAccountsByOwner

Obtén las cuentas de tokens de una billetera

getMultipleAccountsInfo

Obtén por lotes los detalles de varias cuentas

getAccountInfo

Obtén información sobre una sola cuenta

accountSubscribe

Suscríbete a los cambios de una cuenta mediante WebSocket

programSubscribe

Suscríbete a los cambios de las cuentas de un programa mediante WebSocket

logsSubscribe

Suscríbete a los registros de transacciones mediante WebSocket

Resumen

Al implementar estas técnicas de optimización, puedes conseguir lo siguiente:

Reducción del 60 al 90 % en el volumen de llamadas a la API
Latencia significativamente menor para las operaciones en tiempo real
Menor uso de ancho de banda mediante consultas específicas
Mayor resistencia a errores con una lógica inteligente de reintentos
Menores costos operativos mediante un uso eficiente de los recursos

Next Steps

¿Todo listo para implementar estas optimizaciones? Consulta nuestra Guía de optimización de transacciones para conocer las prácticas recomendadas específicas de las transacciones.

​Inicio rápido

Transaction Optimization

Data Retrieval

Real-time Monitoring

Best Practices

​Optimización de transacciones

​Administración de unidades de cómputo

​Optimización de comisiones de prioridad

​Prácticas recomendadas para enviar transacciones

​Optimización de la recuperación de datos

​Métodos de paginación mejorados (V2)

⚡ Performance Boost

​Optimización de la recuperación de datos

​Consultas eficientes de cuentas

​Consultas de saldos de tokens

​Historial de transacciones

​Historial de transferencias

​Monitoreo en tiempo real

​Suscripciones a cuentas

​Monitoreo de cuentas de programas

​Monitoreo de transacciones

​Patrones avanzados

​Lógica inteligente de reintentos

​Procesamiento eficiente en el uso de memoria

​Agrupación de conexiones

​Monitoreo del rendimiento

​Controla el uso de RPC

​Prácticas recomendadas

​Niveles de confirmación

​Administración de recursos

​Manejo de errores

​Errores comunes que debes evitar

​Métodos relacionados

getTransactionsForAddress

getTransfersByAddress

getTransaction

getProgramAccounts

getTokenAccountsByOwner

getMultipleAccountsInfo

getAccountInfo

accountSubscribe

programSubscribe

logsSubscribe

​Resumen

Next Steps

Inicio rápido

Optimización de transacciones

Administración de unidades de cómputo

Optimización de comisiones de prioridad

Prácticas recomendadas para enviar transacciones

Optimización de la recuperación de datos

Métodos de paginación mejorados (V2)

Optimización de la recuperación de datos

Consultas eficientes de cuentas

Consultas de saldos de tokens

Historial de transacciones

Historial de transferencias

Monitoreo en tiempo real

Suscripciones a cuentas

Monitoreo de cuentas de programas

Monitoreo de transacciones

Patrones avanzados

Lógica inteligente de reintentos

Procesamiento eficiente en el uso de memoria

Agrupación de conexiones

Monitoreo del rendimiento

Controla el uso de RPC

Prácticas recomendadas

Niveles de confirmación

Administración de recursos

Manejo de errores

Errores comunes que debes evitar

Métodos relacionados

Resumen