> ## 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.

# Solana Pump AMM-Datenstreaming mit LaserStream

> Einfach einzufügendes LaserStream-Skript, das Pump.fun-Konto- und Transaktionsaktivitäten in Echtzeit streamt, mit rollenden Statistiken und Signaturdekodierung.

Streamen Sie jedes Pump.fun-Kontoupdate und jede Transaktion in Echtzeit mit dem [LaserStream SDK](/docs/de/laserstream/clients). Diese Seite führt durch ein vollständiges TypeScript-Skript, das Sie von Anfang bis Ende ausführen können: Es druckt jede Transaktion, sobald sie eingeht, meldet einmal pro Minute rollende Statistiken (Durchsatz, einzigartige Gebührenzahler, Gesamtgebühren in SOL) und bleibt über Wiederverbindungen hinweg automatisch verbunden.

Es ist ein nützlicher Ausgangspunkt für alles, was kontinuierliche Pump.fun-Transparenz benötigt — Trading-Bots, Analysedashboards, Warnpipelines oder einfach, um die Datenform zu erkunden, damit Sie darauf aufbauend etwas Spezielleres entwickeln können.

<Info>
  **Voraussetzungen:** Ein [Helius API-Schlüssel](https://dashboard.helius.dev/) (Business- oder Professional-Plan für Mainnet LaserStream) und Node.js 18+. Vertrautheit mit [Account-Abonnements](/docs/de/laserstream/guides/account-subscription) und [Transaktionsüberwachung](/docs/de/laserstream/guides/transaction-monitoring) ist hilfreich, aber nicht erforderlich.
</Info>

***

## Einrichtung

Erstellen Sie ein neues Projekt, installieren Sie das SDK + `bs58` (wird verwendet, um Transaktionssignaturen zu dekodieren) und setzen Sie Ihren API-Schlüssel:

```bash theme={"system"}
mkdir pump-monitor && cd pump-monitor
npm init -y
npm install helius-laserstream bs58
npm install --save-dev typescript ts-node @types/node
npx tsc --init
export HELIUS_API_KEY=your-key-here
```

Wählen Sie den Endpunkt, der dem Ort, an dem dieses Skript ausgeführt wird, am nächsten ist — siehe die [LaserStream-Regionen](/docs/de/laserstream/grpc#mainnet-endpunkte).

***

## Das Skript

Speichern Sie dies als `index.ts` und führen Sie dann `npx ts-node index.ts` aus:

```typescript [expandable] theme={"system"}
import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream';
import bs58 from 'bs58';

const PUMP_PROGRAM_ID = '6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P';

// Rolling stats across the session.
const stats = {
  startedAt: Date.now(),
  transactions: 0,
  successes: 0,
  failures: 0,
  uniquePayers: new Set<string>(),
  totalFeesLamports: 0,
  accountUpdates: 0,
};

async function handleUpdate(data: any) {
  if (data.transaction) {
    const tx = data.transaction.transaction;
    if (!tx) return;

    stats.transactions++;
    const failed = !!tx.meta?.err;
    failed ? stats.failures++ : stats.successes++;

    // tx.meta.fee is a u64 string — coerce before adding.
    stats.totalFeesLamports += Number(tx.meta?.fee ?? 0);

    // Fee payer is the first account in the message.
    const firstKey = tx.transaction?.message?.accountKeys?.[0];
    if (firstKey) {
      const payer = typeof firstKey === 'string' ? firstKey : bs58.encode(firstKey);
      stats.uniquePayers.add(payer);
    }

    // tx.signature is a Buffer in the SDK.
    const sig = bs58.encode(tx.signature);
    const slot = data.transaction.slot;
    const flag = failed ? '❌' : '✅';
    console.log(`${flag}  ${sig.slice(0, 12)}…  slot ${slot}  fee ${tx.meta?.fee} lamports`);
  }

  if (data.account) {
    stats.accountUpdates++;
    const acct = data.account.account;
    const pubkey = typeof acct.pubkey === 'string' ? acct.pubkey : bs58.encode(acct.pubkey);
    console.log(`📋  account ${pubkey}  ${acct.data?.length ?? 0} bytes`);
  }
}

function printReport() {
  const minutes = (Date.now() - stats.startedAt) / 60_000;
  console.log('\n📊  Pump.fun activity report');
  console.log(`   Runtime:           ${minutes.toFixed(1)} min`);
  console.log(`   Transactions:      ${stats.transactions} (${stats.successes} ok, ${stats.failures} failed)`);
  console.log(`   Throughput:        ${(stats.transactions / Math.max(minutes, 0.0001)).toFixed(1)} tx/min`);
  console.log(`   Unique fee payers: ${stats.uniquePayers.size}`);
  console.log(`   Total fees:        ${(stats.totalFeesLamports / 1e9).toFixed(4)} SOL`);
  console.log(`   Account updates:   ${stats.accountUpdates}\n`);
}

async function main() {
  const config: LaserstreamConfig = {
    apiKey: process.env.HELIUS_API_KEY ?? 'YOUR_API_KEY',
    endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // pick the region closest to you
  };

  const subscriptionRequest: SubscribeRequest = {
    accounts: {
      'pump-accounts': {
        account: [],
        owner: [PUMP_PROGRAM_ID],
        filters: [],
      },
    },
    transactions: {
      'pump-transactions': {
        accountInclude: [PUMP_PROGRAM_ID],
        accountExclude: [],
        accountRequired: [],
        vote: false,
        failed: false,
      },
    },
    commitment: CommitmentLevel.CONFIRMED,
    slots: {},
    transactionsStatus: {},
    blocks: {},
    blocksMeta: {},
    entry: {},
    accountsDataSlice: [],
  };

  console.log('🚀  Streaming Pump.fun activity. Press Ctrl+C to stop.\n');

  const reportTimer = setInterval(printReport, 60_000);
  process.on('SIGINT', () => {
    clearInterval(reportTimer);
    printReport();
    process.exit(0);
  });

  await subscribe(config, subscriptionRequest, handleUpdate, async (error) => {
    console.error('Stream error:', error);
  });
}

main().catch(console.error);
```

***

## Was das Skript macht

### Ein Abonnement, zwei Filterblöcke

Ein einzelner `subscribe(...)`-Aufruf enthält zwei benannte Filtergruppen:

* Der **`accounts`**-Filter empfängt jedes Konto, das vom Pump.fun-Programm verwaltet wird (Bonding-Kurven, Mint-Zustand usw.), jedes Mal, wenn sich ihre Daten ändern.
* Der **`transactions`**-Filter empfängt jede Transaktion, die mit dem Pump.fun-Programm interagiert. Die `vote: false, failed: false`-Flags verwerfen Stimmen und fehlgeschlagene Transaktionen, bevor sie Ihren Handler erreichen.

Beide kommen über einen einzigen gRPC-Stream an, sodass das SDK nur eine Verbindung zu verwalten hat. Wenn sie abbricht, stellt das SDK die Verbindung automatisch wieder her und Sie erhalten weiterhin Updates von beiden Filtern.

### Lesen der Rohfelder

Einige Werte im Payload benötigen eine kleine Konvertierung, bevor sie einfach zu verwenden sind:

* **`tx.signature`** ist ein [`Buffer`](https://nodejs.org/api/buffer.html). Führen Sie es durch `bs58.encode(...)`, um die Base58-Signatur zu erhalten, die Sie in einem Explorer oder einer `getTransaction`-Antwort sehen würden.
* **`tx.meta.fee`** ist ein u64, das als String gespeichert ist, damit Werte über `Number.MAX_SAFE_INTEGER` in JavaScript keine Genauigkeit verlieren. Wickeln Sie es in `Number(...)` ein, bevor Sie Rechenoperationen durchführen. Dasselbe String-für-u64-Konzept gilt auch für mehrere Blockebenenfelder — siehe [Slot- und Blocküberwachung](/docs/de/laserstream/guides/slot-and-block-monitoring) für die vollständige Datenform.

### Rollende Statistiken

Ein `setInterval` druckt alle 60 Sekunden einen Snapshot: Gesamttransaktionen, Erfolge gegenüber Fehlern, Durchsatz, einzigartige Gebührenzahler und Gesamtgebühren in SOL. Drücken Sie `Ctrl+C`, um einen letzten Snapshot zu erhalten, bevor das Skript beendet wird.

***

## Das Skript erweitern

Einige Richtungen, um dies weiterzuentwickeln:

* **Dekodieren von Anweisungsdiskriminatoren**, um Trades als `buy` / `sell` / `create` zu kennzeichnen — siehe [Dekodieren von Transaktionsdaten](/docs/de/laserstream/guides/decoding-transaction-data) für das Parsing-Muster.
* **Persistieren** der rollenden Statistiken in einer Datenbank (Postgres, Redis, ClickHouse) anstelle von In-Memory `Set` / Zählern.
* **Warnen** bei Schwellenwerten — große Gebührenzahler, plötzliche Volumenspitzen, neue Bonding-Kurvenkonten.
* **Wiederholen** versäumter Aktivitäten beim Start durch Setzen von `fromSlot` auf `SubscribeRequest` (bis zu 24 Stunden zurück — siehe [Historisches Wiederholen](/docs/de/laserstream/historical-replay)).
* **Kombinieren** mit [Slot- und Blocküberwachung](/docs/de/laserstream/guides/slot-and-block-monitoring) für Blockkontext.

***

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Transaktionsüberwachung" icon="receipt" href="/docs/de/laserstream/guides/transaction-monitoring">
    Die allgemeinen Transaktionsfiltermuster, die dieses Skript verwendet.
  </Card>

  <Card title="Dekodieren von Transaktionsdaten" icon="binary" href="/docs/de/laserstream/guides/decoding-transaction-data">
    Parsen Sie das binäre Transaktion-Payload in lesbare Solana-Transaktionen.
  </Card>

  <Card title="Kontoabonnements" icon="user" href="/docs/de/laserstream/guides/account-subscription">
    Überwachen Sie spezifische Kontostandsänderungen mit Filtern.
  </Card>

  <Card title="Historisches Wiederholen" icon="clock-rotate-left" href="/docs/de/laserstream/historical-replay">
    Wiederholen Sie bis zu 24 Stunden vergangene Pump.fun-Aktivität ab einem Startslot.
  </Card>
</CardGroup>