diff --git a/rust/api-server/api/src/buildings/mod.rs b/rust/api-server/api/src/buildings/mod.rs
index ab41a22..bb50bfc 100644
--- a/rust/api-server/api/src/buildings/mod.rs
+++ b/rust/api-server/api/src/buildings/mod.rs
@@ -20,7 +20,6 @@ use service::Query as QueryCore;
 use std::collections::{HashMap, HashSet};
 use std::fs::File;
 use std::ops::Add;
-use std::path::PathBuf;
 use std::time::Duration;
 use struson::json_path;
 use struson::reader::{JsonReader, JsonStreamReader};
@@ -189,7 +188,7 @@ pub(crate) async fn find_building_state(
 
 #[allow(dead_code)]
 pub(crate) async fn load_building_state_from_file(
-    storage_path: &PathBuf,
+    storage_path: &std::path::Path,
 ) -> anyhow::Result<Vec<building_state::Model>> {
     let building_states: Vec<building_state::Model> = {
         let item_file = File::open(storage_path.join("State/BuildingState.json"))?;
@@ -234,7 +233,7 @@ pub(crate) async fn load_state_from_spacetimedb(
     let building_descs =
         load_building_state_from_spacetimedb(client, domain, protocol, database).await?;
 
-    import_building_state(&conn, building_descs, None).await?;
+    import_building_state(conn, building_descs, None).await?;
 
     Ok(())
 }
@@ -279,7 +278,7 @@ pub(crate) async fn import_building_state(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         db_insert_building_state(conn, &mut buffer_before_insert, &on_conflict).await?;
         info!("building_state last batch imported");
     }
@@ -288,7 +287,7 @@ pub(crate) async fn import_building_state(
         start.elapsed().as_secs()
     );
 
-    if known_building_state_ids.len() > 0 {
+    if !known_building_state_ids.is_empty() {
         delete_building_state(conn, known_building_state_ids).await?;
     }
 
@@ -349,24 +348,16 @@ async fn db_insert_building_state(
 
     let things_to_insert = buffer_before_insert
         .iter()
-        .filter(|building_state| {
-            match building_state_from_db_map.get(&building_state.entity_id) {
-                Some(building_state_from_db) => {
-                    if building_state_from_db != *building_state {
-                        return true;
-                    }
-                }
-                None => {
-                    return true;
-                }
-            }
-
-            return false;
-        })
+        .filter(
+            |building_state| match building_state_from_db_map.get(&building_state.entity_id) {
+                Some(building_state_from_db) => building_state_from_db != *building_state,
+                None => true,
+            },
+        )
         .map(|building_state| building_state.clone().into_active_model())
         .collect::<Vec<building_state::ActiveModel>>();
 
-    if things_to_insert.len() == 0 {
+    if things_to_insert.is_empty() {
         debug!("Nothing to insert");
         buffer_before_insert.clear();
         return Ok(());
@@ -386,7 +377,7 @@ async fn db_insert_building_state(
 
 #[allow(dead_code)]
 pub(crate) async fn load_building_desc_from_file(
-    storage_path: &PathBuf,
+    storage_path: &std::path::Path,
 ) -> anyhow::Result<Vec<building_desc::Model>> {
     let building_descs: Vec<building_desc::Model> = {
         let item_file = File::open(storage_path.join("Desc/BuildingDesc.json"))?;
@@ -411,7 +402,7 @@ async fn delete_building_descs(
     Ok(())
 }
 
-pub async fn import_job_building_desc(temp_config: Config) -> () {
+pub async fn import_job_building_desc(temp_config: Config) {
     let config = temp_config.clone();
     if config.live_updates {
         let conn = super::create_importer_default_db_connection(config.clone()).await;
@@ -465,7 +456,7 @@ fn import_internal_building_state(config: Config, conn: DatabaseConnection, clie
 
 pub(crate) async fn handle_transaction_update(
     p0: &DatabaseConnection,
-    tables: &Vec<TableWithOriginalEventTransactionUpdate>,
+    tables: &[TableWithOriginalEventTransactionUpdate],
 ) -> anyhow::Result<()> {
     let on_conflict = sea_query::OnConflict::column(building_state::Column::EntityId)
         .update_columns([
@@ -485,7 +476,7 @@ pub(crate) async fn handle_transaction_update(
             match serde_json::from_str::<building_state::Model>(row.as_ref()) {
                 Ok(building_state) => {
                     let current_building_state =
-                        QueryCore::find_building_state_by_id(&p0, building_state.entity_id).await?;
+                        QueryCore::find_building_state_by_id(p0, building_state.entity_id).await?;
 
                     if current_building_state.is_some() {
                         let current_building_state = current_building_state.unwrap();
@@ -507,7 +498,9 @@ pub(crate) async fn handle_transaction_update(
                         .await?;
                     }
                 }
-                Err(_) => {}
+                Err(error) => {
+                    error!("TransactionUpdate Insert BuildingState Error: {error}");
+                }
             }
         }
     }
@@ -521,7 +514,7 @@ pub(crate) async fn handle_transaction_update(
                     }
 
                     let current_building_state =
-                        QueryCore::find_building_state_by_id(&p0, building_state.entity_id).await?;
+                        QueryCore::find_building_state_by_id(p0, building_state.entity_id).await?;
 
                     if current_building_state.is_some() {
                         let _ = building_state::Entity::delete_many()
@@ -530,7 +523,9 @@ pub(crate) async fn handle_transaction_update(
                             .await?;
                     }
                 }
-                Err(_) => {}
+                Err(error) => {
+                    error!("TransactionUpdate Insert BuildingState Error: {error}");
+                }
             }
         }
     }
@@ -552,7 +547,7 @@ pub(crate) async fn handle_initial_subscription(
         ])
         .to_owned();
 
-    let chunk_size = Some(5000);
+    let chunk_size = 5000;
     let mut buffer_before_insert: Vec<building_state::Model> = vec![];
 
     let mut known_building_state_ids = get_known_building_state_ids(p0).await?;
@@ -564,7 +559,7 @@ pub(crate) async fn handle_initial_subscription(
                         known_building_state_ids.remove(&building_state.entity_id);
                     }
                     buffer_before_insert.push(building_state);
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(5000) {
+                    if buffer_before_insert.len() == chunk_size {
                         db_insert_building_state(p0, &mut buffer_before_insert, &on_conflict)
                             .await?;
                     }
@@ -576,13 +571,13 @@ pub(crate) async fn handle_initial_subscription(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         for buffer_chnk in buffer_before_insert.chunks(5000) {
             db_insert_building_state(p0, &mut buffer_chnk.to_vec(), &on_conflict).await?;
         }
     }
 
-    if known_building_state_ids.len() > 0 {
+    if !known_building_state_ids.is_empty() {
         delete_building_state(p0, known_building_state_ids).await?;
     }
 
diff --git a/rust/api-server/api/src/cargo_desc/mod.rs b/rust/api-server/api/src/cargo_desc/mod.rs
index 5f9216b..911368c 100644
--- a/rust/api-server/api/src/cargo_desc/mod.rs
+++ b/rust/api-server/api/src/cargo_desc/mod.rs
@@ -8,7 +8,6 @@ use serde_json::Value;
 use std::collections::HashMap;
 use std::fs::File;
 use std::ops::Add;
-use std::path::PathBuf;
 use std::time::Duration;
 use struson::json_path;
 use struson::reader::{JsonReader, JsonStreamReader};
@@ -95,24 +94,16 @@ pub(crate) async fn import_cargo_description(
 
             let things_to_insert = buffer_before_insert
                 .iter()
-                .filter(|cargo_desc| {
-                    match cargo_desc_from_db_map.get(&cargo_desc.id) {
-                        Some(cargo_desc_from_db) => {
-                            if cargo_desc_from_db != *cargo_desc {
-                                return true;
-                            }
-                        }
-                        None => {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                })
+                .filter(
+                    |cargo_desc| match cargo_desc_from_db_map.get(&cargo_desc.id) {
+                        Some(cargo_desc_from_db) => cargo_desc_from_db != *cargo_desc,
+                        None => true,
+                    },
+                )
                 .map(|cargo_desc| cargo_desc.clone().into_active_model())
                 .collect::<Vec<cargo_desc::ActiveModel>>();
 
-            if things_to_insert.len() == 0 {
+            if things_to_insert.is_empty() {
                 debug!("Nothing to insert");
                 buffer_before_insert.clear();
                 continue;
@@ -124,8 +115,8 @@ pub(crate) async fn import_cargo_description(
                 let cargo_desc_in = cargo_desc_to_delete
                     .iter()
                     .position(|id| id == cargo_desc.id.as_ref());
-                if cargo_desc_in.is_some() {
-                    cargo_desc_to_delete.remove(cargo_desc_in.unwrap());
+                if let Some(cargo_desc_in) = cargo_desc_in {
+                    cargo_desc_to_delete.remove(cargo_desc_in);
                 }
             }
 
@@ -138,7 +129,7 @@ pub(crate) async fn import_cargo_description(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         let cargo_desc_from_db = cargo_desc::Entity::find()
             .filter(
                 cargo_desc::Column::Id.is_in(
@@ -158,24 +149,16 @@ pub(crate) async fn import_cargo_description(
 
         let things_to_insert = buffer_before_insert
             .iter()
-            .filter(|cargo_desc| {
-                match cargo_desc_from_db_map.get(&cargo_desc.id) {
-                    Some(cargo_desc_from_db) => {
-                        if cargo_desc_from_db != *cargo_desc {
-                            return true;
-                        }
-                    }
-                    None => {
-                        return true;
-                    }
-                }
-
-                return false;
-            })
+            .filter(
+                |cargo_desc| match cargo_desc_from_db_map.get(&cargo_desc.id) {
+                    Some(cargo_desc_from_db) => cargo_desc_from_db != *cargo_desc,
+                    None => true,
+                },
+            )
             .map(|cargo_desc| cargo_desc.clone().into_active_model())
             .collect::<Vec<cargo_desc::ActiveModel>>();
 
-        if things_to_insert.len() == 0 {
+        if things_to_insert.is_empty() {
             debug!("Nothing to insert");
             buffer_before_insert.clear();
         } else {
@@ -194,7 +177,7 @@ pub(crate) async fn import_cargo_description(
         start.elapsed().as_secs()
     );
 
-    if cargo_desc_to_delete.len() > 0 {
+    if !cargo_desc_to_delete.is_empty() {
         info!("cargo_desc's to delete: {:?}", cargo_desc_to_delete);
         cargo_desc::Entity::delete_many()
             .filter(cargo_desc::Column::Id.is_in(cargo_desc_to_delete))
@@ -207,7 +190,7 @@ pub(crate) async fn import_cargo_description(
 
 #[allow(dead_code)]
 pub(crate) async fn load_cargo_description_from_file(
-    storage_path: &PathBuf,
+    storage_path: &std::path::Path,
 ) -> anyhow::Result<Vec<cargo_desc::Model>> {
     let cargo_descriptions: Vec<cargo_desc::Model> = {
         let item_file = File::open(storage_path.join("Desc/CargoDesc.json"))?;
@@ -259,12 +242,12 @@ pub(crate) async fn load_desc_from_spacetimedb(
     let cargo_descriptions =
         load_cargo_description_from_spacetimedb(client, domain, protocol, database).await?;
 
-    import_cargo_description(&conn, cargo_descriptions, None).await?;
+    import_cargo_description(conn, cargo_descriptions, None).await?;
 
     Ok(())
 }
 
-pub async fn import_job_cargo_desc(temp_config: Config) -> () {
+pub async fn import_job_cargo_desc(temp_config: Config) {
     let config = temp_config.clone();
     if config.live_updates {
         let conn = super::create_importer_default_db_connection(config.clone()).await;
diff --git a/rust/api-server/api/src/claim_tech_desc/mod.rs b/rust/api-server/api/src/claim_tech_desc/mod.rs
index b660883..f578270 100644
--- a/rust/api-server/api/src/claim_tech_desc/mod.rs
+++ b/rust/api-server/api/src/claim_tech_desc/mod.rs
@@ -8,7 +8,6 @@ use serde_json::Value;
 use std::collections::HashMap;
 use std::fs::File;
 use std::ops::Add;
-use std::path::PathBuf;
 use std::time::Duration;
 use struson::json_path;
 use struson::reader::{JsonReader, JsonStreamReader};
@@ -16,7 +15,7 @@ use tokio::time::Instant;
 
 #[allow(dead_code)]
 pub(crate) async fn load_claim_tech_desc_from_file(
-    storage_path: &PathBuf,
+    storage_path: &std::path::Path,
 ) -> anyhow::Result<Vec<claim_tech_desc::Model>> {
     let item_file = File::open(storage_path.join("Desc/ClaimTechDesc.json"))?;
     let claim_tech_desc: Value = serde_json::from_reader(&item_file)?;
@@ -57,7 +56,7 @@ pub(crate) async fn load_claim_tech_desc(
 ) -> anyhow::Result<()> {
     let claim_tech_descs =
         load_claim_tech_desc_from_spacetimedb(client, domain, protocol, database).await?;
-    import_claim_tech_desc(&conn, claim_tech_descs, None).await?;
+    import_claim_tech_desc(conn, claim_tech_descs, None).await?;
     Ok(())
 }
 
@@ -134,21 +133,15 @@ pub(crate) async fn import_claim_tech_desc(
                 .filter(|claim_tech_desc| {
                     match claim_tech_desc_from_db_map.get(&claim_tech_desc.id) {
                         Some(claim_tech_desc_from_db) => {
-                            if claim_tech_desc_from_db != *claim_tech_desc {
-                                return true;
-                            }
-                        }
-                        None => {
-                            return true;
+                            claim_tech_desc_from_db != *claim_tech_desc
                         }
+                        None => true,
                     }
-
-                    return false;
                 })
                 .map(|claim_tech_desc| claim_tech_desc.clone().into_active_model())
                 .collect::<Vec<claim_tech_desc::ActiveModel>>();
 
-            if things_to_insert.len() == 0 {
+            if things_to_insert.is_empty() {
                 debug!("Nothing to insert");
                 buffer_before_insert.clear();
                 continue;
@@ -160,8 +153,8 @@ pub(crate) async fn import_claim_tech_desc(
                 let claim_tech_desc_in = claim_tech_desc_to_delete
                     .iter()
                     .position(|id| id == claim_tech_desc.id.as_ref());
-                if claim_tech_desc_in.is_some() {
-                    claim_tech_desc_to_delete.remove(claim_tech_desc_in.unwrap());
+                if let Some(claim_tech_desc_in) = claim_tech_desc_in {
+                    claim_tech_desc_to_delete.remove(claim_tech_desc_in);
                 }
             }
 
@@ -174,7 +167,7 @@ pub(crate) async fn import_claim_tech_desc(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         let claim_tech_desc_from_db = claim_tech_desc::Entity::find()
             .filter(
                 claim_tech_desc::Column::Id.is_in(
@@ -194,24 +187,16 @@ pub(crate) async fn import_claim_tech_desc(
 
         let things_to_insert = buffer_before_insert
             .iter()
-            .filter(|claim_tech_desc| {
-                match claim_tech_desc_from_db_map.get(&claim_tech_desc.id) {
-                    Some(claim_tech_desc_from_db) => {
-                        if claim_tech_desc_from_db != *claim_tech_desc {
-                            return true;
-                        }
-                    }
-                    None => {
-                        return true;
-                    }
-                }
-
-                return false;
-            })
+            .filter(
+                |claim_tech_desc| match claim_tech_desc_from_db_map.get(&claim_tech_desc.id) {
+                    Some(claim_tech_desc_from_db) => claim_tech_desc_from_db != *claim_tech_desc,
+                    None => true,
+                },
+            )
             .map(|claim_tech_desc| claim_tech_desc.clone().into_active_model())
             .collect::<Vec<claim_tech_desc::ActiveModel>>();
 
-        if things_to_insert.len() == 0 {
+        if things_to_insert.is_empty() {
             debug!("Nothing to insert");
             buffer_before_insert.clear();
         } else {
@@ -230,7 +215,7 @@ pub(crate) async fn import_claim_tech_desc(
         start.elapsed().as_secs()
     );
 
-    if claim_tech_desc_to_delete.len() > 0 {
+    if !claim_tech_desc_to_delete.is_empty() {
         info!(
             "claim_tech_desc's to delete: {:?}",
             claim_tech_desc_to_delete
@@ -269,7 +254,7 @@ fn import_interal_claim_tech_desc(config: Config, conn: DatabaseConnection, clie
     });
 }
 
-pub async fn import_job_claim_tech_desc(temp_config: Config) -> () {
+pub async fn import_job_claim_tech_desc(temp_config: Config) {
     let config = temp_config.clone();
     if config.live_updates {
         let conn = super::create_importer_default_db_connection(config.clone()).await;
diff --git a/rust/api-server/api/src/claim_tech_state/mod.rs b/rust/api-server/api/src/claim_tech_state/mod.rs
index 689f571..46f6134 100644
--- a/rust/api-server/api/src/claim_tech_state/mod.rs
+++ b/rust/api-server/api/src/claim_tech_state/mod.rs
@@ -10,11 +10,10 @@ use serde_json::Value;
 use service::Query as QueryCore;
 use std::collections::{HashMap, HashSet};
 use std::fs::File;
-use std::path::PathBuf;
 
 #[allow(dead_code)]
 pub(crate) async fn load_claim_tech_state_from_file(
-    storage_path: &PathBuf,
+    storage_path: &std::path::Path,
 ) -> anyhow::Result<Vec<claim_tech_desc::Model>> {
     let item_file = File::open(storage_path.join("State/ClaimTechState.json"))?;
     let claim_tech_state: Value = serde_json::from_reader(&item_file)?;
@@ -72,22 +71,14 @@ async fn db_insert_claim_tech_state(
         .iter()
         .filter(|claim_tech_state| {
             match claim_tech_state_from_db_map.get(&claim_tech_state.entity_id) {
-                Some(claim_tech_state_from_db) => {
-                    if claim_tech_state_from_db != *claim_tech_state {
-                        return true;
-                    }
-                }
-                None => {
-                    return true;
-                }
+                Some(claim_tech_state_from_db) => claim_tech_state_from_db != *claim_tech_state,
+                None => true,
             }
-
-            return false;
         })
         .map(|claim_tech_state| claim_tech_state.clone().into_active_model())
         .collect::<Vec<claim_tech_state::ActiveModel>>();
 
-    if things_to_insert.len() == 0 {
+    if things_to_insert.is_empty() {
         debug!("Nothing to insert");
         buffer_before_insert.clear();
         return Ok(());
@@ -137,7 +128,7 @@ pub(crate) async fn handle_initial_subscription(
 ) -> anyhow::Result<()> {
     let on_conflict = get_claim_tech_state_on_conflict();
 
-    let chunk_size = Some(5000);
+    let chunk_size = 5000;
     let mut buffer_before_insert: Vec<claim_tech_state::Model> = vec![];
 
     let mut known_building_state_ids = get_known_claim_tech_state_ids(p0).await?;
@@ -149,7 +140,7 @@ pub(crate) async fn handle_initial_subscription(
                         known_building_state_ids.remove(&building_state.entity_id);
                     }
                     buffer_before_insert.push(building_state);
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(5000) {
+                    if buffer_before_insert.len() == chunk_size {
                         db_insert_claim_tech_state(p0, &mut buffer_before_insert, &on_conflict)
                             .await?;
                     }
@@ -161,13 +152,13 @@ pub(crate) async fn handle_initial_subscription(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         for buffer_chnk in buffer_before_insert.chunks(5000) {
             db_insert_claim_tech_state(p0, &mut buffer_chnk.to_vec(), &on_conflict).await?;
         }
     }
 
-    if known_building_state_ids.len() > 0 {
+    if !known_building_state_ids.is_empty() {
         delete_claim_tech_state(p0, known_building_state_ids).await?;
     }
 
@@ -176,7 +167,7 @@ pub(crate) async fn handle_initial_subscription(
 
 pub(crate) async fn handle_transaction_update(
     p0: &DatabaseConnection,
-    tables: &Vec<TableWithOriginalEventTransactionUpdate>,
+    tables: &[TableWithOriginalEventTransactionUpdate],
 ) -> anyhow::Result<()> {
     let on_conflict = get_claim_tech_state_on_conflict();
 
@@ -187,13 +178,11 @@ pub(crate) async fn handle_transaction_update(
         for row in p1.inserts.iter() {
             match serde_json::from_str::<claim_tech_state::Model>(row.as_ref()) {
                 Ok(building_state) => {
-                    let current_building_state = QueryCore::find_claim_tech_state_by_ids(
-                        &p0,
-                        vec![building_state.entity_id],
-                    )
-                    .await?;
+                    let current_building_state =
+                        QueryCore::find_claim_tech_state_by_ids(p0, vec![building_state.entity_id])
+                            .await?;
 
-                    if current_building_state.len() > 0 {
+                    if !current_building_state.is_empty() {
                         let current_building_state = current_building_state.first().unwrap();
                         if current_building_state != &building_state {
                             found_in_inserts.insert(building_state.entity_id);
@@ -239,7 +228,7 @@ pub(crate) async fn handle_transaction_update(
         }
     }
 
-    if ids_to_delete.len() > 0 {
+    if !ids_to_delete.is_empty() {
         delete_claim_tech_state(p0, ids_to_delete).await?;
     }
 
diff --git a/rust/api-server/api/src/claims/mod.rs b/rust/api-server/api/src/claims/mod.rs
index 673323e..da281a0 100644
--- a/rust/api-server/api/src/claims/mod.rs
+++ b/rust/api-server/api/src/claims/mod.rs
@@ -21,7 +21,6 @@ use service::{Query as QueryCore, sea_orm::DatabaseConnection};
 use std::cmp::Ordering;
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::fs::File;
-use std::path::PathBuf;
 use tokio::sync::mpsc::UnboundedSender;
 use tokio::task::JoinHandle;
 
@@ -170,6 +169,11 @@ pub(crate) async fn get_claim_tiles(
     ))
 }
 
+type ClaimLeaderboardTasks =
+    Vec<JoinHandle<Result<(String, Vec<LeaderboardSkill>), (StatusCode, &'static str)>>>;
+
+type FlatInventoryTasks = Vec<JoinHandle<anyhow::Result<(String, Vec<ExpendedRefrence>)>>>;
+
 pub(crate) async fn get_claim(
     state: State<std::sync::Arc<AppState>>,
     Path(id): Path<u64>,
@@ -185,7 +189,7 @@ pub(crate) async fn get_claim(
     let claim = claim.unwrap();
 
     let claim_tech_states =
-        QueryCore::find_claim_tech_state_by_ids(&state.conn, vec![claim.entity_id.clone()])
+        QueryCore::find_claim_tech_state_by_ids(&state.conn, vec![claim.entity_id])
             .await
             .expect("Cannot find claim tech states");
     let claim_tech_descs = QueryCore::all_claim_tech_desc(&state.conn)
@@ -194,7 +198,7 @@ pub(crate) async fn get_claim(
     let tier_upgrades = claim_tech_descs
         .iter()
         .filter(|desc| desc.description.starts_with("Tier "))
-        .map(|desc| desc.clone())
+        .cloned()
         .collect::<Vec<claim_tech_desc::Model>>();
     let tier_upgrades_ids = tier_upgrades
         .iter()
@@ -232,13 +236,10 @@ pub(crate) async fn get_claim(
 
         match claim_tech_state {
             Some(claim_tech_state) => {
-                claim.running_upgrade = match tier_upgrades
+                claim.running_upgrade = tier_upgrades
                     .iter()
                     .find(|desc| desc.id == (claim_tech_state.researching as i64))
-                {
-                    Some(tier) => Some(tier.clone()),
-                    None => None,
-                };
+                    .cloned();
                 claim.running_upgrade_started = Some(claim_tech_state.start_timestamp);
                 let learned: Vec<i64> = claim_tech_state.learned.clone();
                 claim.upgrades = learned
@@ -254,10 +255,10 @@ pub(crate) async fn get_claim(
                 let found_tiers = learned
                     .iter()
                     .filter(|id| tier_upgrades_ids.contains(&(**id)))
-                    .map(|id| id.clone())
+                    .copied()
                     .collect::<Vec<i64>>();
 
-                if found_tiers.len() > 0 {
+                if !found_tiers.is_empty() {
                     claim.tier = tier_upgrades
                         .iter()
                         .find(|desc| desc.id == (found_tiers[found_tiers.len() - 1]))
@@ -284,11 +285,7 @@ pub(crate) async fn get_claim(
             (StatusCode::INTERNAL_SERVER_ERROR, "")
         })?;
 
-    let mut tasks: Vec<
-        tokio::task::JoinHandle<
-            Result<(String, Vec<LeaderboardSkill>), (StatusCode, &'static str)>,
-        >,
-    > = vec![];
+    let mut tasks: ClaimLeaderboardTasks = vec![];
     let player_ids = claim
         .members
         .iter()
@@ -341,7 +338,7 @@ pub(crate) async fn get_claim(
                     player_id: entry.entity_id,
                     player_name,
                     experience: entry.experience,
-                    level: experience_to_level(entry.experience.clone() as i64),
+                    level: experience_to_level(entry.experience as i64),
                     rank: rank as u64,
                 });
             }
@@ -462,7 +459,7 @@ pub(crate) async fn get_claim(
         building_states,
     };
 
-    let mut jobs: Vec<JoinHandle<anyhow::Result<(String, Vec<ExpendedRefrence>)>>> = vec![];
+    let mut jobs: FlatInventoryTasks = vec![];
 
     let conn = state.conn.clone();
     let job_items = items.clone();
@@ -581,7 +578,7 @@ pub(crate) async fn list_claims(
     let tier_upgrades = claim_tech_descs
         .iter()
         .filter(|desc| desc.description.starts_with("Tier "))
-        .map(|desc| desc.clone())
+        .cloned()
         .collect::<Vec<claim_tech_desc::Model>>();
     let tier_upgrades_ids = tier_upgrades
         .iter()
@@ -598,13 +595,10 @@ pub(crate) async fn list_claims(
 
             match claim_tech_state {
                 Some(claim_tech_state) => {
-                    claim_description.running_upgrade = match tier_upgrades
+                    claim_description.running_upgrade = tier_upgrades
                         .iter()
                         .find(|desc| desc.id == (claim_tech_state.researching as i64))
-                    {
-                        Some(tier) => Some(tier.clone()),
-                        None => None,
-                    };
+                        .cloned();
                     let learned: Vec<i64> = claim_tech_state.learned.clone();
                     claim_description.upgrades = learned
                         .iter()
@@ -619,10 +613,10 @@ pub(crate) async fn list_claims(
                     let found_tiers = learned
                         .iter()
                         .filter(|id| tier_upgrades_ids.contains(&(**id)))
-                        .map(|id| id.clone())
+                        .cloned()
                         .collect::<Vec<i64>>();
 
-                    if found_tiers.len() > 0 {
+                    if !found_tiers.is_empty() {
                         claim_description.tier = tier_upgrades
                             .iter()
                             .find(|desc| desc.id == (found_tiers[found_tiers.len() - 1]))
@@ -669,7 +663,7 @@ pub(crate) async fn find_claim_descriptions(
 
 #[allow(dead_code)]
 pub(crate) async fn load_claim_description_state_from_file(
-    storage_path: &PathBuf,
+    storage_path: &std::path::Path,
 ) -> anyhow::Result<Vec<claim_description_state::Model>> {
     let item_file = File::open(storage_path.join("State/ClaimDescriptionState.json"))?;
     let claim_descriptions: Value = serde_json::from_reader(&item_file)?;
@@ -767,22 +761,14 @@ async fn db_insert_player_to_claim(
             match claim_description_from_db_map
                 .get(&(claim_description.claim_id, claim_description.player_id))
             {
-                Some(claim_description_from_db) => {
-                    if claim_description_from_db != *claim_description {
-                        return true;
-                    }
-                }
-                None => {
-                    return true;
-                }
+                Some(claim_description_from_db) => claim_description_from_db != *claim_description,
+                None => true,
             }
-
-            return false;
         })
         .map(|claim_description| claim_description.clone().into_active_model())
         .collect::<Vec<player_to_claim::ActiveModel>>();
 
-    if things_to_insert.len() == 0 {
+    if things_to_insert.is_empty() {
         debug!("Nothing to insert");
         buffer_before_insert.clear();
         return Ok(());
@@ -825,22 +811,14 @@ async fn db_insert_claim_description_state(
         .iter()
         .filter(|claim_description| {
             match claim_description_from_db_map.get(&claim_description.entity_id) {
-                Some(claim_description_from_db) => {
-                    if claim_description_from_db != *claim_description {
-                        return true;
-                    }
-                }
-                None => {
-                    return true;
-                }
+                Some(claim_description_from_db) => claim_description_from_db != *claim_description,
+                None => true,
             }
-
-            return false;
         })
         .map(|claim_description| claim_description.clone().into_active_model())
         .collect::<Vec<claim_description_state::ActiveModel>>();
 
-    if things_to_insert.len() == 0 {
+    if things_to_insert.is_empty() {
         debug!("Nothing to insert");
         buffer_before_insert.clear();
         return Ok(());
@@ -959,7 +937,7 @@ pub(crate) fn get_merged_inventories(
         }
     }
 
-    hashmap.into_iter().map(|(_, value)| value).collect()
+    hashmap.into_values().collect()
 }
 
 pub(crate) async fn handle_initial_subscription(
@@ -969,7 +947,7 @@ pub(crate) async fn handle_initial_subscription(
     let on_conflict = get_claim_description_state_on_conflict();
     let on_conflict_player_to_claim = get_player_to_claim_on_conflict();
 
-    let chunk_size = Some(5000);
+    let chunk_size = 5000;
     let mut buffer_before_insert: Vec<claim_description_state::Model> = vec![];
     let mut buffer_player_to_claim_before_insert: Vec<player_to_claim::Model> = vec![];
 
@@ -983,7 +961,7 @@ pub(crate) async fn handle_initial_subscription(
                         known_inventory_ids.remove(&building_state.entity_id);
                     }
                     buffer_before_insert.push(building_state.clone());
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(5000) {
+                    if buffer_before_insert.len() == chunk_size {
                         db_insert_claim_description_state(
                             p0,
                             &mut buffer_before_insert,
@@ -1009,7 +987,7 @@ pub(crate) async fn handle_initial_subscription(
                             });
                         },
                     );
-                    if buffer_player_to_claim_before_insert.len() == chunk_size.unwrap_or(5000) {
+                    if buffer_player_to_claim_before_insert.len() == chunk_size {
                         db_insert_player_to_claim(
                             p0,
                             &mut buffer_player_to_claim_before_insert,
@@ -1017,7 +995,7 @@ pub(crate) async fn handle_initial_subscription(
                         )
                         .await?;
                     }
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(5000) {
+                    if buffer_before_insert.len() == chunk_size {
                         db_insert_claim_description_state(
                             p0,
                             &mut buffer_before_insert,
@@ -1032,7 +1010,7 @@ pub(crate) async fn handle_initial_subscription(
             }
         }
     }
-    if buffer_player_to_claim_before_insert.len() > 0 {
+    if !buffer_player_to_claim_before_insert.is_empty() {
         db_insert_player_to_claim(
             p0,
             &mut buffer_player_to_claim_before_insert,
@@ -1041,17 +1019,17 @@ pub(crate) async fn handle_initial_subscription(
         .await?;
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         for buffer_chnk in buffer_before_insert.chunks(5000) {
             db_insert_claim_description_state(p0, &mut buffer_chnk.to_vec(), &on_conflict).await?;
         }
     }
 
-    if known_inventory_ids.len() > 0 {
+    if !known_inventory_ids.is_empty() {
         delete_claim_description_state(p0, known_inventory_ids).await?;
     }
 
-    if known_player_to_claim_ids.len() > 0 {
+    if !known_player_to_claim_ids.is_empty() {
         delete_player_to_claim(p0, known_player_to_claim_ids).await?;
     }
 
@@ -1060,7 +1038,7 @@ pub(crate) async fn handle_initial_subscription(
 
 pub(crate) async fn handle_transaction_update(
     p0: &DatabaseConnection,
-    tables: &Vec<TableWithOriginalEventTransactionUpdate>,
+    tables: &[TableWithOriginalEventTransactionUpdate],
     sender: UnboundedSender<WebSocketMessages>,
 ) -> anyhow::Result<()> {
     let on_conflict = get_claim_description_state_on_conflict();
@@ -1072,11 +1050,11 @@ pub(crate) async fn handle_transaction_update(
     let mut potential_player_to_claim_deletes: HashSet<(i64, i64)> = HashSet::new();
 
     for p1 in tables.iter() {
-        let event_type = if p1.inserts.len() > 0 && p1.deletes.len() > 0 {
+        let event_type = if !p1.inserts.is_empty() && !p1.deletes.is_empty() {
             "update"
-        } else if p1.inserts.len() > 0 && p1.deletes.len() == 0 {
+        } else if !p1.inserts.is_empty() && p1.deletes.is_empty() {
             "insert"
-        } else if p1.deletes.len() > 0 && p1.inserts.len() == 0 {
+        } else if !p1.deletes.is_empty() && p1.inserts.is_empty() {
             "delete"
         } else {
             "unknown"
@@ -1274,7 +1252,7 @@ pub(crate) async fn handle_transaction_update(
             continue;
         }
     }
-    if buffer_before_player_to_claim_insert.len() > 0 {
+    if !buffer_before_player_to_claim_insert.is_empty() {
         db_insert_player_to_claim(
             p0,
             &mut buffer_before_player_to_claim_insert,
@@ -1282,7 +1260,7 @@ pub(crate) async fn handle_transaction_update(
         )
         .await?;
     }
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         let mut buffer_before_insert_vec = buffer_before_insert
             .clone()
             .into_iter()
@@ -1291,11 +1269,11 @@ pub(crate) async fn handle_transaction_update(
         db_insert_claim_description_state(p0, &mut buffer_before_insert_vec, &on_conflict).await?;
         buffer_before_insert.clear();
     }
-    if potential_player_to_claim_deletes.len() > 0 {
+    if !potential_player_to_claim_deletes.is_empty() {
         delete_player_to_claim(p0, potential_player_to_claim_deletes).await?;
     }
 
-    if potential_deletes.len() > 0 {
+    if !potential_deletes.is_empty() {
         delete_claim_description_state(p0, potential_deletes).await?;
     }
 
diff --git a/rust/api-server/api/src/collectible_desc/mod.rs b/rust/api-server/api/src/collectible_desc/mod.rs
index 9f53ad0..6d6b928 100644
--- a/rust/api-server/api/src/collectible_desc/mod.rs
+++ b/rust/api-server/api/src/collectible_desc/mod.rs
@@ -44,24 +44,16 @@ async fn db_insert_collectible_descs(
 
     let things_to_insert = buffer_before_insert
         .iter()
-        .filter(|collectible_desc| {
-            match collectible_descs_from_db_map.get(&collectible_desc.id) {
-                Some(collectible_desc_from_db) => {
-                    if collectible_desc_from_db != *collectible_desc {
-                        return true;
-                    }
-                }
-                None => {
-                    return true;
-                }
-            }
-
-            return false;
-        })
+        .filter(
+            |collectible_desc| match collectible_descs_from_db_map.get(&collectible_desc.id) {
+                Some(collectible_desc_from_db) => collectible_desc_from_db != *collectible_desc,
+                None => true,
+            },
+        )
         .map(|collectible_desc| collectible_desc.clone().into_active_model())
         .collect::<Vec<collectible_desc::ActiveModel>>();
 
-    if things_to_insert.len() == 0 {
+    if things_to_insert.is_empty() {
         debug!("Nothing to insert");
         buffer_before_insert.clear();
     } else {
@@ -98,9 +90,8 @@ pub(crate) async fn handle_initial_subscription(
     p0: &DatabaseConnection,
     p1: &Table,
 ) -> anyhow::Result<()> {
-    let chunk_size = Some(500);
-    let mut buffer_before_insert: Vec<collectible_desc::Model> =
-        Vec::with_capacity(chunk_size.unwrap_or(5000));
+    let chunk_size = 500;
+    let mut buffer_before_insert: Vec<collectible_desc::Model> = Vec::with_capacity(chunk_size);
 
     let on_conflict = sea_query::OnConflict::column(collectible_desc::Column::Id)
         .update_columns([
@@ -135,7 +126,7 @@ pub(crate) async fn handle_initial_subscription(
                         known_collectible_desc_ids.remove(&collectible_desc.id);
                     }
                     buffer_before_insert.push(collectible_desc);
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(5000) {
+                    if buffer_before_insert.len() == chunk_size {
                         db_insert_collectible_descs(p0, &mut buffer_before_insert, &on_conflict)
                             .await?;
                     }
@@ -150,11 +141,11 @@ pub(crate) async fn handle_initial_subscription(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         db_insert_collectible_descs(p0, &mut buffer_before_insert, &on_conflict).await?;
     }
 
-    if known_collectible_desc_ids.len() > 0 {
+    if !known_collectible_desc_ids.is_empty() {
         delete_collectible_desc(p0, known_collectible_desc_ids).await?;
     }
 
@@ -201,7 +192,7 @@ pub(crate) async fn handle_initial_subscription(
 //         }
 //     }
 //
-//     if buffer_before_insert.len() > 0 {
+//     if !buffer_before_insert.is_empty() {
 //         let mut buffer_before_insert_vec = buffer_before_insert
 //             .clone()
 //             .into_iter()
@@ -229,7 +220,7 @@ pub(crate) async fn handle_initial_subscription(
 //         }
 //     }
 //
-//     if players_to_delete.len() > 0 {
+//     if !players_to_delete.is_empty() {
 //         delete_collectible_desc(p0, players_to_delete).await?;
 //     }
 //
diff --git a/rust/api-server/api/src/deployable_state/mod.rs b/rust/api-server/api/src/deployable_state/mod.rs
index 06a37a3..33cf927 100644
--- a/rust/api-server/api/src/deployable_state/mod.rs
+++ b/rust/api-server/api/src/deployable_state/mod.rs
@@ -9,11 +9,10 @@ use sea_orm::{
 use serde_json::Value;
 use std::collections::{HashMap, HashSet};
 use std::fs::File;
-use std::path::PathBuf;
 
 #[allow(dead_code)]
 pub(crate) async fn load_deployable_state_from_file(
-    storage_path: &PathBuf,
+    storage_path: &std::path::Path,
 ) -> anyhow::Result<Vec<deployable_state::Model>> {
     let item_file = File::open(storage_path.join("State/DeployableState.json"))?;
     let deployable_state: Value = serde_json::from_reader(&item_file)?;
@@ -71,22 +70,14 @@ async fn db_insert_deployable_state(
         .iter()
         .filter(|deployable_state| {
             match deployable_state_from_db_map.get(&deployable_state.entity_id) {
-                Some(deployable_state_from_db) => {
-                    if deployable_state_from_db != *deployable_state {
-                        return true;
-                    }
-                }
-                None => {
-                    return true;
-                }
+                Some(deployable_state_from_db) => deployable_state_from_db != *deployable_state,
+                None => true,
             }
-
-            return false;
         })
         .map(|deployable_state| deployable_state.clone().into_active_model())
         .collect::<Vec<deployable_state::ActiveModel>>();
 
-    if things_to_insert.len() == 0 {
+    if things_to_insert.is_empty() {
         debug!("Nothing to insert");
         buffer_before_insert.clear();
         return Ok(());
@@ -132,13 +123,13 @@ fn get_deployable_state_on_conflict() -> OnConflict {
 
 pub(crate) async fn handle_transaction_update(
     p0: &DatabaseConnection,
-    tables: &Vec<TableWithOriginalEventTransactionUpdate>,
+    tables: &[TableWithOriginalEventTransactionUpdate],
 ) -> anyhow::Result<()> {
     let on_conflict = get_deployable_state_on_conflict();
 
     let mut buffer_before_insert = HashMap::new();
     let mut found_in_inserts = HashSet::new();
-    let chunk_size = Some(1000);
+    let chunk_size = 1000;
 
     // let mut known_player_username_state_ids = get_known_player_uusername_state_ids(p0).await?;
     for p1 in tables.iter() {
@@ -148,7 +139,7 @@ pub(crate) async fn handle_transaction_update(
                     found_in_inserts.insert(building_state.entity_id);
                     buffer_before_insert.insert(building_state.entity_id, building_state);
 
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(1000) {
+                    if buffer_before_insert.len() == chunk_size {
                         let mut buffer_before_insert_vec = buffer_before_insert
                             .clone()
                             .into_iter()
@@ -167,7 +158,7 @@ pub(crate) async fn handle_transaction_update(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         let mut buffer_before_insert_vec = buffer_before_insert
             .clone()
             .into_iter()
@@ -194,7 +185,7 @@ pub(crate) async fn handle_transaction_update(
         }
     }
 
-    if players_to_delete.len() > 0 {
+    if !players_to_delete.is_empty() {
         delete_deployable_state(p0, players_to_delete).await?;
     }
 
@@ -209,7 +200,7 @@ pub(crate) async fn handle_initial_subscription(
 
     let mut known_deployable_state_ids = known_deployable_state_ids(conn).await?;
 
-    let chunk_size = Some(5000);
+    let chunk_size = 5000;
     let mut buffer_before_insert: Vec<deployable_state::Model> = vec![];
 
     for update in p1.updates.iter() {
@@ -220,7 +211,7 @@ pub(crate) async fn handle_initial_subscription(
                         known_deployable_state_ids.remove(&building_state.entity_id);
                     }
                     buffer_before_insert.push(building_state);
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(5000) {
+                    if buffer_before_insert.len() == chunk_size {
                         db_insert_deployable_state(conn, &mut buffer_before_insert, &on_conflict)
                             .await?;
                     }
@@ -231,13 +222,13 @@ pub(crate) async fn handle_initial_subscription(
             }
         }
     }
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         for buffer_chnk in buffer_before_insert.chunks(5000) {
             db_insert_deployable_state(conn, &mut buffer_chnk.to_vec(), &on_conflict).await?;
         }
     }
 
-    if known_deployable_state_ids.len() > 0 {
+    if !known_deployable_state_ids.is_empty() {
         delete_deployable_state(conn, known_deployable_state_ids).await?;
     }
 
diff --git a/rust/api-server/api/src/inventory/mod.rs b/rust/api-server/api/src/inventory/mod.rs
index 4f616b3..71ddaab 100644
--- a/rust/api-server/api/src/inventory/mod.rs
+++ b/rust/api-server/api/src/inventory/mod.rs
@@ -20,7 +20,6 @@ use service::Query as QueryCore;
 use std::collections::{HashMap, HashSet};
 use std::fs::File;
 use std::io::{BufRead, BufReader};
-use std::path::PathBuf;
 
 pub(crate) fn get_routes() -> AppRouter {
     Router::new()
@@ -119,25 +118,20 @@ pub(crate) async fn find_inventory_by_owner_entity_id(
 
     let mut mobile_entiety_map: HashMap<i64, String> = HashMap::new();
 
-    match &player {
-        Some(player) => {
-            let mobile_entiety_from_player =
-                QueryCore::find_deployable_entity_by_owner_entity_id(&state.conn, player.entity_id)
-                    .await
-                    .map_err(|e| {
-                        error!("Error: {:?}", e);
+    if let Some(player) = &player {
+        let mobile_entiety_from_player =
+            QueryCore::find_deployable_entity_by_owner_entity_id(&state.conn, player.entity_id)
+                .await
+                .map_err(|e| {
+                    error!("Error: {:?}", e);
 
-                        (StatusCode::INTERNAL_SERVER_ERROR, "Unexpected error")
-                    })?;
+                    (StatusCode::INTERNAL_SERVER_ERROR, "Unexpected error")
+                })?;
 
-            for mobile_entiety in mobile_entiety_from_player {
-                mobile_entiety_map.insert(mobile_entiety.entity_id, mobile_entiety.nickname);
-                inventory_ids.push(mobile_entiety.entity_id);
-            }
-
-            ()
+        for mobile_entiety in mobile_entiety_from_player {
+            mobile_entiety_map.insert(mobile_entiety.entity_id, mobile_entiety.nickname);
+            inventory_ids.push(mobile_entiety.entity_id);
         }
-        None => (),
     };
 
     let (inventorys, num_pages) =
@@ -175,9 +169,9 @@ pub(crate) async fn find_inventory_by_owner_entity_id(
                         .unwrap();
 
                     if item_type == "0" {
-                        item_ids.push(content.item_id.clone());
+                        item_ids.push(content.item_id);
                     } else {
-                        cargo_ids.push(content.item_id.clone());
+                        cargo_ids.push(content.item_id);
                     }
                 }
             }
@@ -209,7 +203,7 @@ pub(crate) async fn find_inventory_by_owner_entity_id(
         .map(|item| (item.id, item))
         .collect::<HashMap<i64, item_desc::Model>>();
 
-    for (_index, inventory) in inventorys.into_iter().enumerate() {
+    for inventory in inventorys.into_iter() {
         let mut pockets = vec![];
 
         for pocket in &inventory.pockets {
@@ -264,7 +258,7 @@ pub(crate) async fn find_inventory_by_owner_entity_id(
 
 #[allow(dead_code)]
 pub(crate) async fn load_inventory_state_from_file(
-    storage_path: &PathBuf,
+    storage_path: &std::path::Path,
 ) -> anyhow::Result<Vec<inventory::Model>> {
     let item_file = File::open(storage_path.join("State/InventoryState.json"))?;
     let inventory: Value = serde_json::from_reader(&item_file)?;
@@ -326,24 +320,16 @@ async fn db_insert_inventory_state(
 
     let things_to_insert = buffer_before_insert
         .iter()
-        .filter(|inventory| {
-            match inventorys_from_db_map.get(&inventory.entity_id) {
-                Some(inventory_from_db) => {
-                    if inventory_from_db != *inventory {
-                        return true;
-                    }
-                }
-                None => {
-                    return true;
-                }
-            }
-
-            return false;
-        })
+        .filter(
+            |inventory| match inventorys_from_db_map.get(&inventory.entity_id) {
+                Some(inventory_from_db) => inventory_from_db != *inventory,
+                None => true,
+            },
+        )
         .map(|inventory| inventory.clone().into_active_model())
         .collect::<Vec<inventory::ActiveModel>>();
 
-    if things_to_insert.len() == 0 {
+    if things_to_insert.is_empty() {
         debug!("Nothing to insert");
         buffer_before_insert.clear();
         return Ok(());
@@ -451,7 +437,7 @@ pub(crate) async fn handle_initial_subscription(
         ])
         .to_owned();
 
-    let chunk_size = Some(5000);
+    let chunk_size = 5000;
     let mut buffer_before_insert: Vec<inventory::Model> = vec![];
 
     let mut known_inventory_ids = get_known_inventory_ids(database_connection).await?;
@@ -464,7 +450,7 @@ pub(crate) async fn handle_initial_subscription(
                         known_inventory_ids.remove(&building_state.entity_id);
                     }
                     buffer_before_insert.push(building_state);
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(5000) {
+                    if buffer_before_insert.len() == chunk_size {
                         db_insert_inventory_state(
                             database_connection,
                             &mut buffer_before_insert,
@@ -479,14 +465,14 @@ pub(crate) async fn handle_initial_subscription(
             }
         }
     }
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         for buffer_chnk in buffer_before_insert.chunks(5000) {
             db_insert_inventory_state(database_connection, &mut buffer_chnk.to_vec(), &on_conflict)
                 .await?;
         }
     }
 
-    if known_inventory_ids.len() > 0 {
+    if !known_inventory_ids.is_empty() {
         db_delete_inventorys(database_connection, known_inventory_ids).await?;
     }
 
@@ -495,7 +481,7 @@ pub(crate) async fn handle_initial_subscription(
 
 pub(crate) async fn handle_transaction_update(
     database_connection: &DatabaseConnection,
-    tables: &Vec<TableWithOriginalEventTransactionUpdate>,
+    tables: &[TableWithOriginalEventTransactionUpdate],
 ) -> anyhow::Result<()> {
     let on_conflict = sea_query::OnConflict::column(inventory::Column::EntityId)
         .update_columns([
@@ -512,11 +498,11 @@ pub(crate) async fn handle_transaction_update(
     // let mut inventory_changes = vec![];
 
     for p1 in tables.iter() {
-        let event_type = if p1.inserts.len() > 0 && p1.deletes.len() > 0 {
+        let event_type = if !p1.inserts.is_empty() && !p1.deletes.is_empty() {
             "update"
-        } else if p1.inserts.len() > 0 && p1.deletes.len() == 0 {
+        } else if !p1.inserts.is_empty() && p1.deletes.is_empty() {
             "insert"
-        } else if p1.deletes.len() > 0 && p1.inserts.len() == 0 {
+        } else if !p1.deletes.is_empty() && p1.inserts.is_empty() {
             "delete"
         } else {
             "unknown"
@@ -589,7 +575,7 @@ pub(crate) async fn handle_transaction_update(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         let mut buffer_before_insert_vec = buffer_before_insert
             .clone()
             .into_iter()
@@ -604,7 +590,7 @@ pub(crate) async fn handle_transaction_update(
         buffer_before_insert.clear();
     }
 
-    if potential_deletes.len() > 0 {
+    if !potential_deletes.is_empty() {
         db_delete_inventorys(database_connection, potential_deletes).await?;
     }
 
diff --git a/rust/api-server/api/src/items/mod.rs b/rust/api-server/api/src/items/mod.rs
index eff73e6..32a3394 100644
--- a/rust/api-server/api/src/items/mod.rs
+++ b/rust/api-server/api/src/items/mod.rs
@@ -14,7 +14,6 @@ use service::Query as QueryCore;
 use std::collections::HashMap;
 use std::fs::File;
 use std::ops::Add;
-use std::path::PathBuf;
 use std::time::Duration;
 use struson::json_path;
 use struson::reader::{JsonReader, JsonStreamReader};
@@ -50,7 +49,7 @@ pub async fn list_items(
 
 #[allow(dead_code)]
 pub(crate) async fn load_item_desc_from_file(
-    storage_path: &PathBuf,
+    storage_path: &std::path::Path,
 ) -> anyhow::Result<Vec<item_desc::Model>> {
     let item_file = File::open(storage_path.join("State/InventoryState.json"))?;
     let inventory: Value = serde_json::from_reader(&item_file)?;
@@ -92,7 +91,7 @@ pub(crate) async fn load_state_from_spacetimedb(
     let claim_descriptions =
         load_item_desc_from_spacetimedb(client, domain, protocol, database).await?;
 
-    import_items(&conn, claim_descriptions, Some(3000)).await?;
+    import_items(conn, claim_descriptions, Some(3000)).await?;
 
     Ok(())
 }
@@ -168,24 +167,14 @@ pub(crate) async fn import_items(
 
             let things_to_insert = buffer_before_insert
                 .iter()
-                .filter(|item| {
-                    match items_from_db_map.get(&item.id) {
-                        Some(item_from_db) => {
-                            if item_from_db != *item {
-                                return true;
-                            }
-                        }
-                        None => {
-                            return true;
-                        }
-                    }
-
-                    return false;
+                .filter(|item| match items_from_db_map.get(&item.id) {
+                    Some(item_from_db) => item_from_db != *item,
+                    None => true,
                 })
                 .map(|item| item.clone().into_active_model())
                 .collect::<Vec<item_desc::ActiveModel>>();
 
-            if things_to_insert.len() == 0 {
+            if things_to_insert.is_empty() {
                 debug!("Nothing to insert");
                 buffer_before_insert.clear();
                 continue;
@@ -195,8 +184,8 @@ pub(crate) async fn import_items(
 
             for item in &things_to_insert {
                 let item_in = items_to_delete.iter().position(|id| id == item.id.as_ref());
-                if item_in.is_some() {
-                    items_to_delete.remove(item_in.unwrap());
+                if let Some(item_in) = item_in {
+                    items_to_delete.remove(item_in);
                 }
             }
 
@@ -209,7 +198,7 @@ pub(crate) async fn import_items(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         let items_from_db = item_desc::Entity::find()
             .filter(
                 item_desc::Column::Id.is_in(
@@ -229,24 +218,14 @@ pub(crate) async fn import_items(
 
         let things_to_insert = buffer_before_insert
             .iter()
-            .filter(|item| {
-                match items_from_db_map.get(&item.id) {
-                    Some(item_from_db) => {
-                        if item_from_db != *item {
-                            return true;
-                        }
-                    }
-                    None => {
-                        return true;
-                    }
-                }
-
-                return false;
+            .filter(|item| match items_from_db_map.get(&item.id) {
+                Some(item_from_db) => item_from_db != *item,
+                None => true,
             })
             .map(|item| item.clone().into_active_model())
             .collect::<Vec<item_desc::ActiveModel>>();
 
-        if things_to_insert.len() == 0 {
+        if things_to_insert.is_empty() {
             debug!("Nothing to insert");
             buffer_before_insert.clear();
         } else {
@@ -262,7 +241,7 @@ pub(crate) async fn import_items(
     }
     info!("Importing item finished in {}s", start.elapsed().as_secs());
 
-    if items_to_delete.len() > 0 {
+    if !items_to_delete.is_empty() {
         info!("item's to delete: {:?}", items_to_delete);
         item_desc::Entity::delete_many()
             .filter(item_desc::Column::Id.is_in(items_to_delete))
@@ -273,7 +252,7 @@ pub(crate) async fn import_items(
     Ok(())
 }
 
-pub async fn import_job_item_desc(temp_config: Config) -> () {
+pub async fn import_job_item_desc(temp_config: Config) {
     let temp_config = temp_config.clone();
     let config = temp_config.clone();
     if config.live_updates {
diff --git a/rust/api-server/api/src/items_and_cargo/mod.rs b/rust/api-server/api/src/items_and_cargo/mod.rs
index c40c40e..16f6ff1 100644
--- a/rust/api-server/api/src/items_and_cargo/mod.rs
+++ b/rust/api-server/api/src/items_and_cargo/mod.rs
@@ -45,10 +45,7 @@ pub(crate) async fn list_items_and_cargo(
 ) -> Result<Json<ItemsAndCargoResponse>, (StatusCode, &'static str)> {
     let page = params.page.unwrap_or(1);
     let posts_per_page = params.per_page.unwrap_or(5);
-    let search = match params.search {
-        Some(search) => Some(search.to_lowercase()),
-        None => None,
-    };
+    let search = params.search.map(|search| search.to_lowercase());
     let tier = params.tier;
     let tag = params.tag;
 
diff --git a/rust/api-server/api/src/leaderboard/mod.rs b/rust/api-server/api/src/leaderboard/mod.rs
index 5faa2de..1546575 100644
--- a/rust/api-server/api/src/leaderboard/mod.rs
+++ b/rust/api-server/api/src/leaderboard/mod.rs
@@ -15,7 +15,6 @@ use serde_json::Value;
 use service::Query;
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::fs::File;
-use std::path::PathBuf;
 use tokio::sync::mpsc::UnboundedSender;
 
 #[macro_export]
@@ -203,6 +202,9 @@ pub(crate) struct LeaderboardTime {
     pub(crate) rank: u64,
 }
 
+type LeaderboardRankTypeTasks =
+    Vec<tokio::task::JoinHandle<Result<(String, Vec<RankType>), (StatusCode, &'static str)>>>;
+
 pub(crate) async fn get_top_100(
     state: State<std::sync::Arc<AppState>>,
 ) -> Result<Json<Value>, (StatusCode, &'static str)> {
@@ -218,9 +220,7 @@ pub(crate) async fn get_top_100(
 
     let generated_level_sql = generate_mysql_sum_level_sql_statement!(EXPERIENCE_PER_LEVEL);
 
-    let mut tasks: Vec<
-        tokio::task::JoinHandle<Result<(String, Vec<RankType>), (StatusCode, &'static str)>>,
-    > = vec![];
+    let mut tasks: LeaderboardRankTypeTasks = vec![];
 
     for skill in skills {
         if skill.skill_category == 2 || skill.skill_category == 0 {
@@ -250,7 +250,7 @@ pub(crate) async fn get_top_100(
                     player_id: entry.entity_id,
                     player_name,
                     experience: entry.experience,
-                    level: experience_to_level(entry.experience.clone() as i64),
+                    level: experience_to_level(entry.experience as i64),
                     rank: rank as u64,
                 }));
             }
@@ -345,29 +345,27 @@ pub(crate) async fn get_top_100(
     let results = futures::future::join_all(tasks).await;
     let mut player_ids: Vec<i64> = vec![];
 
-    for results_inner in results {
-        if let Ok(result) = results_inner {
-            if let Ok((name, mut leaderboard)) = result {
-                player_ids.append(
-                    &mut leaderboard
-                        .iter()
-                        .map(|x| match x {
-                            RankType::Skill(x) => x.player_id,
-                            RankType::Level(x) => x.player_id,
-                            RankType::Experience(x) => x.player_id,
-                            RankType::Time(x) => x.player_id,
-                            RankType::ExperiencePerHour(x) => x.player_id,
-                        })
-                        .collect::<Vec<i64>>(),
-                );
-
-                leaderboard_result
-                    .entry(name)
-                    .or_insert(Vec::new())
-                    .append(&mut leaderboard);
-            } else {
-                error!("Error: {result:?}");
-            }
+    for result in results.into_iter().flatten() {
+        if let Ok((name, mut leaderboard)) = result {
+            player_ids.append(
+                &mut leaderboard
+                    .iter()
+                    .map(|x| match x {
+                        RankType::Skill(x) => x.player_id,
+                        RankType::Level(x) => x.player_id,
+                        RankType::Experience(x) => x.player_id,
+                        RankType::Time(x) => x.player_id,
+                        RankType::ExperiencePerHour(x) => x.player_id,
+                    })
+                    .collect::<Vec<i64>>(),
+            );
+
+            leaderboard_result
+                .entry(name)
+                .or_default()
+                .append(&mut leaderboard);
+        } else {
+            error!("Error: {result:?}");
         }
     }
 
@@ -455,7 +453,7 @@ pub(crate) fn experience_to_level(experience: i64) -> i32 {
 
 #[allow(dead_code)]
 pub(crate) async fn load_experience_state_from_file(
-    storage_path: &PathBuf,
+    storage_path: &std::path::Path,
 ) -> anyhow::Result<Vec<experience_state::Model>> {
     let item_file = File::open(storage_path.join("State/ExperienceState.json"))?;
     let experience_state: Value = serde_json::from_reader(&item_file)?;
@@ -469,8 +467,7 @@ pub(crate) async fn load_experience_state_from_file(
                 .clone(),
         )?
         .into_iter()
-        .map(|x| row_to_xp_values(x))
-        .flatten()
+        .flat_map(row_to_xp_values)
         .collect();
 
     Ok(experience_states)
@@ -534,14 +531,13 @@ async fn db_insert_experience_state(
 ) -> anyhow::Result<()> {
     let resolved_buffer_before_insert = buffer_before_insert
         .iter()
-        .map(|x| {
+        .flat_map(|x| {
             x.experience_stacks.iter().map(|y| experience_state::Model {
                 entity_id: x.entity_id,
                 skill_id: y.0,
                 experience: y.1,
             })
         })
-        .flatten()
         .collect::<Vec<experience_state::Model>>();
 
     let experience_state_from_db = experience_state::Entity::find()
@@ -572,22 +568,14 @@ async fn db_insert_experience_state(
             match experience_state_from_db_map
                 .get(&(experience_state.entity_id, experience_state.skill_id))
             {
-                Some(experience_state_from_db) => {
-                    if experience_state_from_db != *experience_state {
-                        return true;
-                    }
-                }
-                None => {
-                    return true;
-                }
+                Some(experience_state_from_db) => experience_state_from_db != *experience_state,
+                None => true,
             }
-
-            return false;
         })
         .map(|experience_state| experience_state.clone().into_active_model())
         .collect::<Vec<experience_state::ActiveModel>>();
 
-    if things_to_insert.len() == 0 {
+    if things_to_insert.is_empty() {
         debug!("Nothing to insert");
         buffer_before_insert.clear();
         return Ok(());
@@ -627,6 +615,9 @@ fn row_to_xp_values(row: Value) -> Vec<experience_state::Model> {
         .collect::<Vec<experience_state::Model>>()
 }
 
+type PlayerLeaderboardTasks =
+    Vec<tokio::task::JoinHandle<Result<(String, RankType), (StatusCode, &'static str)>>>;
+
 pub(crate) async fn player_leaderboard(
     state: State<std::sync::Arc<AppState>>,
     Path(player_id): Path<i64>,
@@ -641,9 +632,7 @@ pub(crate) async fn player_leaderboard(
 
     let mut leaderboard_result: BTreeMap<String, RankType> = BTreeMap::new();
 
-    let mut tasks: Vec<
-        tokio::task::JoinHandle<Result<(String, RankType), (StatusCode, &'static str)>>,
-    > = vec![];
+    let mut tasks: PlayerLeaderboardTasks = vec![];
 
     for skill in skills {
         if skill.skill_category == 2 || skill.skill_category == 0 {
@@ -679,7 +668,7 @@ pub(crate) async fn player_leaderboard(
                     player_id: entry.entity_id,
                     player_name,
                     experience: entry.experience,
-                    level: experience_to_level(entry.experience.clone() as i64),
+                    level: experience_to_level(entry.experience as i64),
                     rank: rank.unwrap(),
                 }),
             ))
@@ -742,13 +731,11 @@ pub(crate) async fn player_leaderboard(
 
     let results = futures::future::join_all(tasks).await;
 
-    for results_inner in results {
-        if let Ok(result) = results_inner {
-            if let Ok((name, leaderboard)) = result {
-                leaderboard_result.entry(name).or_insert(leaderboard);
-            } else {
-                error!("Error: {result:?}");
-            }
+    for result in results.into_iter().flatten() {
+        if let Ok((name, leaderboard)) = result {
+            leaderboard_result.entry(name).or_insert(leaderboard);
+        } else {
+            error!("Error: {result:?}");
         }
     }
 
@@ -837,9 +824,7 @@ pub(crate) async fn get_claim_leaderboard(
 
     let generated_level_sql = generate_mysql_sum_level_sql_statement!(EXPERIENCE_PER_LEVEL);
 
-    let mut tasks: Vec<
-        tokio::task::JoinHandle<Result<(String, Vec<RankType>), (StatusCode, &'static str)>>,
-    > = vec![];
+    let mut tasks: LeaderboardRankTypeTasks = vec![];
 
     for skill in skills {
         if skill.skill_category == 2 || skill.skill_category == 0 {
@@ -871,7 +856,7 @@ pub(crate) async fn get_claim_leaderboard(
                     player_id: entry.entity_id,
                     player_name,
                     experience: entry.experience,
-                    level: experience_to_level(entry.experience.clone() as i64),
+                    level: experience_to_level(entry.experience as i64),
                     rank: rank as u64,
                 }));
             }
@@ -943,29 +928,27 @@ pub(crate) async fn get_claim_leaderboard(
     let results = futures::future::join_all(tasks).await;
     let mut player_ids: Vec<i64> = vec![];
 
-    for results_inner in results {
-        if let Ok(result) = results_inner {
-            if let Ok((name, mut leaderboard)) = result {
-                player_ids.append(
-                    &mut leaderboard
-                        .iter()
-                        .map(|x| match x {
-                            RankType::Skill(x) => x.player_id,
-                            RankType::Level(x) => x.player_id,
-                            RankType::Experience(x) => x.player_id,
-                            RankType::Time(x) => x.player_id,
-                            RankType::ExperiencePerHour(x) => x.player_id,
-                        })
-                        .collect::<Vec<i64>>(),
-                );
-
-                leaderboard_result
-                    .entry(name)
-                    .or_insert(Vec::new())
-                    .append(&mut leaderboard);
-            } else {
-                error!("Error: {result:?}");
-            }
+    for result in results.into_iter().flatten() {
+        if let Ok((name, mut leaderboard)) = result {
+            player_ids.append(
+                &mut leaderboard
+                    .iter()
+                    .map(|x| match x {
+                        RankType::Skill(x) => x.player_id,
+                        RankType::Level(x) => x.player_id,
+                        RankType::Experience(x) => x.player_id,
+                        RankType::Time(x) => x.player_id,
+                        RankType::ExperiencePerHour(x) => x.player_id,
+                    })
+                    .collect::<Vec<i64>>(),
+            );
+
+            leaderboard_result
+                .entry(name)
+                .or_default()
+                .append(&mut leaderboard);
+        } else {
+            error!("Error: {result:?}");
         }
     }
 
@@ -1048,9 +1031,8 @@ pub(crate) async fn handle_initial_subscription(
     .update_columns([experience_state::Column::Experience])
     .to_owned();
 
-    let chunk_size = Some(500);
-    let mut buffer_before_insert: Vec<PackedExperienceState> =
-        Vec::with_capacity(chunk_size.unwrap_or(500));
+    let chunk_size = 500;
+    let mut buffer_before_insert: Vec<PackedExperienceState> = Vec::with_capacity(chunk_size);
     let mut experience_state_to_delete = get_known_experience_states(p0).await?;
     for update in p1.updates.iter() {
         for row in update.inserts.iter() {
@@ -1076,7 +1058,7 @@ pub(crate) async fn handle_initial_subscription(
                     }
 
                     buffer_before_insert.push(experience_state);
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(500) {
+                    if buffer_before_insert.len() == chunk_size {
                         db_insert_experience_state(p0, &mut buffer_before_insert, &on_conflict)
                             .await?;
                     }
@@ -1088,12 +1070,12 @@ pub(crate) async fn handle_initial_subscription(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         db_insert_experience_state(p0, &mut buffer_before_insert, &on_conflict).await?;
         info!("experience_state last batch imported");
     }
 
-    if experience_state_to_delete.len() > 0 {
+    if !experience_state_to_delete.is_empty() {
         delete_experience_state(p0, &mut experience_state_to_delete).await?;
     }
 
@@ -1102,7 +1084,7 @@ pub(crate) async fn handle_initial_subscription(
 
 pub(crate) async fn handle_transaction_update(
     p0: &DatabaseConnection,
-    tables: &Vec<TableWithOriginalEventTransactionUpdate>,
+    tables: &[TableWithOriginalEventTransactionUpdate],
     skill_id_to_skill_name: &HashMap<i64, String>,
     tx: UnboundedSender<WebSocketMessages>,
 ) -> anyhow::Result<()> {
@@ -1119,11 +1101,11 @@ pub(crate) async fn handle_transaction_update(
     let mut potential_deletes = HashSet::new();
 
     for p1 in tables.iter() {
-        let event_type = if p1.inserts.len() > 0 && p1.deletes.len() > 0 {
+        let event_type = if !p1.inserts.is_empty() && !p1.deletes.is_empty() {
             "update"
-        } else if p1.inserts.len() > 0 && p1.deletes.len() == 0 {
+        } else if !p1.inserts.is_empty() && p1.deletes.is_empty() {
             "insert"
-        } else if p1.deletes.len() > 0 && p1.inserts.len() == 0 {
+        } else if !p1.deletes.is_empty() && p1.inserts.is_empty() {
             "delete"
         } else {
             "unknown"
@@ -1376,7 +1358,7 @@ pub(crate) async fn handle_transaction_update(
         .expect("Could not send total experience to websocket");
     }
 
-    if potential_deletes.len() > 0 {
+    if !potential_deletes.is_empty() {
         delete_experience_state(p0, &mut potential_deletes).await?;
     }
 
diff --git a/rust/api-server/api/src/lib.rs b/rust/api-server/api/src/lib.rs
index a59c2f3..56f583e 100644
--- a/rust/api-server/api/src/lib.rs
+++ b/rust/api-server/api/src/lib.rs
@@ -53,7 +53,7 @@ use std::fmt::Display;
 use std::fs::File;
 use std::io::Write;
 use std::ops::{AddAssign, SubAssign};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::process::exit;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
@@ -79,7 +79,7 @@ async fn start(database_connection: DatabaseConnection, config: Config) -> anyho
             &config.spacetimedb.domain.clone(),
             &config.spacetimedb.protocol.clone(),
             &config.spacetimedb.database.clone(),
-            &config.storage_path.clone().into(),
+            Path::new(&config.storage_path.clone()),
         )
         .await;
     }
@@ -131,10 +131,9 @@ async fn create_db_connection(config: &Config) -> DatabaseConnection {
         .idle_timeout(Duration::from_secs(8))
         .sqlx_logging(env::var("SQLX_LOG").is_ok());
 
-    let conn = Database::connect(connection_options)
+    Database::connect(connection_options)
         .await
-        .expect("Database connection failed");
-    conn
+        .expect("Database connection failed")
 }
 
 async fn websocket_handler(
@@ -545,7 +544,7 @@ fn import_data(config: Config) {
                 //
 
                 if config.enabled_importer.contains(&"skill_desc".to_string())
-                    || config.enabled_importer.len() == 0
+                    || config.enabled_importer.is_empty()
                 {
                     let temp_config = config.clone();
                     tasks.push(tokio::spawn(skill_descriptions::import_job_skill_desc(
@@ -556,7 +555,7 @@ fn import_data(config: Config) {
                 if config
                     .enabled_importer
                     .contains(&"claim_tech_desc".to_string())
-                    || config.enabled_importer.len() == 0
+                    || config.enabled_importer.is_empty()
                 {
                     let temp_config = config.clone();
                     tasks.push(tokio::spawn(claim_tech_desc::import_job_claim_tech_desc(
@@ -565,21 +564,21 @@ fn import_data(config: Config) {
                 }
 
                 if config.enabled_importer.contains(&"recipes".to_string())
-                    || config.enabled_importer.len() == 0
+                    || config.enabled_importer.is_empty()
                 {
                     let temp_config = config.clone();
                     tasks.push(tokio::spawn(recipes::import_job_recipes_desc(temp_config)));
                 }
 
                 if config.enabled_importer.contains(&"items".to_string())
-                    || config.enabled_importer.len() == 0
+                    || config.enabled_importer.is_empty()
                 {
                     let temp_config = config.clone();
                     tasks.push(tokio::spawn(items::import_job_item_desc(temp_config)));
                 }
 
                 if config.enabled_importer.contains(&"cargo_desc".to_string())
-                    || config.enabled_importer.len() == 0
+                    || config.enabled_importer.is_empty()
                 {
                     let temp_config = config.clone();
                     tasks.push(tokio::spawn(cargo_desc::import_job_cargo_desc(temp_config)));
@@ -588,7 +587,7 @@ fn import_data(config: Config) {
                 if config
                     .enabled_importer
                     .contains(&"building_desc".to_string())
-                    || config.enabled_importer.len() == 0
+                    || config.enabled_importer.is_empty()
                 {
                     let temp_config = config.clone();
                     tasks.push(tokio::spawn(buildings::import_job_building_desc(
@@ -671,7 +670,7 @@ fn import_trade_order_state(config: Config, conn: DatabaseConnection, client: Cl
                 )
                 .await;
 
-                if let Ok(_) = trade_order_state {
+                if trade_order_state.is_ok() {
                     info!("TradeOrderState imported");
                 } else {
                     error!("TradeOrderState import failed: {:?}", trade_order_state);
@@ -707,18 +706,13 @@ impl AppState {
     }
 }
 
+type WebsocketClient = (
+    tokio::sync::broadcast::Sender<crate::websocket::WebSocketMessages>,
+    HashMap<String, HashSet<i64>>,
+);
+
 struct ClientsState {
-    clients: Arc<
-        RwLock<
-            HashMap<
-                String,
-                (
-                    tokio::sync::broadcast::Sender<crate::websocket::WebSocketMessages>,
-                    HashMap<String, HashSet<i64>>,
-                ),
-            >,
-        >,
-    >,
+    clients: Arc<RwLock<HashMap<String, WebsocketClient>>>,
     topics_listen_to: Arc<RwLock<HashMap<String, HashMap<i64, u64>>>>,
 }
 
@@ -758,12 +752,11 @@ impl ClientsState {
                 client
                     .1
                     .iter()
-                    .map(|(topic, ids)| {
+                    .flat_map(|(topic, ids)| {
                         ids.iter()
                             .map(|id| format!("{}.{:?}", topic, id))
                             .collect::<Vec<String>>()
                     })
-                    .flatten()
                     .collect::<Vec<String>>(),
             );
         }
@@ -950,7 +943,7 @@ pub async fn download_all_tables(
     domain: &str,
     protocol: &str,
     database: &str,
-    storage_path: &PathBuf,
+    storage_path: &Path,
 ) {
     let desc_tables = vec![
         "AchievementDesc",
@@ -1261,7 +1254,7 @@ pub async fn download_all_table(
     protocol: &str,
     database: &str,
     table: &str,
-    storage_path: &PathBuf,
+    storage_path: &Path,
     folder: &str,
 ) -> anyhow::Result<()> {
     let response = client
@@ -1367,7 +1360,7 @@ pub async fn main() -> anyhow::Result<()> {
             storage_path,
         } => {
             cli_config_parameters.host = host.clone();
-            cli_config_parameters.port = port.clone();
+            cli_config_parameters.port = *port;
             cli_config_parameters.storage_path = storage_path.clone();
         }
     }
diff --git a/rust/api-server/api/src/player_state/mod.rs b/rust/api-server/api/src/player_state/mod.rs
index 3028f8f..ff6f286 100644
--- a/rust/api-server/api/src/player_state/mod.rs
+++ b/rust/api-server/api/src/player_state/mod.rs
@@ -15,7 +15,6 @@ use serde_json::{Value, json};
 use service::Query as QueryCore;
 use std::collections::{HashMap, HashSet};
 use std::fs::File;
-use std::path::PathBuf;
 use tokio::sync::mpsc::UnboundedSender;
 
 pub(crate) fn get_routes() -> AppRouter {
@@ -111,19 +110,14 @@ pub async fn find_player_by_id(
             vec![]
         });
 
-    let player_location = state.mobile_entity_state.get(&(id as u64));
+    let player_location = state
+        .mobile_entity_state
+        .get(&(id as u64))
+        .map(|player_location| player_location.clone());
 
-    let player_location = if player_location.is_none() {
-        None
-    } else {
-        Some(player_location.unwrap().clone())
-    };
-
-    let chunk_index = if let Some(player_location) = &player_location {
-        Some(player_location.chunk_index)
-    } else {
-        None
-    };
+    let chunk_index = player_location
+        .as_ref()
+        .map(|player_location| player_location.chunk_index);
 
     let claim_id = if chunk_index.is_some() {
         if let Some(claim_id) = state.claim_tile_state.get(&(chunk_index.unwrap())) {
@@ -135,33 +129,15 @@ pub async fn find_player_by_id(
         None
     };
 
-    let player_action_state = state.player_action_state.get(&(id as u64));
-    let plyer_action_state2 = if player_action_state.is_none() {
-        None
-    } else {
-        Some(player_action_state.unwrap().value().clone())
-    };
-
-    let player_action_state = state.player_action_state.get(&(id as u64));
-    let player_action_state = if player_action_state.is_none() {
-        None
-    } else {
-        Some(player_action_state.unwrap().action_type.get_action_name())
-        // let player_action_state = player_action_state.unwrap().auto_id;
-
-        // if let Some(crafting_recipe) = state.crafting_recipe_desc.get(&player_action_state) {
-        //     Some(crafting_recipe.name.clone())
-        // } else {
-        //     None
-        // }
-    };
-
+    let plyer_action_state2 = state
+        .player_action_state
+        .get(&(id as u64))
+        .map(|player_action_state| player_action_state.value().clone());
+    let player_action_state = state
+        .player_action_state
+        .get(&(id as u64))
+        .map(|player_action_state| player_action_state.action_type.get_action_name());
     let current_action_state = state.action_state.get(&(id as u64));
-    let current_action_state = if current_action_state.is_none() {
-        None
-    } else {
-        Some(current_action_state.unwrap())
-    };
 
     Ok(Json(json!({
         "entity_id": player.entity_id,
@@ -184,7 +160,7 @@ pub async fn find_player_by_id(
 
 #[allow(dead_code)]
 pub(crate) async fn load_player_state_from_file(
-    storage_path: &PathBuf,
+    storage_path: &std::path::Path,
 ) -> anyhow::Result<Vec<player_state::Model>> {
     let player_state_file = File::open(storage_path.join("State/PlayerState.json"))?;
     let player_state: Value = serde_json::from_reader(&player_state_file)?;
@@ -230,24 +206,16 @@ async fn db_insert_player_states(
 
     let things_to_insert = buffer_before_insert
         .iter()
-        .filter(|player_state| {
-            match player_states_from_db_map.get(&player_state.entity_id) {
-                Some(player_state_from_db) => {
-                    if player_state_from_db != *player_state {
-                        return true;
-                    }
-                }
-                None => {
-                    return true;
-                }
-            }
-
-            return false;
-        })
+        .filter(
+            |player_state| match player_states_from_db_map.get(&player_state.entity_id) {
+                Some(player_state_from_db) => player_state_from_db != *player_state,
+                None => true,
+            },
+        )
         .map(|player_state| player_state.clone().into_active_model())
         .collect::<Vec<player_state::ActiveModel>>();
 
-    if things_to_insert.len() == 0 {
+    if things_to_insert.is_empty() {
         debug!("Nothing to insert");
         buffer_before_insert.clear();
         return Ok(());
@@ -340,21 +308,15 @@ async fn db_insert_player_username_states(
         .filter(|player_username_state| {
             match player_username_states_from_db_map.get(&player_username_state.entity_id) {
                 Some(player_username_state_from_db) => {
-                    if player_username_state_from_db != *player_username_state {
-                        return true;
-                    }
-                }
-                None => {
-                    return true;
+                    player_username_state_from_db != *player_username_state
                 }
+                None => true,
             }
-
-            return false;
         })
         .map(|player_username_state| player_username_state.clone().into_active_model())
         .collect::<Vec<player_username_state::ActiveModel>>();
 
-    if things_to_insert.len() == 0 {
+    if things_to_insert.is_empty() {
         debug!("Nothing to insert");
         buffer_before_insert.clear();
         return Ok(());
@@ -379,9 +341,9 @@ pub(crate) async fn handle_initial_subscription_player_username_state(
     p0: &DatabaseConnection,
     p1: &Table,
 ) -> anyhow::Result<()> {
-    let chunk_size = Some(5000);
+    let chunk_size = 5000;
     let mut buffer_before_insert: Vec<player_username_state::Model> =
-        Vec::with_capacity(chunk_size.unwrap_or(5000));
+        Vec::with_capacity(chunk_size);
 
     let on_conflict = sea_query::OnConflict::column(player_username_state::Column::EntityId)
         .update_columns([player_username_state::Column::Username])
@@ -396,7 +358,7 @@ pub(crate) async fn handle_initial_subscription_player_username_state(
                         known_player_username_state_ids.remove(&player_username_state.entity_id);
                     }
                     buffer_before_insert.push(player_username_state);
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(5000) {
+                    if buffer_before_insert.len() == chunk_size {
                         db_insert_player_username_states(
                             p0,
                             &mut buffer_before_insert,
@@ -415,11 +377,11 @@ pub(crate) async fn handle_initial_subscription_player_username_state(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         db_insert_player_username_states(p0, &mut buffer_before_insert, &on_conflict).await?;
     }
 
-    if known_player_username_state_ids.len() > 0 {
+    if !known_player_username_state_ids.is_empty() {
         delete_player_username_state(p0, known_player_username_state_ids).await?;
     }
 
@@ -428,15 +390,15 @@ pub(crate) async fn handle_initial_subscription_player_username_state(
 
 pub(crate) async fn handle_transaction_update_player_username_state(
     p0: &DatabaseConnection,
-    tables: &Vec<TableWithOriginalEventTransactionUpdate>,
+    tables: &[TableWithOriginalEventTransactionUpdate],
 ) -> anyhow::Result<()> {
     let on_conflict = sea_query::OnConflict::column(player_username_state::Column::EntityId)
         .update_columns([player_username_state::Column::Username])
         .to_owned();
 
-    let chunk_size = Some(5000);
+    let chunk_size = 5000;
     let mut buffer_before_insert: Vec<player_username_state::Model> =
-        Vec::with_capacity(chunk_size.unwrap_or(1000));
+        Vec::with_capacity(chunk_size);
 
     let mut found_in_inserts = HashSet::new();
 
@@ -446,7 +408,7 @@ pub(crate) async fn handle_transaction_update_player_username_state(
                 Ok(player_username_state) => {
                     found_in_inserts.insert(player_username_state.entity_id);
                     buffer_before_insert.push(player_username_state);
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(1000) {
+                    if buffer_before_insert.len() == chunk_size {
                         db_insert_player_username_states(
                             p0,
                             &mut buffer_before_insert,
@@ -462,7 +424,7 @@ pub(crate) async fn handle_transaction_update_player_username_state(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         db_insert_player_username_states(p0, &mut buffer_before_insert, &on_conflict).await?;
     }
 
@@ -483,7 +445,7 @@ pub(crate) async fn handle_transaction_update_player_username_state(
         }
     }
 
-    if players_username_to_delete.len() > 0 {
+    if !players_username_to_delete.is_empty() {
         delete_player_username_state(p0, players_username_to_delete).await?;
     }
 
@@ -494,9 +456,8 @@ pub(crate) async fn handle_initial_subscription_player_state(
     p0: &DatabaseConnection,
     p1: &Table,
 ) -> anyhow::Result<()> {
-    let chunk_size = Some(5000);
-    let mut buffer_before_insert: Vec<player_state::Model> =
-        Vec::with_capacity(chunk_size.unwrap_or(5000));
+    let chunk_size = 5000;
+    let mut buffer_before_insert: Vec<player_state::Model> = Vec::with_capacity(chunk_size);
 
     let on_conflict = sea_query::OnConflict::column(player_state::Column::EntityId)
         .update_columns([
@@ -519,7 +480,7 @@ pub(crate) async fn handle_initial_subscription_player_state(
                         known_player_state_ids.remove(&player_state.entity_id);
                     }
                     buffer_before_insert.push(player_state);
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(5000) {
+                    if buffer_before_insert.len() == chunk_size {
                         info!("PlayerState insert");
                         db_insert_player_states(p0, &mut buffer_before_insert, &on_conflict)
                             .await?;
@@ -535,12 +496,12 @@ pub(crate) async fn handle_initial_subscription_player_state(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         info!("PlayerState insert");
         db_insert_player_states(p0, &mut buffer_before_insert, &on_conflict).await?;
     }
 
-    if known_player_state_ids.len() > 0 {
+    if !known_player_state_ids.is_empty() {
         delete_player_state(p0, known_player_state_ids).await?;
     }
 
@@ -549,7 +510,7 @@ pub(crate) async fn handle_initial_subscription_player_state(
 
 pub(crate) async fn handle_transaction_update_player_state(
     p0: &DatabaseConnection,
-    tables: &Vec<TableWithOriginalEventTransactionUpdate>,
+    tables: &[TableWithOriginalEventTransactionUpdate],
     sender: UnboundedSender<WebSocketMessages>,
 ) -> anyhow::Result<()> {
     let on_conflict = sea_query::OnConflict::column(player_state::Column::EntityId)
@@ -564,7 +525,7 @@ pub(crate) async fn handle_transaction_update_player_state(
         ])
         .to_owned();
 
-    let chunk_size = Some(5000);
+    let chunk_size = 5000;
     let mut buffer_before_insert = HashMap::new();
 
     let mut found_in_inserts = HashSet::new();
@@ -579,7 +540,7 @@ pub(crate) async fn handle_transaction_update_player_state(
                         .unwrap();
                     buffer_before_insert.insert(player_state.entity_id, player_state);
 
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(1000) {
+                    if buffer_before_insert.len() == chunk_size {
                         let mut buffer_before_insert_vec = buffer_before_insert
                             .clone()
                             .into_iter()
@@ -598,7 +559,7 @@ pub(crate) async fn handle_transaction_update_player_state(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         let mut buffer_before_insert_vec = buffer_before_insert
             .clone()
             .into_iter()
@@ -626,7 +587,7 @@ pub(crate) async fn handle_transaction_update_player_state(
         }
     }
 
-    if players_to_delete.len() > 0 {
+    if !players_to_delete.is_empty() {
         delete_player_state(p0, players_to_delete).await?;
     }
 
diff --git a/rust/api-server/api/src/recipes/mod.rs b/rust/api-server/api/src/recipes/mod.rs
index 9ab8943..fd3ce27 100644
--- a/rust/api-server/api/src/recipes/mod.rs
+++ b/rust/api-server/api/src/recipes/mod.rs
@@ -17,7 +17,6 @@ use service::Query as QueryCore;
 use std::collections::HashMap;
 use std::fs::File;
 use std::ops::Add;
-use std::path::PathBuf;
 use std::time::Duration;
 use struson::json_path;
 use struson::reader::{JsonReader, JsonStreamReader};
@@ -189,7 +188,7 @@ fn get_all_consumed_items_from_stack(
 
 #[allow(dead_code)]
 pub(crate) async fn load_crafting_recipe_desc_from_file(
-    storage_path: &PathBuf,
+    storage_path: &std::path::Path,
 ) -> anyhow::Result<Vec<crafting_recipe::Model>> {
     let crafting_recipe_desc_file = File::open(storage_path.join("Desc/CraftingRecipeDesc.json"))?;
     let crafting_recipe_desc: Value = serde_json::from_reader(&crafting_recipe_desc_file)?;
@@ -242,7 +241,7 @@ pub(crate) async fn load_desc_from_spacetimedb(
     Ok(())
 }
 
-pub async fn import_job_recipes_desc(temp_config: Config) -> () {
+pub async fn import_job_recipes_desc(temp_config: Config) {
     let temp_config = temp_config.clone();
     let config = temp_config.clone();
     if config.live_updates {
@@ -391,7 +390,7 @@ pub(crate) async fn import_crafting_recipe_descs(
                 .map(|crafting_recipe_desc| crafting_recipe_desc.clone().into_active_model())
                 .collect::<Vec<crafting_recipe::ActiveModel>>();
 
-            if things_to_insert.len() == 0 {
+            if things_to_insert.is_empty() {
                 debug!("Nothing to insert");
                 buffer_before_insert.clear();
                 continue;
@@ -417,7 +416,7 @@ pub(crate) async fn import_crafting_recipe_descs(
         }
     };
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         let crafting_recipe_descs_from_db = crafting_recipe::Entity::find()
             .filter(
                 crafting_recipe::Column::Id.is_in(
@@ -454,7 +453,7 @@ pub(crate) async fn import_crafting_recipe_descs(
             .map(|crafting_recipe_desc| crafting_recipe_desc.clone().into_active_model())
             .collect::<Vec<crafting_recipe::ActiveModel>>();
 
-        if things_to_insert.len() == 0 {
+        if things_to_insert.is_empty() {
             debug!("Nothing to insert");
             buffer_before_insert.clear();
         } else {
@@ -473,7 +472,7 @@ pub(crate) async fn import_crafting_recipe_descs(
         start.elapsed().as_secs()
     );
 
-    if crafting_recipe_descs_to_delete.len() > 0 {
+    if !crafting_recipe_descs_to_delete.is_empty() {
         info!(
             "crafting_recipe_desc's to delete: {:?}",
             crafting_recipe_descs_to_delete
@@ -555,7 +554,7 @@ pub(crate) async fn import_crafting_recipe_descs(
 //         .map(|recipe| recipe.clone().into_active_model())
 //         .collect::<Vec<crafting_recipe::ActiveModel>>();
 
-//     if things_to_insert.len() == 0 {
+//     if things_to_insert.is_empty() {
 //         debug!("Nothing to insert");
 //         buffer_before_insert.clear();
 //         return Ok(());
@@ -677,9 +676,9 @@ pub(crate) async fn import_crafting_recipe_descs(
 //     for p1 in tables.iter() {
 //         let event_type = if p1.inserts.len() > 0 && p1.deletes.len() > 0 {
 //             "update"
-//         } else if p1.inserts.len() > 0 && p1.deletes.len() == 0 {
+//         } else if p1.inserts.len() > 0 && p1.deletes.is_empty() {
 //             "insert"
-//         } else if p1.deletes.len() > 0 && p1.inserts.len() == 0 {
+//         } else if p1.deletes.len() > 0 && p1.inserts.is_empty() {
 //             "delete"
 //         } else {
 //             "unknown"
diff --git a/rust/api-server/api/src/skill_descriptions/mod.rs b/rust/api-server/api/src/skill_descriptions/mod.rs
index c0a416c..961e310 100644
--- a/rust/api-server/api/src/skill_descriptions/mod.rs
+++ b/rust/api-server/api/src/skill_descriptions/mod.rs
@@ -10,7 +10,6 @@ use serde_json::Value;
 use std::collections::HashMap;
 use std::fs::File;
 use std::ops::Add;
-use std::path::PathBuf;
 use std::time::Duration;
 use struson::json_path;
 use struson::reader::{JsonReader, JsonStreamReader};
@@ -18,7 +17,7 @@ use tokio::time::Instant;
 
 #[allow(dead_code)]
 pub(crate) async fn load_skill_desc_from_file(
-    storage_path: &PathBuf,
+    storage_path: &std::path::Path,
 ) -> anyhow::Result<Vec<skill_desc::Model>> {
     let skill_desc_file = File::open(storage_path.join("Desc/SkillDesc.json"))?;
     let skill_desc: Value = serde_json::from_reader(&skill_desc_file)?;
@@ -60,7 +59,7 @@ pub(crate) async fn load_desc_from_spacetimedb(
     let claim_descriptions =
         load_skill_desc_from_spacetimedb(client, domain, protocol, database).await?;
 
-    import_skill_descs(&conn, claim_descriptions, Some(3000)).await?;
+    import_skill_descs(conn, claim_descriptions, Some(3000)).await?;
 
     Ok(())
 }
@@ -131,24 +130,16 @@ pub(crate) async fn import_skill_descs(
 
             let things_to_insert = buffer_before_insert
                 .iter()
-                .filter(|skill_desc| {
-                    match skill_descs_from_db_map.get(&skill_desc.id) {
-                        Some(skill_desc_from_db) => {
-                            if skill_desc_from_db != *skill_desc {
-                                return true;
-                            }
-                        }
-                        None => {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                })
+                .filter(
+                    |skill_desc| match skill_descs_from_db_map.get(&skill_desc.id) {
+                        Some(skill_desc_from_db) => skill_desc_from_db != *skill_desc,
+                        None => true,
+                    },
+                )
                 .map(|skill_desc| skill_desc.clone().into_active_model())
                 .collect::<Vec<skill_desc::ActiveModel>>();
 
-            if things_to_insert.len() == 0 {
+            if things_to_insert.is_empty() {
                 debug!("Nothing to insert");
                 buffer_before_insert.clear();
                 continue;
@@ -160,8 +151,8 @@ pub(crate) async fn import_skill_descs(
                 let skill_desc_in = skill_descs_to_delete
                     .iter()
                     .position(|id| id == skill_desc.id.as_ref());
-                if skill_desc_in.is_some() {
-                    skill_descs_to_delete.remove(skill_desc_in.unwrap());
+                if let Some(skill_desc_in) = skill_desc_in {
+                    skill_descs_to_delete.remove(skill_desc_in);
                 }
             }
 
@@ -174,7 +165,7 @@ pub(crate) async fn import_skill_descs(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         let skill_descs_from_db = skill_desc::Entity::find()
             .filter(
                 skill_desc::Column::Id.is_in(
@@ -194,24 +185,16 @@ pub(crate) async fn import_skill_descs(
 
         let things_to_insert = buffer_before_insert
             .iter()
-            .filter(|skill_desc| {
-                match skill_descs_from_db_map.get(&skill_desc.id) {
-                    Some(skill_desc_from_db) => {
-                        if skill_desc_from_db != *skill_desc {
-                            return true;
-                        }
-                    }
-                    None => {
-                        return true;
-                    }
-                }
-
-                return false;
-            })
+            .filter(
+                |skill_desc| match skill_descs_from_db_map.get(&skill_desc.id) {
+                    Some(skill_desc_from_db) => skill_desc_from_db != *skill_desc,
+                    None => true,
+                },
+            )
             .map(|skill_desc| skill_desc.clone().into_active_model())
             .collect::<Vec<skill_desc::ActiveModel>>();
 
-        if things_to_insert.len() == 0 {
+        if things_to_insert.is_empty() {
             debug!("Nothing to insert");
             buffer_before_insert.clear();
         } else {
@@ -230,7 +213,7 @@ pub(crate) async fn import_skill_descs(
         start.elapsed().as_secs()
     );
 
-    if skill_descs_to_delete.len() > 0 {
+    if !skill_descs_to_delete.is_empty() {
         info!("skill_desc's to delete: {:?}", skill_descs_to_delete);
         skill_desc::Entity::delete_many()
             .filter(skill_desc::Column::Id.is_in(skill_descs_to_delete))
@@ -258,7 +241,7 @@ fn import_skill_descriptions(config: Config, conn: DatabaseConnection, client: C
                 )
                 .await;
 
-                if let Ok(_) = skill_descriptions_desc {
+                if skill_descriptions_desc.is_ok() {
                     info!("SkillDescriptionsDesc imported");
                 } else {
                     error!(
@@ -270,7 +253,7 @@ fn import_skill_descriptions(config: Config, conn: DatabaseConnection, client: C
     });
 }
 
-pub async fn import_job_skill_desc(temp_config: Config) -> () {
+pub async fn import_job_skill_desc(temp_config: Config) {
     let config = temp_config.clone();
     if config.live_updates {
         let conn = super::create_importer_default_db_connection(config.clone()).await;
diff --git a/rust/api-server/api/src/trading_orders/mod.rs b/rust/api-server/api/src/trading_orders/mod.rs
index f102f62..d883150 100644
--- a/rust/api-server/api/src/trading_orders/mod.rs
+++ b/rust/api-server/api/src/trading_orders/mod.rs
@@ -16,7 +16,6 @@ use sea_orm::{
 use serde::{Deserialize, Serialize};
 use service::Query as QueryCore;
 use std::collections::HashMap;
-use std::path::PathBuf;
 use struson::json_path;
 use struson::reader::{JsonReader, JsonStreamReader};
 use tokio::time::Instant;
@@ -65,13 +64,13 @@ async fn get_trade_orders(
         vec![]
     };
 
-    let items_ids = if items_ids.len() > 0 {
+    let items_ids = if !items_ids.is_empty() {
         Some(items_ids)
     } else {
         None
     };
 
-    let cargo_ids = if cargo_ids.len() > 0 {
+    let cargo_ids = if !cargo_ids.is_empty() {
         Some(cargo_ids)
     } else {
         None
@@ -183,7 +182,9 @@ pub(crate) struct TradeOrdersResponse {
     per_page: u64,
 }
 
-pub(crate) async fn load_trade_order_from_file(storage_path: &PathBuf) -> anyhow::Result<String> {
+pub(crate) async fn load_trade_order_from_file(
+    storage_path: &std::path::PathBuf,
+) -> anyhow::Result<String> {
     Ok(std::fs::read_to_string(
         storage_path.join("State/TradeOrderState.json"),
     )?)
@@ -221,7 +222,7 @@ pub(crate) async fn load_trade_order(
 ) -> anyhow::Result<()> {
     let trade_orders = match &config.import_type {
         crate::config::ImportType::File => {
-            load_trade_order_from_file(&PathBuf::from(&config.storage_path)).await?
+            load_trade_order_from_file(&std::path::PathBuf::from(&config.storage_path)).await?
         }
         crate::config::ImportType::Game => {
             load_trade_order_from_spacetimedb(client, domain, protocol, database).await?
@@ -313,7 +314,7 @@ pub(crate) async fn import_trade_order(
                 .map(|trade_order| trade_order.clone().into_active_model())
                 .collect::<Vec<trade_order::ActiveModel>>();
 
-            if things_to_insert.len() == 0 {
+            if things_to_insert.is_empty() {
                 debug!("Nothing to insert");
                 buffer_before_insert.clear();
                 continue;
@@ -339,7 +340,7 @@ pub(crate) async fn import_trade_order(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         let trade_order_from_db = trade_order::Entity::find()
             .filter(
                 trade_order::Column::EntityId.is_in(
@@ -376,7 +377,7 @@ pub(crate) async fn import_trade_order(
             .map(|trade_order| trade_order.clone().into_active_model())
             .collect::<Vec<trade_order::ActiveModel>>();
 
-        if things_to_insert.len() == 0 {
+        if things_to_insert.is_empty() {
             debug!("Nothing to insert");
             buffer_before_insert.clear();
         } else {
@@ -395,7 +396,7 @@ pub(crate) async fn import_trade_order(
         start.elapsed().as_secs()
     );
 
-    if trade_order_to_delete.len() > 0 {
+    if !trade_order_to_delete.is_empty() {
         info!("trade_order's to delete: {:?}", trade_order_to_delete);
         trade_order::Entity::delete_many()
             .filter(trade_order::Column::EntityId.is_in(trade_order_to_delete))
diff --git a/rust/api-server/api/src/vault_state/mod.rs b/rust/api-server/api/src/vault_state/mod.rs
index 73f5f63..ee3dc88 100644
--- a/rust/api-server/api/src/vault_state/mod.rs
+++ b/rust/api-server/api/src/vault_state/mod.rs
@@ -71,26 +71,18 @@ async fn db_insert_player_states(
     let things_to_insert = buffer_before_insert
         .iter()
         .map(|player_state| player_state.clone().to_model())
-        .filter(|player_state| {
-            match player_states_from_db_map.get(&player_state.entity_id) {
-                Some(player_state_from_db) => {
-                    if player_state_from_db != player_state {
-                        return true;
-                    }
-                }
-                None => {
-                    return true;
-                }
-            }
-
-            return false;
-        })
+        .filter(
+            |player_state| match player_states_from_db_map.get(&player_state.entity_id) {
+                Some(player_state_from_db) => player_state_from_db != player_state,
+                None => true,
+            },
+        )
         .map(|player_state| player_state.clone().into_active_model())
         .collect::<Vec<vault_state::ActiveModel>>();
 
     let mut things_to_insert_collectibles = buffer_before_insert
-        .into_iter()
-        .map(|player_state| {
+        .iter_mut()
+        .flat_map(|player_state| {
             player_state
                 .clone()
                 .collectibles
@@ -98,7 +90,6 @@ async fn db_insert_player_states(
                 .map(|collectible| collectible.to_model(player_state.entity_id))
                 .collect::<Vec<vault_state_collectibles::Model>>()
         })
-        .flatten()
         .filter(|player_state| {
             if let Some(list_of_vault_state_collectibles_to_delete) =
                 list_of_vault_state_collectibles_to_delete
@@ -109,21 +100,14 @@ async fn db_insert_player_states(
             match vault_states_collectibles_from_db_map
                 .get(&(player_state.entity_id, player_state.id))
             {
-                Some(player_state_from_db) => {
-                    if player_state_from_db != player_state {
-                        return true;
-                    }
-                }
-                None => {
-                    return true;
-                }
+                Some(player_state_from_db) => player_state_from_db != player_state,
+                None => true,
             }
-            return false;
         })
         .map(|player_state| player_state.clone().into_active_model())
         .collect::<Vec<vault_state_collectibles::ActiveModel>>();
 
-    if things_to_insert.len() == 0 {
+    if things_to_insert.is_empty() {
         debug!("Nothing to insert");
         buffer_before_insert.clear();
     } else {
@@ -135,7 +119,7 @@ async fn db_insert_player_states(
         buffer_before_insert.clear();
     }
 
-    if things_to_insert_collectibles.len() == 0 {
+    if things_to_insert_collectibles.is_empty() {
         debug!("Nothing to insert");
         things_to_insert_collectibles.clear();
     } else {
@@ -179,9 +163,8 @@ pub(crate) async fn handle_initial_subscription(
     p0: &DatabaseConnection,
     p1: &Table,
 ) -> anyhow::Result<()> {
-    let chunk_size = Some(500);
-    let mut buffer_before_insert: Vec<RawVaultState> =
-        Vec::with_capacity(chunk_size.unwrap_or(5000));
+    let chunk_size = 500;
+    let mut buffer_before_insert: Vec<RawVaultState> = Vec::with_capacity(chunk_size);
 
     let on_conflict = sea_query::OnConflict::column(vault_state::Column::EntityId)
         .update_columns([vault_state::Column::Shards])
@@ -216,7 +199,7 @@ pub(crate) async fn handle_initial_subscription(
                         known_player_state_ids.remove(&player_state.entity_id);
                     }
                     buffer_before_insert.push(player_state);
-                    if buffer_before_insert.len() == chunk_size.unwrap_or(5000) {
+                    if buffer_before_insert.len() == chunk_size {
                         db_insert_player_states(
                             p0,
                             &mut buffer_before_insert,
@@ -237,7 +220,7 @@ pub(crate) async fn handle_initial_subscription(
         }
     }
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         db_insert_player_states(
             p0,
             &mut buffer_before_insert,
@@ -248,11 +231,11 @@ pub(crate) async fn handle_initial_subscription(
         .await?;
     }
 
-    if known_player_state_ids.len() > 0 {
+    if !known_player_state_ids.is_empty() {
         delete_player_state(p0, known_player_state_ids, false).await?;
     }
 
-    if known_vault_state_collectibles_ids.len() > 0 {
+    if !known_vault_state_collectibles_ids.is_empty() {
         delete_vault_state_collectibles(p0, known_vault_state_collectibles_ids).await?;
     }
 
@@ -263,15 +246,15 @@ async fn delete_vault_state_collectibles(
     p0: &DatabaseConnection,
     p1: HashSet<(i64, i32)>,
 ) -> anyhow::Result<()> {
-    let to_chunk = p1.iter().map(|x| x.clone()).collect::<Vec<_>>();
+    let to_chunk = p1.iter().clone().collect::<Vec<_>>();
 
     for chunk in to_chunk.chunks(3000) {
         let filter_to_process = chunk
             .iter()
             .map(|(entity_id, id)| {
                 vault_state_collectibles::Column::EntityId
-                    .eq(entity_id.clone())
-                    .and(vault_state_collectibles::Column::Id.eq(id.clone()))
+                    .eq(*entity_id)
+                    .and(vault_state_collectibles::Column::Id.eq(*id))
             })
             .collect::<Vec<_>>();
 
@@ -298,7 +281,7 @@ async fn delete_vault_state_collectibles(
 
 pub(crate) async fn handle_transaction_update(
     p0: &DatabaseConnection,
-    tables: &Vec<TableWithOriginalEventTransactionUpdate>,
+    tables: &[TableWithOriginalEventTransactionUpdate],
 ) -> anyhow::Result<()> {
     let on_conflict = sea_query::OnConflict::column(vault_state::Column::EntityId)
         .update_columns([vault_state::Column::Shards])
@@ -343,7 +326,7 @@ pub(crate) async fn handle_transaction_update(
         .into_iter()
         .collect::<HashSet<(i64, i32)>>();
 
-    if buffer_before_insert.len() > 0 {
+    if !buffer_before_insert.is_empty() {
         let mut buffer_before_insert_vec = buffer_before_insert
             .clone()
             .into_iter()
@@ -377,11 +360,11 @@ pub(crate) async fn handle_transaction_update(
         }
     }
 
-    if players_to_delete.len() > 0 {
+    if !players_to_delete.is_empty() {
         delete_player_state(p0, players_to_delete, true).await?;
     }
 
-    if known_vault_state_collectibles_ids.len() > 0 {
+    if !known_vault_state_collectibles_ids.is_empty() {
         delete_vault_state_collectibles(p0, known_vault_state_collectibles_ids).await?;
     }
 
diff --git a/rust/api-server/api/src/websocket.rs b/rust/api-server/api/src/websocket.rs
index f20e120..fc80c3d 100644
--- a/rust/api-server/api/src/websocket.rs
+++ b/rust/api-server/api/src/websocket.rs
@@ -128,7 +128,7 @@ pub fn start_websocket_bitcraft_logic(
         let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
 
         let tmp_config = config.clone();
-        let _ = tokio::spawn(async move {
+        tokio::spawn(async move {
             let db = crate::create_importer_default_db_connection(tmp_config.clone()).await;
 
             let skill_id_to_skill_name = skill_desc::Entity::find()
@@ -140,7 +140,6 @@ pub fn start_websocket_bitcraft_logic(
                 .await
                 .unwrap()
                 .into_iter()
-                .map(|(id, name)| (id, name))
                 .collect::<HashMap<i64, String>>();
 
             loop {
@@ -153,42 +152,39 @@ pub fn start_websocket_bitcraft_logic(
                 let mut raw_events_data = vec![];
 
                 for event in evenets.iter() {
-                    match event {
-                        WebSocketMessage::TransactionUpdate(transaction_update) => {
-                            let mut compressor =
-                                async_compression::tokio::write::ZstdEncoder::new(vec![]);
-                            let _ = compressor
-                                .write_all(
-                                    serde_json::to_string(&transaction_update)
-                                        .unwrap()
-                                        .as_bytes(),
-                                )
-                                .await;
-                            compressor.flush().await.unwrap();
-                            compressor.shutdown().await.unwrap();
-
-                            let user_id = transaction_update.caller_identity.__identity__.clone();
-
-                            let user_id = app_state.user_map.get(&user_id.as_ref().to_string());
-
-                            raw_events_data.push(
-                                RawEventData {
-                                    timestamp: transaction_update.timestamp.microseconds,
-                                    request_id: transaction_update.reducer_call.request_id as i64,
-                                    reducer_name: transaction_update
-                                        .reducer_call
-                                        .reducer_name
-                                        .clone()
-                                        .parse()
-                                        .unwrap(),
-                                    reducer_id: transaction_update.reducer_call.reducer_id as i64,
-                                    event_data: compressor.into_inner(),
-                                    user_id: user_id.cloned(),
-                                }
-                                .into_active_model(),
-                            );
-                        }
-                        _ => {}
+                    if let WebSocketMessage::TransactionUpdate(transaction_update) = event {
+                        let mut compressor =
+                            async_compression::tokio::write::ZstdEncoder::new(vec![]);
+                        let _ = compressor
+                            .write_all(
+                                serde_json::to_string(&transaction_update)
+                                    .unwrap()
+                                    .as_bytes(),
+                            )
+                            .await;
+                        compressor.flush().await.unwrap();
+                        compressor.shutdown().await.unwrap();
+
+                        let user_id = transaction_update.caller_identity.__identity__.clone();
+
+                        let user_id = app_state.user_map.get(&user_id.to_string());
+
+                        raw_events_data.push(
+                            RawEventData {
+                                timestamp: transaction_update.timestamp.microseconds,
+                                request_id: transaction_update.reducer_call.request_id as i64,
+                                reducer_name: transaction_update
+                                    .reducer_call
+                                    .reducer_name
+                                    .clone()
+                                    .parse()
+                                    .unwrap(),
+                                reducer_id: transaction_update.reducer_call.reducer_id as i64,
+                                event_data: compressor.into_inner(),
+                                user_id: user_id.cloned(),
+                            }
+                            .into_active_model(),
+                        );
                     }
                 }
 
@@ -206,7 +202,7 @@ pub fn start_websocket_bitcraft_logic(
                             )
                             .increment(1);
 
-                            if transaction_update.status.committed.tables.len() == 0 {
+                            if transaction_update.status.committed.tables.is_empty() {
                                 continue;
                             }
 
@@ -215,13 +211,13 @@ pub fn start_websocket_bitcraft_logic(
                                     "websocket_message_table_count",
                                     &[
                                         ("type", "TransactionUpdate".to_string()),
-                                        ("table", format!("{}", table.table_name.as_ref())),
+                                        ("table", format!("{}", table.table_name)),
                                     ]
                                 )
                                 .increment(1);
 
                                 if let Some(table_vec) =
-                                    tables.get_mut(&table.table_name.as_ref().to_string())
+                                    tables.get_mut(&table.table_name.to_string())
                                 {
                                     //TODO this probebly has to be rewriten
                                     table.updates.iter().for_each(|updates| {
@@ -262,7 +258,7 @@ pub fn start_websocket_bitcraft_logic(
                             )
                             .increment(1);
 
-                            if subscription_update.database_update.tables.len() == 0 {
+                            if subscription_update.database_update.tables.is_empty() {
                                 continue;
                             }
 
@@ -271,7 +267,7 @@ pub fn start_websocket_bitcraft_logic(
                                     "websocket_message_table_count",
                                     &[
                                         ("type", "InitialSubscription".to_string()),
-                                        ("table", format!("{}", table.table_name.as_ref())),
+                                        ("table", format!("{}", table.table_name)),
                                     ]
                                 )
                                 .increment(1);
@@ -282,7 +278,7 @@ pub fn start_websocket_bitcraft_logic(
                                     for update in table.updates.iter() {
                                         for row in update.inserts.iter() {
                                             let user_state: user_state::Model =
-                                                match serde_json::from_str(&row) {
+                                                match serde_json::from_str(row) {
                                                     Ok(user_state) => user_state,
                                                     Err(error) => {
                                                         error!(
@@ -428,7 +424,7 @@ pub fn start_websocket_bitcraft_logic(
                                     for update in table.updates.iter() {
                                         for row in update.inserts.iter() {
                                             let mobile_entity_state: entity::mobile_entity_state::Model =
-                                                match serde_json::from_str(&row) {
+                                                match serde_json::from_str(row) {
                                                     Ok(mobile_entity_state) => mobile_entity_state,
                                                     Err(error) => {
                                                         error!("InitialSubscription Insert mobile_entity_state Error: {:?} -> {:?}", error, row);
@@ -454,7 +450,7 @@ pub fn start_websocket_bitcraft_logic(
                                     for update in table.updates.iter() {
                                         for row in update.inserts.iter() {
                                             let claim_tile_state: entity::claim_tile_state::Model =
-                                                match serde_json::from_str(&row) {
+                                                match serde_json::from_str(row) {
                                                     Ok(claim_tile_state) => claim_tile_state,
                                                     Err(error) => {
                                                         error!(
@@ -477,7 +473,7 @@ pub fn start_websocket_bitcraft_logic(
                                     for update in table.updates.iter() {
                                         for row in update.inserts.iter() {
                                             let crafting_recipe_desc: entity::crafting_recipe::Model =
-                                                match serde_json::from_str(&row) {
+                                                match serde_json::from_str(row) {
                                                     Ok(crafting_recipe_desc) => crafting_recipe_desc,
                                                     Err(error) => {
                                                         error!("InitialSubscription Insert crafting_recipe_desc Error: {:?} -> {:?}", error, row);
@@ -497,7 +493,7 @@ pub fn start_websocket_bitcraft_logic(
                                     for update in table.updates.iter() {
                                         for row in update.inserts.iter() {
                                             let player_action_state: entity::player_action_state::Model =
-                                                match serde_json::from_str(&row) {
+                                                match serde_json::from_str(row) {
                                                     Ok(player_action_state) => player_action_state,
                                                     Err(error) => {
                                                         error!("InitialSubscription Insert player_action_state Error: {:?} -> {:?}", error, row);
@@ -517,7 +513,7 @@ pub fn start_websocket_bitcraft_logic(
                                     for update in table.updates.iter() {
                                         for row in update.inserts.iter() {
                                             let action_state: entity::action_state::Model =
-                                                match serde_json::from_str(&row) {
+                                                match serde_json::from_str(row) {
                                                     Ok(action_state) => action_state,
                                                     Err(error) => {
                                                         error!(
@@ -576,13 +572,11 @@ pub fn start_websocket_bitcraft_logic(
 
                     if table_name == "user_state" {
                         for row in table.iter() {
-                            if row.inserts.len() == 0 {
+                            if row.inserts.is_empty() {
                                 continue;
                             }
 
-                            match serde_json::from_str::<user_state::Model>(
-                                &row.inserts[0].as_ref(),
-                            ) {
+                            match serde_json::from_str::<user_state::Model>(&row.inserts[0]) {
                                 Ok(user_state) => {
                                     app_state.user_map.insert(
                                         user_state.identity.__identity__,
@@ -713,7 +707,7 @@ pub fn start_websocket_bitcraft_logic(
 
                             for row in current_table.deletes.iter() {
                                 let mobile_entity_state: entity::mobile_entity_state::Model =
-                                    match serde_json::from_str(&row) {
+                                    match serde_json::from_str(row) {
                                         Ok(mobile_entity_state) => mobile_entity_state,
                                         Err(error) => {
                                             error!(
@@ -732,7 +726,7 @@ pub fn start_websocket_bitcraft_logic(
 
                             for row in current_table.inserts.iter() {
                                 let mobile_entity_state: entity::mobile_entity_state::Model =
-                                    match serde_json::from_str(&row) {
+                                    match serde_json::from_str(row) {
                                         Ok(mobile_entity_state) => mobile_entity_state,
                                         Err(error) => {
                                             error!(
@@ -898,7 +892,7 @@ pub fn start_websocket_bitcraft_logic(
                         for current_table in table.iter() {
                             for row in current_table.inserts.iter() {
                                 let claim_tile_state: entity::claim_tile_state::Model =
-                                    match serde_json::from_str(&row) {
+                                    match serde_json::from_str(row) {
                                         Ok(claim_tile_state) => claim_tile_state,
                                         Err(error) => {
                                             error!(
@@ -920,7 +914,7 @@ pub fn start_websocket_bitcraft_logic(
                         for current_table in table.iter() {
                             for row in current_table.inserts.iter() {
                                 let action_state: entity::action_state::Model =
-                                    match serde_json::from_str(&row) {
+                                    match serde_json::from_str(row) {
                                         Ok(action_state) => action_state,
                                         Err(error) => {
                                             error!(
@@ -956,7 +950,7 @@ pub fn start_websocket_bitcraft_logic(
                         for current_table in table.iter() {
                             for row in current_table.inserts.iter() {
                                 let player_action_state: entity::player_action_state::Model =
-                                    match serde_json::from_str(&row) {
+                                    match serde_json::from_str(row) {
                                         Ok(player_action_state) => player_action_state,
                                         Err(error) => {
                                             error!(
@@ -1054,11 +1048,9 @@ pub fn start_websocket_bitcraft_logic(
                         debug!("Received identity token: {identity_token:?}");
                     }
                 }
+            } else if let Message::Ping(_) = message {
             } else {
-                if let Message::Ping(_) = message {
-                } else {
-                    warn!("Message: {:?}", message);
-                }
+                warn!("Message: {:?}", message);
             }
         }
     });
diff --git a/rust/api-server/entity/src/collectible_desc.rs b/rust/api-server/entity/src/collectible_desc.rs
index 133e37a..ecd81a1 100644
--- a/rust/api-server/entity/src/collectible_desc.rs
+++ b/rust/api-server/entity/src/collectible_desc.rs
@@ -93,7 +93,7 @@ impl<'de> Deserialize<'de> for InvalidatesType {
                         14 => Ok(InvalidatesType::Deployable),
                         15 => Ok(InvalidatesType::Title),
                         16 => Ok(InvalidatesType::Crown),
-                        _ => Err(de::Error::custom("invalid enum variant")),
+                        _ => Err(de::Error::custom("invalid enum variant invalidates_type")),
                     }
                 } else {
                     Err(de::Error::custom("expected a map with a single key"))
@@ -124,7 +124,7 @@ impl<'de> Deserialize<'de> for InvalidatesType {
                         14 => Ok(InvalidatesType::Deployable),
                         15 => Ok(InvalidatesType::Title),
                         16 => Ok(InvalidatesType::Crown),
-                        _ => Err(de::Error::custom("invalid enum variant")),
+                        _ => Err(de::Error::custom("invalid enum variant invalidates_type")),
                     }
                 } else {
                     Err(de::Error::custom(
@@ -158,6 +158,7 @@ pub enum CollectibleType {
     Deployable = 14,
     Title = 15,
     Crown = 16,
+    Pet = 17,
 }
 
 impl<'de> Deserialize<'de> for CollectibleType {
@@ -198,7 +199,8 @@ impl<'de> Deserialize<'de> for CollectibleType {
                         14 => Ok(CollectibleType::Deployable),
                         15 => Ok(CollectibleType::Title),
                         16 => Ok(CollectibleType::Crown),
-                        _ => Err(de::Error::custom("invalid enum variant")),
+                        17 => Ok(CollectibleType::Pet),
+                        _ => Err(de::Error::custom("invalid enum variant collectible_type")),
                     }
                 } else {
                     Err(de::Error::custom("expected a map with a single key"))
@@ -230,7 +232,8 @@ impl<'de> Deserialize<'de> for CollectibleType {
                         14 => Ok(CollectibleType::Deployable),
                         15 => Ok(CollectibleType::Title),
                         16 => Ok(CollectibleType::Crown),
-                        _ => Err(de::Error::custom("invalid enum variant")),
+                        17 => Ok(CollectibleType::Pet),
+                        _ => Err(de::Error::custom("invalid enum variant collectible_type")),
                     }
                 } else {
                     Err(de::Error::custom(
@@ -284,7 +287,7 @@ impl<'de> Deserialize<'de> for CollectibleRarity {
                         4 => Ok(CollectibleRarity::Epic),
                         5 => Ok(CollectibleRarity::Legendary),
                         6 => Ok(CollectibleRarity::Mythic),
-                        _ => Err(de::Error::custom("invalid enum variant")),
+                        _ => Err(de::Error::custom("invalid enum variant collectible_rarity")),
                     }
                 } else {
                     Err(de::Error::custom("expected a map with a single key"))
@@ -305,7 +308,7 @@ impl<'de> Deserialize<'de> for CollectibleRarity {
                         4 => Ok(CollectibleRarity::Epic),
                         5 => Ok(CollectibleRarity::Legendary),
                         6 => Ok(CollectibleRarity::Mythic),
-                        _ => Err(de::Error::custom("invalid enum variant")),
+                        _ => Err(de::Error::custom("invalid enum variant collectible_rarity")),
                     }
                 } else {
                     Err(de::Error::custom(
diff --git a/rust/api-server/entity/src/player_action_state.rs b/rust/api-server/entity/src/player_action_state.rs
index 6e6e659..5b6db26 100644
--- a/rust/api-server/entity/src/player_action_state.rs
+++ b/rust/api-server/entity/src/player_action_state.rs
@@ -28,26 +28,25 @@ where
     D: Deserializer<'de>,
 {
     let json = serde_json::Value::deserialize(deserializer)?;
-    match json {
-        serde_json::Value::Array(array) => {
-            if array.len() == 2 {
-                if let serde_json::Value::Number(number) = array[0].clone() {
-                    if let Some(number) = number.as_i64() {
-                        if number == 1 {
-                            return Ok(None);
-                        }
+
+    if let serde_json::Value::Array(array) = json {
+        if array.len() == 2 {
+            if let serde_json::Value::Number(number) = array[0].clone() {
+                if let Some(number) = number.as_i64() {
+                    if number == 1 {
+                        return Ok(None);
                     }
                 }
+            }
 
-                if let serde_json::Value::Number(number) = array[1].clone() {
-                    if let Some(number) = number.as_i64() {
-                        return Ok(Some(number as i32));
-                    }
+            if let serde_json::Value::Number(number) = array[1].clone() {
+                if let Some(number) = number.as_i64() {
+                    return Ok(Some(number as i32));
                 }
             }
         }
-        _ => {}
     }
+
     Err(serde::de::Error::custom("Invalid value"))
 }
 
@@ -223,6 +222,7 @@ impl<'de> Deserialize<'de> for ActionType {
     }
 }
 
+#[cfg(test)]
 mod tests {
     use super::*;
 
diff --git a/rust/api-server/entity/src/skill_desc.rs b/rust/api-server/entity/src/skill_desc.rs
index 9c2052f..a76498d 100644
--- a/rust/api-server/entity/src/skill_desc.rs
+++ b/rust/api-server/entity/src/skill_desc.rs
@@ -43,7 +43,7 @@ impl SkillDescRaw {
             description: self.description.clone(),
             icon_asset_name: self.icon_asset_name.clone(),
             title: self.title.clone(),
-            skill_category: skill_category,
+            skill_category,
         })
     }
 }
diff --git a/rust/api-server/migration/src/m20240801_163734_changes_experience_state.rs b/rust/api-server/migration/src/m20240801_163734_changes_experience_state.rs
index a60c1af..42c100c 100644
--- a/rust/api-server/migration/src/m20240801_163734_changes_experience_state.rs
+++ b/rust/api-server/migration/src/m20240801_163734_changes_experience_state.rs
@@ -455,6 +455,7 @@ enum Inventory {
     Table,
     EntityId,
     Pockets,
+    #[allow(clippy::enum_variant_names)]
     InventoryIndex,
     CargoIndex,
     OwnerEntityId,
diff --git a/rust/api-server/migration/src/m20241208_205237_raw_event_data.rs b/rust/api-server/migration/src/m20241208_205237_raw_event_data.rs
index 6d774de..398c647 100644
--- a/rust/api-server/migration/src/m20241208_205237_raw_event_data.rs
+++ b/rust/api-server/migration/src/m20241208_205237_raw_event_data.rs
@@ -36,7 +36,7 @@ impl MigrationTrait for Migration {
                     )
                     .col(
                         ColumnDef::new(RawEventData::EventData)
-                            .var_binary(1000000000 as u32)
+                            .var_binary(1_000_000_000_u32)
                             .not_null(),
                     )
                     .to_owned(),
diff --git a/rust/api-server/service/src/query.rs b/rust/api-server/service/src/query.rs
index d700abc..7b12ef1 100644
--- a/rust/api-server/service/src/query.rs
+++ b/rust/api-server/service/src/query.rs
@@ -184,13 +184,9 @@ impl Query {
                     _ => unreachable!(),
                 }
             })
-            .apply_if(tier.clone(), |query, value| {
-                match db.get_database_backend() {
-                    DbBackend::Postgres => {
-                        query.filter(Expr::col(item_desc::Column::Tier).eq(value))
-                    }
-                    _ => unreachable!(),
-                }
+            .apply_if(*tier, |query, value| match db.get_database_backend() {
+                DbBackend::Postgres => query.filter(Expr::col(item_desc::Column::Tier).eq(value)),
+                _ => unreachable!(),
             })
             .all(db)
             .await
@@ -276,13 +272,9 @@ impl Query {
                     _ => unreachable!(),
                 }
             })
-            .apply_if(tier.clone(), |query, value| {
-                match db.get_database_backend() {
-                    DbBackend::Postgres => {
-                        query.filter(Expr::col(cargo_desc::Column::Tier).eq(value))
-                    }
-                    _ => unreachable!(),
-                }
+            .apply_if(*tier, |query, value| match db.get_database_backend() {
+                DbBackend::Postgres => query.filter(Expr::col(cargo_desc::Column::Tier).eq(value)),
+                _ => unreachable!(),
             })
             .all(db)
             .await
@@ -1396,7 +1388,7 @@ impl Query {
                 u64::try_from(level).unwrap()
             })
             .collect::<Vec<u64>>();
-        let level = level.get(0).unwrap().clone();
+        let level = *level.first().unwrap();
 
         let query_rank = sea_orm::sea_query::Query::select()
             .column(experience_state::Column::EntityId)
@@ -1575,11 +1567,7 @@ impl Query {
                 let total_experience: i64 = row.try_get("", "total_experience").unwrap();
                 let experience_per_hour: i64 = row.try_get("", "experience_per_hour").unwrap();
 
-                (
-                    entity_id,
-                    total_experience.try_into().unwrap(),
-                    experience_per_hour.try_into().unwrap(),
-                )
+                (entity_id, total_experience, experience_per_hour)
             })
             .collect())
     }
@@ -1611,8 +1599,7 @@ impl Query {
                                 .select_only()
                                 .filter(skill_desc::Column::SkillCategory.is_in(value))
                                 .column(skill_desc::Column::Id)
-                                .into_query()
-                                .into(),
+                                .into_query(),
                         ),
                 );
             })
@@ -1762,11 +1749,7 @@ impl Query {
                 let total_experience: i64 = row.try_get("", "total_experience").unwrap();
                 let experience_per_hour: i64 = row.try_get("", "experience_per_hour").unwrap();
 
-                (
-                    entity_id,
-                    total_experience.try_into().unwrap(),
-                    experience_per_hour.try_into().unwrap(),
-                )
+                (entity_id, total_experience, experience_per_hour)
             })
             .collect())
     }