ERPC releases Solana Stream SDK v4.0.0 with faster UDP Shreds processing and gRPC recovery
ELSOUL LABO B.V. and Validators DAO officially released Solana Stream SDK v4.0.0, an open-source SDK for handling Solana streaming data, on November 6, 2026. Local benchmarks measured approximately 108× faster internal Rust UDP Shreds processing and approximately 4× the throughput for the TypeScript event queue. Geyser gRPC also resumes receiving updates sooner after a disconnect. The SDK is free to use, with Rust and TypeScript samples to help developers get started.
Taking advantage of low-latency data delivery in an application also depends on how quickly incoming data is processed. Version 4.0.0 makes internal processing after data arrives more efficient and improves connection recovery after disconnects. Using it with ERPC Shreds UDP Forwarding Premium lets developers improve both the delivery path and the receiving implementation for their Solana applications.
Processing and recovery improvements measured in three tests
In the Rust UDP receive path, v4 accelerates datagram decoding, insertion into an internal buffer, and deshredding, which reconstructs data from Shreds. It reduces processing overhead by revising internal-state cleanup and clock reads that were repeated for each packet, while preserving data-retention periods. In the comparison, internal processing time per datagram fell from 94,236 ns to 855–881 ns, an improvement of approximately 108×.
The benchmark ran on an Apple M-series Mac, processing 403,200 datagrams across 300 slots per run. Results compare the median of five runs. The measurement covers the internal decode→insert→deshred path. It excludes network delivery time and subsequent processing in the user's application. Reducing the work required to reconstruct incoming Shreds helps developers devote more computing resources to application logic.
The TypeScript Geyser gRPC samples and starters reduce waiting while events remain in the queue, allowing received data to be retrieved more efficiently. In a queue-only test processing two million events on Node.js 24, throughput increased from 5.7–7.4 million events per second to 24.8–29.4 million events per second, an improvement of approximately 4×.
For Geyser gRPC, the client that handles reconnection and the initial retry interval have been updated. In a test that triggered 20 disconnects on a local tonic server, the median gap between updates received before and after each disconnect fell from 552 ms with the 3.0 runner to 103 ms with the 4.0 runner. This measures the interval until updates resume in the local test environment.
These three results come from different tests with different scopes and conditions. They show the improvements in Rust internal processing, the TypeScript event queue, and gRPC reconnection, respectively. Implementation details and test conditions are available in PR #129, listed under Related links.
Retaining Alpenglow support and updating clients
Alpenglow support was introduced in v3.0.0. Version 4.0.0 retains the distinction between block markers, which represent block header, footer, and parent updates, and entries, which contain transactions. Applications can handle information about block structure separately from the entries they need to process.
Version 4.0.0 updates the clients to Agave 4.4.1 and Yellowstone gRPC 17.x. During reconnection, a
Disconnected event can report information that identifies partially received data, along with the resume position. This gives applications the information they need to implement their own handling of duplicate replayed data and data received only in part.The migration from v3 to v4 preserves the Geyser protobuf definitions while updating reconnection events and the Solana message and transaction types used in Rust. The published migration guide describes changes to event handlers and dependency versions.
Use Rust for UDP, or Rust and TypeScript for gRPC
The published Rust package solana-stream-sdk and TypeScript package @validators-dao/solana-stream-sdk are both available at v4.0.0. Supported languages for each connection type are listed below.
| Connection type | Supported languages |
|---|---|
| Shreds UDP | Rust |
| Geyser gRPC | Rust and TypeScript |
| Shreds gRPC | Rust and TypeScript |
Use the Rust client to receive Shreds over UDP. The Rust UDP sample and starter use the published SDK v4.0.0 and let you try receiving data, reconstructing data from Shreds, and detecting instructions for a program you want to monitor. Change the monitored program and the processing that follows detection to use this as a starting point for your own application.
For TypeScript development, you can use Geyser gRPC or Shreds gRPC. This release's event queue improvements are included in the Geyser gRPC samples and starters. Choose the published implementation that matches your language and delivery method.
Making use of Shreds UDP Forwarding Premium
ERPC Shreds UDP Forwarding Premium connects multiple nodes in a mesh within each region and forwards the earliest copy of each Shred received by that mesh. Both arrival time along the delivery path and reconstruction time inside the SDK after arrival affect how soon received data becomes usable. The improvements to Rust UDP reception can be applied on the receiving side to data delivered by Premium.
In the Frankfurt comparison on October 30, 2026, Standard and Premium were captured simultaneously for 120 seconds on one machine using the same clock. UDP payloads with identical content were matched from the pcap. Premium arrived first for 98% of this matched set, and the median arrival difference was 1.78 ms. Of the payloads observed on Standard, 93.9% were also observed on Premium.
The Premium figure shows arrival-time differences between delivery paths, while the SDK figure shows internal receiver processing and connection recovery. In an actual application, recording both packet arrival and the time a relevant instruction is detected lets you check how much of the delivery lead carries through to the processing result.
Compare in your own environment with hourly access and samples
Shreds UDP Forwarding Premium is available with hourly billing at €1.39 per hour. Start using the service from the dashboard and verify reception with the Rust UDP starter. Using the same region, receiving server, and application workload lets you assess differences in arrival times separately from processing time after reception.
First, register your public IPv4 address and UDP port in the dashboard, and allow inbound traffic from the listed sources. Once you have checked packet reception and data reconstruction with the Rust UDP starter, include the programs you want to monitor and your application's actual processing in the evaluation. Combine the samples and delivery service to measure the time from reception to detection in your own environment.
Related links
- Rust UDP sample and starter: https://github.com/ValidatorsDAO/solana-stream/tree/main/temp-release/shreds-udp-rs
- Solana Stream SDK v4 migration guide: https://github.com/ValidatorsDAO/solana-stream/blob/main/docs/migration-v4.md
- SDK performance improvements and test records: https://github.com/ValidatorsDAO/solana-stream/pull/129
- Shreds UDP Forwarding documentation: https://erpc.global/en/doc/shredstream/udp-forwarding/
- Use Shreds UDP Forwarding Premium: https://dashboard.erpc.global/en/user/shreds?plan=udp
- ERPC pricing: https://erpc.global/en/price/
