Validators DAO Releases Solana Stream SDK v1.1.1 — Open-Sourcing a Rust Starter Client for the Fastest UDP Shreds

Solana Stream SDK, an open-source stream client for Solana developed and operated by ELSOUL LABO B.V. (Headquarters: Amsterdam, the Netherlands; CEO: Fumitake Kawasaki) and Validators DAO, has released its latest version, v1.1.1. Along with this release, a Rust-based starter client that directly handles UDP Shreds—the fastest layer in the Solana network—has been newly open-sourced.

This release presents a concrete implementation example that receives Shreds over UDP directly between validators, without passing through higher-level API layers such as RPC, WebSocket, or gRPC, and processes them through reconstruction and detection via the shortest possible path. For use cases where latency directly translates into value, this provides a practical starting point for operating at the fastest layer in real-world environments.

On Solana, even for the same on-chain event, the timing at which it can be detected varies significantly depending on where it is observed—whether from Shreds, Geyser gRPC, or RPC / WebSocket. From the perspective of detection timing, Shreds are observed first, followed by Geyser gRPC, and then RPC / WebSocket.

Shreds represent data at the stage where fragments that compose a block are exchanged directly between validators. Geyser gRPC delivers events such as blocks, logs, and account updates after Shreds have been received and organized internally by a node. RPC / WebSocket sit at the highest layer, providing access to already stored and organized data through queries and subscriptions.

Shreds are delivered over UDP. UDP does not involve connection establishment, retransmission control, or ordering guarantees, keeping protocol overhead to an absolute minimum. As a result, under identical conditions, data arrives faster than with gRPC or WebSocket, which are based on TCP.

When aiming for the fastest possible detection on Solana, UDP Shreds become the first choice by necessity, driven by these communication characteristics and the network’s design.

Validators DAO has received a large number of inquiries regarding fastest-possible detection using UDP Shreds. Among them, the most common request has been to detect token mints and early trades on pump.fun as quickly as possible.

For token mints and initial trades, differences on the order of tens of milliseconds can materially affect outcomes. pump.fun is therefore a concrete example where the characteristics and value of the fastest layer are most clearly demonstrated, and where demand is especially concentrated. In this release, the starter code includes pump.fun-based detection logic as the default configuration, reflecting this real-world demand. This does not limit usage to pump.fun, but rather serves as a practical example for realistically reproducing fastest-layer detection.

When handling UDP Shreds, an extremely large volume of transactions flows through the system, including many that are too small to matter for strategy or UX decisions.

The starter code adopts a design that allows a value threshold to be set, enabling detection only for transactions above that threshold. This filtering is applied not via post-hoc RPC checks, but directly at the evaluation stage immediately after Shreds are reconstructed. The threshold is optional: setting it to 0 enables detection of all transactions. Users can define how much data to react to based on their specific use case.

The above example shows logs detecting only pump.fun-related token mints and trades with amounts of 1 SOL or greater, illustrating a state where only relevant information is captured at high density on the fastest layer.

UDP Shreds include information from before a block is fully finalized. As a result, failed transactions may appear, and data may be missing or arrive out of order. This is not a flaw, but an inherent property of the fastest layer itself.

By processing data as it flows without waiting for confirmation or normalization, changes can be detected earlier than on any other layer. This starter code explicitly acknowledges this premise and demonstrates an implementation that achieves detection using Shreds alone, without relying on RPC.

Internally, processing is organized as a clear sequence: receive → buffer → reconstruct → evaluate → output. Responsibilities such as UDP reception, FEC buffering, deshredding, watch logic, and output are separated and handled as independent elements. This design allows users to run the code as-is initially, then progressively modify only the parts that become necessary for their use case.

GitHub (Solana Stream SDK): https://github.com/ValidatorsDAO/solana-stream
Rust Crate: https://crates.io/crates/solana-stream-sdk
ERPC Website: https://erpc.global/ Validators DAO Official Discord: https://discord.gg/C7ZQSrCkYR

Questions and feedback regarding Solana Stream SDK v1.1.1 and the UDP Shreds client are welcomed on the Validators DAO official Discord.