Skip to main content

Direct Shreds Quickstart

⚡ Integrate with AI
I'm integrating Blockspace Direct Shreds into a dedicated trading infrastructure setup.

Product: Blockspace Direct Shreds — dedicated UDP shred delivery from Everstake validator nodes to my IP, on a private link. Zero co-tenant variance.
Edge: 3ms p50 in-region. No shared-tenant bandwidth contention.
Auth: Source-IP allowlist — no token. My destination IP must be registered in the Blockspace dashboard; platform team applies routing within ~30 minutes.
Wire format: Standard Solana shred layout, ~1232 bytes/datagram, max 1500. Receive on UDP port 8001 (default — I can nominate a different port).
Reference receiver: https://github.com/jito-labs/shredstream-proxy
Full reference: https://docs.blockspace.everstake.one/llms-full.txt

My stack: [ADAPT: Rust / TypeScript / Python — pick one and tell me which].
My listener should bind to UDP 0.0.0.0:8001, decode each shred using solana-ledger (Rust) or an equivalent library, and print slot + shred_index for every received shred.

Generate a minimal working listener. Include: dependency list, socket binding, shred payload parsing, and a note on how to de-duplicate shreds if I subscribe to multiple regions (de-dupe by slot + shred_index).
Open in Claude →Open in ChatGPT →Open in Perplexity →

1. Provision​

After subscribing, register your destination IP(s) in the dashboard. The platform team applies the routing within 30 minutes; you'll get a confirmation email when the link is live.

2. Open the receive port​

Shreds arrive as UDP packets on the port you nominate (default 8001). Make sure that port is open on the destination host's firewall and any cloud security groups in front of it.

# Example: open UDP/8001 on a Linux host
sudo ufw allow 8001/udp

3. Listen for shreds​

Each UDP datagram is one Solana shred — typically ~1232 bytes, max 1500. The wire format matches the standard Solana shred layout, so any shred decoder (e.g. solana-ledger's Shred::new_from_payload) will parse them.

use std::net::UdpSocket;

let socket = UdpSocket::bind("0.0.0.0:8001")?;
let mut buf = [0u8; 1500];
loop {
    let (len, _src) = socket.recv_from(&mut buf)?;
    let shred_bytes = &buf[..len];
    handle_shred(shred_bytes);
}

4. Verify​

You should see UDP packets arriving continuously under normal Solana load. If nothing arrives:

  • Confirm the destination IP is correct in the dashboard (typos here are the most common issue).
  • Verify your firewall allows the Blockspace validator-node IPs for your region (surfaced in the dashboard).
  • Check iptables -L, cloud security groups, and any host-level firewall.
  • tcpdump -i any udp port 8001 will show whether packets are reaching the NIC at all.
Multiple destinations

If you subscribe twice with two destination IPs (hot/standby setup), both IPs receive the same shred stream — your application can pick whichever arrives first, or de-dupe by (slot, shred_index) if you funnel them into one processor.

If you subscribe to multiple regions, each region streams the same shreds independently. Cross-region funneling produces duplicates by definition — de-dupe by (slot, shred_index).

Reconstructing blocks​

Shreds are slot fragments, not blocks. Combine shred decoding with a Solana-ledger-compatible reassembler.

Receiver software​

There's no Blockspace-specific protocol. The recommended starting point is jito-labs/shredstream-proxy — drop-in UDP receiver and forwarder for raw shreds.