Use clippy in relatively-untouched modules

.github/workflows/run-tests-on-push-to-main.yml

@@ -27,7 +27,14 @@ jobs:
         run: |
           cargo clippy \
             --package acropolis_common \
-            --package acropolis_codec
+            --package acropolis_codec \
+            --package acropolis_module_assets_state \
+            --package acropolis_module_block_unpacker \
+            --package acropolis_module_consensus \
+            --package acropolis_module_drdd_state \
+            --package acropolis_module_snapshot_bootstrapper \
+            --package acropolis_module_spdd_state \
+            --package acropolis_module_utxo_state
 
       - name: Run Build
         run: cargo build --verbose

modules/assets_state/src/asset_registry.rs

@@ -26,6 +26,12 @@ pub struct AssetRegistry {
     id_to_key: Vec<AssetKey>,
 }
 
+impl Default for AssetRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl AssetRegistry {
     pub fn new() -> Self {
         Self {
@@ -52,8 +58,8 @@ impl AssetRegistry {
 
     pub fn lookup_id(&self, policy: &PolicyId, name: &AssetName) -> Option<AssetId> {
         let key = AssetKey {
-            policy: Arc::new(policy.clone()),
-            name: Arc::new(name.clone()),
+            policy: Arc::new(*policy),
+            name: Arc::new(*name),
         };
         self.key_to_id.get(&key).copied()
     }

modules/assets_state/src/assets_state.rs

@@ -84,7 +84,7 @@ impl AssetsState {
                     // Always handle the mint deltas (This is how assets get initialized)
                     {
                         let mut reg = registry.lock().await;
-                        state = match state.handle_mint_deltas(&deltas_msg.deltas, &mut *reg) {
+                        state = match state.handle_mint_deltas(&deltas_msg.deltas, &mut reg) {
                             Ok(new_state) => new_state,
                             Err(e) => {
                                 error!("Asset deltas handling error: {e:#}");
@@ -97,7 +97,7 @@ impl AssetsState {
                     if storage_config.store_info {
                         let mut reg = registry.lock().await;
                         state = match state
-                            .handle_cip25_metadata(&mut *reg, &deltas_msg.cip25_metadata_updates)
+                            .handle_cip25_metadata(&mut reg, &deltas_msg.cip25_metadata_updates)
                         {
                             Ok(new_state) => new_state,
                             Err(e) => {
@@ -125,20 +125,19 @@ impl AssetsState {
 
                         if storage_config.store_info {
                             let reg = registry.lock().await;
-                            state =
-                                match state.handle_cip68_metadata(&utxo_deltas_msg.deltas, &*reg) {
-                                    Ok(new_state) => new_state,
-                                    Err(e) => {
-                                        error!("CIP-68 metadata handling error: {e:#}");
-                                        state
-                                    }
-                                };
+                            state = match state.handle_cip68_metadata(&utxo_deltas_msg.deltas, &reg)
+                            {
+                                Ok(new_state) => new_state,
+                                Err(e) => {
+                                    error!("CIP-68 metadata handling error: {e:#}");
+                                    state
+                                }
+                            };
                         }
 
                         if storage_config.store_transactions.is_enabled() {
                             let reg = registry.lock().await;
-                            state = match state.handle_transactions(&utxo_deltas_msg.deltas, &*reg)
-                            {
+                            state = match state.handle_transactions(&utxo_deltas_msg.deltas, &reg) {
                                 Ok(new_state) => new_state,
                                 Err(e) => {
                                     error!("Transactions handling error: {e:#}");
@@ -161,7 +160,7 @@ impl AssetsState {
                         Self::check_sync(&current_block, block_info, "address");
 
                         let reg = registry.lock().await;
-                        state = match state.handle_address_deltas(&address_deltas_msg.deltas, &*reg)
+                        state = match state.handle_address_deltas(&address_deltas_msg.deltas, &reg)
                         {
                             Ok(new_state) => new_state,
                             Err(e) => {
@@ -299,7 +298,7 @@ impl AssetsState {
                     }
                     AssetsStateQuery::GetAssetInfo { policy, name } => {
                         let reg = registry.lock().await;
-                        match reg.lookup_id(&policy, &name) {
+                        match reg.lookup_id(policy, name) {
                             Some(asset_id) => match state.get_asset_info(&asset_id, &reg) {
                                 Ok(Some(info)) => AssetsStateQueryResponse::AssetInfo(info),
                                 Ok(None) => AssetsStateQueryResponse::NotFound,
@@ -318,7 +317,7 @@ impl AssetsState {
                     }
                     AssetsStateQuery::GetAssetHistory { policy, name } => {
                         let reg = registry.lock().await;
-                        match reg.lookup_id(&policy, &name) {
+                        match reg.lookup_id(policy, name) {
                             Some(asset_id) => match state.get_asset_history(&asset_id) {
                                 Ok(Some(history)) => {
                                     AssetsStateQueryResponse::AssetHistory(history)
@@ -339,7 +338,7 @@ impl AssetsState {
                     }
                     AssetsStateQuery::GetAssetAddresses { policy, name } => {
                         let reg = registry.lock().await;
-                        match reg.lookup_id(&policy, &name) {
+                        match reg.lookup_id(policy, name) {
                             Some(asset_id) => match state.get_asset_addresses(&asset_id) {
                                 Ok(Some(addresses)) => {
                                     AssetsStateQueryResponse::AssetAddresses(addresses)
@@ -360,7 +359,7 @@ impl AssetsState {
                     }
                     AssetsStateQuery::GetAssetTransactions { policy, name } => {
                         let reg = registry.lock().await;
-                        match reg.lookup_id(&policy, &name) {
+                        match reg.lookup_id(policy, name) {
                             Some(asset_id) => match state.get_asset_transactions(&asset_id) {
                                 Ok(Some(txs)) => AssetsStateQueryResponse::AssetTransactions(txs),
                                 Ok(None) => AssetsStateQueryResponse::NotFound,
@@ -379,7 +378,7 @@ impl AssetsState {
                     }
                     AssetsStateQuery::GetPolicyIdAssets { policy } => {
                         let reg = registry.lock().await;
-                        match state.get_policy_assets(&policy, &reg) {
+                        match state.get_policy_assets(policy, &reg) {
                             Ok(Some(assets)) => AssetsStateQueryResponse::PolicyIdAssets(assets),
                             Ok(None) => AssetsStateQueryResponse::NotFound,
                             Err(e) => AssetsStateQueryResponse::Error(e.to_string()),

modules/assets_state/src/state.rs

@@ -5,7 +5,7 @@ use acropolis_common::{
     math::update_value_with_delta,
     queries::assets::{AssetHistory, PolicyAssets},
     Address, AddressDelta, AssetAddressEntry, AssetInfoRecord, AssetMetadataStandard,
-    AssetMintRecord, AssetName, Datum, Lovelace, NativeAssetDelta, PolicyAsset, PolicyId,
+    AssetMintRecord, AssetName, Datum, Lovelace, NativeAssetsDelta, PolicyAsset, PolicyId,
     ShelleyAddress, TxIdentifier, UTXODelta,
 };
 use anyhow::Result;
@@ -27,19 +27,14 @@ pub struct AssetsStorageConfig {
     pub index_by_policy: bool,
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Default, Clone, Copy)]
 pub enum StoreTransactions {
+    #[default]
     None,
     All,
     Last(u64),
 }
 
-impl Default for StoreTransactions {
-    fn default() -> Self {
-        StoreTransactions::None
-    }
-}
-
 impl StoreTransactions {
     pub fn is_enabled(&self) -> bool {
         !matches!(self, StoreTransactions::None)
@@ -123,7 +118,7 @@ impl State {
             if let Some(key) = registry.lookup(*id) {
                 out.push(PolicyAsset {
                     policy: *key.policy,
-                    name: key.name.as_ref().clone(),
+                    name: *key.name.as_ref(),
                     quantity: *amount,
                 });
             }
@@ -235,7 +230,7 @@ impl State {
                 let key = registry.lookup(*asset_id)?;
                 Some(PolicyAsset {
                     policy: *policy_id,
-                    name: (*key.name).clone(),
+                    name: *key.name,
                     quantity: *supply,
                 })
             })
@@ -273,7 +268,7 @@ impl State {
 
     pub fn handle_mint_deltas(
         &self,
-        deltas: &[(TxIdentifier, Vec<(PolicyId, Vec<NativeAssetDelta>)>)],
+        deltas: &[(TxIdentifier, NativeAssetsDelta)],
         registry: &mut AssetRegistry,
     ) -> Result<Self> {
         let mut new_supply = self.supply.clone();
@@ -286,7 +281,7 @@ impl State {
         for (tx_identifier, tx_deltas) in deltas {
             for (policy_id, asset_deltas) in tx_deltas {
                 for delta in asset_deltas {
-                    let asset_id = registry.get_or_insert(*policy_id, delta.name.clone());
+                    let asset_id = registry.get_or_insert(*policy_id, delta.name);
 
                     if let Some(supply) = new_supply.as_mut() {
                         let delta_amount = delta.amount;
@@ -314,7 +309,7 @@ impl State {
                             .entry(asset_id)
                             .and_modify(|rec| rec.mint_or_burn_count += 1)
                             .or_insert(AssetInfoRecord {
-                                initial_mint_tx: tx_identifier.clone(),
+                                initial_mint_tx: *tx_identifier,
                                 mint_or_burn_count: 1,
                                 onchain_metadata: None,
                                 metadata_standard: None,
@@ -385,7 +380,7 @@ impl State {
                     if let Some(asset_id) = registry.lookup_id(policy_id, &asset.name) {
                         let entry = txs_map.entry(asset_id).or_default();
 
-                        let should_push = entry.back().map_or(true, |last| last != &tx_identifier);
+                        let should_push = entry.back() != Some(&tx_identifier);
 
                         if should_push {
                             entry.push_back(tx_identifier);

modules/consensus/src/consensus.rs

@@ -95,7 +95,7 @@ impl Consensus {
                                                 block_info,
                                                 CardanoMessage::BlockValidation(status),
                                             )) => match status {
-                                                ValidationStatus::Go => all_ok && true,
+                                                ValidationStatus::Go => all_ok,
                                                 ValidationStatus::NoGo(err) => {
                                                     error!(
                                                         block = block_info.number,

modules/spdd_state/src/spdd_state.rs

@@ -142,9 +142,9 @@ impl SPDDState {
                     }
                 };
 
-                return Arc::new(Message::StateQueryResponse(StateQueryResponse::SPDD(
+                Arc::new(Message::StateQueryResponse(StateQueryResponse::SPDD(
                     response,
-                )));
+                )))
             }
         });
 

modules/spdd_state/src/state.rs

@@ -57,7 +57,7 @@ impl State {
     // we plus 2 to epoch number
     pub fn get_epoch_total_active_stakes(&self, epoch: u64) -> Option<u64> {
         if epoch <= 2 {
-            return None;
+            None
         } else {
             self.spdd_history
                 .get_by_index(epoch - 2)

modules/utxo_state/src/address_delta_publisher.rs

@@ -61,7 +61,7 @@ impl AddressDeltaObserver for AddressDeltaPublisher {
                 Message::Cardano((block.clone(), CardanoMessage::AddressDeltas(message)));
             self.context
                 .message_bus
-                .publish(&topic, Arc::new(message_enum))
+                .publish(topic, Arc::new(message_enum))
                 .await
                 .unwrap_or_else(|e| error!("Failed to publish: {e}"));
         }

modules/utxo_state/src/fjall_async_immutable_utxo_store.rs

@@ -59,7 +59,7 @@ impl FjallAsyncImmutableUTXOStore {
     fn should_flush(&self) -> bool {
         let count = self.write_counter.fetch_add(1, Ordering::Relaxed) + 1;
         let threshold = self.flush_every.load(Ordering::Relaxed);
-        threshold != 0 && count % threshold == 0
+        threshold != 0 && count.is_multiple_of(threshold)
     }
 }
 

modules/utxo_state/src/fjall_immutable_utxo_store.rs

@@ -57,7 +57,7 @@ impl FjallImmutableUTXOStore {
     fn should_flush(&self) -> bool {
         let count = self.write_counter.fetch_add(1, Ordering::Relaxed) + 1;
         let threshold = self.flush_every.load(Ordering::Relaxed);
-        threshold != 0 && count % threshold == 0
+        threshold != 0 && count.is_multiple_of(threshold)
     }
 }