> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Transaktionsüberwachung mit LaserStream
> Streamen Sie Solana-Transaktionen in Echtzeit mit LaserStream — Programmfilterung, Ausführungsdetails, Token-Saldoänderungen und sicheres Wiederverbinden.
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`](/docs/de/laserstream/clients) SDK.
**Voraussetzungen:** Dieser Leitfaden setzt voraus, dass Sie das [LaserStream gRPC Schnellstart](/docs/de/laserstream/grpc) 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.` 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](/docs/de/laserstream/token-account-filtering) und den **Watching a Wallet** Tab unten.
**Überwachen Sie Transaktionen, die bestimmte Programme betreffen**
Verfolgen Sie alle Transaktionen, die Programme betreffen, die für Sie wichtig sind:
```typescript theme={"system"}
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**
```typescript theme={"system"}
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**
```typescript theme={"system"}
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äten**
`accountInclude` 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).
```typescript theme={"system"}
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:
```typescript [expandable] theme={"system"}
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:
```typescript [expandable] theme={"system"}
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:
```typescript [expandable] theme={"system"}
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:
```typescript [expandable] theme={"system"}
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
```typescript theme={"system"}
{
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[];
};
}
```
```typescript theme={"system"}
{
accountIndex: number;
mint: string;
owner: string;
uiTokenAmount: {
amount: string;
decimals: number;
uiAmount: number;
uiAmountString: string;
};
}
```
```typescript theme={"system"}
{
programIdIndex: number; // Index in accountKeys array
accounts: number[];
data: string; // Instruction data (base58)
}
```
***
## Referenz zur Filterlogik
**`accountInclude`:** Transaktion muss eines dieser Konten betreffen.
`["A", "B"]` stimmt überein mit Transaktionen, die Konto A ODER Konto B betreffen.
**`accountRequired`:** Transaktion muss alle diese Konten betreffen.
`["A", "B"]` stimmt überein mit Transaktionen, die Konto A UND Konto B betreffen.
**`accountExclude`:** Transaktion darf keines dieser Konten betreffen.
Endgültiger Filter: `(accountInclude OR empty) AND (accountRequired AND all) AND NOT (accountExclude OR any)`.
***
## Leistungserwägungen
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
```typescript theme={"system"}
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:
```typescript theme={"system"}
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
**Symptom:** Überwältigendes Transaktionsvolumen.
**Lösungen:** Strengere Filter hinzufügen (`accountRequired`, `accountExclude`); höhere Verpflichtungsstufe verwenden; Sampling oder Ratenbegrenzung implementieren; asynchron verarbeiten.
**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.
**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](/docs/de/laserstream/guides/decoding-transaction-data).
***
## Nächste Schritte
Netzwerk-Consensus und Blockproduktion verfolgen.
Praxisbeispiel: Pump.fun AMM-Transaktionen überwachen.
Die binären Transaktionsdaten in lesbare Solana-Transaktionen parsen.
Der gleiche Arbeitsablauf mit dem rohen Yellowstone gRPC-Protokoll.