Congestión en Solana: cómo enviar transacciones de Solana de la mejor manera

Introducción

"Error en la simulación de la transacción: no se encontró el blockhash". "No se pudo enviar la transacción". Estos mensajes de error se han vuelto demasiado comunes. La congestión de la red ha convertido incluso las transacciones básicas en un juego de azar. No tienes por qué sufrirlo.

Esta guía explora estrategias sencillas para navegar eficazmente los periodos de mucho tráfico y garantizar que tus transacciones se procesen. Abordaremos de forma integral la congestión de la red, incluidas las comisiones de prioridad, la optimización de unidades de cómputo y el truco secreto exclusivo de Helius para que tus transacciones siempre se procesen.

En esta guía, exploraremos:

• Cómo usar transacciones serializadas para las comisiones de prioridad
• Cómo usar claves de cuentas para las comisiones de prioridad
• Estrategias avanzadas de comisiones de prioridad
• Técnicas de optimización de transacciones
• Cómo aprovechar endpoints con stake para garantizar la entrega

Comisiones de prioridad

Las comisiones de prioridad funcionan como un mecanismo de puja que te permite indicar a los validadores la importancia de tu transacción. Estas comisiones, cuyo precio se expresa en microlamports por unidad de cómputo, se determinan según las cuentas específicas con las que interactúa tu transacción, lo que crea mercados de comisiones independientes para cada cuenta. Si defines estas comisiones estratégicamente según la congestión específica de cada cuenta, puedes aumentar considerablemente las probabilidades de que tu transacción se incluya en el siguiente bloque.

A continuación, veremos cómo puedes configurar correctamente las comisiones de prioridad mediante distintos enfoques con la Priority Fee API de Helius:

Transacción serializada

El método más directo para configurar las comisiones de prioridad es usar una transacción serializada. Una transacción serializada es una representación binaria de una transacción convertida en un búfer con formato de transmisión que puede enviarse a través de la red.

1. Serializa tu transacción y pásala a la API:

const serializedTx = transaction.serialize();

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      transaction: serializedTx,
      options: { recommended: true }
    }]
  }),
});

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

2. Agrega la comisión recomendada a tu transacción; el orden de las instrucciones no importa:

transaction.add(
  ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  })
);

Claves de cuentas

Otro enfoque consiste en proporcionar a la Priority Fee API una lista de las claves de cuentas involucradas en la transacción:‍

1. Extrae las claves de cuentas de tu transacción:

const transaction = new Transaction();

// Add your instructions to the transaction

// Extract all account keys from the transaction
const accountKeys = transaction.compileMessage().accountKeys;

// Convert PublicKeys to base58 strings
const publicKeys = accountKeys.map(key => key.toBase58());

2. Pasa las claves de cuentas a la Priority Fee API:

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      accountKeys: publicKeys,
      options: { recommended: true }
    }]
  }),
});

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

3. Agrega la comisión recomendada a tu transacción:

transaction.add(
  ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  })
);

Aunque ambos métodos funcionan, se recomienda usar transacciones serializadas. Usar claves de cuentas requiere llevar un seguimiento manual e incluir todas las cuentas relevantes, lo que puede generar estimaciones de comisiones imprecisas si omites alguna. 

El método de transacción serializada elimina este riesgo porque incluye automáticamente todas las cuentas necesarias y proporciona estimaciones de comisiones más precisas según el contexto completo de la transacción.

Estrategias avanzadas de comisiones de prioridad

En la mayoría de los casos, basta con usar una transacción serializada con la comisión de prioridad recomendada. Sin embargo, para tener un control más granular, la Priority Fee API te permite solicitar estimaciones para distintos niveles de prioridad y habilitar la evaluación de slots vacíos.

Niveles de prioridad

Este es un ejemplo de cómo solicitar todos los niveles de comisiones de prioridad:

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      transaction: serializedTx,
      options: {
        includeAllPriorityFeeLevels: true
      }
    }]
  }),
});

const { result } = await response.json();
console.log(result.priorityFeeLevels);

Esto devolverá un objeto con distintos niveles de prioridad:

{
  "priorityFeeLevels": {
    "min": 10000.0,
    "low": 10000.0,
    "medium": 10000.0,
    "high": 100000.0,
    "veryHigh": 5483924.800000011,
    "unsafeMax": 8698904817.0
  }
}

Los niveles de prioridad corresponden a distintos percentiles de las comisiones de transacciones recientes:

• min: percentil 0
• low: percentil 25
• medium: percentil 50
• high: percentil 75
• veryHigh: percentil 95
• unsafeMax: percentil 100 (úsalo con precaución)

Para mejorar aún más la tasa de procesamiento de transacciones, considera usar los niveles de prioridad high o very high. Sin embargo, ten cuidado al usar niveles de prioridad más altos, especialmente veryHigh e unsafeMax, ya que pueden aumentar considerablemente los costos de las transacciones.‍

Evaluación de slots vacíos

Una actualización reciente de la Priority Fee API permite estimar las comisiones de forma más inteligente al considerar los slots vacíos. Cuando los bloques no contienen transacciones para una cuenta específica, puedes configurar la API para evaluar estos slots como si tuvieran comisiones de cero, lo que proporciona estimaciones más precisas durante periodos de baja actividad en la red:

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      transaction: serializedTx,
      options: {
        recommended: true,
        evaluateEmptySlotAsZero: true
      }
    }]
  }),
});

Cuando evaluateEmptySlotAsZero está habilitado, la API:

• Identifica los bloques sin transacciones para tus cuentas
• Cuenta estos slots vacíos como si tuvieran comisiones de cero
• Reduce las estimaciones durante periodos de poca congestión
• Evita que pagues de más cuando la actividad de la red es baja

Estrategias de optimización de transacciones

Además de las comisiones de prioridad, optimizar las transacciones implica varios componentes clave que trabajan en conjunto para mejorar la tasa de procesamiento:

Gestión de unidades de cómputo

1. Usa el SDK de Helius para obtener las unidades de cómputo óptimas para tu transacción:‍

const response = await helius.rpc.getComputeUnits({
  transaction: serializedTransaction
});

const computeUnits = response.computeUnits;

2. Agrega el límite de unidades de cómputo a tu transacción:

transaction.add(
  ComputeBudgetProgram.setComputeUnitLimit({
    units: computeUnits
  })
);

Niveles de compromiso

‍Para la mayoría de las aplicaciones, usar el nivel de compromiso processed ofrece el mejor equilibrio. Este nivel:

• Proporciona el tiempo de confirmación más rápido
• Ofrece seguridad suficiente para la mayoría de los casos de uso
• Reduce el riesgo de que caduque el hash del bloque
• Minimiza las transacciones descartadas durante la congestión

Usa siempre el mismo nivel de compromiso para enviar y confirmar transacciones. Así mantendrás un comportamiento coherente en tu aplicación.

Configuración de RPC

Configura maxRetries en 0 e implementa tu propia lógica de reintentos para tener mayor control sobre el reenvío de transacciones. Usa skipPreflight: true para reducir la latencia. Esto resulta especialmente útil durante periodos de alta congestión:

const signature = await connection.sendTransaction(transaction, {
  maxRetries: 0,
  skipPreflight: true
});

Cómo usar un endpoint con stake

El endpoint con stake de Helius proporciona acceso directo y garantizado a conexiones con stake, lo que elimina la necesidad de optimizar manualmente las comisiones de prioridad:

const connection = new Connection(
  'https://staked.helius-rpc.com?api-key=YOUR_API_KEY'
);

// Transaction will be processed with optimal priority
const signature = await connection.sendTransaction(transaction);

El endpoint con stake:

• Proporciona ancho de banda con stake garantizado
• Reduce los fallos de transacciones durante la congestión
• Ofrece una propagación de transacciones más rápida mediante infraestructura dedicada

Conclusión

Usar eficazmente las comisiones de prioridad es crucial para procesar transacciones correctamente en Solana, especialmente durante la congestión de la red. Al aprovechar la Priority Fee API de Helius e implementar las estrategias descritas, puedes aumentar considerablemente la tasa de éxito de tus transacciones sin perder de vista los costos. Mantente al tanto y adáptate a las condiciones de la red para obtener resultados óptimos.

Si llegaste hasta aquí, ¡gracias! Esperamos que esta guía te haya ayudado a entender cómo optimizar tus transacciones en Solana. Suscríbete a nuestro boletín para no perderte ninguna novedad sobre Solana. 

¿Quieres profundizar más?

Explora hoy mismo los artículos más recientes del blog de Helius y continúa tu recorrido por Solana.