Transaktionsüberwachung – Helius LaserStream

Mit der Transaktionsüberwachung kannst du die Ausführung von Transaktionen, ihren Erfolgs- oder Fehlerstatus, Programminteraktionen und Änderungen am Guthaben von token in Solana in Echtzeit verfolgen. Dieser Leitfaden behandelt Filterstrategien und praktische Implementierungen mit dem helius-laserstream SDK.

Voraussetzungen: Dieser Leitfaden setzt voraus, dass du den LaserStream gRPC Quickstart abgeschlossen hast und einen API key besitzt.

Optionen für die Transaktionsfilterung

LaserStream verwendet dieselbe Filterstruktur wie Yellowstone gRPC, einschließlich des Filters tokenAccounts (ATA-Erweiterung). Diese Felder legst du in transactions.<label> fest:

accountInclude — stimmt überein, wenn eines dieser Konten vorkommt (logisches ODER)
accountRequired — stimmt nur überein, wenn alle diese Konten vorkommen (logisches UND)
accountExclude — verwirft die Transaktion, wenn eines dieser Konten vorkommt
vote / failed — boolesche Flags für Abstimmungs- und fehlgeschlagene Transaktionen
tokenAccounts — optionale Erweiterung für zugehörige Token-Konten (ATA) ("balanceChanged", "all" oder "none"), sodass eine accountInclude-Wallet auch mit Transaktionen übereinstimmt, bei denen sie ein SPL-Tokenguthaben besitzt. Sieh dir Filtern nach Token-Konten (ATA) und unten den Tab Watching a Wallet an.
matchMints — optionales Flag, das die Kontolisten zusätzlich mit den Mints in den Token-Guthaben vor und nach einer Transaktion abgleicht. Dadurch erfasst ein Mint in accountInclude jede Übertragung, jeden Swap, jeden Mint-Vorgang und jeden Burn dieses Tokens. Sieh dir Filtern nach Token-Mints und unten den Tab Watching a Token an.

Program Filtering
Account-Specific
Advanced Filtering
Watching a Wallet
Watching a Token

Überwache Transaktionen, an denen bestimmte Programme beteiligt sindVerfolge alle Transaktionen, die für dich relevante Programme betreffen:

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

const subscriptionRequest: SubscribeRequest = {
  transactions: {
    "program-filter": {
      accountInclude: [
        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Token Program
        "11111111111111111111111111111111",              // System Program
        "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"  // Your program
      ],
      accountExclude: [],
      accountRequired: [],
      vote: false,
      failed: false
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {},
  slots: {},
  transactionsStatus: {},
  blocks: {},
  blocksMeta: {},
  entry: {},
  accountsDataSlice: [],
};

Ideal für: programmspezifische Überwachung, Nachverfolgung von DeFi-Protokollen und Interaktionen mit Smart Contracts.

Überwache Transaktionen, die bestimmte Konten betreffen

const subscriptionRequest: SubscribeRequest = {
  transactions: {
    "wallet-filter": {
      accountInclude: [
        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC mint
        "YourWalletAddress"                                // Your wallet
      ],
      accountExclude: [],
      accountRequired: [],
      vote: false,
      failed: true // Include failures to track errors
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {}, slots: {}, transactionsStatus: {},
  blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
};

Anwendungsfall: Wallet-Überwachung, Nachverfolgung von token-Mints und Dashboards für Kontoaktivitäten.

Kombiniere mehrere Filterkriterien

const subscriptionRequest: SubscribeRequest = {
  transactions: {
    "advanced-filter": {
      accountInclude: ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"],
      accountRequired: ["YourProgramId"], // Must include this program
      accountExclude: ["VoteProgram"],     // Exclude vote-related txs
      vote: false,
      failed: false
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {}, slots: {}, transactionsStatus: {},
  blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
};

Filterlogik: accountInclude (ODER) UND accountRequired (UND) UND NICHT accountExclude.

Erfasse eingehende token-Übertragungen, nicht nur direkte AktivitätenaccountInclude stimmt nur mit Transaktionen überein, bei denen die Wallet direkt in den Kontoschlüsseln vorkommt. Wenn jemand der Wallet einen SPL-token sendet, betrifft die Übertragung das zugehörige token-Konto (ATA) der Wallet und nicht den pubkey der Wallet. Deshalb erkennt ein einfacher Filter mit accountInclude: [wallet] diese Übertragung nicht.Lege tokenAccounts fest, um auch Transaktionen abzugleichen, bei denen die Wallet ein token-Guthaben besitzt. Das Feld akzeptiert einen String:

"balanceChanged" — stimmt überein, wenn sich ein token-Guthaben im Besitz der Wallet geändert hat oder das zugehörige token-Konto geschlossen wurde. Ideal für „Informiere mich, wenn tatsächlich Geld bewegt wurde“ – gezielter, mit geringerem Volumen und als Standard empfohlen.
"all" — stimmt mit jeder Transaktion überein, die auf ein token-Guthaben im Besitz der Wallet verweist, auch wenn es unverändert bleibt. Das Volumen ist deutlich höher.
"none" — keine Erweiterung; entspricht dem Weglassen des Felds.

const subscriptionRequest: SubscribeRequest = {
  transactions: {
    "wallet-with-tokens": {
      accountInclude: ["YourWalletAddress"],
      accountExclude: [],
      accountRequired: [],
      vote: false,
      failed: false,
      tokenAccounts: "balanceChanged" // also match the wallet's ATAs
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {}, slots: {}, transactionsStatus: {},
  blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
};

Der Abgleich basiert auf dem Eigentümer. Er erfasst jedes Token-Konto, das der Wallet gehört (einschließlich nicht kanonischer Konten), nicht nur die abgeleitete ATA-Adresse. Das SDK konvertiert den String für dich in das TokenAccountExpansionControlFlag-Enum auf Wire-Ebene.

Erfasse jede Transaktion für einen Mint, nicht nur Transaktionen, die ihn ausdrücklich nennenEin einfaches accountInclude: [mint] stimmt nur mit Transaktionen überein, deren Kontoschlüssel den Mint enthalten, etwa MintTo, Burn oder TransferChecked. Ein klassisches SPL-Transfer verweist nie auf den Mint. Deshalb werden die meisten Übertragungen des Tokens nicht erfasst.Setze matchMints: true. Die Kontolisten werden dann zusätzlich mit den Mints in preTokenBalances und postTokenBalances der Transaktion abgeglichen:

const USDC = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';

const subscriptionRequest: SubscribeRequest = {
  transactions: {
    "usdc-activity": {
      accountInclude: [USDC],
      accountExclude: [],
      accountRequired: [],
      vote: false,
      failed: false,
      matchMints: true // also match via pre/post token-balance mints
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  accounts: {}, slots: {}, transactionsStatus: {},
  blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
};

Kombiniere es mit tokenAccounts, um ein Token für eine Wallet zu überwachen: Füge die Wallet mit tokenAccounts: "balanceChanged" zu accountInclude und den Mint mit matchMints: true zu accountRequired hinzu. Erfordert helius-laserstream 0.8.5+ (JS), 0.6.4+ (Rust) oder go/v0.3.0+ (Go). Die vollständige Semantik findest du unter Filtern nach Token-Mints.

Praktische Beispiele

Beispiel 1: DEX-Transaktionen überwachen

Verfolge Transaktionen, die gängige DEX-Programme betreffen:

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

async function monitorDEXTransactions() {
  const subscriptionRequest: SubscribeRequest = {
    transactions: {
      "dex-filter": {
        accountInclude: [
          "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8", // Raydium
          "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK", // Raydium CLMM
          "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"   // Jupiter
        ],
        accountExclude: [],
        accountRequired: [],
        vote: false,
        failed: false
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {}, slots: {}, transactionsStatus: {},
    blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
  };

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

  await subscribe(config, subscriptionRequest, async (data) => {
    if (!data.transaction?.transaction) return;
    const tx = data.transaction.transaction;
    console.log(`\n🔄 DEX Transaction:`);
    console.log(`  Signature: ${bs58.encode(tx.signature)}`);
    console.log(`  Slot: ${data.transaction.slot}`);
    console.log(`  Status: ${tx.meta?.err ? 'Failed' : 'Success'}`);
    console.log(`  Fee: ${tx.meta?.fee || 0} lamports`);
    console.log(`  Compute Units: ${tx.meta?.computeUnitsConsumed || 0}`);

    // Token balance changes
    if (tx.meta?.preTokenBalances?.length > 0) {
      console.log(`  Token Balance Changes:`);
      tx.meta.preTokenBalances.forEach((preBalance: any, index: number) => {
        const postBalance = tx.meta.postTokenBalances[index];
        if (preBalance && postBalance) {
          const change = postBalance.uiTokenAmount.uiAmount - preBalance.uiTokenAmount.uiAmount;
          if (change !== 0) {
            console.log(`    ${preBalance.mint}: ${change > 0 ? '+' : ''}${change}`);
          }
        }
      });
    }
  }, async (error) => {
    console.error('Stream error:', error);
  });
}

monitorDEXTransactions().catch(console.error);

Beispiel 2: Fehlgeschlagene Transaktionen überwachen

Verfolge fehlgeschlagene Transaktionen, um Probleme in der Anwendung zu erkennen:

async function monitorFailedTransactions() {
  const subscriptionRequest: SubscribeRequest = {
    transactions: {
      "failures": {
        accountInclude: ["YourProgramId"],
        accountExclude: [],
        accountRequired: [],
        vote: false,
        failed: true // Only failed transactions
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {}, slots: {}, 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.transaction?.transaction?.meta?.err) return;
    const tx = data.transaction.transaction;
    console.log(`\n❌ Failed Transaction:`);
    console.log(`  Signature: ${bs58.encode(tx.signature)}`);
    console.log(`  Slot: ${data.transaction.slot}`);
    console.log(`  Error: ${JSON.stringify(tx.meta.err)}`);
    console.log(`  Fee: ${tx.meta.fee} lamports`);
    console.log(`  Compute Units: ${tx.meta.computeUnitsConsumed || 0}`);
  }, async (error) => {
    console.error('Stream error:', error);
  });
}

Beispiel 3: Transaktionen mit hohem Wert überwachen

Verfolge Transaktionen mit umfangreichen SOL-Übertragungen:

async function monitorHighValueTransactions() {
  const subscriptionRequest: SubscribeRequest = {
    transactions: {
      "system-program": {
        accountInclude: ["11111111111111111111111111111111"],
        accountExclude: [],
        accountRequired: [],
        vote: false,
        failed: false
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {}, slots: {}, 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.transaction?.transaction?.meta) return;
    const tx = data.transaction.transaction;
    const preBalances = tx.meta.preBalances || [];
    const postBalances = tx.meta.postBalances || [];

    let maxChange = 0;
    preBalances.forEach((preBalance: number, index: number) => {
      const postBalance = postBalances[index] || 0;
      maxChange = Math.max(maxChange, Math.abs(postBalance - preBalance));
    });

    const changeInSOL = maxChange / 1e9;
    if (changeInSOL > 10) {
      console.log(`\n💰 High-Value Transaction:`);
      console.log(`  Signature: ${bs58.encode(tx.signature)}`);
      console.log(`  Slot: ${data.transaction.slot}`);
      console.log(`  Max SOL Transfer: ${changeInSOL.toFixed(2)} SOL`);
      console.log(`  Fee: ${tx.meta.fee / 1e9} SOL`);
    }
  }, async (error) => {
    console.error('Stream error:', error);
  });
}

Beispiel 4: Eine Wallet überwachen (einschließlich Token-Übertragungen)

Überwache alle Geldbewegungen einer Wallet – einschließlich eingehender SPL-Token-Übertragungen, die ihre ATAs betreffen –, indem du tokenAccounts zu einem einfachen accountInclude-Filter hinzufügst:

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

async function watchWallet(wallet: string) {
  const subscriptionRequest: SubscribeRequest = {
    transactions: {
      "wallet-activity": {
        accountInclude: [wallet],
        accountExclude: [],
        accountRequired: [],
        vote: false,
        failed: false,
        // Also match txs touching token accounts this wallet owns.
        // "balanceChanged" = only when an owned token balance actually moved.
        tokenAccounts: "balanceChanged"
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {}, slots: {}, 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.transaction?.transaction) return;
    const tx = data.transaction.transaction;
    console.log(`\n👛 Wallet activity:`);
    console.log(`  Signature: ${bs58.encode(tx.signature)}`);
    console.log(`  Slot: ${data.transaction.slot}`);

    // Surface token balances this wallet owns that changed in the tx
    const owned = (tx.meta?.postTokenBalances || []).filter((b: any) => b.owner === wallet);
    owned.forEach((post: any) => {
      const pre = (tx.meta.preTokenBalances || []).find(
        (b: any) => b.accountIndex === post.accountIndex
      );
      const before = pre?.uiTokenAmount?.uiAmount || 0;
      const after = post.uiTokenAmount?.uiAmount || 0;
      if (after !== before) {
        console.log(`  ${post.mint}: ${after - before > 0 ? '+' : ''}${after - before}`);
      }
    });
  }, async (error) => {
    console.error('Stream error:', error);
  });
}

Datenstruktur der Transaktion

Transaction Message Structure

{
  signature: string;
  isVote: boolean;
  transaction: {
    message: {
      accountKeys: string[];        // All accounts involved
      instructions: Instruction[];  // Program instructions
      recentBlockhash: string;
    };
    signatures: string[];
  };
  meta: {
    err: any;                      // Error details if failed
    fee: number;                   // Transaction fee in lamports
    computeUnitsConsumed: number;
    preBalances: number[];
    postBalances: number[];
    preTokenBalances: TokenBalance[];
    postTokenBalances: TokenBalance[];
    logMessages: string[];
  };
}

Token Balance Changes

{
  accountIndex: number;
  mint: string;
  owner: string;
  uiTokenAmount: {
    amount: string;
    decimals: number;
    uiAmount: number;
    uiAmountString: string;
  };
}

Instruction Details

{
  programIdIndex: number; // Index in accountKeys array
  accounts: number[];
  data: string;           // Instruction data (base58)
}

Referenz zur Filterlogik

Include Logic (OR)

accountInclude: Die Transaktion muss MINDESTENS EINES dieser Konten betreffen.["A", "B"] stimmt mit Transaktionen überein, die Konto A ODER Konto B betreffen.

Required Logic (AND)

accountRequired: Die Transaktion muss ALLE diese Konten betreffen.["A", "B"] stimmt mit Transaktionen überein, die Konto A UND Konto B betreffen.

Exclude Logic (NOT)

accountExclude: Die Transaktion darf KEINES dieser Konten betreffen.

Combined Logic

Abschließender Filter: (accountInclude OR empty) AND (accountRequired AND all) AND NOT (accountExclude OR any).

Leistungsaspekte

Volume Management
Data Processing

Transaktions-streams können ein hohes Datenvolumen haben. So kannst du Schritt halten:

Beginne mit spezifischen Programmfiltern (abonniere nicht „alle Transaktionen“)
Verwende confirmed statt processed, wenn du etwa 1,5 Sekunden zusätzliche Latenz tolerieren kannst
Überwache deine Verarbeitungskapazität mit einem Zähler
Erwäge, parallele Consumer hinter einer Warteschlange auszuführen

let count = 0;
const startTime = Date.now();
// inside your subscribe handler:
count++;
if (count % 100 === 0) {
  const elapsed = (Date.now() - startTime) / 1000;
  console.log(`Processing ${(count / elapsed).toFixed(1)} tx/sec`);
}

Extrahiere nur die benötigten Daten, um den Speicherverbrauch niedrig zu halten:

import bs58 from 'bs58';

function extractTransactionData(tx: any) {
  return {
    signature: bs58.encode(tx.signature),
    slot: tx.slot,
    success: !tx.meta?.err,
    fee: tx.meta?.fee || 0,
    computeUnits: tx.meta?.computeUnitsConsumed || 0,
  };
}

Fehlerbehandlung

Too Many Transactions

Symptom: Überwältigendes Transaktionsvolumen.Lösungen: Füge strengere Filter hinzu (accountRequired, accountExclude); verwende ein höheres commitment; implementiere Sampling oder eine rate limit; verarbeite die Daten asynchron.

Missing Transactions

Symptom: Erwartete Transaktionen werden nicht angezeigt.Lösungen: Prüfe, ob die Programmadressen korrekt sind; prüfe, ob die Transaktionen tatsächlich existieren; verwende processed für schnellere Aktualisierungen; lockere restriktive accountRequired-/accountExclude-Filter.

Parse Errors

Symptom: Die Transaktionsdaten können nicht geparst werden.Lösungen: Behandle fehlende Felder robust; validiere die Struktur vor der Verarbeitung; kapsle das Parsen in try/catch; sieh dir Transaktionsdaten decodieren an.

Nächste Schritte

Slot & Block Monitoring

Verfolge den Netzwerkkonsens und die Blockproduktion.

Stream Pump AMM Data

Praxisbeispiel: Überwache Pump.fun-AMM-Transaktionen.

Decoding Transaction Data

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

Yellowstone protocol reference

Derselbe Workflow mit dem zugrunde liegenden Yellowstone-gRPC-Protokoll.

Hier starten

Echtzeitdaten

Trading mit niedriger Latenz

Historische Daten und Wallet-Daten

Anleitungen zu RPC-Methoden

Produktionsreife

Orb verwenden

Weitere Anleitungen

Transaktionsüberwachung mit LaserStream

Optionen für die Transaktionsfilterung

Praktische Beispiele

Beispiel 1: DEX-Transaktionen überwachen

Beispiel 2: Fehlgeschlagene Transaktionen überwachen

Beispiel 3: Transaktionen mit hohem Wert überwachen

Beispiel 4: Eine Wallet überwachen (einschließlich Token-Übertragungen)

Datenstruktur der Transaktion

Referenz zur Filterlogik

Include Logic (OR)

Required Logic (AND)

Exclude Logic (NOT)

Combined Logic

Leistungsaspekte

Fehlerbehandlung

Nächste Schritte

Slot & Block Monitoring

Stream Pump AMM Data

Decoding Transaction Data

Yellowstone protocol reference

​Optionen für die Transaktionsfilterung

​Praktische Beispiele

​Beispiel 1: DEX-Transaktionen überwachen

​Beispiel 2: Fehlgeschlagene Transaktionen überwachen

​Beispiel 3: Transaktionen mit hohem Wert überwachen

​Beispiel 4: Eine Wallet überwachen (einschließlich Token-Übertragungen)

​Datenstruktur der Transaktion

​Referenz zur Filterlogik

Include Logic (OR)

Required Logic (AND)

Exclude Logic (NOT)

Combined Logic

​Leistungsaspekte

​Fehlerbehandlung

​Nächste Schritte

Slot & Block Monitoring

Stream Pump AMM Data

Decoding Transaction Data

Yellowstone protocol reference

Optionen für die Transaktionsfilterung

Praktische Beispiele

Beispiel 1: DEX-Transaktionen überwachen

Beispiel 2: Fehlgeschlagene Transaktionen überwachen

Beispiel 3: Transaktionen mit hohem Wert überwachen

Beispiel 4: Eine Wallet überwachen (einschließlich Token-Übertragungen)

Datenstruktur der Transaktion

Referenz zur Filterlogik

Leistungsaspekte

Fehlerbehandlung

Nächste Schritte