refactor(indexer): cargo fmt

apps/indexer/src/build.rs

@@ -21,7 +21,8 @@ fn main() {
     } else {
         match std::fs::read_to_string(path) {
             Ok(res) => res,
-            Err(_) => env::var("GIT_HASH").expect("Failed to retrieve git version from file or environnment")
+            Err(_) => env::var("GIT_HASH")
+                .expect("Failed to retrieve git version from file or environnment"),
         }
     };
 

apps/indexer/src/config.rs

@@ -16,7 +16,7 @@ pub struct ChainConfig {
     /// For auto withdraw
     pub account_address: Option<String>,
     pub account_private_key: Option<String>,
-    #[serde(default="cooling_down_default")]
+    #[serde(default = "cooling_down_default")]
     pub cooling_down: u64,
 }
 

apps/indexer/src/ethereum_indexer/client.rs

@@ -48,7 +48,10 @@ impl EthereumClient {
     pub async fn new(config: ChainConfig) -> Result<EthereumClient> {
         let provider = Provider::<Http>::try_from(&config.rpc_url)?;
 
-        let chain_id = provider.get_chainid().await.expect("Failed to retrieve ChainId");
+        let chain_id = provider
+            .get_chainid()
+            .await
+            .expect("Failed to retrieve ChainId");
 
         let provider_signer = if let Some(pk) = &config.account_private_key {
             let wallet: LocalWallet = pk.parse::<LocalWallet>()?.with_chain_id(chain_id.as_u32());
@@ -85,24 +88,25 @@ impl EthereumClient {
 
     ///
     pub async fn get_block_number(&self) -> Result<u64> {
-
-        match self.provider
-            .get_block_number()
-            .await {
-                Ok(v) => Ok(v.try_into().unwrap()),
-                Err(e) => Err(anyhow!("{:?}", e)),
-            }
+        match self.provider.get_block_number().await {
+            Ok(v) => Ok(v.try_into().unwrap()),
+            Err(e) => Err(anyhow!("{:?}", e)),
+        }
     }
 
     pub async fn get_block_timestamp(&self, block_id: u64) -> u64 {
-        match self.provider
+        match self
+            .provider
             .get_block(block_id)
             .await
-            .expect(&format!("Can't fetch block {}", block_id)) {
-                None => 0,
-                Some(block) => block.timestamp.try_into().expect("Can't convert block timestamp to u64")
+            .expect(&format!("Can't fetch block {}", block_id))
+        {
+            None => 0,
+            Some(block) => block
+                .timestamp
+                .try_into()
+                .expect("Can't convert block timestamp to u64"),
         }
-
     }
     /// Fetches logs for the given block options.
     ///

apps/indexer/src/ethereum_indexer/events.rs

@@ -1,4 +1,7 @@
-use crate::{storage::{BridgeChain, CrossChainTx, CrossChainTxKind, Event, EventLabel, Request}, utils::normalize_hex};
+use crate::{
+    storage::{BridgeChain, CrossChainTx, CrossChainTxKind, Event, EventLabel, Request},
+    utils::normalize_hex,
+};
 use anyhow::{anyhow, Result};
 use ethers::prelude::*;
 use serde_json::{json, Value};

apps/indexer/src/ethereum_indexer/indexer.rs

@@ -93,12 +93,12 @@ where
                     Ok(_) => (),
                     Err(e) => {
                         log::error!(
-                        "Error processing logs for block {:?}\n{:?}",
-                        block_number,
-                        e
-                    );
-                    need_cool_down = true;
-                },
+                            "Error processing logs for block {:?}\n{:?}",
+                            block_number,
+                            e
+                        );
+                        need_cool_down = true;
+                    }
                 };
             }
 

apps/indexer/src/handlers/requests.rs

@@ -3,39 +3,54 @@ use axum::{
     http::StatusCode,
     Json,
 };
-use serde::{Deserialize, Serialize};
 use serde::ser::SerializeStruct;
+use serde::{Deserialize, Serialize};
 
 use super::AppState;
-use crate::{storage::{
-    protocol::ProtocolParser,
-    store::{EventStore, RequestStore},
-    Event, Request,
-}, utils::{denormalize_hex, normalize_hex}};
-
+use crate::{
+    storage::{
+        protocol::ProtocolParser,
+        store::{EventStore, RequestStore},
+        Event, Request,
+    },
+    utils::{denormalize_hex, normalize_hex},
+};
 
 #[derive(Debug, Deserialize)]
 pub struct RequestWrapper(pub Request);
 
 impl Serialize for RequestWrapper {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: serde::Serializer {
+        S: serde::Serializer,
+    {
         let RequestWrapper(ref inner) = *self;
         let mut state = serializer.serialize_struct("Request", 7)?;
         state.serialize_field("hash", &inner.hash)?;
         state.serialize_field("chain_src", &inner.chain_src)?;
-        state.serialize_field("from", &denormalize_hex(&inner.from).expect("Failed to denormalize 'from'"))?;
-        state.serialize_field("to", &denormalize_hex(&inner.to).expect("Failed to denormalize 'to'"))?;
-        state.serialize_field("collection_src", &denormalize_hex(&inner.collection_src).expect("Failed to denormalize 'collection_src'"))?;
-        state.serialize_field("collection_dst", &denormalize_hex(&inner.collection_dst).expect("Failed to denormalize 'collection_dst'"))?;
+        state.serialize_field(
+            "from",
+            &denormalize_hex(&inner.from).expect("Failed to denormalize 'from'"),
+        )?;
+        state.serialize_field(
+            "to",
+            &denormalize_hex(&inner.to).expect("Failed to denormalize 'to'"),
+        )?;
+        state.serialize_field(
+            "collection_src",
+            &denormalize_hex(&inner.collection_src)
+                .expect("Failed to denormalize 'collection_src'"),
+        )?;
+        state.serialize_field(
+            "collection_dst",
+            &denormalize_hex(&inner.collection_dst)
+                .expect("Failed to denormalize 'collection_dst'"),
+        )?;
         state.serialize_field("content", &inner.content)?;
         state.end()
     }
 }
 
-
-
 #[derive(Debug, Serialize, Deserialize)]
 pub struct RequestInfo {
     req: RequestWrapper,

apps/indexer/src/starknet_indexer/indexer.rs

@@ -3,8 +3,11 @@ use super::events;
 use crate::config::ChainConfig;
 use crate::storage::protocol::ProtocolParser;
 use crate::storage::{
-    store::{BlockStore, CrossChainTxStore, EventStore, PendingWithdrawStore, RequestStore, StarknetBridgeRequestStore},
-    BlockIndex, BridgeChain, CrossChainTxKind, EventLabel, PendingWithdraw
+    store::{
+        BlockStore, CrossChainTxStore, EventStore, PendingWithdrawStore, RequestStore,
+        StarknetBridgeRequestStore,
+    },
+    BlockIndex, BridgeChain, CrossChainTxKind, EventLabel, PendingWithdraw,
 };
 use crate::utils;
 use crate::ChainsBlocks;
@@ -28,7 +31,12 @@ pub struct StarknetIndexer<
 
 impl<T> StarknetIndexer<T>
 where
-    T: RequestStore + EventStore + BlockStore + CrossChainTxStore + StarknetBridgeRequestStore + PendingWithdrawStore,
+    T: RequestStore
+        + EventStore
+        + BlockStore
+        + CrossChainTxStore
+        + StarknetBridgeRequestStore
+        + PendingWithdrawStore,
 {
     ///
     pub async fn new(
@@ -111,14 +119,15 @@ where
             let latest_u64 = match self
                 .client
                 .block_id_to_u64(&BlockId::Tag(BlockTag::Latest))
-                .await {
-                    Ok(v) => v,
-                    Err(e) => {
-                        log::error!("Failed to retrieve blockid: {:#}", e);
-                        need_cool_down = true;
-                        continue;
-                    }
-                };
+                .await
+            {
+                Ok(v) => v,
+                Err(e) => {
+                    log::error!("Failed to retrieve blockid: {:#}", e);
+                    need_cool_down = true;
+                    continue;
+                }
+            };
 
             // Don't fetch if we already are on the head of the chain.
             if from_u64 >= latest_u64 {
@@ -129,22 +138,32 @@ where
             let blocks_events = match self
                 .client
                 .fetch_events(BlockId::Number(from_u64), BlockId::Number(latest_u64))
-                .await {
-                    Ok(r) => r,
-                    Err(e) => {
-                        log::error!("Failed to fetch events for block ({:#}-{:#}): {:#}", from_u64, latest_u64, e);
-                        need_cool_down = true;
-                        continue;
-                    }
-                };
+                .await
+            {
+                Ok(r) => r,
+                Err(e) => {
+                    log::error!(
+                        "Failed to fetch events for block ({:#}-{:#}): {:#}",
+                        from_u64,
+                        latest_u64,
+                        e
+                    );
+                    need_cool_down = true;
+                    continue;
+                }
+            };
 
             // log::debug!("blocks events: {:?}", blocks_events);
 
             for (block_number, events) in blocks_events {
                 match self.process_events(block_number, events).await {
                     Ok(_) => (),
                     Err(e) => {
-                        log::error!("Failed to process events for block {:#}: {:#}", block_number, e);
+                        log::error!(
+                            "Failed to process events for block {:#}: {:#}",
+                            block_number,
+                            e
+                        );
                         need_cool_down = true;
                         continue;
                     }
@@ -205,12 +224,13 @@ where
                         }
 
                         if ev.label == EventLabel::WithdrawCompletedL2 {
-                            self.store.insert_request(ev.tx_hash.clone(), req.clone()).await?;
+                            self.store
+                                .insert_request(ev.tx_hash.clone(), req.clone())
+                                .await?;
                         }
 
                         if ev.label == EventLabel::DepositInitiatedL2 {
-                            self
-                                .store
+                            self.store
                                 .insert_pending_withdraw(PendingWithdraw {
                                     req_hash: req.clone().hash,
                                     tx_hash: ev.tx_hash,

apps/indexer/src/storage/mongo/mod.rs

@@ -1,13 +1,12 @@
-use super::StarknetBridgeRequest;
 use super::PendingWithdraw;
+use super::StarknetBridgeRequest;
 
 use crate::storage::{
     BlockIndex, BridgeChain, CrossChainTx, CrossChainTxKind, Event, EventLabel, Request,
 };
 use anyhow::Result;
 use mongodb::{bson::Bson, options::ClientOptions, Client, Collection};
 
-
 mod block_store;
 mod event_store;
 mod pending_withdraw_store;

apps/indexer/src/utils.rs

@@ -49,16 +49,22 @@ mod tests {
     pub fn test_normalize_hex() {
         let s = "0x123456";
         let r = normalize_hex(s).unwrap();
-        assert_eq!(r, "0x0000000000000000000000000000000000000000000000000000000000123456");
+        assert_eq!(
+            r,
+            "0x0000000000000000000000000000000000000000000000000000000000123456"
+        );
 
         let s = "0x1212121212121212121212121212121212121212121212121212121212121212";
         let r = normalize_hex(s).unwrap();
         assert_eq!(r, s);
-        
+
         // support ethereum checksum address
         let s = "0x8c7173Db918EB0f015ba2D319E94e1EaB95c63fb";
         let r = normalize_hex(s).unwrap();
-        assert_eq!(r, "0x0000000000000000000000008c7173db918eb0f015ba2d319e94e1eab95c63fb");
+        assert_eq!(
+            r,
+            "0x0000000000000000000000008c7173db918eb0f015ba2d319e94e1eab95c63fb"
+        );
     }
 
     #[test]
@@ -70,7 +76,7 @@ mod tests {
         let s = "0x1212121212121212121212121212121212121212121212121212121212121212";
         let r = denormalize_hex(s).unwrap();
         assert_eq!(r, s);
-        
+
         // support ethereum checksum address
         let s = "0x0000000000000000000000008c7173db918eb0f015ba2d319e94e1eab95c63fb";
         let r = denormalize_hex(s).unwrap();