Struct StellarBlockFilter

pub struct StellarBlockFilter<T> {
    pub _client: PhantomData<T>,
}

Implementation of the block filter for Stellar blockchain

Fields

_client: PhantomData<T>

Implementations

impl<T> StellarBlockFilter<T>

pub fn find_matching_transaction( &self, transaction: &StellarTransaction, monitor: &Monitor, matched_transactions: &mut Vec<TransactionCondition>, )

Finds matching transactions based on monitor conditions

Arguments

• transaction - The Stellar transaction to check
• monitor - The monitor containing match conditions
• matched_transactions - Vector to store matching transactions

pub fn convert_arguments_to_match_param_entry( &self, arguments: &[Value], function_spec: Option<&StellarContractFunction>, ) -> Vec<StellarMatchParamEntry>

Converts Stellar function arguments into match parameter entries

Arguments

• arguments - Vector of argument values to convert
• function_spec - Optional function specification for named parameters

Returns

Vector of converted parameter entries

pub fn find_matching_functions_for_transaction( &self, monitored_addresses: &[String], contract_specs: &[(String, StellarFormattedContractSpec)], transaction: &StellarTransaction, monitor: &Monitor, matched_functions: &mut Vec<FunctionCondition>, matched_on_args: &mut StellarMatchArguments, )

Finds matching functions within a transaction

Arguments

• monitored_addresses - List of addresses being monitored
• contract_specs - List of contract specifications (SEP-48 ABIs) for monitored addresses
• transaction - The transaction to check
• monitor - The monitor containing match conditions
• matched_functions - Vector to store matching functions
• matched_on_args - Arguments that matched the conditions

pub fn find_matching_events_for_transaction( &self, events: &[EventMap], transaction: &StellarTransaction, monitor: &Monitor, matched_events: &mut Vec<EventCondition>, matched_on_args: &mut StellarMatchArguments, )

Finds matching events for a transaction

Arguments

• events - List of decoded events
• transaction - The transaction to check
• monitor - The monitor containing match conditions
• matched_events - Vector to store matching events
• matched_on_args - Arguments that matched the conditions

pub async fn decode_events( &self, events: &Vec<StellarEvent>, monitored_addresses: &[String], _contract_specs: &[(String, StellarFormattedContractSpec)], ) -> Vec<EventMap>

Decodes Stellar events into a more processable format

Arguments

• events - Raw Stellar events to decode
• monitored_addresses - List of addresses being monitored

Returns

Vector of decoded events mapped to their transaction hashes

pub fn compare_map( &self, param_value: &str, operator: &str, compare_value: &str, ) -> bool

Compares two values that might be JSON or plain strings using the specified operator.

Arguments

• param_value - The first value to compare, which could be a JSON string or plain string
• operator - The comparison operator (“==”, “!=”, “>”, “>=”, “<”, “<=”)
• compare_value - The second value to compare against, which could be a JSON string or plain string

Supported Comparison Cases

1. JSON vs JSON: Both values are valid JSON

   • Supports equality (==, !=)
   • Supports numeric comparisons (>, >=, <, <=) when both values are numbers

2. JSON vs String: First value is JSON, second is plain string

   • Supports dot notation to access nested JSON values (e.g., “user.address.city”)
   • Can check if the string matches a key in a JSON object
   • Falls back to direct string comparison if above checks fail

3. String vs JSON: First value is string, second is JSON

   • Currently returns false as this is an invalid comparison

4. String vs String: Neither value is valid JSON

   • Performs direct string comparison

Returns

• bool - True if the comparison succeeds, false otherwise

pub fn evaluate_expression( &self, expression: &str, args: &Option<Vec<StellarMatchParamEntry>>, ) -> bool

Evaluates a complex matching expression against provided arguments

Arguments

• expression - The expression to evaluate (supports AND/OR operations)
• args - The arguments to evaluate against

Returns

Boolean indicating if the expression evaluates to true

Trait Implementations

impl<T: BlockChainClient + StellarClientTrait> BlockFilter for StellarBlockFilter<T>

fn filter_block<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, client: &'life1 Self::Client, network: &'life2 Network, block: &'life3 BlockType, monitors: &'life4 [Monitor], contract_specs: Option<&'life5 [(String, ContractSpec)]>, ) -> Pin<Box<dyn Future<Output = Result<Vec<MonitorMatch>, FilterError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Filters a Stellar block against provided monitors

Arguments

• client - The blockchain client to use
• _network - The network being monitored
• block - The block to filter
• monitors - List of monitors to check against
• contract_specs - List of contract specs to use for decoding events

Returns

Result containing vector of matching monitors or a filter error

type Client = T