Solana Streamer SDK

Using EventTypeFilter can reduce unnecessary event processing by 60-80%, lowering memory usage and network bandwidth. You can use include_only to whitelist specific events or exclude_only to blacklist noise (like EventType::BlockMeta).

use solana_streamer_sdk::streaming::event_parser::common::{filter::EventTypeFilter, EventType};

// No filter - receive all events
let event_type_filter = None;

// Filter specific event types - only receive PumpSwap buy/sell events
let event_type_filter = Some(EventTypeFilter::include_only(vec![
    EventType::PumpSwapBuy,
    EventType::PumpSwapSell,
]));

// Exclude high-frequency noise, keep everything else
let event_type_filter = Some(EventTypeFilter::exclude_only(vec![EventType::BlockMeta]));

The SDK provides multiple ways to ingest data depending on your requirements:

• Yellowstone gRPC Client: An optimized client specifically for Solana event streaming.
• ShredStream Client: An alternative streaming implementation.
• Async Processing: All event handling is non-blocking to ensure high performance.

The SDK is organized into several functional modules:

• common/: General utilities and types.
• protos/: Protocol buffer definitions.
• streaming/: The core event streaming system, which includes:
  • event_parser/: A streamer-compatible event facade based on sol-parser-sdk. It contains public event metadata, filtering types, and the SDK distribution entry point.
  • parser_sdk_bridge/: An adaptation layer for sol-parser-sdk events.
  • rpc_parse.rs: Helpers for parsing RPC transactions.
  • sdk_bridge.rs: High-level SDK interoperability modules.
  • shred_stream.rs: ShredStream client.
  • yellowstone_grpc.rs: Yellowstone gRPC client.
  • yellowstone_sub_system.rs: Yellowstone subsystem.
• lib.rs: The main library entry point.

The project is moving towards supporting three distinct parsing modes to handle the trade-off between latency and data completeness. While implementation details are evolving, the conceptual modes are:

• Strict: Skips instructions if the program ID or necessary accounts cannot be parsed. It does not produce 'guessed' events.
• Cached: Performs full parsing only when the Address Lookup Table (ALT) is present in the local cache. If a cache miss occurs, it skips the instruction and loads the table asynchronously (non-blocking).
• BestEffort (Current Default): Uses Pubkey placeholders and discriminator fallbacks to provide the most data possible, even if identity is uncertain. This is intended for compatibility and high-speed streams where some inaccuracy is acceptable.

When choosing between gRPC and Shredstream, understand the fundamental differences in the data provided. Use gRPC if you require full transaction context, and Shredstream if you prioritize low latency and can tolerate partial data.

When deploying the SDK in production, keep the following in mind:

• Network Stability: A stable network connection is required for continuous event stream transmission.
• Rate Limiting: Be aware of rate limits imposed by public gRPC endpoints.
• Error Recovery: You must implement your own error handling and reconnection logic to handle stream interruptions.
• Compliance: Ensure your usage complies with all relevant laws and regulations.

The parsing system delegates heavy lifting to sol-parser-sdk while providing a streamlined interface for the streamer.

• Protocol Parsing: Yellowstone gRPC, ShredStream, RPC transaction parsing, and account parsing are all delegated to sol-parser-sdk via a facade.
• Local Processing: The streamer's local handling is reserved for infrastructure tasks and non-DEX compatibility cases (e.g., ComputeBudget metadata).
• Extensibility: The streaming::sdk_bridge module allows advanced users to access raw SDK functionality without needing to rewrite existing bot callback logic.

The SDK uses a unified event model to provide type-safe access to various protocol events. This allows you to handle events from different sources using a consistent interface.

Key components include:

• DexEvent Enum: A type-safe enum that contains all possible protocol events.
• Protocol Enum: Used to easily identify the source of an event.
• SDK Bridge: A mechanism that adapts sol-parser-sdk::DexEvent into the streamer's own DexEvent type, ensuring compatibility between the underlying parser and the streamer's interface.