Transaktionsüberwachung - Helius LaserStream

Die Transaktionsüberwachung ermöglicht es Ihnen, die Ausführung von Transaktionen, den Erfolgs-/Fehlerstatus, Programm-Interaktionen und Token-Saldoänderungen in Solana in Echtzeit zu verfolgen. Dieser Leitfaden behandelt Filterstrategien und praktische Implementierungen mit dem helius-laserstream SDK.

Voraussetzungen: Dieser Leitfaden setzt voraus, dass Sie das LaserStream gRPC Schnellstart abgeschlossen haben und über einen API-Schlüssel verfügen.

Transaktionsfilter-Optionen

LaserStream verwendet dieselbe Filterform wie Yellowstone gRPC, einschließlich des tokenAccounts (ATA-Erweiterung) Filters. Die Felder, die Sie innerhalb von transactions.<label> festlegen werden:

accountInclude — Übereinstimmung, wenn eines dieser Konten erscheint (logisches ODER)
accountRequired — Übereinstimmung nur, wenn alle diese Konten erscheinen (logisches UND)
accountExclude — verwerfen, wenn eines dieser Konten erscheint
vote / failed — boolesche Flags für Abstimmungs- und fehlgeschlagene Transaktionen
tokenAccounts — Opt-in für die erweiterte assoziierte Token-Konto (ATA) Erweiterung ("balanceChanged", "all", oder "none"), sodass ein accountInclude Wallet auch Transaktionen abgleicht, bei denen es einen SPL-Token-Saldo besitzt. Siehe Token-Konto (ATA) Filterung und den Watching a Wallet Tab unten.

Programmfiltierung
Kontospezifisch
Erweiterte Filterung
Beobachten eines Wallets

Überwachen Sie Transaktionen, die bestimmte Programme betreffenVerfolgen Sie alle Transaktionen, die Programme betreffen, die für Sie wichtig sind:

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

Am besten geeignet für: Programmspezifische Überwachung, DeFi-Protokollverfolgung, Smart-Contract-Interaktionen.

Überwachen Sie 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, Token-Mint-Verfolgung, Kontoaktivitäts-Dashboards.

Kombinieren Sie 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.

Fangen Sie eingehende Token-Transfers auf, nicht nur direkte AktivitätenaccountInclude erfasst nur Transaktionen, bei denen das Wallet direkt in den Kontoschlüsseln erscheint. Wenn jemand dem Wallet einen SPL-Token sendet, berührt der Transfer das assoziierte Token-Konto (ATA) des Wallets, nicht den Wallet-Pubkey — daher sieht ein einfaches accountInclude: [wallet] es nie.Setzen Sie tokenAccounts, um die Übereinstimmung mit Transaktionen zu erweitern, bei denen das Wallet einen Token-Saldo besitzt. Es nimmt einen String an:

"balanceChanged" — Übereinstimmung, wenn sich ein besessener Token-Saldo geändert hat (oder sein Token-Konto geschlossen wurde). Am besten geeignet für “sagen Sie mir, wann wirklich Geld bewegt wurde” — enger, mit geringem Volumen, die empfohlene Standardeinstellung.
"all" — Übereinstimmung mit jeder Transaktion, die einen besessenen Token-Saldo referenziert, auch wenn unverändert. Erheblich höheres Volumen.
"none" — keine Erweiterung (gleichbedeutend mit dem Weglassen des Feldes).

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

Die Übereinstimmung basiert auf dem Besitzer — sie erfasst jedes Token-Konto, das das Wallet besitzt (einschließlich nicht-kanonischer), nicht nur die abgeleitete ATA-Adresse. Das SDK konvertiert den String für Sie in das Wire-Level TokenAccountExpansionControlFlag Enum.

Praktische Beispiele

Beispiel 1: Überwachen von DEX-Transaktionen

Verfolgen Sie Transaktionen, die beliebte 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: Überwachen fehlgeschlagener Transaktionen

Verfolgen Sie fehlgeschlagene Transaktionen, um Anwendungsprobleme 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: Überwachen von Hochwerttransaktionen

Verfolgen Sie Transaktionen mit signifikanten SOL-Transfers:

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: Überwachen eines Wallets (einschl. Token-Transfers)

Überwachen Sie alles, was Geld für ein Wallet bewegt — einschließlich eingehender SPL-Token-Transfers, die seine ATAs berühren — indem Sie tokenAccounts zu einem einfachen accountInclude Filter hinzufügen:

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

Transaktionsdatenstruktur

Transaktionsnachrichtenstruktur

{
  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-Saldoänderungen

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

Anweisungsdetails

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

Referenz zur Filterlogik

Einschlusslogik (ODER)

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

Erforderliche Logik (UND)

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

Ausschlusslogik (NICHT)

accountExclude: Transaktion darf keines dieser Konten betreffen.

Kombinierte Logik

Endgültiger Filter: (accountInclude OR empty) AND (accountRequired AND all) AND NOT (accountExclude OR any).

Leistungserwägungen

Volumenmanagement
Datenverarbeitung

Transaktionsströme können hohes Volumen haben. Um Schritt zu halten:

Beginnen Sie mit spezifischen Programmfiltern (nicht auf “alle Transaktionen” abonnieren)
Verwenden Sie confirmed anstelle von processed, wenn Sie ~1.5s zusätzliche Latenz tolerieren können
Überwachen Sie Ihre Verarbeitungskapazität mit einem Zähler
Erwägen Sie den Einsatz paralleler Verbraucher hinter einer Warteschlange

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

Extrahieren Sie nur das, was Sie benötigen, um den Speicherbedarf 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

Zu viele Transaktionen

Symptom: Überwältigendes Transaktionsvolumen.Lösungen: Strengere Filter hinzufügen (accountRequired, accountExclude); höhere Verpflichtungsstufe verwenden; Sampling oder Ratenbegrenzung implementieren; asynchron verarbeiten.

Fehlende Transaktionen

Symptom: Erwartete Transaktionen erscheinen nicht.Lösungen: Überprüfen Sie, ob Programmadressen korrekt sind; prüfen Sie, ob die Transaktionen tatsächlich existieren; versuchen Sie processed für schnellere Updates; lockern Sie restriktive accountRequired/accountExclude Filter.

Parse-Fehler

Symptom: Transaktionsdaten können nicht geparst werden.Lösungen: Fehlende Felder anmutig behandeln; Struktur vor der Verarbeitung validieren; Parsen in try/catch einwickeln; siehe Dekodierung von Transaktionsdaten.

Nächste Schritte

Slot- & Blocküberwachung

Netzwerk-Consensus und Blockproduktion verfolgen.

Stream Pump AMM Daten

Praxisbeispiel: Pump.fun AMM-Transaktionen überwachen.

Dekodierung von Transaktionsdaten

Die binären Transaktionsdaten in lesbare Solana-Transaktionen parsen.

Yellowstone-Protokollreferenz

Der gleiche Arbeitsablauf mit dem rohen Yellowstone gRPC-Protokoll.

Hier starten

Echtzeitdaten

Niedrig-Latenz-Handel

Historische & Wallet-Daten

RPC-Methodenanleitungen

Produktionsbereitschaft

Orb verwenden

Weitere Anleitungen

Transaktionsüberwachung mit LaserStream

Transaktionsfilter-Optionen

Praktische Beispiele

Beispiel 1: Überwachen von DEX-Transaktionen

Beispiel 2: Überwachen fehlgeschlagener Transaktionen

Beispiel 3: Überwachen von Hochwerttransaktionen

Beispiel 4: Überwachen eines Wallets (einschl. Token-Transfers)

Transaktionsdatenstruktur

Referenz zur Filterlogik

Einschlusslogik (ODER)

Erforderliche Logik (UND)

Ausschlusslogik (NICHT)

Kombinierte Logik

Leistungserwägungen

Fehlerbehandlung

Nächste Schritte

Slot- & Blocküberwachung

Stream Pump AMM Daten

Dekodierung von Transaktionsdaten

Yellowstone-Protokollreferenz

​Transaktionsfilter-Optionen

​Praktische Beispiele

​Beispiel 1: Überwachen von DEX-Transaktionen

​Beispiel 2: Überwachen fehlgeschlagener Transaktionen

​Beispiel 3: Überwachen von Hochwerttransaktionen

​Beispiel 4: Überwachen eines Wallets (einschl. Token-Transfers)

​Transaktionsdatenstruktur

​Referenz zur Filterlogik

Einschlusslogik (ODER)

Erforderliche Logik (UND)

Ausschlusslogik (NICHT)

Kombinierte Logik

​Leistungserwägungen

​Fehlerbehandlung

​Nächste Schritte

Slot- & Blocküberwachung

Stream Pump AMM Daten

Dekodierung von Transaktionsdaten

Yellowstone-Protokollreferenz

Transaktionsfilter-Optionen

Praktische Beispiele

Beispiel 1: Überwachen von DEX-Transaktionen

Beispiel 2: Überwachen fehlgeschlagener Transaktionen

Beispiel 3: Überwachen von Hochwerttransaktionen

Beispiel 4: Überwachen eines Wallets (einschl. Token-Transfers)

Transaktionsdatenstruktur

Referenz zur Filterlogik

Leistungserwägungen

Fehlerbehandlung

Nächste Schritte