ShredStream Access

syntax = "proto3";

package shredstream;

service ShredstreamProxy {
  rpc SubscribeEntries(SubscribeEntriesRequest) returns (stream Entry);
}

message SubscribeEntriesRequest {}

message Entry {
  uint64 slot = 1;
  // bincode-serialized Vec<solana_entry::entry::Entry>
  bytes entries = 2;
}

pub struct Entry {
    pub num_hashes: u64,
    pub hash: Hash,                          // [u8; 32]
    pub transactions: Vec<VersionedTransaction>,
}

use tonic::{Request, transport::Channel, metadata::MetadataValue};
use shredstream_proxy_client::ShredstreamProxyClient;
use solana_entry::entry::Entry as LedgerEntry;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Plaintext h2c — the proxy does not terminate TLS, so use http://
    let channel = Channel::from_static("http://88.216.132.50:9090")
        .connect()
        .await?;

    let mut client = ShredstreamProxyClient::new(channel)
        .max_decoding_message_size(64 * 1024 * 1024);

    let mut request = Request::new(SubscribeEntriesRequest {});
    request.metadata_mut().insert(
        "x-api-key",
        MetadataValue::from_str("ak_YOUR_KEY")?,
    );

    let mut stream = client.subscribe_entries(request).await?.into_inner();

    while let Some(msg) = stream.message().await? {
        let entries: Vec<LedgerEntry> = bincode::deserialize(&msg.entries)?;
        for entry in &entries {
            for tx in &entry.transactions {
                // tx is a solana_sdk::transaction::VersionedTransaction
                println!("slot={} sig={}", msg.slot, tx.signatures[0]);
            }
        }
    }

    Ok(())
}

const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

const packageDef = protoLoader.loadSync('./shredstream.proto');
const proto = grpc.loadPackageDefinition(packageDef);

// Plaintext h2c — no TLS on this endpoint.
const client = new proto.shredstream.ShredstreamProxy(
  '88.216.132.50:9090',
  grpc.credentials.createInsecure(),
  { 'grpc.max_receive_message_length': 64 * 1024 * 1024 }
);

const metadata = new grpc.Metadata();
metadata.add('x-api-key', 'ak_YOUR_KEY');

const stream = client.subscribeEntries({}, metadata);

stream.on('data', (msg) => {
  // msg.slot    -> string | number
  // msg.entries -> Buffer, bincode Vec<solana_entry::entry::Entry>
  // Decode it with a bincode reader to reach the VersionedTransactions.
  console.log(`slot=${msg.slot} entries_bytes=${msg.entries.length}`);
});

// Slots can be skipped and the stream can drop — reconnect with backoff.
stream.on('error', (err) => console.error('stream error:', err));
stream.on('end', () => console.log('stream ended'));

import grpc
import shredstream_pb2
import shredstream_pb2_grpc

# Plaintext h2c — no TLS on this endpoint.
channel = grpc.insecure_channel(
    "88.216.132.50:9090",
    options=[("grpc.max_receive_message_length", 64 * 1024 * 1024)],
)
stub = shredstream_pb2_grpc.ShredstreamProxyStub(channel)

metadata = [("x-api-key", "ak_YOUR_KEY")]

for msg in stub.SubscribeEntries(shredstream_pb2.SubscribeEntriesRequest(), metadata=metadata):
    # msg.entries is bincode-serialized Vec<solana_entry::entry::Entry>;
    # decode it to reach the transactions inside each entry.
    print(f"slot={msg.slot} entries_bytes={len(msg.entries)}")

grpcurl -plaintext \
  -proto shredstream.proto \
  -H 'x-api-key: ak_YOUR_KEY' \
  -d '{}' \
  88.216.132.50:9090 shredstream.ShredstreamProxy/SubscribeEntries

use std::net::UdpSocket;
use solana_ledger::shred::Shred;

fn main() -> std::io::Result<()> {
    // Bind the port issued with your subscription
    let socket = UdpSocket::bind("0.0.0.0:8001")?;

    let mut buf = [0u8; 65535];
    println!("Listening for shreds...");

    loop {
        let (amt, _src) = socket.recv_from(&mut buf)?;
        match Shred::new_from_serialized_shred(buf[..amt].to_vec()) {
            Ok(shred) => println!("slot={} index={}", shred.slot(), shred.index()),
            Err(_) => continue, // coding shred or partial packet
        }
    }
}

const dgram = require('dgram');
const server = dgram.createSocket('udp4');

server.on('error', (err) => {
  console.log(`server error:\n${err.stack}`);
  server.close();
});

server.on('message', (msg, rinfo) => {
  console.log(`Received ${msg.length} bytes from ${rinfo.address}:${rinfo.port}`);
  // Raw shred bytes. Deshredding in JS needs custom logic or WASM bindings
  // to the Solana Rust crates — most teams do this step in Rust.
});

server.on('listening', () => {
  const address = server.address();
  console.log(`server listening ${address.address}:${address.port}`);
});

// Bind the port issued with your subscription
server.bind(8001);