Struct EVMBlockFilter

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

Filter implementation for EVM-compatible blockchains

Fields

_client: PhantomData<T>

Implementations

impl<T> EVMBlockFilter<T>

pub fn find_matching_transaction( &self, tx_status: &TransactionStatus, transaction: &EVMTransaction, tx_receipt: &Option<EVMTransactionReceipt>, monitor: &Monitor, matched_transactions: &mut Vec<TransactionCondition>, )

Finds transactions that match the monitor’s conditions.

Arguments

• tx_status - Status of the transaction (success/failure)
• transaction - The transaction to check
• tx_receipt - Transaction receipt
• monitor - Monitor containing match conditions
• matched_transactions - Vector to store matching transactions

pub fn find_matching_functions_for_transaction( &self, contract_specs: &[(String, EVMContractSpec)], transaction: &EVMTransaction, monitor: &Monitor, matched_functions: &mut Vec<FunctionCondition>, matched_on_args: &mut EVMMatchArguments, )

Finds function calls in a transaction that match the monitor’s conditions.

Decodes the transaction input data using the contract ABI and matches against the monitor’s function conditions.

Arguments

• contract_specs - List of contract specifications
• transaction - The transaction containing the function call
• monitor - Monitor containing function match conditions
• matched_functions - Vector to store matching functions
• matched_on_args - Arguments from matched function calls

pub fn find_matching_events_for_transaction( &self, logs: &[EVMReceiptLog], monitor: &Monitor, matched_events: &mut Vec<EventCondition>, matched_on_args: &mut EVMMatchArguments, involved_addresses: &mut Vec<String>, )

Finds events in a transaction receipt that match the monitor’s conditions.

Processes event logs from the transaction receipt and matches them against the monitor’s event conditions.

Arguments

• logs - Transaction receipt containing event logs
• monitor - Monitor containing event match conditions
• matched_events - Vector to store matching events
• matched_on_args - Arguments from matched events
• involved_addresses - Addresses involved in matched events

pub fn evaluate_expression( &self, expression: &str, args: &[EVMMatchParamEntry], ) -> Result<bool, EvaluationError>

Evaluates a match expression against provided parameters.

Arguments

• expression - The expression to evaluate
• args - Optional parameters to use in evaluation

Returns

true if the expression matches, false otherwise

pub fn decode_events( &self, abi: &ContractSpec, log: &EVMReceiptLog, ) -> Option<EVMMatchParamsMap>

Decodes event logs using the provided ABI.

Arguments

• abi - Contract ABI for decoding
• log - Event log to decode

Returns

Option containing EVMMatchParamsMap with decoded event data if successful

Trait Implementations

impl<T: BlockChainClient + EvmClientTrait> BlockFilter for EVMBlockFilter<T>

fn filter_block<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, client: &'life1 T, 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,

Processes a block and finds matches based on monitor conditions.

Arguments

• client - Blockchain client for additional data fetching
• network - Network of the blockchain
• block - The block to process
• monitors - Active monitors containing match conditions

Returns

Vector of matches found in the block

type Client = T