LaserStream gRPC Schnellstart

Überblick

LaserStream ist ein verwalteter Solana gRPC-Streaming-Dienst. Es ist mit dem offenen Yellowstone gRPC-Protokoll leitungs-kompatibel — so funktioniert jeder Yellowstone-Client sofort — und bietet Produktionsfunktionen wie historische Wiedergabe, Multi-Node-Failover und eine vollständig verwaltete Umgebung. LaserStream nutzt das Open-Source gRPC-Protokoll, um sicherzustellen, dass kein Anbieter-Lock-In entsteht und maximale Kompatibilität mit bestehenden gRPC-Implementierungen gewährleistet ist. Sie können sich entweder mit dem standardmäßigen @triton-one/yellowstone-grpc Client verbinden oder das leistungsoptimierte Helius LaserStream SDK für zusätzlichen Nutzen wie höhere Durchsatzrate, automatische Wiederverbindungen, Abonnementverwaltung, Fehlerbehandlung und mehr verwenden.

LaserStream SDK ist 40x schneller im Vergleich zu JavaScript Yellowstone Clients

Erfahren Sie, wie wir Rust Core mit Zero-Copy NAPI-Bindungen verwendet haben, um die Leistung des JavaScript SDK zu maximieren.

Leistungshinweis: Wenn Sie Verzögerungen oder Leistungsprobleme mit Ihrer LaserStream-Verbindung feststellen, beziehen Sie sich bitte auf den Fehlerbehebungsabschnitt für häufige Ursachen und Lösungen.

Endpunkte & Regionen

LaserStream ist in mehreren Regionen weltweit verfügbar. Wählen Sie den Endpunkt, der Ihrer Anwendung am nächsten liegt, für optimale Leistung:

Mainnet-Endpunkte

Region	Standort	Endpunkt
ewr	Newark, NJ (nahe bei New York)	`https://laserstream-mainnet-ewr.helius-rpc.com`
pitt	Pittsburgh, USA (Zentral)	`https://laserstream-mainnet-pitt.helius-rpc.com`
slc	Salt Lake City, USA (Westküste)	`https://laserstream-mainnet-slc.helius-rpc.com`
lax	Los Angeles, USA (Westküste)	`https://laserstream-mainnet-lax.helius-rpc.com`
lon	London, Europa	`https://laserstream-mainnet-lon.helius-rpc.com`
ams	Amsterdam, Europa	`https://laserstream-mainnet-ams.helius-rpc.com`
fra	Frankfurt, Europa	`https://laserstream-mainnet-fra.helius-rpc.com`
tyo	Tokio, Asien	`https://laserstream-mainnet-tyo.helius-rpc.com`
sgp	Singapur, Asien	`https://laserstream-mainnet-sgp.helius-rpc.com`

Devnet-Endpunkt

Netzwerk	Standort	Endpunkt
Devnet	Newark, NJ (nahe bei New York)	`https://laserstream-devnet-ewr.helius-rpc.com`

Netzwerk- & Regionenauswahl:

Für Produktionsanwendungen wählen Sie den Mainnet-Endpunkt, der Ihrem Server am nächsten liegt, für die beste Leistung (z.B. bei Bereitstellung in Europa: Amsterdam (ams) oder Frankfurt (fra))
Für Tests nutzen Sie: https://laserstream-devnet-ewr.helius-rpc.com.

`zstd` Kompression

Alle LaserStream gRPC-Endpunkte unterstützen zstd Kompression. Die Kompression ist opt-in: Antworten bleiben unkomprimiert, es sei denn, Ihr Client kündigt die zstd Unterstützung an. Aktivieren Sie zstd im Helius LaserStream TypeScript SDK:

import { CompressionAlgorithms } from 'helius-laserstream'
import type { LaserstreamConfig } from 'helius-laserstream'

const config: LaserstreamConfig = {
  apiKey: 'YOUR_API_KEY',
  endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com',
  channelOptions: {
    'grpc.default_compression_algorithm': CompressionAlgorithms.zstd,
  },
}

zstd reduziert die Netzwerkbandbreite, fügt jedoch Kompressionsarbeit hinzu. Benchmarken Sie es mit Ihrer Abonnement-Arbeitslast, bevor Sie es für latenzempfindliche Streams aktivieren.

Log-Kürzung

Standardmäßig kürzt LaserStream Transaktionslog-Nachrichten auf 10 KB für bessere Geschwindigkeit und Leistung. Wenn Sie vollständige Logs benötigen, stehen dedizierte unkürzte Endpunkte zur Verfügung — siehe Log-Kürzung.

Schnellstart

Beginnen Sie mit LaserStream von Ihrem Helius Dashboard. Mainnet erfordert einen Business- oder Professional-Tarif; Devnet ist auf dem Entwickler- und höher verfügbar. Siehe Tarife & Preise für Details.

Neues Projekt erstellen

mkdir laserstream-grpc-demo
cd laserstream-grpc-demo
npm init -y

Abhängigkeiten installieren

npm install helius-laserstream
npm install --save-dev typescript tsx @types/node

Wir verwenden tsx, da der Standard npx tsc --init in TypeScript 5.x verbatimModuleSyntax, module: "nodenext" und types: [] setzt, die alle ein schnelles ts-node index.ts ausführen brechen. tsx führt .ts Dateien ohne tsconfig aus.

Erhalten Sie Ihren API-Schlüssel

Generieren Sie einen Schlüssel im Helius Dashboard.Dieser Schlüssel dient als Ihr Authentifizierungstoken für LaserStream.

Tarifanforderungen: LaserStream Devnet ist in allen Tarifen verfügbar. LaserStream Mainnet erfordert einen Business- oder Professional-Tarif.

Abonnement-Skript erstellen

Erstellen Sie index.ts mit folgendem Inhalt:

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

async function main() {
  const subscriptionRequest: SubscribeRequest = {
    transactions: {
      "token-filter": { // user-defined label for this filter
        accountInclude: ['TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'],
        accountExclude: [],
        accountRequired: [],
        vote: false,
        failed: false
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {},
    slots: {},
    transactionsStatus: {},
    blocks: {},
    blocksMeta: {},
    entry: {},
    accountsDataSlice: [],
    // Optionally, you can replay missed data by specifying a `fromSlot` (u64 number):
    // fromSlot: currentSlot - 1000,
    // Note: replay is currently limited to the last ~216,000 slots (≈24 hours).
  };

// Replace the values below with your actual LaserStream API key and endpoint
const config: LaserstreamConfig = {
  apiKey: 'YOUR_API_KEY', // Replace with your key from https://dashboard.helius.dev/
  endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
}

  await subscribe(config, subscriptionRequest, async (data) => {
    
    console.log(data);

  }, async (error) => {
    console.error(error);
  });
}

main().catch(console.error);

Ersetzen Sie Ihren API-Schlüssel und wählen Sie Ihre Region

Aktualisieren Sie in index.ts das config Objekt mit:

Ihrem tatsächlichen API-Schlüssel aus dem Helius Dashboard
Dem LaserStream-Endpunkt, der Ihrem Serverstandort am nächsten liegt

const config: LaserstreamConfig = {
  apiKey: 'YOUR_ACTUAL_API_KEY', // Replace with your key from Helius Dashboard
  endpoint: 'https://laserstream-mainnet-fra.helius-rpc.com', // Example: Frankfurt mainnet
  // For devnet: endpoint: 'https://laserstream-devnet-ewr.helius-rpc.com'
}

Netzwerk- & Regionenauswahl-Beispiele:

Für Produktion (Mainnet):
- Europa: Verwenden Sie fra (Frankfurt), ams (Amsterdam) oder lon (London)
- US Ost: Verwenden Sie ewr (New York)
- US West: Verwenden Sie slc (Salt Lake City) oder lax (Los Angeles)
- Asien: Verwenden Sie tyo (Tokio) oder sgp (Singapur)
Für Entwicklung (Devnet):
- Verwenden Sie https://laserstream-devnet-ewr.helius-rpc.com

Ausführen und Ergebnisse anzeigen

npx tsx index.ts

Jedes Mal, wenn eine confirmed Token-Transaktion TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA beinhaltet, sehen Sie die Daten in Ihrer Konsole.

Häufige Workflows

Schritt-für-Schritt-Anleitungen für die am häufigsten beobachteten Workflows. Jede Anleitung verwendet das helius-laserstream SDK mit eingebautem Auto-Reconnect und historischer Wiedergabe.

Konto-Abonnements

Überwachen Sie Änderungen am Saldo, an Daten und am Eigentum von spezifischen Konten mit Filtern.

Transaktionsüberwachung

Streamen Sie Transaktionen, die Zielkonten betreffen, filtern Sie nach Programm, Abstimmung oder Fehlerstatus.

Slot- & Blocküberwachung

Verfolgen Sie Netzwerk-Consensus, Blockproduktion und Übergänge des Verpflichtungsniveaus.

Transaktionsdaten dekodieren

Analysieren Sie die binären transactionUpdate Nutzlasten in lesbare Solana-Transaktionen.

Stream Pump AMM-Daten

Praxisbeispiel: Überwachen Sie Pump AMM-Trades mit reconnect-sicheren Filtern.

Der @triton-one/yellowstone-grpc Client funktioniert gegen dieselben Endpunkte, wenn Sie das rohe Yellowstone-Protokoll bevorzugen. Siehe die Yellowstone gRPC Referenz für Protokollebene-Details.

Im Subscribe-Request müssen Sie die folgenden allgemeinen Parameter einbeziehen:

Historische Wiedergabe: Sie können optional ein fromSlot Feld (eine u64 Zahl) im Haupt- SubscribeRequest Objekt einschließen, um Daten ab einem bestimmten Slot zurückzuspielen. Die Wiedergabe ist derzeit auf die letzten 216.000 Slots (≈24 Stunden) beschränkt; beachten Sie, dass Wiedergaben, die älter als ~20 Minuten sind, nur endgültige Daten zurückgeben.

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

Als Nächstes müssen Sie die Filter für die Daten angeben, zu denen Sie sich anmelden möchten, z.B. Konten, Blöcke, Slots oder Transaktionen.

Slots

Definieren Sie Filter für Slot-Updates. Der von Ihnen verwendete Schlüssel (z.B. mySlotLabel) ist ein benutzerdefiniertes Label für diese spezifische Filterkonfiguration, das es Ihnen ermöglicht, möglicherweise mehrere benannte Konfigurationen zu definieren, falls erforderlich (obwohl normalerweise eine ausreicht).

slots: {
  // mySlotLabel is a user-defined name for this slot update filter configuration
  mySlotLabel: {
    // filterByCommitment: true => Only broadcast slot updates at the specified subscribeRequest commitment
    filterByCommitment: true
    // interslotUpdates: true allows receiving updates for changes occurring within a slot, not just new slots.
    interslotUpdates: true
  }
},

Konten

Definieren Sie Filter für Konto-Updates. Der von Ihnen verwendete Schlüssel (z.B. tokenAccounts) ist ein benutzerdefiniertes Label für diese spezifische Filterkonfiguration.

array

Passt zu jedem öffentlichen Schlüssel aus dem bereitgestellten Array.

array

Der öffentliche Schlüssel des Kontoinhabers. Passt zu jedem öffentlichen Schlüssel aus dem bereitgestellten Array.

array

Ähnlich den Filtern in getProgramAccounts. Dies ist ein Array von datasize und/oder memcmp Filtern. Für memcmp geht das Vergleichsobjekt auf einen der bytes, base58 oder base64 direkt auf dem memcmp Objekt.

enum

veraltet

Veraltet — hat keine Wirkung ab Agave 4.2. Das Setzen von notifyOn hat keine Wirkung. Das Feld wird zu einem späteren Zeitpunkt entfernt.

Wenn alle Felder leer sind, werden alle Konten gesendet. Andernfalls:

Felder arbeiten als logisches UND.
Werte innerhalb von Arrays wirken als logisches ODER (außer innerhalb von filters, die als logisches UND funktionieren).

accounts: {
  // tokenAccounts is a user-defined label for this account filter configuration
  tokenAccounts: {
    // Matches any of these public keys (logical OR)
    account: ["9SHQTA66Ekh7ZgMnKWsjxXk6DwXku8przs45E8bcEe38"],
    // Matches owners that are any of these public keys
    owner: ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"],
    // Filters - all must match (AND logic)
    filters: [
      { datasize: 165 },
      {
        memcmp: {
          offset: 0,
          base58: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
        }
      }
    ]
  }
},

Verfolgen Sie mehr als ~10.000 Konten? Anstelle einer expliziten Pubkey-Liste (32 Byte pro Konto) verwenden Sie einen komprimierten Cuckoo-Filter (~3–4 Byte pro Konto), um in einem einzigen Stream zu Hunderttausenden von Konten zu abonnieren. Verfügbar in den Rust- und JavaScript-SDKs.

Transaktion

Definieren Sie Filter für Transaktionsupdates. Der Schlüssel, den Sie verwenden (z.B. myTxSubscription), ist ein benutzerdefiniertes Label für diese spezifische Filterkonfiguration.Wenn alle Felder leer gelassen werden, werden alle Transaktionen gesendet. Andernfalls:

Felder arbeiten als logisches UND.
Werte innerhalb von Arrays werden als logisches ODER behandelt (außer bei accountRequired, bei denen alle übereinstimmen müssen).

transactions: {
  // myTxSubscription is a user-defined label for this transaction filter configuration
  myTxSubscription: {
    vote: false,
    failed: false,
    signature: "",
    // Transaction must include at least one of these public keys (OR)
    accountInclude: ["86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY"],
    // Exclude if it matches any of these
    accountExclude: [],
    // Require all accounts in this array (AND)
    accountRequired: []
  }
},

Block

Definieren Sie Filter für Block-Updates. Der von Ihnen verwendete Schlüssel (z.B. myBlockLabel) ist ein benutzerdefiniertes Label für diese spezifische Filterkonfiguration.

blocks: {
  // myBlockLabel is a user-defined label for this block filter configuration
  myBlockLabel: {
    // Only broadcast blocks referencing these accounts
    accountInclude: ["86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY"],
    includeTransactions: true,
    includeAccounts: false,
    includeEntries: false
  }
},

Blocks Meta

Dies funktioniert ähnlich wie Blöcke, schließt jedoch Transaktionen, Konten und Einträge aus. Der von Ihnen verwendete Schlüssel (z.B. blockmetadata) ist ein benutzerdefiniertes Label für dieses Abonnement. Derzeit sind keine Filter für Block-Metadaten verfügbar — alle Nachrichten werden standardmäßig gesendet.

blocksMeta: {
  blockmetadata: {}
},

Einträge

Abonnieren Sie Ledger-Einträge. Der von Ihnen verwendete Schlüssel (z.B. entrySubscribe) ist ein benutzerdefiniertes Label für dieses Abonnement. Derzeit sind keine Filter für Einträge verfügbar; alle Einträge werden gesendet.

entry: {
  entrySubscribe: {}
},

Codebeispiele (LaserStream SDK)

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

async function main() {
    const subscriptionRequest: SubscribeRequest = {
        transactions: {},
        commitment: CommitmentLevel.CONFIRMED,
        accounts: {},
        slots: {
            slot: { filterByCommitment: true },
        },
        transactionsStatus: {},
        blocks: {},
        blocksMeta: {},
        entry: {},
        accountsDataSlice: [],
    };

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

    await subscribe(config, subscriptionRequest, async (data) => {
        console.log(data);
    }, async (error) => {
        console.error(error);
    });
}

main().catch(console.error);

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

async function main() {
    const subscriptionRequest: SubscribeRequest = {
        accounts: {
            "usdc-account": { // user-defined label for this filter
                account: ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"], // USDC mint account
                owner: [],
                filters: []
            }
        },
        accountsDataSlice: [],
        commitment: CommitmentLevel.CONFIRMED,
        slots: {},
        transactions: {},
        transactionsStatus: {},
        blocks: {},
        blocksMeta: {},
        entry: {}
    };

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

    await subscribe(config, subscriptionRequest, async (data) => {
        console.log(data);
    }, async (error) => {
        console.error(error);
    });
}

main().catch(console.error);

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

async function main() {
    const subscriptionRequest: SubscribeRequest = {
        transactions: {
            "token-filter": { // user-defined label for this filter
                accountInclude: ['TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'],
                accountExclude: [],
                accountRequired: [],
                vote: false,
                failed: false
            }
        },
        commitment: CommitmentLevel.CONFIRMED,
        accounts: {},
        slots: {},
        transactionsStatus: {},
        blocks: {},
        blocksMeta: {},
        entry: {},
        accountsDataSlice: [],
    };

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

    await subscribe(config, subscriptionRequest, async (data) => {
        console.log(data);
    }, async (error) => {
        console.error(error);
    });
}

main().catch(console.error);

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

async function main() {
    const subscriptionRequest: SubscribeRequest = {
        entry: {},
        accounts: {},
        accountsDataSlice: [],
        slots: {},
        blocks: {
            blocks: {
                accountInclude: []
            }
        },
        blocksMeta: {},
        transactions: {},
        transactionsStatus: {},
        commitment: CommitmentLevel.CONFIRMED,
    };

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

    await subscribe(config, subscriptionRequest, async (data) => {
        console.log(data);
    }, async (error) => {
        console.error(error);
    });
}

main().catch(console.error);

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

async function main() {
    const subscriptionRequest: SubscribeRequest = {
        entry: {},
        accounts: {},
        accountsDataSlice: [],
        slots: {},
        blocks: {},
        blocksMeta: {
            blockmetadata: {}
        },
        transactions: {},
        transactionsStatus: {},
        commitment: CommitmentLevel.CONFIRMED,
    };

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

    await subscribe(config, subscriptionRequest, async (data) => {
        console.log(data);
    }, async (error) => {
        console.error(error);
    });
}

main().catch(console.error);

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

async function main() {
    const subscriptionRequest: SubscribeRequest = {
        entry: {
            entrySubscribe: {}  // Subscribe to all entries
        },
        accounts: {},
        accountsDataSlice: [],
        slots: {},
        blocks: {},
        blocksMeta: {},
        transactions: {},
        transactionsStatus: {},
        commitment: CommitmentLevel.CONFIRMED,
    };

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

    await subscribe(config, subscriptionRequest, async (data) => {
        console.log(data);
    }, async (error) => {
        console.error(error);
    });
}

main().catch(console.error);

SDK-Optionen

Wir bieten offizielle SDKs für mehrere Programmiersprachen an:

TypeScript: LaserStream TypeScript SDK
Rust: LaserStream Rust SDK
Go: LaserStream Go SDK

Für andere Sprachen oder benutzerdefinierte Implementierungen können Sie die Yellowstone gRPC Proto-Dateien direkt verwenden, um gRPC-Clients für Ihre bevorzugte Sprache zu generieren.

Fehlerbehebung / FAQ

Q: Ich erlebe Verzögerungen oder langsame Leistung mit meiner LaserStream-Verbindung. Was könnte dies verursachen?

A: Leistungsprobleme mit LaserStream-Verbindungen werden typischerweise durch Folgendes verursacht:

JavaScript Client Langsamkeit: Der JavaScript-Client kann zurückbleiben, wenn zu viele Nachrichten verarbeitet oder zu viel Bandbreite verbraucht wird. Ziehen Sie in Betracht, Ihre Abonnements enger zu filtern, wechseln Sie zum LaserStream JavaScript SDK oder versuchen Sie, eine andere Sprache zu verwenden.
Begrenzte lokale Bandbreite: Schwere Abonnements können Clients mit begrenzter Netzwerkbandbreite überwältigen. Überwachen Sie Ihre Netzwerknutzung und ziehen Sie in Betracht, Ihre Verbindung zu verbessern oder den Abonnementumfang zu reduzieren.
Geografische Entfernung: Lange Netzwerkpfade erhöhen die Latenz und den Paketverlust. Verwenden Sie den Endpunkt, der Ihrem Server am nächsten liegt. Für Hochlatenz-Verbindungen erhöhen Sie Ihre Netzwerk-Lesepuffergrößen (kann die Bandbreite um 5x+ verbessern):
sudo sysctl -w net.core.rmem_max=67108864 net.ipv4.tcp_rmem="4096 87380 67108864"
Um es über Neustarts hinweg zu behalten, fügen Sie zu /etc/sysctl.conf hinzu:
net.core.rmem_max=67108864 net.ipv4.tcp_rmem=4096 87380 67108864
Erhöhen Sie die HTTP/2 Stream und Verbindung Fenstergrößen auf 64MB, um Durchflusskontrollengpässe zu vermeiden. Beide sind erforderlich — das Erhöhen nur des Streamfensters lässt das verbindungsseitige Fenster als bindende Einschränkung zurück:
// Rust (tonic) Channel::from_static("https://laserstream-mainnet-ewr.helius-rpc.com") .initial_stream_window_size(1024 * 1024 * 64) // 64MB stream window .initial_connection_window_size(1024 * 1024 * 64) // 64MB connection window .connect() .await?;
Engpässe bei der Client-seitigen Verarbeitung: Stellen Sie sicher, dass Ihre Nachrichtenverarbeitungslogik optimiert ist und den Hauptthread nicht für längere Zeit blockiert.

Debugging von Client-Verzögerungen: Um Ihnen beim Debuggen des Clients zu helfen, haben wir ein Tool entwickelt, um die maximale Bandbreite von Ihrem Knoten zu einem LaserStream gRPC-Server zu testen. Um es zu verwenden, führen Sie aus:

cargo install helius-laserstream-bandwidth
helius-laserstream-bandwidth --laserstream-url $LASERSTREAM_URL --api-key $API_KEY

Die Ausgabe gibt die maximale Netzwerkkapazität zwischen Ihrem Server und dem LaserStream-Server zurück. Mindestens benötigen Sie 10MB/s, um alle Transaktionsdaten zu abonnieren und 80MB/s, um alle Kontodaten zu abonnieren. Wir empfehlen, mindestens 2x der erforderlichen Kapazität für optimale Leistung zu haben.

Q: Ich bekomme Verbindungsfehler. Was sollte ich überprüfen?

A: Überprüfen Sie, ob Ihr API-Schlüssel und Endpunkt korrekt sind und dass Ihr Netzwerk ausgehende gRPC-Verbindungen zum angegebenen Endpunkt zulässt. Prüfen Sie die Helius-Statusseite auf etwaige anstehende Vorfälle.

Q: Warum funktionieren meine Filter nicht wie erwartet?

A: Überprüfen Sie die logischen Operatoren (AND/OR) in den Filterabschnitten. Stellen Sie sicher, dass die öffentlichen Schlüssel korrekt sind. Überprüfen Sie das in Ihrer Anfrage spezifizierte Verpflichtungsniveau.

Q: Kann ich in einer Anfrage mehrere Datentypen (z.B. Konten und Transaktionen) abonnieren?

A: Ja, Sie können Filterkonfigurationen unter mehreren Schlüsseln definieren (z.B. accounts, transactions) innerhalb desselben SubscribeRequest Objekts.

Q: Unterstützt LaserStream Konsumentengruppen?

A: Wir implementieren keine Konsumentengruppen. Stattdessen liefert LaserStream die gleichen Ergebnisse, die Teams wünschen: Fortsetzung, Wiedergabe und Multi-Node-Zuverlässigkeit ohne Koordinationsschicht (und die Latenz/den Overhead, die damit einhergehen). Wir glauben, dass für die meisten Arbeitslasten Konsumentengruppen nicht benötigt werden und sie Latenz und betrieblichen Overhead hinzufügen. Ein Beispiel: Eine einzelne LaserStream gRPC-Verbindung kann bis zu 10× Solanas Transaktions- + Kontodaten senden, und die meisten Clients abonnieren einen kleinen, gefilterten Ausschnitt. Die Verwendung von Konsumentengruppen in diesem Fall verbrennt Leistungsreserven und stellt einen weiteren Ausfallpunkt dar.

Q: Warum werden meine Transaktionslog-Nachrichten abgeschnitten?

A: LaserStream kürzt Transaktionslog-Nachrichten standardmäßig auf 10 KB für bessere Geschwindigkeit und Leistung. Wenn Sie vollständige Logs benötigen, verbinden Sie sich mit einem dedizierten, ungekürzten Endpunkt — siehe Log-Kürzung für die Liste.

Q: Warum erhalte ich nur Pong-Antworten ohne Konto- oder Slot-Daten?

A: Wenn Sie in Ihrem ursprünglichen SubscribeRequest Feld ein ping Feld einfügen, ignoriert LaserStream alle Abonnementfilter stillschweigend — es wird nur ein Pong mit null Konto-, Transaktions- oder Slot-Daten zurückgegeben. Um dies zu beheben, entfernen Sie ping aus der ursprünglichen Subscribe-Anfrage und senden Sie stattdessen Pings separat über den Sink des Streams, nachdem das Abonnement etabliert wurde. Dies hält die Verbindung am Leben, ohne Ihre Filter zu beeinträchtigen.

Erste Schritte

Daten-Streaming & Ereignisüberwachung

Daten-APIs & RPCs

Handel

Transaktionen senden

Wallet-as-a-Service

Privatsphäre

Ressourcen

LaserStream gRPC Schnellstart

Überblick

LaserStream SDK ist 40x schneller im Vergleich zu JavaScript Yellowstone Clients

Endpunkte & Regionen

Mainnet-Endpunkte

Devnet-Endpunkt

`zstd` Kompression

Log-Kürzung

Schnellstart

Häufige Workflows

Konto-Abonnements

Transaktionsüberwachung

Slot- & Blocküberwachung

Transaktionsdaten dekodieren

Stream Pump AMM-Daten

Codebeispiele (LaserStream SDK)

SDK-Optionen

Fehlerbehebung / FAQ

​Überblick

LaserStream SDK ist 40x schneller im Vergleich zu JavaScript Yellowstone Clients

​Endpunkte & Regionen

​Mainnet-Endpunkte

​Devnet-Endpunkt

​zstd Kompression

​Log-Kürzung

​Schnellstart

​Häufige Workflows

Konto-Abonnements

Transaktionsüberwachung

Slot- & Blocküberwachung

Transaktionsdaten dekodieren

Stream Pump AMM-Daten

​Subscribe-Request

​Codebeispiele (LaserStream SDK)

​SDK-Optionen

​Fehlerbehebung / FAQ

Überblick

Endpunkte & Regionen

Mainnet-Endpunkte

Devnet-Endpunkt

`zstd` Kompression

Log-Kürzung

Schnellstart

Häufige Workflows

Subscribe-Request

Codebeispiele (LaserStream SDK)

SDK-Optionen

Fehlerbehebung / FAQ