feat sum

crates/cli/src/main.rs

@@ -58,6 +58,9 @@ impl ResultHandler {
                 ExpressionResult::Log(query_res) => {
                     println!("{}", to_table(query_res)?);
                 }
+                ExpressionResult::Sum(query_res) => {
+                    println!("{}", to_table(query_res)?);
+                }
             }
         }
 

crates/cli/src/repl.rs

@@ -241,6 +241,12 @@ impl Repl {
                         queue!(stdout(), MoveToNextLine(1), Print(line.cyan())).unwrap();
                     });
                 }
+                ExpressionResult::Sum(query_res) => {
+                    let table = to_table(query_res)?;
+                    table.to_string().split("\n").for_each(|line| {
+                        queue!(stdout(), MoveToNextLine(1), Print(line.green())).unwrap();
+                    });
+                }
             }
         }
 

crates/core/src/common/query_result.rs

@@ -25,6 +25,23 @@ pub enum ExpressionResult {
     Transaction(Vec<TransactionQueryRes>),
     #[serde(rename = "log")]
     Log(Vec<LogQueryRes>),
+    #[serde(rename = "sum")]
+    Sum(Vec<SumQueryRes>),
+}
+
+
+#[serde_with::skip_serializing_none]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
+pub struct SumQueryRes {
+    pub sum: Option<U256>,
+}
+
+impl Default for SumQueryRes {
+    fn default() -> Self {
+        Self {
+            sum: None,
+        }
+    }
 }
 
 // TODO: should this be replaced with Alloy's Block?

crates/core/src/common/serializer.rs

@@ -25,6 +25,7 @@ pub(crate) fn dump_results(result: &ExpressionResult, dump: &Dump) -> Result<(),
                 ExpressionResult::Block(blocks) => serialize_csv(blocks)?,
                 ExpressionResult::Transaction(txs) => serialize_csv(txs)?,
                 ExpressionResult::Log(logs) => serialize_csv(logs)?,
+                ExpressionResult::Sum(sums) => serialize_csv(sums)?,
             };
 
             std::fs::write(dump.path(), content)?;
@@ -59,6 +60,7 @@ fn serialize_parquet(result: &ExpressionResult) -> Result<Vec<u8>, Box<dyn Error
             create_parquet_schema_and_data(transactions)?
         }
         ExpressionResult::Log(logs) => create_parquet_schema_and_data(logs)?,
+        ExpressionResult::Sum(sums) => create_parquet_schema_and_data(sums)?,
     };
 
     let batch = RecordBatch::try_new(Arc::new(schema), data)?;

crates/core/src/common/types.rs

@@ -10,6 +10,21 @@ use pest::iterators::Pairs;
 #[derive(Debug, PartialEq)]
 pub enum Expression {
     Get(GetExpression),
+    Sum(SumExpression),
+}
+
+
+#[derive(Debug, PartialEq)]
+pub struct SumExpression {
+    pub query: GetExpression,
+}
+
+impl SumExpression {
+    fn new(query: GetExpression) -> Self {
+        Self {
+            query
+        }
+    }
 }
 
 #[derive(Debug, PartialEq)]

crates/core/src/interpreter/backend/execution_engine.rs

@@ -3,9 +3,10 @@ use super::{
     resolve_block::resolve_block_query,
     resolve_logs::resolve_log_query,
     resolve_transaction::resolve_transaction_query,
+    resolve_sum_query::resolve_sum_query
 };
 use crate::common::{
-    entity::Entity, query_result::{ExpressionResult, QueryResult}, serializer::dump_results, types::{Expression, GetExpression}
+    entity::Entity, query_result::{ExpressionResult, QueryResult}, serializer::dump_results, types::{Expression, GetExpression, SumExpression}
 };
 use anyhow::Result;
 
@@ -36,6 +37,10 @@ impl ExecutionEngine {
                     let result = self.run_get_expr(&get_expr).await?;
                     query_results.push(QueryResult::new(result));
                 }
+                Expression::Sum(sum_expr) => {
+                    let result = self.run_sum_expr(&sum_expr).await?;
+                    query_results.push(QueryResult::new(result));
+                }
             }
         }
 
@@ -59,20 +64,29 @@ impl ExecutionEngine {
 
         Ok(result)
     }
+
+    async fn run_sum_expr(
+        &self,
+        expr: &SumExpression,
+    ) -> Result<ExpressionResult> {
+        let query_result = self.run_get_expr(&expr.query).await?;
+        let result  = resolve_sum_query( &query_result)?;
+        Ok(result)
+    }
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
     use crate::common::{
-        account::{Account, AccountField},
+        account::{Account, AccountField, AccountFilter},
         block::{Block, BlockField, BlockId, BlockRange},
         chain::{Chain, ChainOrRpc},
         dump::{Dump, DumpFormat},
         ens::NameOrAddress,
         logs::{LogField, LogFilter, Logs},
-        query_result::{AccountQueryRes, BlockQueryRes, LogQueryRes, TransactionQueryRes},
-        transaction::{Transaction, TransactionField},
+        query_result::{AccountQueryRes, BlockQueryRes, LogQueryRes, SumQueryRes, TransactionQueryRes},
+        transaction::{Transaction, TransactionField, TransactionFilter},
         types::{Expression, GetExpression},
     };
     use alloy::{
@@ -82,6 +96,70 @@ mod test {
     use pretty_assertions::assert_eq;
     use std::str::FromStr;
 
+    #[tokio::test]
+    async fn test_sum_balance_of_mutiple_chain() {
+        let execution_engine = ExecutionEngine::new();
+        let expressions = vec![Expression::Sum(
+            SumExpression {
+                query: GetExpression {
+                    entity: Entity::Account(
+                        Account::new(
+                            Some(vec![NameOrAddress::Name(String::from("vitalik.eth"))]),
+                            None,
+                            vec![AccountField::Balance],
+                        )
+                ),
+                chains: vec![ChainOrRpc::Chain(Chain::Ethereum), ChainOrRpc::Chain(Chain::Base),ChainOrRpc::Chain(Chain::Arbitrum)],
+                dump: None,
+           }
+        })];
+
+        let execution_result = execution_engine.run(expressions).await;
+        let expected = vec![SumQueryRes {
+            sum: Some(U256::from(0)),
+        }];
+
+        match execution_result {
+            Ok(results) => {
+                assert_eq!(results[0].result, ExpressionResult::Sum(expected));
+            }
+            Err(_) => panic!("Error"),
+        }
+    }
+
+    #[tokio::test]
+    async fn test_sum_value_of_mutile_block_for_mutiple_chain() {
+        let execution_engine = ExecutionEngine::new();
+        let expressions = vec![Expression::Sum(SumExpression {
+            query: GetExpression {
+                entity: Entity::Transaction(Transaction::new(
+                     Some(vec![
+                        b256!("8cfc4f5f4729423f59dd1d263ead2f824b3f133b02b9e27383964c7d50cd47cb"),
+                        b256!("72546b3ca8ef0dfb85fe66d19645e44cb519858c72fbcad0e1c1699256fed890")
+                    ]),
+                    None,
+                    vec![TransactionField::Value],
+                )),
+                chains: vec![ChainOrRpc::Chain(Chain::Ethereum), ChainOrRpc::Chain(Chain::Base),ChainOrRpc::Chain(Chain::Arbitrum)], 
+                dump: None,
+            },
+        })];
+        println!("{:?}", expressions);
+
+        let execution_result = execution_engine.run(expressions).await;
+        let expected = vec![SumQueryRes {
+            sum: Some(U256::from(0)),
+        }];
+
+        match execution_result {
+            Ok(results) => {
+                assert_eq!(results[0].result, ExpressionResult::Sum(expected));
+            }
+            Err(_) => panic!("Error")
+        }
+    }
+
+
     #[tokio::test]
     async fn test_get_logs() {
         let execution_engine = ExecutionEngine::new();

crates/core/src/interpreter/backend/mod.rs

@@ -2,4 +2,5 @@ mod resolve_account;
 mod resolve_block;
 mod resolve_logs;
 mod resolve_transaction;
+mod resolve_sum_query;
 pub mod execution_engine;

crates/core/src/interpreter/backend/resolve_sum_query.rs

@@ -0,0 +1,58 @@
+use crate::common::{
+    account::{Account, AccountField},
+    chain::{Chain, ChainOrRpc},
+    ens::NameOrAddress,
+    query_result::{ExpressionResult, SumQueryRes},
+};
+use alloy::{
+    primitives::Address,
+    providers::{Provider, ProviderBuilder, RootProvider},
+    transports::http::{Client, Http},
+};
+use anyhow::Result;
+use futures::future::try_join_all;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+#[derive(Debug, Serialize, Deserialize, thiserror::Error)]
+pub enum AccountResolverErrors {
+    #[error("Mismatch between Entity and EntityId, {0} can't be resolved as a account id")]
+    MismatchEntityAndEntityId(String),
+}
+
+/// Resolve the query to get accounts after receiving an account entity expression
+/// Iterate through entity_ids and map them to a futures list. Execute all futures concurrently and collect the results.
+pub fn resolve_sum_query(
+    exp: &ExpressionResult,
+) -> Result<ExpressionResult>{
+    //let mut result = Vec::new();
+
+    // for chain in chains {
+    //     let provider = Arc::new(ProviderBuilder::new().on_http(chain.rpc_url()?));
+
+    //     // TODO: Handle filter
+    //     // TODO: Remove unwrap
+    //     for account_id in account.ids().unwrap() {
+    //         let fields = account.fields().clone();
+    //         let provider = provider.clone();
+
+    //         let account_future = async move {
+    //             match account_id {
+    //                 NameOrAddress::Address(address) => {
+    //                     get_account(address, fields, &provider, chain).await
+    //                 }
+    //                 NameOrAddress::Name(name) => {
+    //                     let address = to_address(name).await?;
+    //                     get_account(&address, fields, &provider, chain).await
+    //                 }
+    //             }
+    //         };
+
+    //         all_account_futures.push(account_future);
+    //     }
+    // }
+
+    // let account_res = try_join_all(all_account_futures).await?;
+    let res = ExpressionResult::Sum(vec![SumQueryRes::default()]); 
+    Ok(res)
+}