Binary

Binary (Binary transaction stream) is a Shred Stream that delivers compact serialized Solana VersionedTransaction bytes extracted from shreds.

It skips the raw UDP packet layer: you do not run a deshredder. Your client receives transaction bytes over gRPC (ShrederBinaryService.SubscribeBinaryTransactions), deserializes them locally, and runs strategy logic.

The protobuf field binary_transaction is serialized VersionedTransaction. The official Rust example deserializes it with bincode.

In GeyserBench Binary uses kind = "shrederbinary".

Highlights

Serialized VersionedTransaction bytes
Transport: gRPC SubscribeBinaryTransactions (shreder_binary proto)
Filters: account_include, account_exclude, account_required (same model as Decoded Shreds)
Deserialization in Rust with bincode

Filters

Filter	Behavior
`account_include`	Allows only transactions involving any of these accounts
`account_exclude`	Excludes transactions involving any of these accounts
`account_required`	Allows only transactions involving all of these accounts

Usage example (Rust)

Connect, subscribe with a filter, and deserialize each binary_transaction payload.

git clone https://github.com/shrederxyz/shreder-rust-example.git
cd shreder-rust-example
# set the endpoint in src/examples/binary/main.rs
cargo run --example binary

Full example: src/examples/binary

use futures::{channel::mpsc::unbounded, sink::SinkExt};
use shreder_binary::{
    shreder_binary_service_client::ShrederBinaryServiceClient,
    SubscribeBinaryTransactionsRequest, SubscribeRequestFilterBinaryTransactions,
};

let entrypoint = "http://fra.binary.shreder.xyz:9991";
let mut client = ShrederBinaryServiceClient::connect(entrypoint)
    .await
    .unwrap();

let request = SubscribeBinaryTransactionsRequest {
    transactions: maplit::hashmap! {
        "pumpfun".to_owned() => SubscribeRequestFilterBinaryTransactions {
            account_include: vec![],
            account_exclude: vec![],
            account_required: vec![
                "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P".to_owned()
            ],
        }
    },
};

let (mut subscribe_tx, subscribe_rx) = unbounded();
let response = client
    .subscribe_binary_transactions(subscribe_rx)
    .await
    .unwrap();
let mut stream = response.into_inner();

let _ = subscribe_tx.send(request).await;

Deserialize updates

use solana_transaction::versioned::VersionedTransaction;

while let Some(response) = stream.message().await.unwrap() {
    let update = response.transaction.expect("transaction must be present");
    let tx = update.transaction.expect("transaction must be present");

    let versioned_tx = match bincode::deserialize::<VersionedTransaction>(&tx.binary_transaction) {
        Ok(vt) => vt,
        Err(e) => {
            println!("Failed to deserialize VersionedTransaction: {e}");
            continue;
        }
    };

    println!(
        "filters: {:?}, slot {}, signatures: {}, instructions: {}",
        response.filters,
        update.slot,
        tx.signatures.len(),
        versioned_tx.message.instructions().len(),
    );
}

Replace the entrypoint with your regional Binary URL. A transaction is delivered once through the non-preconf path. If you also subscribe to Preconfs, the same logical transaction can arrive once from each source.

When to use it

Strictest shred-path latency requirements
Hot paths that prefer compact bytes over richer decoded structs
Teams that do not want to operate raw shred infrastructure

Use Preconfs when you need pre-shred delivery from connected leaders. Its dedicated proto extends the Binary contract with explicit request and response source markers.

Endpoints

Binary is available in Frankfurt, Amsterdam, New York, and Tokyo.

Region	Endpoint
Frankfurt	`http://fra.binary.shreder.xyz:9991`
Amsterdam	`http://ams.binary.shreder.xyz:9991`
New York	`http://ny.binary.shreder.xyz:9991`
Tokyo	`http://tyo.binary.shreder.xyz:9991`

Product: Binary
Rust example: main.rs
Benchmark: Binary vs DoubleZero Edge
Tooling: GeyserBench (kind = "shrederbinary")

On this page