eql_core 0.1.17

EVM Query Language core components
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use crate::common::{
    chain::ChainOrRpc,
    logs::{LogField, Logs},
    query_result::LogQueryRes,
};
use alloy::providers::{Provider, ProviderBuilder};
use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::sync::Arc;

#[derive(Debug, Serialize, Deserialize, thiserror::Error)]
pub enum LogResolverErrors {
    #[error("Query returned no results within the given filters")]
    NoLogsFound,
}

pub async fn resolve_log_query(
    logs: &Logs,
    chain_or_rpcs: &[ChainOrRpc],
) -> Result<Vec<LogQueryRes>> {
    let mut all_results = Vec::new();

    for chain_or_rpc in chain_or_rpcs {
        let provider = Arc::new(ProviderBuilder::new().on_http(chain_or_rpc.rpc_url()?));
        let filtered_logs = provider.get_logs(&logs.build_bloom_filter()).await?;
        let chain = chain_or_rpc.to_chain().await?;

        if !filtered_logs.is_empty() {
            let chain_results: Vec<LogQueryRes> = filtered_logs
                .into_iter()
                .map(|log| {
                    let mut result = LogQueryRes::default();

                    for field in logs.fields() {
                        match field {
                            LogField::Address => result.address = Some(log.inner.address),
                            LogField::Topic0 => result.topic0 = log.topic0().copied(),
                            LogField::Topic1 => {
                                result.topic1 = log.inner.data.topics().get(1).copied()
                            }
                            LogField::Topic2 => {
                                result.topic2 = log.inner.data.topics().get(2).copied()
                            }
                            LogField::Topic3 => {
                                result.topic3 = log.inner.data.topics().get(3).copied()
                            }
                            LogField::Data => result.data = Some(log.data().data.clone()),
                            LogField::BlockHash => result.block_hash = log.block_hash,
                            LogField::BlockNumber => result.block_number = log.block_number,
                            LogField::BlockTimestamp => {
                                result.block_timestamp = log.block_timestamp
                            }
                            LogField::TransactionHash => {
                                result.transaction_hash = log.transaction_hash
                            }
                            LogField::TransactionIndex => {
                                result.transaction_index = log.transaction_index
                            }
                            LogField::LogIndex => result.log_index = log.log_index,
                            LogField::Removed => result.removed = Some(log.removed),
                            LogField::Chain => result.chain = Some(chain.clone()),
                        }
                    }

                    result
                })
                .collect();

            all_results.extend(chain_results);
        }
    }

    if all_results.is_empty() {
        return Err(LogResolverErrors::NoLogsFound.into());
    }

    Ok(all_results)
}