feat(rpc): add async fetch_last_5_blocks_and_receipts and extract analyze_max_gas_transaction

- implemented parallel fetching of last 5 blocks using Tokio
- moved transaction analysis logic into a separate function for reusability
- improved modularity and readability of async RPC handling

Author: sntntn

rustCode/Cargo.toml

@@ -14,3 +14,4 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 reqwest = { version = "0.11", features = ["json"] }
 dotenvy = "0.15"
+futures = "0.3.31"

rustCode/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod models;
 pub mod rpc;
+pub mod utils;
 
 use crate::rpc::fetch::fetch_latest_block;
 use std::ffi::CString;

rustCode/src/main.rs

@@ -4,8 +4,8 @@ mod rpc;
 mod utils;
 
 use config::{get_testnet_rpc_url, get_mainnet_rpc_url, load_testnet_env};
-use rpc::fetch::{fetch_latest_block, fetch_block_by_number, fetch_transaction_receipt};
-use utils::{print_block_info, print_transactions, find_max_gas_transaction, hex_to_u64, calculate_gas_percentage, consume_and_calculate_gas};
+use rpc::fetch::{fetch_latest_block, fetch_block_by_number, fetch_last_5_blocks_and_receipts};
+use utils::{print_block_info, hex_to_u64, analyze_max_gas_transaction};
 use tokio;
 
 #[tokio::main]
@@ -28,35 +28,24 @@ async fn main() {
     print_block_info(&block_mainnet);
 
     let transactions = block_mainnet.transactions;
-    print_transactions(&transactions);
+    //print_transactions(&transactions);
 
-    println!("----------------------");
-    
-    if let Some(max_tx) = find_max_gas_transaction(&transactions){
-        println!("Transakcija sa najvecim gas limitom: ");
-        println!("Hash {}", max_tx.hash);
-        println!("Gas limit: (hex): {}", max_tx.gas);
-        println!();
-
-        let receipt = fetch_transaction_receipt(&mainnet_rpc_url, &max_tx.hash).await;
-        //println!("{:?}", receipt);    // OVO MOZE
-        let tx_gas_used = hex_to_u64(&receipt.gas_used);
-        let block_gas_used = hex_to_u64(&block_mainnet.gas_used);
-        let percent_of_block = calculate_gas_percentage(tx_gas_used, block_gas_used);
+    analyze_max_gas_transaction(&mainnet_rpc_url, &transactions, &block_mainnet.gas_used).await;
 
-        println!("Gas potrosen od ove transakcije: {}", tx_gas_used);
-        println!("Gas potrosen u bloku: {}", block_gas_used);
-        println!("Procenat potrosnje u bloku: {:.6}%", percent_of_block);
-        println!();
-        
-        println!("Funkcija uzima ownership");
-        let percent_of_block1 = consume_and_calculate_gas(receipt, block_mainnet.gas_used);
-        println!("Procenat potrosnje u bloku: {:.6}%", percent_of_block1);
-        //println!("{:?}", receipt);                                         //OVO NE MOZE jer je promenjen owner
-        //println!("{}",block_response.gas_used);
-        //let tx_gas_used1 = hex_to_u64(&receipt.gas_used);
-        //let block_gas_used1 = hex_to_u64(&block_response.gas_used);
-    } else {
-            println!("Nema transakcija u ovom bloku");
+    println!();
+    println!("=======================");
+    println!("Fetchujem 5 poslednjih blokova i njihove max gas transakcije...");
+    println!("=======================\n");
+
+    let latest_block_number = hex_to_u64(&block_mainnet.number);
+    let summaries = fetch_last_5_blocks_and_receipts(mainnet_rpc_url, latest_block_number).await;
+
+    println!("\n===== REZIME 5 BLOKOVA =====");
+    for s in summaries {
+        println!(
+            "Blok {} | TX {} | Gas {} | {:.3}%",
+            s.block_number, s.tx_hash, s.gas_used, s.percent_in_block
+        );
     }
-}
+
+}

rustCode/src/models/mod.rs

@@ -15,6 +15,7 @@ pub struct SimpleBlock {
     pub transactions: Vec<SimpleTransaction>,
 }
 
+#[allow(dead_code)]
 #[derive(Debug, Deserialize)]
 pub struct SimpleTransaction {
     pub hash: String,
@@ -36,7 +37,16 @@ pub struct RPCResponseReceipt {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TransactionReceipt {
+    pub block_hash: String,
+    pub block_number: String,
     pub transaction_hash: String,
     pub gas_used: String,
     pub cumulative_gas_used: String,
+}
+
+pub struct TxSummary {
+    pub block_number: String,
+    pub tx_hash: String,
+    pub gas_used: u64,
+    pub percent_in_block: f64,
 }

rustCode/src/rpc/fetch.rs

@@ -1,6 +1,8 @@
-use crate::models::{RPCResponseBlock, RPCResponseReceipt, SimpleBlock, TransactionReceipt};
+use crate::models::{RPCResponseBlock, RPCResponseReceipt, SimpleBlock, TransactionReceipt, TxSummary};
 use reqwest::Client;
 use serde_json::json;
+use std::sync::Arc;
+use crate::utils::{find_max_gas_transaction, hex_to_u64, calculate_gas_percentage};
 
 pub async fn fetch_latest_block(rpc_url: &str, transaction_bool: bool) -> SimpleBlock {
     let req_body = json!( {
@@ -65,4 +67,53 @@ pub async fn fetch_transaction_receipt(rpc_url: &str, tx_hash: &str) -> Transact
     let receipt_resp: RPCResponseReceipt = resp.json().await.expect("Greska pri parsiranju odgovora");
 
     receipt_resp.result
+}
+
+pub async fn fetch_last_5_blocks_and_receipts(rpc_url: String, latest_block_number: u64) 
+-> Vec<TxSummary> {
+    let rpc_arc = Arc::new(rpc_url);
+    
+    let mut tasks = Vec::new();
+
+    for i in 0..5 {
+        let rpc = Arc::clone(&rpc_arc);
+        let block_number = latest_block_number.saturating_sub(i); // da ne padne ispod 0
+
+        let task = tokio::spawn(async move {
+            let block_number_hex = format!("0x{:x}", block_number);
+            let block = fetch_block_by_number(&rpc, &block_number_hex, true).await;
+
+            if let Some(max_tx) = find_max_gas_transaction(&block.transactions) {
+                let receipt = fetch_transaction_receipt(&rpc, &max_tx.hash).await;
+                let tx_gas_used = hex_to_u64(&receipt.gas_used);
+                let block_gas_used = hex_to_u64(&block.gas_used);
+                let percent = calculate_gas_percentage(tx_gas_used, block_gas_used);
+
+                println!(
+                    "Blok {} | Max TX: {} | Gas: {} | %. u bloku: {:.3}%",
+                    block.number, max_tx.hash, tx_gas_used, percent
+                );
+
+                Some(TxSummary {
+                    block_number: block.number.clone(),
+                    tx_hash: max_tx.hash.clone(),
+                    gas_used: tx_gas_used,
+                    percent_in_block: percent,
+                })            
+            } else {
+                println!("Blok {} nema transakcije.", block.number);
+                None
+            }
+        });
+
+        tasks.push(task);
+    }
+
+    let results = futures::future::join_all(tasks).await;
+
+    // filtriram samo uspesne
+    results
+        .into_iter()
+        .filter_map(|res| res.ok().flatten())
+        .collect()
 }

rustCode/src/utils/functions.rs

@@ -1,4 +1,5 @@
 use crate::models::{SimpleTransaction, TransactionReceipt};
+use crate::rpc::fetch::fetch_transaction_receipt;
 
 pub fn find_max_gas_transaction(transactions: &[SimpleTransaction]) -> Option<&SimpleTransaction> {
     transactions
@@ -21,4 +22,42 @@ pub fn consume_and_calculate_gas(receipt: TransactionReceipt, block_gas_used_hex
     let tx_gas_used = hex_to_u64(&receipt.gas_used);
     let block_gas_used = hex_to_u64(&block_gas_used_hex);
     calculate_gas_percentage(tx_gas_used, block_gas_used)
+}
+
+pub async fn analyze_max_gas_transaction(
+    mainnet_rpc_url: &str,
+    transactions: &[SimpleTransaction],
+    block_gas_used_hex: &str,
+) {
+    println!("----------------------");
+
+    if let Some(max_tx) = find_max_gas_transaction(transactions) {
+        println!("Transakcija sa najvecim gas limitom: ");
+        println!("Hash {}", max_tx.hash);
+        println!("Gas limit: {}", hex_to_u64(&max_tx.gas));
+        println!();
+
+        let receipt = fetch_transaction_receipt(mainnet_rpc_url, &max_tx.hash).await;
+        //println!("{:?}", receipt);                                         // OVO MOZE
+        let tx_gas_used = hex_to_u64(&receipt.gas_used);
+        let block_gas_used = hex_to_u64(block_gas_used_hex);
+        let percent_of_block = calculate_gas_percentage(tx_gas_used, block_gas_used);
+
+        println!("Gas potrosen od ove transakcije: {}", tx_gas_used);
+        println!("Gas potrosen u bloku: {}", block_gas_used);
+        println!("Procenat potrosnje u bloku: {:.6}%", percent_of_block);
+        println!();
+
+        // Ownership primer
+        println!("Ponovljeno izracunavanje preko dodele ownership-a");
+        let percent_of_block1 = consume_and_calculate_gas(receipt, block_gas_used_hex.to_string());
+        println!("Procenat potrosnje u bloku: {:.6}%", percent_of_block1);
+        //println!("{:?}", receipt);                                         //OVO NE MOZE jer je promenjen owner
+        //println!("{}",block_mainnet.gas_used);
+        //let tx_gas_used1 = hex_to_u64(&receipt.gas_used);
+        //let block_gas_used1 = hex_to_u64(&block_mainnet.gas_used);
+
+    } else {
+        println!("Nema transakcija u ovom bloku");
+    }
 }

rustCode/src/utils/prints.rs

@@ -8,6 +8,7 @@ pub fn print_block_info(block: &SimpleBlock) {
     println!("Broj transakcija: {}", block.transactions.len());
 }
 
+#[allow(dead_code)]
 pub fn print_transactions(transactions: &[SimpleTransaction]) {
     for tx in transactions {
         println!("---");