Monitoreo de slots y bloques - Helius LaserStream

El monitoreo de slots y bloques te permite observar el consenso de la red Solana, los tiempos de producción de bloques y su estado general. Con LaserStream, puedes rastrear el avance de los slots, la finalización de bloques y las métricas de rendimiento de la red en tiempo real mediante el SDK de helius-laserstream.

Requisitos previos: Esta guía supone que completaste el inicio rápido de gRPC de LaserStream y tienes una clave de API.

Tipos de monitoreo

Slot Updates
Block Data
Block Metadata

Rastrea el avance del consenso de la redMonitorea el avance de los slots en los distintos niveles de compromiso:

import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream';

const subscriptionRequest: SubscribeRequest = {
  slots: {
    slotSubscribe: {
      filterByCommitment: false // Receive all commitment levels
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {}, transactions: {}, transactionsStatus: {},
  blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
};

Los datos del slot incluyen: número de slot, slot principal, estado de compromiso (processed / confirmed / finalized) e información del líder.

Ideal para: monitorear el estado de la red, analizar los tiempos de los slots y rastrear el consenso.

Monitorea la información completa de los bloquesTransmite bloques completos con transacciones y actualizaciones de cuentas:

const subscriptionRequest: SubscribeRequest = {
  blocks: {
    blockSubscribe: {
      accountInclude: [], // All accounts
      includeTransactions: true,
      includeAccounts: true,
      includeEntries: false
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {}, transactions: {}, transactionsStatus: {},
  slots: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
};

Los datos del bloque incluyen: metadatos del bloque, transacciones, actualizaciones de cuentas y tiempos del bloque.

Volumen alto: Los streams de bloques completos generan una cantidad considerable de datos. Usa filtros accountInclude para reducir el volumen.

Información ligera de los bloquesObtén los metadatos de los bloques sin los detalles de las transacciones:

const subscriptionRequest: SubscribeRequest = {
  blocksMeta: {
    blockMetaSubscribe: {}
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {}, transactions: {}, transactionsStatus: {},
  slots: {}, blocks: {}, entry: {}, accountsDataSlice: [],
};

Los metadatos incluyen: hash del bloque, hash principal, slot, altura, cantidad de transacciones y recompensas.

Eficiente: Una alternativa de menor ancho de banda que transmitir bloques completos.

Ejemplos prácticos

Ejemplo 1: Monitor del estado de la red

Rastrea el avance de los slots e identifica problemas en la red:

import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream';

let lastSlot = 0;
let lastTimestamp = Date.now();
const slotTimes: number[] = [];

// CommitmentLevel only ships the forward (name → number) mapping, so we keep
// a small reverse lookup for the numeric status the SDK returns on slot updates.
const STATUS_NAMES = ['PROCESSED', 'CONFIRMED', 'FINALIZED'] as const;

async function monitorNetworkHealth() {
  const subscriptionRequest: SubscribeRequest = {
    slots: {
      slotSubscribe: {
        filterByCommitment: true // Track processed commitment levels
      }
    },
    commitment: CommitmentLevel.PROCESSED,
    accounts: {}, transactions: {}, transactionsStatus: {},
    blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
  };

  const config: LaserstreamConfig = {
    apiKey: 'YOUR_API_KEY',
    endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com',
  };

  await subscribe(config, subscriptionRequest, async (data) => {
    if (!data.slot) return;
    const slot = data.slot;
    // The SDK returns u64 fields as strings to preserve precision.
    const currentSlot = Number(slot.slot);
    const currentTime = Date.now();

    console.log(`\n📊 Slot Update:`);
    console.log(`  Slot: ${currentSlot}`);
    console.log(`  Parent: ${slot.parent}`);
    // slot.status is a numeric enum (0=processed, 1=confirmed, 2=finalized).
    console.log(`  Status: ${STATUS_NAMES[slot.status] ?? slot.status}`);

    if (lastSlot > 0) {
      const slotDiff = currentSlot - lastSlot;
      const timeDiff = currentTime - lastTimestamp;

      if (slotDiff === 1) {
        slotTimes.push(timeDiff);
        if (slotTimes.length > 100) slotTimes.shift();

        const avg = slotTimes.reduce((a, b) => a + b, 0) / slotTimes.length;
        console.log(`  Slot Time: ${timeDiff}ms`);
        console.log(`  Avg Slot Time: ${avg.toFixed(1)}ms`);

        if (timeDiff > 800) {
          console.log(`  ⚠️  SLOW SLOT: ${timeDiff}ms (normal ~400ms)`);
        }
      } else if (slotDiff > 1) {
        console.log(`  ⚠️  SKIPPED ${slotDiff - 1} SLOTS`);
      }
    }

    lastSlot = currentSlot;
    lastTimestamp = currentTime;
  }, async (error) => {
    console.error('Stream error:', error);
  });
}

monitorNetworkHealth().catch(console.error);

Ejemplo 2: Monitor de producción de bloques

Rastrea la producción de bloques y el volumen de transacciones:

async function monitorBlockProduction() {
  const subscriptionRequest: SubscribeRequest = {
    blocksMeta: {
      blockMetaSubscribe: {}
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {}, transactions: {}, transactionsStatus: {},
    slots: {}, blocks: {}, entry: {}, accountsDataSlice: [],
  };

  const config: LaserstreamConfig = {
    apiKey: 'YOUR_API_KEY',
    endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com',
  };

  await subscribe(config, subscriptionRequest, async (data) => {
    if (!data.blockMeta) return;
    const blockMeta = data.blockMeta;

    console.log(`\n🧱 Block Produced:`);
    console.log(`  Slot: ${blockMeta.slot}`);
    // blockHeight is a wrapper object: { blockHeight: '397657352' }
    console.log(`  Block Height: ${blockMeta.blockHeight?.blockHeight}`);
    console.log(`  Block Hash: ${blockMeta.blockhash}`);
    console.log(`  Parent Slot: ${blockMeta.parentSlot}`);
    console.log(`  Parent Hash: ${blockMeta.parentBlockhash}`);
    console.log(`  Transactions: ${blockMeta.executedTransactionCount}`);
    console.log(`  Entries: ${blockMeta.entriesCount}`);
    if (blockMeta.blockTime?.timestamp) {
      // blockTime.timestamp is a u64 as a string (Unix seconds).
      console.log(`  Block Time: ${new Date(Number(blockMeta.blockTime.timestamp) * 1000).toISOString()}`);
    }

    // rewards is a wrapper object: { rewards: [...], numPartitions: number | null }
    if (blockMeta.rewards?.rewards?.length > 0) {
      console.log(`  Rewards:`);
      blockMeta.rewards.rewards.forEach((r: any) => {
        console.log(`    ${r.pubkey}: ${r.lamports} lamports (${r.rewardType})`);
      });
    }

    if (Number(blockMeta.executedTransactionCount) > 3000) {
      console.log(`  🔥 HIGH ACTIVITY: ${blockMeta.executedTransactionCount} transactions`);
    }
  }, async (error) => {
    console.error('Stream error:', error);
  });
}

Ejemplo 3: Monitor de bloques filtrados

Monitorea los bloques que contienen actividad de programas específicos:

async function monitorDEXBlocks() {
  const subscriptionRequest: SubscribeRequest = {
    blocks: {
      blockSubscribe: {
        accountInclude: [
          "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8", // Raydium
          "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK", // Raydium CLMM
          "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"   // Jupiter
        ],
        includeTransactions: true,
        includeAccounts: false,
        includeEntries: false
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {}, transactions: {}, transactionsStatus: {},
    slots: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
  };

  const config: LaserstreamConfig = {
    apiKey: 'YOUR_API_KEY',
    endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com',
  };

  await subscribe(config, subscriptionRequest, async (data) => {
    if (!data.block) return;
    const block = data.block;

    let successfulDexTx = 0;
    let totalFees = 0; // lamports
    block.transactions?.forEach((tx: any) => {
      if (tx.meta && !tx.meta.err) {
        successfulDexTx++;
        // tx.meta.fee is a u64 string — coerce before adding.
        totalFees += Number(tx.meta.fee ?? 0);
      }
    });

    console.log(`\n🔄 DEX Activity Block:`);
    console.log(`  Slot: ${block.slot}`);
    console.log(`  Block Height: ${block.blockHeight?.blockHeight}`);
    console.log(`  Block Hash: ${block.blockhash}`);
    console.log(`  Total transactions in block: ${block.executedTransactionCount}`);
    console.log(`  Matched DEX transactions: ${block.transactions?.length ?? 0}`);
    console.log(`  Successful DEX transactions: ${successfulDexTx}`);
    if (successfulDexTx > 0) {
      console.log(`  Total Fees: ${(totalFees / 1e9).toFixed(4)} SOL`);
      console.log(`  Avg Fee: ${(totalFees / successfulDexTx / 1e9).toFixed(6)} SOL`);
    }
  }, async (error) => {
    console.error('Stream error:', error);
  });
}

Estructuras de datos

Slot Data Structure

{
  slot: string;     // Current slot number (u64 as string)
  parent: string;   // Parent slot number (u64 as string)
  status: number;   // CommitmentLevel enum: 0 = processed, 1 = confirmed, 2 = finalized
}

Cada slot representa aproximadamente 400 ms de tiempo de red. Los tres niveles de compromiso reflejan garantías cada vez más sólidas: processed (inicial), confirmed (votado por una supermayoría), finalized (irreversible).

Los campos u64 (slot, parent) llegan como cadenas para conservar la precisión más allá de Number.MAX_SAFE_INTEGER. Conviértelos con Number(slot.slot) cuando necesites realizar operaciones aritméticas. status es una enumeración numérica; usa CommitmentLevel[slot.status] para obtener el nombre legible.

Block Metadata Structure

{
  slot: string;                                  // u64 as string
  blockhash: string;
  rewards: {
    rewards: Array<{
      pubkey: string;
      lamports: string;                          // u64 as string
      rewardType: string;                        // "fee" | "rent" | "voting" | "staking"
    }>;
    numPartitions: number | null;
  };
  blockTime: { timestamp: string };              // Unix seconds as a u64 string
  blockHeight: { blockHeight: string };          // u64 as string, wrapped
  parentSlot: string;                            // u64 as string
  parentBlockhash: string;
  executedTransactionCount: string;              // u64 as string
  entriesCount: string;                          // u64 as string
}

Los campos numéricos (slot, parentSlot, executedTransactionCount, entriesCount y los valores dentro de blockHeight e blockTime) se emiten como cadenas porque son u64 en el proto subyacente. Envuélvelos en Number(...) para realizar operaciones aritméticas o comparaciones.

Full Block Structure

{
  slot: string;                                  // u64 as string
  blockhash: string;
  rewards: {
    rewards: Array<{
      pubkey: string;
      lamports: string;                          // u64 as string
      rewardType: string;
    }>;
    numPartitions: number | null;
  };
  blockTime: { timestamp: string };              // Unix seconds (u64 string)
  blockHeight: { blockHeight: string };          // u64 as string, wrapped
  parentSlot: string;                            // u64 as string
  parentBlockhash: string;
  executedTransactionCount: string;              // total executed tx in the block (u64 as string)
  updatedAccountCount: string;                   // total account updates in the block (u64 as string)
  entriesCount: string;                          // u64 as string
  transactions: Array<{
    signature: Buffer;                           // base58-encode for display
    isVote: boolean;
    transaction: TransactionMessage;             // full transaction payload
    meta: TransactionMeta;                       // execution metadata (fee, err, balances, …)
    index: string;                               // u64 as string
  }>;
  accounts: AccountUpdate[];                     // populated when includeAccounts: true
  entries: Entry[];                              // populated when includeEntries: true
}

Los bloques completos pueden ocupar varios MB con todas las transacciones y cuentas. Se aplica la misma convención de representar u64 como cadena: envuelve los campos numéricos con Number(...) para realizar operaciones aritméticas. Dentro de cada transacción, meta.fee, meta.preBalances, meta.postBalances, etc., también son cadenas.

Consideraciones de rendimiento

Slot Monitoring

Ligero: ancho de banda muy bajo y sobrecarga de procesamiento mínima. Adecuado para paneles de monitoreo.

Block Metadata

Equilibrado: ancho de banda moderado e información a nivel de bloque sin todos los datos. Adecuado para análisis.

Full Blocks

Volumen alto: datos completos de las transacciones que requieren un procesamiento sólido. Úsalos siempre con filtros.

Filtered Blocks

Optimizado: usa accountInclude y desactiva los includeAccounts/includeEntries que no necesites.

Casos de uso

Network Monitoring
Analytics & Metrics
Application Synchronization

Rastrea el estado y el rendimiento de la red: tiempos de los slots, congestión y consenso.

const targetSlotTime = 400; // ms
const tolerance = 200; // ms
if (Math.abs(slotTime - targetSlotTime) > tolerance) {
  console.log(`Network performance issue detected`);
}

Recopila datos analíticos de la blockchain: volumen de transacciones, análisis de comisiones, tamaño de los bloques y patrones de actividad.

const dailyStats = {
  date: new Date().toDateString(),
  totalTransactions: 0,
  totalFees: 0,
  blockCount: 0
};

Mantén las aplicaciones sincronizadas con la red mediante actualizaciones basadas en slots y confirmaciones de bloques.

if (data.slot && data.slot.status === 'finalized') {
  updateApplicationState(data.slot.slot);
}

Manejo de errores

Missing Slots

Síntoma: Hay brechas en el avance de los slots.Causas: Problemas de conectividad de red, tiempo de inactividad de los validadores o retrasos en el procesamiento del cliente.Soluciones: Rastrea las brechas entre slots y genera alertas; implementa lógica de recuperación mediante la repetición histórica; monitorea el estado de la conexión.

High Volume

Síntoma: Hay demasiados datos de bloques.Soluciones: Usa metadatos de bloques en lugar de bloques completos; aplica filtros de cuentas; desactiva las inclusiones innecesarias (entradas y cuentas); procesa los datos de forma asíncrona.

Timing Issues

Síntoma: Los tiempos de los slots son inconsistentes.Análisis: Calcula promedios móviles; rastrea las desviaciones; monitorea las métricas de estado de la red; correlaciónalas con el rendimiento de los validadores.

Prácticas recomendadas

Directrices para producción:

Comienza con los metadatos — usa metadatos de bloques antes de suscribirte a bloques completos
Aplica filtros — usa accountInclude para descartar datos irrelevantes
Monitorea los tiempos — rastrea el avance de los slots como indicador temprano del estado de la red
Maneja las brechas — combínalo con la repetición histórica para rellenar automáticamente los slots faltantes al restablecer la conexión
Procesa de forma asíncrona — no bloquees el procesamiento del stream con cálculos pesados
Adapta el compromiso a tus necesidades — processed para interfaces de baja latencia, confirmed/finalized para escrituras de estado

Próximos pasos

Transaction Monitoring

Filtra transacciones por programa, cuenta, voto o estado de error.

Stream Pump AMM Data

Ejemplo práctico: monitorea transacciones de Pump AMM.

Decoding Transaction Data

Analiza los payloads binarios transactionUpdate y conviértelos en transacciones de Solana legibles.

Yellowstone protocol reference

El mismo flujo de trabajo con el protocolo gRPC de Yellowstone sin procesar.

Comienza aquí

Datos en tiempo real

Trading de baja latencia

Datos históricos y de billeteras

Guías de métodos RPC

Preparación para producción

Uso de Orb

Otras guías prácticas

Monitoreo de slots y bloques con LaserStream

Tipos de monitoreo

Ejemplos prácticos

Ejemplo 1: Monitor del estado de la red

Ejemplo 2: Monitor de producción de bloques

Ejemplo 3: Monitor de bloques filtrados

Estructuras de datos

Consideraciones de rendimiento

Slot Monitoring

Block Metadata

Full Blocks

Filtered Blocks

Casos de uso

Manejo de errores

Prácticas recomendadas

Próximos pasos

Transaction Monitoring

Stream Pump AMM Data

Decoding Transaction Data

Yellowstone protocol reference

​Tipos de monitoreo

​Ejemplos prácticos

​Ejemplo 1: Monitor del estado de la red

​Ejemplo 2: Monitor de producción de bloques

​Ejemplo 3: Monitor de bloques filtrados

​Estructuras de datos

​Consideraciones de rendimiento

Slot Monitoring

Block Metadata

Full Blocks

Filtered Blocks

​Casos de uso

​Manejo de errores

​Prácticas recomendadas

​Próximos pasos

Transaction Monitoring

Stream Pump AMM Data

Decoding Transaction Data

Yellowstone protocol reference

Tipos de monitoreo

Ejemplos prácticos

Ejemplo 1: Monitor del estado de la red

Ejemplo 2: Monitor de producción de bloques

Ejemplo 3: Monitor de bloques filtrados

Estructuras de datos

Consideraciones de rendimiento

Casos de uso

Manejo de errores

Prácticas recomendadas

Próximos pasos