Zero-Slot-Ausführung mit Sender und LaserStream erreichen

Einführung

Jeder möchte, dass seine Transaktionen so schnell wie möglich landen. Doch die Trading-Infrastruktur von Solana wird immer ausgefeilter und die On-Chain-Märkte reifen. Eine Transaktion einfach zu senden und auf das Beste zu hoffen, reicht daher nicht mehr aus – Überlastung, Konkurrenz und Eigenheiten des Netzwerks machen aus „schnell“ ein „frustrierend unzuverlässig“.

Das Ziel ist klar: Sobald ein Signal eintrifft – ein Preis überschreitet einen bestimmten Schwellenwert, ein Account wird aktualisiert oder ein Programm wird aufgerufen –, sollte die darauf reagierende Transaktion im selben Slot landen. 

Das ist der Kern der Zero-Slot-Ausführung: Erkennung und Übermittlung greifen so nahtlos ineinander, dass du Chancen nutzt, bevor sie innerhalb von Millisekunden verschwinden. 

In der Praxis wird das immer schwieriger. Dafür brauchst du eine Signalerfassung mit extrem niedriger Latenz und eine zuverlässige, deterministische Zustellung.

Helius bietet beides.

Helius kombiniert LaserStream zur blitzschnellen Ereigniserkennung mit Sender zur optimierten Transaktionsübermittlung. So entsteht eine durchgängige Pipeline, die speziell für die Zero-Slot-Ausführung entwickelt wurde.

Keine zusammengeflickte Infrastruktur, kein Rätselraten, keine verschwendeten Zyklen – nur die schnellsten Signale und die schnellsten Wege zu den Leadern. Damit verschafft sich dein Trading einen Wettbewerbsvorteil.

LaserStream und Sender: Ein einheitlicher Workflow

Sender ergänzt LaserStream und schafft eine nahtlose, durchgängige Pipeline für reaktionsschnelle Trading-Workflows auf Solana. In der Praxis sieht das so aus:

1. Nutze LaserStream, um Signale zu erkennen: Die Erfassung auf Shred-Ebene und erweiterte Filter liefern On-Chain-Ereignisse in Echtzeit schneller als jede andere Pipeline.
2. Nutze Helius Sender, um auf Signale zu reagieren: Transaktionen werden gleichzeitig über SWQoS und Jito versendet. Globales Routing und eine Validator-bewusste Zustellung maximieren die Aufnahme und minimieren die Latenz.
3. Profitiere: Gemeinsam machen diese Dienste profitable Chancen in der Praxis nutzbar – nicht nur in der Theorie.

Mit Helius erhalten Entwickler einen vertikal integrierten Stack, der gezielt auf Geschwindigkeit und Zuverlässigkeit ausgelegt ist:

• Du musst keine RPCs von Drittanbietern, Relays oder selbst entwickelte Infrastruktur zusammenfügen.
• Globales Routing, automatische Wiederholungsversuche und Validator-bewusste Zustellung sind integriert.
• Transparent und fair – wir führen nicht aktiv Sandwich-Angriffe gegen Nutzer durch und extrahieren keinerlei negatives MEV auf Kosten unserer Nutzer.

Helius bietet mit LaserStream bereits die führende Signalerkennung. Warum solltest du sie nicht mit dem führenden Transaktionsversand durch Sender kombinieren? 

Gemeinsam bilden sie eine einzige, einheitliche Pipeline für Solana-Workflows, bei denen jede Millisekunde zählt. Überlass Helius die Lese-Schreib-Schleife, um deterministische, profitable Ergebnisse zu erzielen.

Wie sieht das in der Praxis aus?

Das richtige Signal finden

Arbitrage- und Liquidationschancen können auf Solana innerhalb von Millisekunden verschwinden. Deshalb ist es entscheidend, das richtige On-Chain-Signal rechtzeitig zu erkennen. Ein „Signal“ bezeichnet hier jedes Echtzeitereignis, das eine handelbare Chance bietet, etwa einen Token-Transfer, ein Account-Update oder einen Programmaufruf. Ohne Erfassung mit extrem niedriger Latenz verschwindet der Vorteil, bevor du handeln kannst. Zuverlässiges, schnelles Datenstreaming ist daher unverzichtbar.

LaserStream ist der Solana-Datenstreaming-Dienst der nächsten Generation von Helius. Er kombiniert die Geschwindigkeit der Erfassung auf Shred-Ebene mit der Zuverlässigkeit und Reichweite eines global verteilten Dienstes – ohne die Kosten und den Betriebsaufwand mehrerer dedizierter Nodes.

Mit den erweiterten Filtern von LaserStream können sich Entwickler auf bestimmte Signale konzentrieren, etwa Transaktionstypen und Account-Updates, aber auch allgemeine Block-Streams. Für ein noch früheres Signal streamen Preprocessed Transactions signierte, aus Shreds decodierte Transaktionen bis zu 8 ms vor dem Commitment-Level processed. Sie lassen sich genauso mit Sender kombinieren.

Die Integration ist nahtlos. LaserStream wurde als direkter Ersatz für Yellowstone gRPC entwickelt und unterstützt mehrere Clients, darunter Rust, Go und TypeScript. 

Der beste Datenstreaming-Dienst ist jedoch nur die halbe Miete. Die Chancen, die Signale bieten, bestehen aus zwei Teilen:

• Ereigniserkennung – potenzielle Signale wahrnehmen.
• Reaktive Transaktionsübermittlung – als Reaktion auf ein potenzielles Signal Transaktionen erstellen, übermitteln und landen lassen.

LaserStream verschafft dir bei der Ereigniserkennung einen Vorteil und ermöglicht eine effektivere reaktive Transaktionsübermittlung. LaserStream ist jedoch kein Dienst zum Senden von Transaktionen. Transaktionen effektiv auf Solana landen zu lassen, ist leider nicht so einfach wie ein unkomplizierter sendTransaction-RPC-Aufruf.

Workflows für den Transaktionsversand optimieren

Die Aufnahme einer Transaktion ist ein Optimierungsproblem mit mehreren Variablen und erfordert ein tiefes Verständnis verschiedener Bereiche der Solana-Architektur. Faktoren wie Ankunftszeit, erfolgreiche Simulation, Konflikte bei Account-Sperren, zugehörige Transaktionsgebühren und Priorität beeinflussen gemeinsam, wann eine bestimmte Transaktion On-Chain ausgeführt wird. 

Wenn du auch nur einen dieser Faktoren in deinem Workflow zur Signalerkennung und Transaktionserstellung vernachlässigst, kann das gravierende Folgen haben und einen Wettbewerbsvorteil in eine verpasste Chance verwandeln. 

Selbst wenn ein Trader ein Signal Millisekunden vor der Konkurrenz erkennt, können eine verspätete Ankunft oder unzureichende Gebühren dazu führen, dass die Transaktion einen Slot zu spät On-Chain fehlschlägt. Aus einer profitablen Chance wird so entgangener Umsatz.

Um Transaktionen effektiv landen zu lassen, brauchst du einen ganzheitlichen Workflow. Er muss die Priorität maximieren, die Latenz minimieren und mögliche Fehlerfälle im gesamten Stack berücksichtigen. 

Um eine Transaktion heute effektiv auf Solana landen zu lassen, muss ein Entwickler Folgendes tun:

Staked Connections verwenden

Staked Connections nutzen Solanas Stake-Weighted Quality of Service (SWQoS). Dabei wird der Traffic von gestakten Validatoren und gekoppelten RPCs priorisiert, um Leader besser zu erreichen und Daten schneller zu verbreiten. Entwickler sollten über Staked Connections routen, um Fehler bei der Weiterleitung zu minimieren. Das verbessert Ankunftszeiten und Aufnahmeraten, ohne sich ausschließlich auf öffentliche Endpunkte zu verlassen, die überlastet sein können.

Dynamische Priority Fees hinzufügen

Priority Fees verbessern die Position einer Transaktion im Scheduler des Leaders während der Banking Stage. Dort ordnet ein Prio-Graph, also eine abhängigkeitsbewusste Prioritätswarteschlange, die On-Chain-Ausführung anhand der Gebühren pro CU. Priority Fees sollten dynamisch berechnet werden. So vermeidest du statische Werte, die zu Über- oder Unterzahlungen führen und die Aufnahme beim Zugriff auf umkämpften State behindern.

CU-Nutzung optimieren

Compute Units (CUs) quantifizieren den Rechenbedarf einer Transaktion. Wenn sie das angeforderte Budget überschreitet, schlägt die Ausführung fehl. Eine zu hohe Anforderung treibt dagegen die Prioritätskosten nach oben. Sofern nicht anders angegeben, fordert eine Transaktion standardmäßig 200.000 CUs an. Du kannst die CUs einer Transaktion optimieren, indem du sie vorab simulierst, um ihren Verbrauch zu schätzen, und mit der SetComputeUnitLimit-Anweisung des Compute Budget Program einen konkreten Wert anforderst.

Das richtige Commitment-Level zum Abrufen von Daten verwenden

Commitment-Level bestimmen die Bestätigungstiefe abgerufener Daten wie Blockhashes. Diese müssen aktuell sein, damit sie nicht ablaufen und die Transaktion gültig bleibt. Das Level confirmed ist bei getLatestBlockhash-Aufrufen deutlich schneller als finalized.

Preflight-Prüfungen überspringen

Preflight-Prüfungen simulieren eine Transaktion vor der Übermittlung auf dem RPC-Node. Dabei werden Signaturen, Anweisungen und die Ausführung geprüft, um Fehler frühzeitig zu erkennen. Das kann jedoch mehr als 100 ms zusätzliche Latenz verursachen. Bei zeitkritischen Workflows und wenn Entwickler absolut sicher sind, dass sie korrekt formatierte Transaktionen senden, sollten sie den Parameter skipPreflight in der RPC-Methode sendTransaction auf true setzen.

Es wird dringend empfohlen, Prototypen zu entwickeln, ohne Preflight-Prüfungen zu überspringen. So stellst du sicher, dass Transaktionen korrekt formatiert sind und erfolgreich On-Chain landen. Das Überspringen beschleunigt den Prozess zwar, ist aber ein Blindflug: Transaktionen können aus vielen Gründen fehlschlagen. Ohne diese Prüfungen erhältst du keine Hinweise auf die Ursache.

Den Parameter maxRetries auf null setzen

Der Parameter maxRetries in der Methode sendTransaction aktiviert bei Fehlern automatische erneute Sendeversuche auf RPC-Seite. Das kann ineffizient sein, wenn etwa doppelte Transaktionen mit veralteten Blockhashes gesendet werden. Entwickler sollten maxRetries auf 0 setzen, um die Kontrolle zurückzugewinnen. Implementiere eigene Wiederholungsversuche auf Client-Seite, die exponentielles Backoff verwenden, Blockhashes und Gebühren bei einer erneuten Übertragung aktualisieren und die Blockhöhe überwachen, damit Versuche kontrolliert ablaufen.

Jito in Betracht ziehen

Jito-Tips ermöglichen Off-Chain-Bundles über MEV-Auktionen. Sie garantieren die Aufnahme und Reihenfolge von Transaktionen für Teilblöcke. Das ist ideal für Trader oder Arbitrageure, die eine Ausführung am Blockanfang oder die Atomizität mehrerer Transaktionen benötigen. Besonders vorteilhaft ist das für wertvolle, zeitkritische Transaktionen oder solche, die um umkämpften State konkurrieren. Diese Auktionen verursachen jedoch eine Verzögerung. Dadurch können Transaktionen sogar später landen als gut optimierte Transaktionen, die über Staked Connections gesendet werden. Entwickler müssen diese Auktionen außerhalb des Protokolls mit der Zuverlässigkeit von Staked Connections kombinieren, damit jede benötigte Transaktion jederzeit so schnell wie möglich landet.

Wenn du diese Best Practices umsetzt, verstärken sich ihre Effekte gegenseitig. Die Fehlerraten sinken drastisch und Transaktionen landen zuverlässiger. Das manuell zu verwalten, mit den neuesten Protokollentwicklungen Schritt zu halten und Workflows daran anzupassen, erfordert jedoch erheblichen Engineering-Aufwand. Dazu gehören kontinuierliches Tuning, Änderungen an der Infrastruktur und Fehlerbehandlung – Aufwand, der an anderer Stelle besser eingesetzt wäre.

Sender

Sender ist der Transaktionsversanddienst von Helius mit extrem niedriger Latenz. Er nutzt SWQoS und die Off-Chain-Auktionen von Jito für eine MEV-optimierte Aufnahme und verwendet zugleich geografisches Routing, um Verzögerungen bei der Weiterleitung zu minimieren. 

Sender übermittelt Transaktionen gleichzeitig über Staked Connections und das Auktionssystem von Jito. Damit bietet der Dienst zwei Wege zum Landen, erhöht die Zuverlässigkeit und verkürzt die Ausführungszeit, ohne zusätzliche Credits zu verbrauchen.

Sender ist in allen Tarifen mit einem standardmäßigen Rate Limit von 6 TPS verfügbar, das sich auf Anfrage erhöhen lässt. Der Dienst wurde für Trader, MEV-Searcher und Hochfrequenzanwendungen entwickelt, die deterministische Ergebnisse benötigen. Sender ergänzt LaserStream und ermöglicht nahtlose reaktive Workflows für die Zero-Slot-Ausführung.

So funktioniert Sender

Sender verarbeitet Transaktionen wie bei der regulären Transaktionsverarbeitung: über eine einfache JSON-RPC-POST-Anfrage, bei der die Transaktion in base64 serialisiert und an einen der Endpunkte übermittelt wird. 

Sender bietet einen globalen HTTPS-Endpunkt, der Anfragen automatisch an die nächstgelegene geografische Region weiterleitet. Er wird für Frontend-Anwendungen empfohlen, um CORS-Probleme zu vermeiden. 

Sender bietet außerdem mehrere regionale HTTP-Endpunkte für optimale Server-zu-Server-Latenz, etwa in Salt Lake City, Tokio und Frankfurt.

Wichtig ist, dass es keine Authentifizierung über API-Schlüssel gibt. Der Dienst ist minimalistisch aufgebaut, ohne zwischengeschaltete Dienste zwischen Empfang und Übermittlung der Transaktion. Das macht ihn ideal für Anwendungsfälle mit extrem niedriger Latenz. 

Damit du Sender effektiv nutzen kannst, muss eine Transaktion wie folgt vorbereitet werden:

• Ein Mindest-Tip von 0,0002 SOL für Jito oder 0,000005 SOL (5.000 Lamports) für Übermittlungen ausschließlich über SWQoS. Dafür kannst du ?swqos_only=true an den Endpunkt anhängen
• Der Parameter skipPreflight muss auf true gesetzt sein – Sender ist darauf optimiert, Geschwindigkeit gegenüber der Transaktionsvalidierung zu priorisieren
• Der Parameter maxRetries muss auf 0 gesetzt sein – Wiederholungsversuche erhöhen die Latenz
• Priority Fees sollten hinzugefügt werden, um die Priorität der Transaktion in der Banking Stage des Leaders zu erhöhen

Alle über Sender gesendeten Transaktionen müssen sowohl einen Tip als auch Priority Fees enthalten. 

Ein Tip ist erforderlich, um auf die Infrastruktur von Jito und die auktionsbasierte Transaktionsaufnahme zuzugreifen. Priority Fees signalisieren dem Leader, also dem für die Verarbeitung der Transaktion verantwortlichen Validator, die Bereitschaft, für eine bevorzugte Verarbeitung zu zahlen. Das bietet einen doppelten Vorteil: Tips ermöglichen den Zugriff auf die Auktionsinfrastruktur von Jito, während Priority Fees die Priorität einer Transaktion erhöhen. Beides maximiert gemeinsam die Transaktionsaufnahme.

Wir empfehlen, Tips dynamisch über Jitos Tip Floor API abzurufen, etwa indem du das 75. Perzentil nimmst und einen kleinen Puffer hinzufügst. Priority Fees kannst du über die Priority Fee API von Helius abrufen. 

Nach der Übermittlung versendet Sender die Transaktionen parallel über SWQoS und Jito. Das maximiert die Transaktionsaufnahme ohne zusätzliche Kosten. 

Wir empfehlen außerdem, Verbindungen in Leerlaufphasen, also nach mehr als einer Minute, durch einen Ping an /ping (also https://sender.helius-rpc.com/ping) warm zu halten, um Kaltstarts zu vermeiden. Halte dich außerdem an die Best Practices für die Transaktionsübermittlung, um eine optimale Transaktionsaufnahme zusätzlich sicherzustellen. 

Erste Schritte

So beginnst du mit LaserStream und Sender zu traden:

Mit LaserStream arbeiten

LaserStream bietet dieselbe Entwicklererfahrung wie gRPC. Ändere einfach den Endpunkt und den API-Schlüssel so, dass sie auf LaserStream verweisen. Dann profitierst du sofort von allen Vorteilen, die LaserStream bietet.

Vorhandenen Code migrierst du ganz einfach so:

// Before: Using standard Yellowstone gRPC
const connection = new GeyserConnection(
  "your-current-endpoint.com",
  { token: "your-current-token" }
);

// After: Using LaserStream (just change the endpoint and token)
const connection = new GeyserConnection(
  "https://laserstream-mainnet-ewr.helius-rpc.com", // Choose the closest region to you
  { token: "your-helius-api-key" }
);

Wir empfehlen, mit einem der Clients von LaserStream zu arbeiten, um den Entwicklungsprozess zu vereinfachen.

Ein Abonnement zu eröffnen, ist zum Beispiel so einfach:

// Using the dedicated LaserStream SDK
import { subscribe, CommitmentLevel, LaserstreamConfig } from 'helius-laserstream';

const config = {
  apiKey: "your-helius-api-key",
  endpoint: "https://laserstream-mainnet-ewr.helius-rpc.com" // Choose the closest region to you
};

// The SDK automatically handles:
// - Connection management
// - Reconnection with backoff
// - Historical replay after disconnects
// - Subscription management
await subscribe(config, subscriptionRequest, handleData, handleError);

Teste LaserStream kostenlos

Möchtest du LaserStream vor der Migration testen? Hol dir eine kostenlose Testversion, um die Latenz von LaserStream zu messen, sie mit alternativen Streaming-Lösungen zu vergleichen und den Dienst für deinen konkreten Anwendungsfall zu bewerten.

Mit Sender arbeiten

Helius Sender steht allen Nutzern zur Verfügung und verbraucht keine zusätzlichen Credits. Du brauchst weder einen kostenpflichtigen Tarif noch einen besonderen Zugang.

Erstelle zunächst ein Konto im Helius Dashboard. Navigiere dann zum Bereich API-Schlüssel und kopiere den bereitgestellten Schlüssel. Du brauchst ihn, um Blockhashes abzurufen und die Transaktion zu bestätigen, da Sender nur die Transaktionsübermittlung übernimmt.

Unten siehst du einen einfachen SOL-Transfer mit Sender. Dieses Beispiel enthält alle erforderlichen Komponenten: Tip, Priority Fee und das Überspringen der Preflight-Prüfungen.

import { pipe } from "@solana/kit";
import {
  createSolanaRpc,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  signTransactionMessageWithSigners,
  lamports,
  getBase64EncodedWireTransaction,
} from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";
import {
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
} from "@solana-program/compute-budget";

(async () => {
  const HELIUS_API_KEY = "your_api_key";
  const PRIV_KEY_B58 = "your_private_key";
  const RECIPIENT = "recipient_address";
  const TIP_ACCOUNTS = [
    "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
    "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
    "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
    "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
    "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
    "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
    "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
    "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
    "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
    "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
  ];

  // Load signer from base58 private key
  const ownerSigner = await createKeyPairSignerFromBytes(bs58.decode(PRIV_KEY_B58));

  // Init RPC and fetch blockhash
  const rpc = createSolanaRpc(`https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`);
  const { value: blockhash } = await rpc.getLatestBlockhash().send();

  // Build and sign transaction
  const tx = pipe(
    createTransactionMessage({ version: 0 }),
    (m) => setTransactionMessageFeePayerSigner(ownerSigner, m),
    (m) => setTransactionMessageLifetimeUsingBlockhash(blockhash, m),
    (m) => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: 1000 }), m),
    (m) => appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: 200_000 }), m),
    (m) =>
      appendTransactionMessageInstruction(
        getTransferSolInstruction({
          source: ownerSigner,
          destination: RECIPIENT,
          amount: lamports(1_000_000n), // 0.001 SOL
        }),
        m
      ),
    (m) =>
      appendTransactionMessageInstruction(
        getTransferSolInstruction({
          source: ownerSigner,
          destination: TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)],
          amount: lamports(200_000n), // 0.0002 SOL
        }),
        m
      )
  );

  const signedTx = await signTransactionMessageWithSigners(tx);
  const base64Tx = getBase64EncodedWireTransaction(signedTx);

  // Send via Sender
  const res = await fetch("https://sender.helius-rpc.com/fast", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: Date.now().toString(),
      method: "sendTransaction",
      params: [
        base64Tx,
        { encoding: "base64", skipPreflight: true, maxRetries: 0 },
      ],
    }),
  });

  const { result: sig, error } = await res.json();
  if (error) throw new Error(error.message);

  console.log("Transaction sent: ", sig);
  console.log(`Explorer: https://orb.helius.dev/tx/${sig}?cluster=mainnet`);
})();

Mit unserem Node.js SDK kannst du Transaktionen nahtlos über Sender senden. Die Methode `sendTransactionWithSender` berechnet alle Compute Units und Gebühren einschließlich Jito-Tips dynamisch: 

import { createHelius } from "helius-sdk";
import { address, createKeyPairSignerFromBytes, lamports } from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";
import bs58 from "bs58";

(async () => {
  const apiKey = ""; // From Helius dashboard
  const helius = createHelius({ apiKey });

  try {
    const feePayerSigner = await createKeyPairSignerFromBytes(
      bs58.decode(process.env.FEEPAYER_SECRET ?? "")
    );

    const toPubkey = address("your_to_address");

    const transferIx = getTransferSolInstruction({
      amount: lamports(1_000_000n), // 0.001 SOL
      destination: toPubkey,
      source: feePayerSigner,
    });

    const sig = await helius.tx.sendTransactionWithSender({
      signers: [feePayerSigner],
      instructions: [transferIx],
      version: 0,
      commitment: "confirmed",
      minUnits: 1_000,
      bufferPct: 0.1,
      region: "US_EAST",
      swqosOnly: true,
      pollTimeoutMs: 60_000,
      pollIntervalMs: 2_000,
    });

    console.log("Confirmed signature:", sig);
    console.log(
      `Explorer link: https://orb.helius.dev/tx/${sig}?cluster=mainnet`
    );
  } catch (error) {
    console.error("Error:", error);
  }
})();

Mit unserem Rust SDK und der Methode send_smart_transaction_with_sender() lässt sich dieser Prozess ebenfalls vereinfachen.

Mit LaserStream und Sender arbeiten

Die wahre Stärke von Helius zeigt sich, wenn du LaserStream und Sender in einem einzigen Workflow kombinierst. LaserStream liefert verwertbare Signale genau in dem Moment, in dem sie auftreten. Sender sorgt dafür, dass die darauf reagierenden Transaktionen so schnell wie möglich landen.

Das Muster ist unkompliziert:

• Abonniere mit LaserStream, um Account-Änderungen, Programmaufrufe oder Transfers zu erkennen.
• Erstelle eine Transaktion als Reaktion auf ein bestimmtes Signal.
• Versende die Transaktion über Sender, um den schnellsten und zuverlässigsten Weg zur Aufnahme sicherzustellen.

Dieses Minimalbeispiel zeigt den vollständigen Workflow in der Praxis: 

import bs58 from "bs58";
import { subscribe, CommitmentLevel } from "helius-laserstream";
import {
  pipe,
  createSolanaRpc,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  signTransactionMessageWithSigners,
  getBase64EncodedWireTransaction,
  createKeyPairSignerFromBytes,
  lamports,
  address,
} from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";
import {
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
} from "@solana-program/compute-budget";

const HELIUS_API_KEY = "your_api_key";
const LASERSTREAM_ENDPOINT = "https://laserstream-mainnet-ewr.helius-rpc.com"; // Pick the nearest region
const PRIV_KEY_B58 = "your_private_key";
const RECIPIENT = "recipient_address";
const TIP_ACCOUNTS = [
    "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
    "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
    "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
    "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
    "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
    "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
    "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
    "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
    "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
    "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
  ];

// Example: scope the stream to a program you care about
const PROGRAM_OWNER_TO_WATCH = "11111111111111111111111111111111";

(async () => {
  // Setup signer and fetch blockhash
  const ownerSigner = await createKeyPairSignerFromBytes(bs58.decode(PRIV_KEY_B58));
  const rpc = createSolanaRpc(`https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`);

  // Setup LaserStream config and request
  const config = {
    apiKey: HELIUS_API_KEY,
    endpoint: LASERSTREAM_ENDPOINT,
  };

  // We keep it scoped to a given program for less noise
  const request = {
    accounts: {
      watch: {
        account: [],
        owner: [PROGRAM_OWNER_TO_WATCH],
        filters: [],
      },
    },
    commitment: CommitmentLevel.PROCESSED, // Can also change to CONFIRMED for more reliability
    slots: {},
    transactions: {},
    transactionsStatus: {},
    blocks: {},
    blocksMeta: {},
    entry: {},
    accountsDataSlice: [],
  };

  // On signal, build and send a reactive transaction via Sender
  const handleData = async () => {
    // Fresh blockhash for lifetime
    const { value: blockhash } = await rpc.getLatestBlockhash().send();

    // Build the transaction with compute-budget ixs first, then user ixs
    const tx = pipe(
      createTransactionMessage({ version: 0 }),
      (m) => setTransactionMessageFeePayerSigner(ownerSigner, m),
      (m) => setTransactionMessageLifetimeUsingBlockhash(blockhash, m),
      (m) => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: 100_000 }), m),
      (m) => appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: 200_000 }), m),
      (m) =>
        // In prod, this could be a buy / sell instruction
        appendTransactionMessageInstruction(
          getTransferSolInstruction({
            source: ownerSigner,
            destination: address(RECIPIENT),
            amount: lamports(1_000_000n), // 0.001 SOL
          }),
          m
        ),
      (m) =>
        appendTransactionMessageInstruction(
          getTransferSolInstruction({
            source: ownerSigner,
            destination: address(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
            amount: lamports(200_000n), // 0.0002 SOL tip
          }),
          m
        )
    );

    const signedTx = await signTransactionMessageWithSigners(tx);
    const base64Tx = getBase64EncodedWireTransaction(signedTx);

    // Send via Sender (i.e., skip preflight and no RPC-side retries)
    const res = await fetch("https://sender.helius-rpc.com/fast", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: Date.now().toString(),
        method: "sendTransaction",
        params: [base64Tx, { encoding: "base64", skipPreflight: true, maxRetries: 0 }],
      }),
    });

    const { result: sig, error } = await res.json();
    if (error) throw new Error(error.message);

    console.log("Reactive transaction sent: ", sig);
    console.log(`Explorer:  https://orb.helius.dev/tx/${sig}?cluster=mainnet`);
  };

  const handleError = console.error;

  // Start the stream (signals → reactive sends)
  const stream = await subscribe(config, request, handleData, handleError);
  console.log(`LaserStream subscription started (id: ${stream.id})`);
})();

Warum Helius

Helius ist die erste Wahl, um Transaktionsworkflows auf Solana zu optimieren. Das liegt an unserer Position als größter Validator des Netzwerks nach Stake. Gestakte Bandbreite ist für uns daher kein Problem. So beseitigen wir effektiv Engpässe und Fehlerfälle, die durch die Herabstufung von Transaktionen oder verworfene Pakete bei Überlastung entstehen. Deine Transaktionen erhalten ohne Einschränkungen einen direkten Weg mit hoher Priorität zu den Leadern. 

Helius verknüpft verschiedene Hardware- und Softwareoptimierungen eng mit unserer gestakten Bandbreite und bleibt damit der führende Anbieter. Wir erreichen die niedrigste durchschnittliche Slot-Latenz – ein Beleg für unsere umfassende Solana-Expertise. 

Durch unser Engagement für Solana stehen wir bei aktueller Forschung und neuen Beiträgen an vorderster Front. So zeigen etwa die Ergebnisse von Chorus One zur Transaktionslatenz, dass SWQoS Jito häufig übertreffen kann, wenn es darum geht, die Zeit bis zur Aufnahme zu verkürzen. Das gilt besonders für Nutzer mit einer p95-Latenz von mehr als 40 Sekunden. Sender routet intelligent und gleichzeitig über SWQoS und Jito. So erreicht der Dienst maximale Zuverlässigkeit für alle Transaktionstypen. 

Letztlich sind ein hoher Stake und das Routing von Transaktionen über Staked Connections die wichtigsten Faktoren, um die Zeit bis zur Aufnahme zu verkürzen.

Schneller

LaserStream reduziert Latenz und Unsicherheit. Je früher ein Signal eintrifft, desto vorhersehbarer werden die Ergebnisse. In Kombination mit Sender sorgen Transaktionen, die als Reaktion auf ein Signal gesendet werden, für mehr operative Sicherheit, bessere Entscheidungen und höhere Zuverlässigkeit. Diese einheitliche Pipeline optimiert nicht nur isoliert auf Geschwindigkeit, sondern auf Verlässlichkeit.

Mit LaserStream wissen Entwickler, dass sie mit dem besten Datenstreaming-Dienst auf dem Markt arbeiten. Mit Sender können sie sicher sein, dass ihre Transaktionen über die schnellsten und zuverlässigsten Wege zu den Block-Leadern geleitet werden. 

Gemeinsam entsteht ein sich verstärkender Effekt:

• Niedrigere E2E-Latenz: Von der Ereigniserkennung bis zur Transaktionsaufnahme wird jeder Schritt auf Millisekunden reduziert
• Höhere Erfolgsraten: Transaktionen landen dort und dann, wo sie sollen. Chancen werden genutzt statt verpasst
• Weniger Engineering-Aufwand: Du kannst dich stärker auf Produkt, Strategie und die Feinabstimmung von Trading-Algorithmen konzentrieren, statt dedizierte Nodes für einen optimalen Transaktionsversand zu verwalten und anzupassen
• Zero-Slot-Ausführung: LaserStream liefert Benachrichtigungen, während Transaktionen für einen bestimmten Slot ausgeführt werden – nicht erst, nachdem der Slot abgeschlossen ist. Eine als Reaktion auf eine Benachrichtigung gesendete Transaktion kann daher im selben Slot landen 

In der Praxis bedeutet das: Trader nutzen mehr Arbitragechancen, Liquidatoren gewinnen mehr Auktionen und Hochfrequenzanwendungen bieten eine reibungslosere Nutzererfahrung. Zero-Slot-Ausführung ist nicht nur ein schicksalhaftes theoretisches Ideal, sondern ein wiederholbarer Workflow, den nur Helius ermöglicht.

Besuche das Helius Dashboard und leg noch heute los.