Slot- und Block-Monitoring – Helius LaserStream

Mit Slot- und Block-Monitoring erhältst du Einblick in den Netzwerkkonsens von Solana, das Timing der Blockproduktion und den allgemeinen Netzwerkzustand. Mit LaserStream kannst du den Fortschritt von Slot, die Finalisierung von Blöcken und Messwerte zur Netzwerkleistung in Echtzeit über das helius-laserstream SDK verfolgen.

Voraussetzungen: Dieser Leitfaden setzt voraus, dass du den Schnellstart für LaserStream gRPC abgeschlossen hast und über einen API key verfügst.

Monitoring-Typen

Slot Updates
Block Data
Block Metadata

Verfolge den Fortschritt des NetzwerkkonsensesÜberwache den Fortschritt von Slot über mehrere commitment-Werte hinweg:

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: [],
};

Slot-Daten umfassen: Slot-Nummer, übergeordneten Slot, commitment-Status (processed / confirmed / finalized) und Leader-Informationen.

Ideal für: Überwachung des Netzwerkzustands, Analyse des Slot-Timings und Verfolgung des Konsenses.

Überwache vollständige BlockinformationenStreame vollständige Blöcke mit Transaktionen und Kontoaktualisierungen:

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

Blockdaten umfassen: Blockmetadaten, Transaktionen, Kontoaktualisierungen und Block-Timing.

Hohes Datenvolumen: streams vollständiger Blöcke erzeugen erhebliche Datenmengen. Verwende accountInclude-Filter, um das Volumen zu reduzieren.

Kompakte BlockinformationenRufe Blockmetadaten ohne Transaktionsdetails ab:

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

Metadaten umfassen: Block-Hash, Hash des übergeordneten Blocks, Slot, Höhe, Transaktionsanzahl und Belohnungen.

Effizient: Eine Alternative zum Streaming vollständiger Blöcke, die weniger Bandbreite benötigt.

Praktische Beispiele

Beispiel 1: Überwachung des Netzwerkzustands

Verfolge den Fortschritt von Slot und erkenne Netzwerkprobleme:

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);

Beispiel 2: Überwachung der Blockproduktion

Verfolge die Blockproduktion und das Transaktionsvolumen:

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

Beispiel 3: Gefilterte Blocküberwachung

Überwache Blöcke mit Aktivitäten bestimmter Programme:

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

Datenstrukturen

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
}

Jeder Slot entspricht etwa 400 ms Netzwerkzeit. Die drei commitment-Werte stehen für zunehmend stärkere Garantien: processed (anfänglich), confirmed (von einer Supermehrheit bestätigt), finalized (unumkehrbar).

u64-Felder (slot, parent) werden als Zeichenfolgen übertragen, damit die Genauigkeit oberhalb von Number.MAX_SAFE_INTEGER erhalten bleibt. Konvertiere sie mit Number(slot.slot), wenn du arithmetische Operationen ausführen musst. status ist ein numerisches Enum – verwende CommitmentLevel[slot.status] für den lesbaren Namen.

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
}

Numerische Felder (slot, parentSlot, executedTransactionCount, entriesCount sowie die Werte in blockHeight und blockTime) werden als Zeichenfolgen ausgegeben, da sie im zugrunde liegenden Proto u64-Werte sind. Umschließe sie für arithmetische Operationen oder Vergleiche mit Number(...).

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
}

Vollständige Blöcke können zusammen mit allen Transaktionen und Konten mehrere MB groß sein. Auch hier gilt die Konvention, u64-Werte als Zeichenfolgen auszugeben. Umschließe numerische Felder für arithmetische Operationen mit Number(...). Innerhalb jeder Transaktion sind meta.fee, meta.preBalances, meta.postBalances usw. ebenfalls Zeichenfolgen.

Leistungsaspekte

Slot Monitoring

Ressourcenschonend: sehr geringe Bandbreite und minimaler Verarbeitungsaufwand. Gut für Monitoring-Dashboards geeignet.

Block Metadata

Ausgewogen: moderate Bandbreite und Einblicke auf Blockebene ohne vollständige Daten. Für Analysen geeignet.

Full Blocks

Hohes Volumen: vollständige Transaktionsdaten, die eine robuste Verarbeitung erfordern. Verwende immer Filter.

Filtered Blocks

Optimiert: Verwende accountInclude und deaktiviere nicht benötigte includeAccounts/includeEntries.

Anwendungsfälle

Network Monitoring
Analytics & Metrics
Application Synchronization

Verfolge Netzwerkzustand und -leistung – Slot-Timing, Überlastung und Konsens.

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

Erfasse Blockchain-Analysedaten – Transaktionsvolumen, Gebührenanalyse, Blockgröße und Aktivitätsmuster.

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

Halte Anwendungen mit dem Netzwerk synchron – Aktualisierungen auf Basis von Slot und Blockbestätigungen.

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

Fehlerbehandlung

Missing Slots

Symptom: Lücken im Fortschritt von Slot.Ursachen: Probleme mit der Netzwerkverbindung, Ausfallzeiten von Validatoren oder Verzögerungen bei der Client-Verarbeitung.Lösungen: Erfasse Lücken zwischen Slot und löse Warnungen aus. Implementiere eine Aufhollogik über die historische Wiedergabe. Überwache den Verbindungszustand.

High Volume

Symptom: Zu viele Blockdaten.Lösungen: Verwende Blockmetadaten statt vollständiger Blöcke. Wende Kontofilter an. Deaktiviere nicht benötigte Inhalte wie Einträge und Konten. Verarbeite Daten asynchron.

Timing Issues

Symptom: Inkonsistentes Slot-Timing.Analyse: Berechne gleitende Mittelwerte. Verfolge Abweichungen. Überwache Messwerte zum Netzwerkzustand. Korreliere sie mit der Validatorleistung.

Best Practices

Richtlinien für die Produktion:

Beginne mit Metadaten – verwende Blockmetadaten, bevor du vollständige Blöcke abonnierst
Wende Filter an – verwende accountInclude, um irrelevante Daten zu verwerfen
Überwache das Timing – verfolge den Fortschritt von Slot als Frühwarnsignal für den Netzwerkzustand
Behandle Lücken – kombiniere dies mit der historischen Wiedergabe, damit fehlende Slot bei einer erneuten Verbindung automatisch per backfill ergänzt werden
Verarbeite asynchron – blockiere die Verarbeitung des stream nicht mit rechenintensiven Operationen
Passe commitment an den Bedarf an – processed für Benutzeroberflächen mit niedriger Latenz, confirmed/finalized für Schreibvorgänge am Status

Nächste Schritte

Transaction Monitoring

Filtere Transaktionen nach Programm, Konto, Abstimmung oder Fehlerstatus.

Stream Pump AMM Data

Praxisbeispiel: Überwache Pump-AMM-Transaktionen.

Decoding Transaction Data

Parse die binären transactionUpdate-payloads in lesbare Solana-Transaktionen.

Yellowstone protocol reference

Derselbe Ablauf mit dem unverarbeiteten Yellowstone-gRPC-Protokoll.

Hier starten

Echtzeitdaten

Trading mit niedriger Latenz

Historische Daten und Wallet-Daten

Anleitungen zu RPC-Methoden

Produktionsreife

Orb verwenden

Weitere Anleitungen

Slot- und Block-Monitoring mit LaserStream

Monitoring-Typen

Praktische Beispiele

Beispiel 1: Überwachung des Netzwerkzustands

Beispiel 2: Überwachung der Blockproduktion

Beispiel 3: Gefilterte Blocküberwachung

Datenstrukturen

Leistungsaspekte

Slot Monitoring

Block Metadata

Full Blocks

Filtered Blocks

Anwendungsfälle

Fehlerbehandlung

Best Practices

Nächste Schritte

Transaction Monitoring

Stream Pump AMM Data

Decoding Transaction Data

Yellowstone protocol reference

​Monitoring-Typen

​Praktische Beispiele

​Beispiel 1: Überwachung des Netzwerkzustands

​Beispiel 2: Überwachung der Blockproduktion

​Beispiel 3: Gefilterte Blocküberwachung

​Datenstrukturen

​Leistungsaspekte

Slot Monitoring

Block Metadata

Full Blocks

Filtered Blocks

​Anwendungsfälle

​Fehlerbehandlung

​Best Practices

​Nächste Schritte

Transaction Monitoring

Stream Pump AMM Data

Decoding Transaction Data

Yellowstone protocol reference

Monitoring-Typen

Praktische Beispiele

Beispiel 1: Überwachung des Netzwerkzustands

Beispiel 2: Überwachung der Blockproduktion

Beispiel 3: Gefilterte Blocküberwachung

Datenstrukturen

Leistungsaspekte

Anwendungsfälle

Fehlerbehandlung

Best Practices

Nächste Schritte