just format

Author: gemcoder21

apps/api/src/assets/cilent.rs

@@ -18,10 +18,7 @@ impl AssetsClient {
 
     pub fn add_assets(&self, assets: Vec<Asset>) -> Result<usize, Box<dyn Error + Send + Sync>> {
         let assets = assets.into_iter().map(|x| x.as_basic_primitive()).collect();
-        self.database
-            .assets()?
-            .add_assets(assets)
-            .map_err(|e| Box::new(e) as Box<dyn Error + Send + Sync>)
+        self.database.assets()?.add_assets(assets).map_err(|e| Box::new(e) as Box<dyn Error + Send + Sync>)
     }
 
     #[allow(unused)]
@@ -37,20 +34,12 @@ impl AssetsClient {
         Ok(self.database.assets()?.get_asset_full(asset_id)?)
     }
 
-    pub fn get_assets_by_device_id(
-        &self,
-        device_id: &str,
-        wallet_index: i32,
-        from_timestamp: Option<u32>,
-    ) -> Result<Vec<AssetId>, Box<dyn Error + Send + Sync>> {
+    pub fn get_assets_by_device_id(&self, device_id: &str, wallet_index: i32, from_timestamp: Option<u32>) -> Result<Vec<AssetId>, Box<dyn Error + Send + Sync>> {
         let subscriptions = self.database.subscriptions()?.get_subscriptions_by_device_id(device_id, Some(wallet_index))?;
 
         let chain_addresses = subscriptions.into_iter().map(|x| ChainAddress::new(x.chain, x.address)).collect();
 
-        Ok(self
-            .database
-            .assets_addresses()?
-            .get_assets_by_addresses(chain_addresses, from_timestamp, true)?)
+        Ok(self.database.assets_addresses()?.get_assets_by_addresses(chain_addresses, from_timestamp, true)?)
     }
 }
 
@@ -68,14 +57,7 @@ impl SearchClient {
 
         let assets: Vec<AssetDocument> = self
             .client
-            .search(
-                ASSETS_INDEX_NAME,
-                &request.query,
-                &build_filter(filters),
-                [].as_ref(),
-                request.limit,
-                request.offset,
-            )
+            .search(ASSETS_INDEX_NAME, &request.query, &build_filter(filters), [].as_ref(), request.limit, request.offset)
             .await?;
 
         Ok(assets.into_iter().map(|x| AssetBasic::new(x.asset, x.properties, x.score)).collect())
@@ -84,14 +66,7 @@ impl SearchClient {
     pub async fn get_perpetuals_search(&self, request: &SearchRequest) -> Result<Vec<Perpetual>, Box<dyn Error + Send + Sync>> {
         let perpetuals: Vec<PerpetualDocument> = self
             .client
-            .search(
-                PERPETUALS_INDEX_NAME,
-                &request.query,
-                &build_filter(vec![]),
-                [].as_ref(),
-                request.limit,
-                request.offset,
-            )
+            .search(PERPETUALS_INDEX_NAME, &request.query, &build_filter(vec![]), [].as_ref(), request.limit, request.offset)
             .await?;
 
         Ok(perpetuals.into_iter().map(|x| x.perpetual).collect())
@@ -100,14 +75,7 @@ impl SearchClient {
     pub async fn get_nfts_search(&self, request: &SearchRequest) -> Result<Vec<NFTCollection>, Box<dyn Error + Send + Sync>> {
         let nfts: Vec<NFTDocument> = self
             .client
-            .search(
-                NFTS_INDEX_NAME,
-                &request.query,
-                &build_filter(vec![]),
-                [].as_ref(),
-                request.limit,
-                request.offset,
-            )
+            .search(NFTS_INDEX_NAME, &request.query, &build_filter(vec![]), [].as_ref(), request.limit, request.offset)
             .await?;
 
         Ok(nfts.into_iter().map(|x| x.collection).collect())

apps/api/src/assets/mod.rs

@@ -30,10 +30,7 @@ pub async fn add_asset(
     let asset = chain_client
         .lock()
         .await
-        .get_token_data(
-            asset_id.chain,
-            asset_id.token_id.clone().ok_or(ApiError::BadRequest("Missing token_id".to_string()))?,
-        )
+        .get_token_data(asset_id.chain, asset_id.token_id.clone().ok_or(ApiError::BadRequest("Missing token_id".to_string()))?)
         .await?;
     client.lock().await.add_assets(vec![asset.clone()])?;
 

apps/api/src/chain/balance.rs

@@ -13,21 +13,13 @@ pub async fn get_balances_coin(chain: ChainParam, address: AddressParam, client:
 }
 
 #[get("/chain/balances/<chain>/<address>/assets")]
-pub async fn get_balances_assets(
-    chain: ChainParam,
-    address: AddressParam,
-    client: &State<Mutex<ChainClient>>,
-) -> Result<ApiResponse<Vec<AssetBalance>>, ApiError> {
+pub async fn get_balances_assets(chain: ChainParam, address: AddressParam, client: &State<Mutex<ChainClient>>) -> Result<ApiResponse<Vec<AssetBalance>>, ApiError> {
     let request = ChainAddress::new(chain.0, address.0);
     Ok(client.lock().await.get_balances_assets(request).await?.into())
 }
 
 #[get("/chain/balances/<chain>/<address>/staking")]
-pub async fn get_balances_staking(
-    chain: ChainParam,
-    address: AddressParam,
-    client: &State<Mutex<ChainClient>>,
-) -> Result<ApiResponse<Option<AssetBalance>>, ApiError> {
+pub async fn get_balances_staking(chain: ChainParam, address: AddressParam, client: &State<Mutex<ChainClient>>) -> Result<ApiResponse<Option<AssetBalance>>, ApiError> {
     let request = ChainAddress::new(chain.0, address.0);
     Ok(client.lock().await.get_balances_staking(request).await?.into())
 }

apps/api/src/chain/client.rs

@@ -40,12 +40,7 @@ impl ChainClient {
         self.providers.get_staking_apy(chain).await
     }
 
-    pub async fn get_block_transactions(
-        &self,
-        chain: Chain,
-        block_number: i64,
-        transaction_type: Option<&str>,
-    ) -> Result<Vec<Transaction>, Box<dyn Error + Send + Sync>> {
+    pub async fn get_block_transactions(&self, chain: Chain, block_number: i64, transaction_type: Option<&str>) -> Result<Vec<Transaction>, Box<dyn Error + Send + Sync>> {
         let transactions = self.providers.get_block_transactions(chain, block_number as u64).await?;
         Ok(self.filter_transactions(transactions, transaction_type))
     }

apps/api/src/chain/transaction.rs

@@ -24,12 +24,7 @@ pub async fn get_block_transactions(
     transaction_type: Option<&str>,
     client: &State<Mutex<ChainClient>>,
 ) -> Result<ApiResponse<Vec<Transaction>>, ApiError> {
-    Ok(client
-        .lock()
-        .await
-        .get_block_transactions(chain.0, block_number, transaction_type)
-        .await?
-        .into())
+    Ok(client.lock().await.get_block_transactions(chain.0, block_number, transaction_type).await?.into())
 }
 
 #[get("/chain/blocks/<chain>/<block_number>/finalize?<address>&<transaction_type>")]

apps/api/src/fiat/client.rs

@@ -61,11 +61,7 @@ impl FiatQuotesClient {
         self.fiat_client.get_off_ramp_assets().await
     }
 
-    pub async fn process_and_publish_webhook(
-        &self,
-        provider: &str,
-        webhook_data: serde_json::Value,
-    ) -> Result<streamer::FiatWebhookPayload, Box<dyn Error + Send + Sync>> {
+    pub async fn process_and_publish_webhook(&self, provider: &str, webhook_data: serde_json::Value) -> Result<streamer::FiatWebhookPayload, Box<dyn Error + Send + Sync>> {
         self.fiat_client.process_and_publish_webhook(provider, webhook_data).await
     }
 

apps/api/src/fiat/mod.rs

@@ -70,11 +70,7 @@ pub async fn get_fiat_quotes_by_type(
 }
 
 #[post("/fiat/quotes/url", data = "<request>")]
-pub async fn get_fiat_quote_url(
-    request: Json<FiatQuoteUrlRequest>,
-    ip: std::net::IpAddr,
-    client: &State<Mutex<FiatQuotesClient>>,
-) -> Result<ApiResponse<FiatQuoteUrl>, ApiError> {
+pub async fn get_fiat_quote_url(request: Json<FiatQuoteUrlRequest>, ip: std::net::IpAddr, client: &State<Mutex<FiatQuotesClient>>) -> Result<ApiResponse<FiatQuoteUrl>, ApiError> {
     let ip_address = if cfg!(debug_assertions) { DEBUG_FIAT_IP } else { &ip.to_string() };
     let (url, quote) = client.lock().await.get_quote_url(&request, ip_address).await?;
     metrics_fiat_quote_url(&quote);
@@ -96,16 +92,7 @@ pub async fn get_fiat_on_ramp_quotes(
     Ok(client
         .lock()
         .await
-        .get_quotes_old(
-            &asset_id.0,
-            Some(amount),
-            None,
-            FiatQuoteType::Buy,
-            currency,
-            &wallet_address.0,
-            &ip_addr,
-            provider,
-        )
+        .get_quotes_old(&asset_id.0, Some(amount), None, FiatQuoteType::Buy, currency, &wallet_address.0, &ip_addr, provider)
         .await?
         .into())
 }
@@ -132,20 +119,12 @@ pub async fn get_fiat_off_ramp_assets(client: &State<Mutex<FiatQuotesClient>>) -
 }
 
 #[post("/fiat/webhooks/<provider>", data = "<webhook_data>")]
-pub async fn create_fiat_webhook(
-    provider: &str,
-    webhook_data: Json<serde_json::Value>,
-    client: &State<Mutex<FiatQuotesClient>>,
-) -> Result<ApiResponse<FiatWebhook>, ApiError> {
+pub async fn create_fiat_webhook(provider: &str, webhook_data: Json<serde_json::Value>, client: &State<Mutex<FiatQuotesClient>>) -> Result<ApiResponse<FiatWebhook>, ApiError> {
     Ok(client.lock().await.process_and_publish_webhook(provider, webhook_data.0).await?.payload.into())
 }
 
 #[get("/fiat/orders/<provider>/<order_id>")]
-pub async fn get_fiat_order(
-    provider: &str,
-    order_id: &str,
-    client: &State<Mutex<FiatQuotesClient>>,
-) -> Result<ApiResponse<primitives::FiatTransaction>, ApiError> {
+pub async fn get_fiat_order(provider: &str, order_id: &str, client: &State<Mutex<FiatQuotesClient>>) -> Result<ApiResponse<primitives::FiatTransaction>, ApiError> {
     Ok(client.lock().await.get_order_status(provider, order_id).await?.into())
 }
 

apps/api/src/main.rs

@@ -109,10 +109,7 @@ async fn rocket_api(settings: Settings) -> Rocket<Build> {
     let webhooks_client = WebhooksClient::new(stream_producer.clone());
     let support_client = SupportClient::new(database.clone());
     let ip_check_providers: Vec<Arc<dyn IpCheckProvider>> = vec![
-        Arc::new(AbuseIPDBClient::new(
-            settings.ip.abuseipdb.url.clone(),
-            settings.ip.abuseipdb.key.secret.clone(),
-        )),
+        Arc::new(AbuseIPDBClient::new(settings.ip.abuseipdb.url.clone(), settings.ip.abuseipdb.key.secret.clone())),
         Arc::new(IpApiClient::new(settings.ip.ipapi.url.clone(), settings.ip.ipapi.key.secret.clone())),
     ];
     let ip_security_client = IpSecurityClient::new(ip_check_providers, cacher_client.clone());

apps/api/src/metrics/parser.rs

@@ -33,27 +33,17 @@ pub fn init_parser_metrics(registry: &mut Registry) {
 }
 
 pub fn update_parser_metrics(database: &Database) {
-    let states = database
-        .client()
-        .ok()
-        .and_then(|mut c| c.parser_state().get_parser_states().ok())
-        .unwrap_or_default();
+    let states = database.client().ok().and_then(|mut c| c.parser_state().get_parser_states().ok()).unwrap_or_default();
 
     for state in states {
         if let Some(current_block) = PARSER_CURRENT_BLOCK.get() {
-            current_block
-                .get_or_create(&ParserStateLabels { chain: state.clone().chain })
-                .set(state.current_block);
+            current_block.get_or_create(&ParserStateLabels { chain: state.clone().chain }).set(state.current_block);
         }
         if let Some(latest_block) = PARSER_LATEST_BLOCK.get() {
-            latest_block
-                .get_or_create(&ParserStateLabels { chain: state.clone().chain })
-                .set(state.latest_block);
+            latest_block.get_or_create(&ParserStateLabels { chain: state.clone().chain }).set(state.latest_block);
         }
         if let Some(is_enabled) = PARSER_IS_ENABLED.get() {
-            is_enabled
-                .get_or_create(&ParserStateLabels { chain: state.clone().chain })
-                .set(state.is_enabled as i64);
+            is_enabled.get_or_create(&ParserStateLabels { chain: state.clone().chain }).set(state.is_enabled as i64);
         }
         if let Some(updated_at) = PARSER_UPDATED_AT.get() {
             updated_at

apps/api/src/nft/mod.rs

@@ -13,11 +13,7 @@ use std::io::Cursor;
 // by device
 
 #[get("/nft/assets/device/<device_id>?<wallet_index>")]
-pub async fn get_nft_assets_old(
-    device_id: DeviceIdParam,
-    wallet_index: i32,
-    client: &State<Mutex<NFTClient>>,
-) -> Result<ApiResponse<ResponseResultNew<Vec<NFTData>>>, ApiError> {
+pub async fn get_nft_assets_old(device_id: DeviceIdParam, wallet_index: i32, client: &State<Mutex<NFTClient>>) -> Result<ApiResponse<ResponseResultNew<Vec<NFTData>>>, ApiError> {
     Ok(ResponseResultNew::new(client.lock().await.get_nft_assets(&device_id.0, wallet_index).await?).into())
 }
 
@@ -29,11 +25,7 @@ pub async fn get_nft_assets_v2(device_id: DeviceIdParam, wallet_index: i32, clie
 // by address. mostly for testing purposes
 
 #[get("/nft/assets/chain/<chain>?<address>")]
-pub async fn get_nft_assets_by_chain(
-    chain: ChainParam,
-    address: AddressParam,
-    client: &State<Mutex<NFTClient>>,
-) -> Result<ApiResponse<Vec<NFTData>>, ApiError> {
+pub async fn get_nft_assets_by_chain(chain: ChainParam, address: AddressParam, client: &State<Mutex<NFTClient>>) -> Result<ApiResponse<Vec<NFTData>>, ApiError> {
     Ok(client.lock().await.get_nft_assets_by_chain(chain.0, &address.0).await?.into())
 }
 
@@ -85,12 +77,7 @@ pub async fn report_nft(request: Json<ReportNft>, client: &State<Mutex<NFTClient
     Ok(client
         .lock()
         .await
-        .report_nft(
-            &request.device_id,
-            request.collection_id.clone(),
-            request.asset_id.clone(),
-            request.reason.clone(),
-        )?
+        .report_nft(&request.device_id, request.collection_id.clone(), request.asset_id.clone(), request.reason.clone())?
         .into())
 }