⚡ Démarrage rapide (shreds bruts)

Le Raw Shred Stream livre des shreds Solana bruts sur votre serveur sous forme de datagrammes UDP, directement dans votre propre récepteur. Ce guide binde un socket UDP et reçoit ces datagrammes pour que vous puissiez confirmer que les données arrivent. À partir de là, le déshredding, le réassemblage et le décodage des transactions tournent dans votre propre pipeline — avec un décodeur optimisé, pour conserver l'avantage de latence.

Les shreds bruts nécessitent votre propre déshredding/décodage. Les datagrammes ci-dessous sont des octets de shred Solana bruts — à vous de réassembler les slots et de décoder les transactions, avec un décodeur optimisé pour conserver l'avantage de latence. Vous voulez vous passer entièrement de décodeur ? Le Decoded Shred Stream livre des transactions déjà réassemblées au format wire standard. Voir Construire un récepteur pour le pipeline complet des shreds bruts.

📋 Prérequis

Créez un compte sur ShredStream.com
Lancez un Raw Shred Stream et choisissez votre région
Entrez l'adresse IP de votre serveur et le port UDP où vous souhaitez recevoir les shreds
Ouvrez votre pare-feu pour le trafic UDP entrant sur ce port — voir Configuration réseau

💻 Binder un socket UDP

Chaque exemple binde un socket UDP sur le port que vous avez configuré sur ShredStream.com (via la variable d'environnement SHREDSTREAM_PORT) et affiche la taille de chaque datagramme reçu. Définissez SHREDSTREAM_PORT (ou modifiez la valeur par défaut) avec le port que vous avez configuré pour votre stream dans le tableau de bord ShredStream.com.

🟨 JavaScript / TypeScript

javascript

import dgram from 'node:dgram';

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

sock.on('message', (shred) => {
  // Octets de shred Solana bruts — passez-les à votre déshredder / décodeur.
  console.log(`shred: ${shred.length} bytes`);
});

sock.bind(PORT, '0.0.0.0');

🐍 Python

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)
    # Octets de shred Solana bruts — passez-les à votre déshredder / décodeur.
    print(f"shred: {len(shred)} bytes")

🦀 Rust

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 (len, _) = sock.recv_from(&mut buf)?;
        // Octets de shred Solana bruts — passez-les à votre déshredder / décodeur.
        println!("shred: {} bytes", len);
    }
}

🐹 Go

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)
        }
        // Octets de shred Solana bruts — passez-les à votre déshredder / décodeur.
        fmt.Printf("shred: %d bytes\n", n)
    }
}

Chaque datagramme est un shred Solana brut. Pour en tirer des transactions, réassemblez les shreds par slot puis décodez — voir Construire un récepteur.

🧩 Client historique : `shredstream`

Attention : notre client n'est plus recommandé pour les usages sensibles à la latence. Privilégiez donc un autre client, ou directement notre service Decoded Shred Stream.

S'il vous faut une solution qui tourne dès aujourd'hui, le client historique shredstream binde le port, déshredde et réassemble côté client, et vous remet des transactions Solana prêtes. Le déshredding côté client coûte de la latence — parfait pour démarrer, pas pour rivaliser sur la latence.

Langage	Installation	Paquet
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]);
        }
    }
}

⚙️ Configuration des buffers OS

Les shreds Solana arrivent à très haut débit ; le buffer de réception UDP par défaut est bien trop petit et provoquera des pertes de paquets. Autorisez au moins 25 Mo au niveau OS :

bash

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

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

Pensez aussi à demander cette taille sur votre socket dans le code de votre récepteur (setsockopt / SO_RCVBUF). Voir Configuration réseau pour la configuration complète du pare-feu et des buffers.

➡️ Étapes suivantes

Construire un récepteur — ce que votre récepteur de shreds bruts doit gérer
Configuration réseau — pare-feu et configuration OS
Bonnes pratiques — monitoring, redondance et performances
Dépannage — problèmes courants et solutions