⚡ Schnellstart (rohe Shreds)

Der Raw Shred Stream liefert rohe Solana-Shreds als UDP-Datagramme an Ihren Server, direkt in Ihren eigenen Receiver. Dieser Schnellstart bindet einen UDP-Socket und empfängt diese Datagramme, damit Sie prüfen können, dass Daten fließen. Von dort an laufen Deshredding, Reassemblierung und Transaktions-Dekodierung in Ihrer eigenen Pipeline — über einen optimierten Decoder, damit der Latenzvorteil erhalten bleibt.

Wollen Sie den Decoder komplett überspringen? Der Decoded Shred Stream liefert Transaktionen bereits reassembliert im Standard-Wire-Format. Siehe Einen Receiver bauen für die vollständige Roh-Shred-Pipeline.

📋 Voraussetzungen

Konto erstellen auf ShredStream.com
Shred-Stream starten und Region auswählen
IP-Adresse Ihres Servers und den UDP-Port eingeben, auf dem Sie shreds empfangen möchten
Firewall öffnen für eingehenden UDP-Verkehr auf diesem Port — siehe Netzwerkeinrichtung

💻 Einen UDP-Socket binden

Jedes Beispiel bindet den Port, den Sie bei ShredStream.com konfiguriert haben, und gibt die Größe jedes eingehenden rohen Shred-Datagramms aus. Die empfangenen Bytes sind rohe Solana-Shreds — geben Sie sie an Ihren eigenen Deshredder und Decoder weiter.

python

import os, socket
PORT = int(os.environ.get("SHREDSTREAM_PORT", 8080))
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(("0.0.0.0", PORT))
while True:
    shred, _ = sock.recvfrom(65535)
    # Rohe Solana-Shred-Bytes — an deinen Deshredder / Decoder weitergeben.
    print(f"shred: {len(shred)} bytes")

javascript

import dgram from 'node:dgram';

const PORT = parseInt(process.env.SHREDSTREAM_PORT || '8080');
const sock = dgram.createSocket('udp4');

sock.on('message', (shred) => {
  // Rohe Solana-Shred-Bytes — an deinen Deshredder / Decoder weitergeben.
  console.log(`shred: ${shred.length} bytes`);
});

sock.bind(PORT, '0.0.0.0');

rust

use std::net::UdpSocket;

fn main() -> std::io::Result<()> {
    let port: u16 = std::env::var("SHREDSTREAM_PORT")
        .ok().and_then(|v| v.parse().ok()).unwrap_or(8080);
    let sock = UdpSocket::bind(("0.0.0.0", port))?;
    let mut buf = [0u8; 65535];
    loop {
        let (n, _) = sock.recv_from(&mut buf)?;
        // Rohe Solana-Shred-Bytes — an deinen Deshredder / Decoder weitergeben.
        println!("shred: {} bytes", n);
    }
}

package main

import (
    "fmt"
    "net"
    "os"
    "strconv"
)

func main() {
    port, _ := strconv.Atoi(os.Getenv("SHREDSTREAM_PORT"))
    if port == 0 {
        port = 8080
    }
    conn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4zero, Port: port})
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    buf := make([]byte, 65535)
    for {
        n, _, err := conn.ReadFromUDP(buf)
        if err != nil {
            panic(err)
        }
        // Rohe Solana-Shred-Bytes — an deinen Deshredder / Decoder weitergeben.
        fmt.Printf("shred: %d bytes\n", n)
    }
}

Ersetzen Sie den Standardport 8080 durch den Port, den Sie für Ihren Stream im ShredStream.com-Dashboard konfiguriert haben.

Rohe Shreds sind noch keine dekodierten Transaktionen. Um von diesen Datagrammen zu Transaktionen zu gelangen, müssen Sie die Shreds pro Slot nach Index ordnen, FEC/Merkle behandeln, die Payloads reassemblieren und die Solana-Transaktionen dekodieren. Wollen Sie diesen Schritt komplett überspringen, siehe Decoded Shred Stream: Die Transaktionen treffen bereits reassembliert ein.

🧩 Legacy-Client: `shredstream`

Achtung: Unser Client wird für latenzkritische Anwendungsfälle nicht mehr empfohlen. Bevorzugen Sie daher einen anderen Client oder direkt unseren Dienst Decoded Shred Stream.

Wenn Sie sofort etwas Lauffähiges brauchen: Der Legacy-Client shredstream bindet den Port, übernimmt Deshredding und Reassemblierung clientseitig und liefert fertige Solana-Transaktionen. Clientseitiges Deshredding kostet Latenz — gut für den Einstieg, nicht für den Wettbewerb um Latenz.

Sprache	Installation	Paket
JavaScript / TypeScript	`npm install shredstream`	npm
Python	`pip install shredstream`	PyPI
Rust	`cargo add shredstream`	crates.io
Go	`go get github.com/shredstream/shredstream-sdk-go/v2`	GitHub

rust

// cargo add shredstream
use shredstream::ShredListener;

fn main() {
    let port: u16 = std::env::var("SHREDSTREAM_PORT")
        .ok().and_then(|v| v.parse().ok()).unwrap_or(8001);
    let mut listener = ShredListener::bind(port).expect("bind");

    // Client-side deshredding → ready Solana transactions
    for (slot, transactions) in listener.transactions() {
        for tx in &transactions {
            println!("slot {}: {}", slot, tx.signatures[0]);
        }
    }
}

⚙️ OS-Buffer-Tuning

Solana erzeugt shreds mit sehr hoher Rate. Setzen Sie den Socket-Empfangspuffer auf OS-Ebene ausreichend hoch, sonst verlieren Sie unter Last Pakete:

bash

# Linux
sudo sysctl -w net.core.rmem_max=33554432

# macOS
sudo sysctl -w kern.ipc.maxsockbuf=33554432

Fordern Sie den größeren Buffer anschließend auch in Ihrem Empfänger über SO_RCVBUF an. Die vollständige Firewall- und Buffer-Konfiguration finden Sie unter Netzwerkeinrichtung.

➡️ Nächste Schritte