Solana shreds: raw over UDP, decoded over gRPC.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// build.rs compiles proto/raiden_binary.proto with tonic-build + protox (no protoc needed)
pub mod raiden_binary { tonic::include_proto!("raiden_binary"); }
use raiden_binary::{raiden_binary_service_client::RaidenBinaryServiceClient,
    SubscribeBinaryTransactionsRequest, SubscribeRequestFilterBinaryTransactions};
use std::collections::HashMap;
use tokio_stream::StreamExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // plaintext gRPC; your registered source IP is the credential
    let mut client = RaidenBinaryServiceClient::connect("http://fra.pulse.raiden.wtf:16000").await?;
    let filter = SubscribeRequestFilterBinaryTransactions {
        account_include: vec![],
        account_exclude: vec![],
        account_required: vec!["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P".into()],
    };
    let request = SubscribeBinaryTransactionsRequest {
        transactions: HashMap::from([("pumpfun".to_string(), filter)]),
    };
    // send one request, then keep the request stream open
    let outbound = tokio_stream::iter(vec![request]).chain(tokio_stream::pending());
    let mut stream = client.subscribe_binary_transactions(outbound).await?.into_inner();
    while let Some(resp) = stream.message().await? {
        let Some(update) = resp.transaction else { continue };
        let Some(tx) = update.transaction else { continue };
        let sig = tx.signatures.first().map(|s| bs58::encode(s).into_string()).unwrap_or_default();
        // tx.binary_transaction is a bincode VersionedTransaction
        println!("slot={} sig={} alt_writable={}", update.slot, sig, update.loaded_writable_addresses.len());
    }
    Ok(())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import grpc from '@grpc/grpc-js';
import protoLoader from '@grpc/proto-loader';
import bs58 from 'bs58';

const def = protoLoader.loadSync('raiden_binary.proto', { keepCase: true, longs: String, defaults: true });
const { raiden_binary } = grpc.loadPackageDefinition(def);

// plaintext gRPC; your registered source IP is the credential
const client = new raiden_binary.RaidenBinaryService('fra.pulse.raiden.wtf:16000', grpc.credentials.createInsecure());
const stream = client.SubscribeBinaryTransactions();

stream.on('data', ({ transaction: update, filters }) => {
  if (!update || !update.transaction) return;
  const tx = update.transaction;
  const sig = tx.signatures.length ? bs58.encode(tx.signatures[0]) : '-';
  console.log(`slot=${update.slot} sig=${sig} filters=${filters} bytes=${tx.binary_transaction.length}`);
});
stream.on('error', (e) => console.error('rpc error:', grpc.status[e.code], e.details));

stream.write({ transactions: { pumpfun: { account_required: ['6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P'] } } });