⚡ Inicio rápido (shreds en bruto)

Raw Shred Stream entrega shreds Solana en bruto por UDP, directamente en tu propio receptor: vinculas un socket UDP, recibes los datagramas y los pasas a tu propio pipeline de deshredding y decodificación — con un decodificador optimizado, para que la ventaja de latencia se conserve. Esta guía te lleva del puerto abierto al primer datagrama recibido.

Los shreds en bruto llegan como bytes sin procesar — este quickstart solo los recibe e imprime su tamaño. ¿Quieres saltarte el decodificador por completo? Decoded Shred Stream entrega las transacciones ya reensambladas en formato wire estándar. Consulta Construir un receptor para el pipeline completo de shreds en bruto.

📋 Requisitos previos

Crea una cuenta en ShredStream.com
Lanza un Raw Shred Stream y elige tu región
Introduce la dirección IP de tu servidor y el puerto UDP donde quieres recibir shreds
Abre tu firewall para tráfico UDP entrante en ese puerto — consulta Configuración de red

💻 Recibe tu primer shred

Cada ejemplo vincula un socket UDP a 0.0.0.0 y recibe shreds en bruto en el puerto que configuraste en ShredStream.com. Reemplaza el puerto por el que configuraste para tu stream en el panel de control de ShredStream.com.

javascript

import dgram from 'node:dgram';

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

sock.on('message', (shred) => {
  // Bytes de shred Solana en bruto — pásalos a tu deshredder / decodificador.
  console.log(`shred: ${shred.length} bytes`);
});

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)
    # Bytes de shred Solana en bruto — pásalos a tu deshredder / decodificador.
    print(f"shred: {len(shred)} bytes")

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)?;
        // Bytes de shred Solana en bruto — pásalos a tu deshredder / decodificador.
        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)
        }
        // Bytes de shred Solana en bruto — pásalos a tu deshredder / decodificador.
        fmt.Printf("shred: %d bytes\n", n)
    }
}

Los bytes que recibes son shreds Solana en bruto: para convertirlos en transacciones tienes que reensamblarlos por slot, aplicar la recuperación FEC, verificar el Merkle y decodificar las entradas. Ese trabajo lo asumes tú — o lo evitas por completo con Decoded Shred Stream: las transacciones llegan ya reensambladas.

🧩 Cliente heredado: `shredstream`

Atención: nuestro cliente ya no se recomienda para usos sensibles a la latencia. Opta por otro cliente, o directamente por nuestro servicio Decoded Shred Stream.

Si necesitas algo que funcione hoy mismo, el cliente heredado shredstream vincula el puerto, hace el deshredding y el reensamblado en el cliente y te entrega transacciones Solana listas. El deshredding en el cliente cuesta latencia: sirve para empezar, no para competir en latencia.

Lenguaje	Instalación	Paquete
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]);
        }
    }
}

⚙️ Ajuste de buffer del SO

Los validadores de Solana producen shreds a una tasa muy alta. Aumenta el buffer de recepción a nivel del SO para evitar pérdida de paquetes bajo carga:

bash

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

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

Además, solicita ese tamaño en tu socket con SO_RCVBUF desde el código de tu receptor. Consulta Configuración de red para la configuración completa de firewall y buffers.

➡️ Siguientes pasos