Struct TychoStreamDecoder 

pub struct TychoStreamDecoder<H>
where
    H: HeaderLike,
{ /* private fields */ }

A decoder to process raw messages.

This struct decodes incoming messages of type FeedMessage and converts it into the BlockUpdate struct.

Important:

• Supports registering exchanges and their associated filters for specific protocol components.
• Allows the addition of client-side filters for custom conditions.

Note: Tokens provided via set_tokens are used to decode startup snapshots and initialize protocol states. This is not an ongoing filter — components arriving after startup include their own token metadata.

Implementations

impl<H> TychoStreamDecoder<H>

where H: HeaderLike + Clone + Sync + Send + 'static + Debug,

pub fn new() -> Self

pub async fn set_tokens(&self, tokens: HashMap<Bytes, Token>)

Provides token metadata used to decode startup snapshots and initialize protocol states.

This is not an ongoing stream filter. Components arriving after startup include their own token metadata for decoding.

pub fn skip_state_decode_failures(&mut self, skip: bool)

pub fn min_token_quality(&mut self, quality: u32)

Sets the minimum token quality for decoding.

Tokens arriving in stream deltas below this threshold are ignored. Defaults to 100. Set this to the same value used in load_all_tokens() to apply consistent filtering.

pub fn register_decoder_with_context<T>( &mut self, exchange: &str, context: DecoderContext, )

where T: ProtocolSim + TryFromWithBlock<ComponentWithState, H, Error = InvalidSnapshotError> + Send + 'static,

Registers a decoder for a given exchange with a decoder context.

This method maps an exchange identifier to a specific protocol simulation type. The associated type must implement the TryFromWithBlock trait to enable decoding of state updates from ComponentWithState objects. This allows the decoder to transform the component data into the appropriate protocol simulation type based on the current blockchain state and the provided block header. For example, to register a decoder for the uniswap_v2 exchange with an additional decoder context, you must call this function with register_decoder_with_context::<UniswapV2State>("uniswap_v2", context). This ensures that the exchange ID uniswap_v2 is properly associated with the UniswapV2State decoder for use in the protocol stream.

pub fn register_decoder<T>(&mut self, exchange: &str)

where T: ProtocolSim + TryFromWithBlock<ComponentWithState, H, Error = InvalidSnapshotError> + Send + 'static,

Registers a decoder for a given exchange.

This method maps an exchange identifier to a specific protocol simulation type. The associated type must implement the TryFromWithBlock trait to enable decoding of state updates from ComponentWithState objects. This allows the decoder to transform the component data into the appropriate protocol simulation type based on the current blockchain state and the provided block header. For example, to register a decoder for the uniswap_v2 exchange, you must call this function with register_decoder::<UniswapV2State>("uniswap_v2", vm_attributes). This ensures that the exchange ID uniswap_v2 is properly associated with the UniswapV2State decoder for use in the protocol stream.

pub fn register_filter( &mut self, exchange: &str, predicate: fn(&ComponentWithState) -> bool, )

Registers a client-side filter function for a given exchange.

Associates a filter function with an exchange ID, enabling custom filtering of protocol components. The filter function is applied client-side to refine the data received from the stream. It can be used to exclude certain components based on attributes or conditions that are not supported by the server-side filtering logic. This is particularly useful for implementing custom behaviors, such as:

• Filtering out pools with specific attributes (e.g., unsupported features).
• Blacklisting pools based on custom criteria.
• Excluding pools that do not meet certain requirements (e.g., token pairs or liquidity constraints).

For example, you might use a filter to exclude pools that are not fully supported in the protocol, or to ignore pools with certain attributes that are irrelevant to your application.

pub async fn decode( &self, msg: &FeedMessage<H>, ) -> Result<Update, StreamDecodeError>

Decodes a FeedMessage into a BlockUpdate containing the updated states of protocol components

pub async fn apply_deltas_ephemeral( &self, pending_deltas: &HashMap<String, BlockAggregatedChanges>, header: H, ) -> Result<Update, StreamDecodeError>

Applies pending deltas from one or more TxDeltaIndexers against the current confirmed state and returns an ephemeral Update.

This is the read-only counterpart of decode(). It clones pool states, applies the supplied pending_deltas, and returns the result — without writing back to DecoderState. Calling this method twice with the same input produces identical results.

Only native protocols are supported. VM protocols (extractor prefix "vm:") are rejected at registration time in with_pending_indexer.

Parameters

• pending_deltas — map from extractor name to the BlockAggregatedChanges produced by the corresponding TxDeltaIndexer::generate_deltas() call.
• header — the target block header. Its block_number_or_timestamp() is stamped on the returned Update; its block_number and block_timestamp are injected into each state delta so that protocols relying on block context (e.g. aerodrome slipstreams, etherfi) receive correct values.

Trait Implementations

impl<H> Default for TychoStreamDecoder<H>

where H: HeaderLike + Clone + Sync + Send + 'static + Debug,

fn default() -> Self

Returns the “default value” for a type.