Migrate to the 2024 rust edition

Author: stanislav-tkach

integration_tests/rust/Cargo.toml

@@ -1,9 +1,9 @@
 [workspace]
-resolver = "2"
+resolver = "3"
 members = ["overhead_benchmark"]
 
 [workspace.package]
-edition = "2021"
+edition = "2024"
 
 [workspace.lints.rust]
 warnings = "deny"

rust/Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-resolver = "2"
+resolver = "3"
 members = [
     "c509-certificate",
     "cardano-blockchain-types",
@@ -21,7 +21,7 @@ members = [
 ]
 
 [workspace.package]
-edition = "2021"
+edition = "2024"
 authors = ["Steven Johnson <[email protected]>"]
 homepage = "https://github.com/input-output-hk/catalyst-libs"
 repository = "https://github.com/input-output-hk/catalyst-libs"

rust/c509-certificate/Cargo.toml

@@ -42,7 +42,7 @@ ignored = ["strum"]
 [dev-dependencies]
 clap = { version = "4.5.23", features = ["derive"] }
 serde_json = "1.0.134"
-rand = "0.8.5"
+rand = "0.9.0"
 chrono = "0.4.39"
 
 [[example]]

rust/c509-certificate/examples/cli/main.rs

@@ -6,7 +6,7 @@ use std::{
     path::PathBuf,
 };
 
-use asn1_rs::{oid, Oid};
+use asn1_rs::{Oid, oid};
 use c509_certificate::{
     attributes::attribute::Attribute,
     big_uint::UnwrappedBigUint,
@@ -131,7 +131,7 @@ struct C509Json {
 }
 
 /// Ed25519 oid and parameter - default algorithm.
-const ED25519: (Oid, Option<String>) = (oid!(1.3.101 .112), None);
+const ED25519: (Oid, Option<String>) = (oid!(1.3.101.112), None);
 
 /// Integer indicate that certificate is self-signed.
 /// 2 for Natively Signed C509 Certificate following X.509 v3
@@ -288,7 +288,7 @@ fn parse_or_default_date(
 
 /// Generate random serial number if not provided
 fn parse_serial_number(serial_number: Option<UnwrappedBigUint>) -> UnwrappedBigUint {
-    let random_number: u64 = rand::thread_rng().gen();
+    let random_number: u64 = rand::rng().random();
     serial_number.unwrap_or(UnwrappedBigUint::new(random_number))
 }
 

rust/c509-certificate/src/extensions/mod.rs

@@ -71,28 +71,28 @@ impl Encode<()> for Extensions {
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         // If there is only one extension and it is KeyUsage, encode as int
         // encoding as absolute value of the second int and the sign of the first int
-        if let Some(extension) = self.0.first() {
-            if self.0.len() == 1 && extension.registered_oid().c509_oid().oid() == &KEY_USAGE_OID {
-                match extension.value() {
-                    ExtensionValue::Int(value) => {
-                        let ku_value = if extension.critical() {
-                            value
-                                .checked_neg()
-                                .ok_or_else(|| minicbor::encode::Error::message(format!("Invalid key usage value (will overflow during negation): {value}")))?
-                        } else {
-                            *value
-                        };
-                        encode_helper(e, "Extensions KeyUsage", ctx, &ku_value)?;
-                        return Ok(());
-                    },
-                    _ => {
-                        return Err(minicbor::encode::Error::message(
-                            "KeyUsage extension value should be an integer",
-                        ));
-                    },
+        if let Some(extension) = self.0.first()
+            && self.0.len() == 1 && extension.registered_oid().c509_oid().oid() == &KEY_USAGE_OID {
+            match extension.value() {
+                ExtensionValue::Int(value) => {
+                    let ku_value = if extension.critical() {
+                        value
+                            .checked_neg()
+                            .ok_or_else(|| minicbor::encode::Error::message(format!("Invalid key usage value (will overflow during negation): {value}")))?
+                    } else {
+                        *value
+                    };
+                    encode_helper(e, "Extensions KeyUsage", ctx, &ku_value)?;
+                    return Ok(());
+                }
+                _ => {
+                    return Err(minicbor::encode::Error::message(
+                        "KeyUsage extension value should be an integer",
+                    ));
                 }
             }
         }
+
         // Else handle the array of `Extension`
         encode_array_len(e, "Extensions", self.0.len() as u64)?;
         for extension in &self.0 {

rust/cardano-blockchain-types/src/multi_era_block_data.rs

@@ -16,6 +16,7 @@ use pallas_traverse::MultiEraTx;
 use tracing::debug;
 
 use crate::{
+    Slot,
     auxdata::{
         block::BlockAuxData, metadatum_label::MetadatumLabel, metadatum_value::MetadatumValue,
     },
@@ -24,7 +25,6 @@ use crate::{
     point::Point,
     txn_index::TxnIndex,
     txn_witness::{TxnWitness, VKeyHash},
-    Slot,
 };
 
 /// Self-referencing CBOR encoded data of a multi-era block.
@@ -127,8 +127,8 @@ impl MultiEraBlock {
 
             // Special case, when the previous block is actually UNKNOWN, we can't check it.
             if !previous.is_unknown()
-                    // Otherwise, we make sure the hash chain is intact
-                    && previous != &decoded_block.header().previous_hash()
+                // Otherwise, we make sure the hash chain is intact
+                && previous != &decoded_block.header().previous_hash()
             {
                 debug!("{}, {:?}", previous, decoded_block.header().previous_hash());
 
@@ -273,10 +273,10 @@ impl MultiEraBlock {
         vkey_hash: &VKeyHash,
         tx_num: TxnIndex,
     ) -> Option<VerifyingKey> {
-        if let Some(witnesses) = self.witness_map() {
-            if witnesses.check_witness_in_tx(vkey_hash, tx_num) {
-                return witnesses.get_witness_vkey(vkey_hash);
-            }
+        if let Some(witnesses) = self.witness_map()
+            && witnesses.check_witness_in_tx(vkey_hash, tx_num)
+        {
+            return witnesses.get_witness_vkey(vkey_hash);
         }
 
         None
@@ -339,8 +339,12 @@ impl Display for MultiEraBlock {
             pallas_traverse::MultiEraBlock::Conway(_) => "Conway".to_string(),
             _ => "Unknown".to_string(),
         };
-        write!(f, "{block_era} block : {}, Previous {} : Slot# {slot} : {fork} : Block# {block_number} : Size {size} : Txns {txns} : AuxData? {aux_data}",
-    self.point(), self.previous())?;
+        write!(
+            f,
+            "{block_era} block : {}, Previous {} : Slot# {slot} : {fork} : Block# {block_number} : Size {size} : Txns {txns} : AuxData? {aux_data}",
+            self.point(),
+            self.previous()
+        )?;
         Ok(())
     }
 }
@@ -510,10 +514,12 @@ pub(crate) mod tests {
             );
 
             assert!(block.is_err());
-            assert!(block
-                .unwrap_err()
-                .to_string()
-                .contains("Previous slot is not less than current slot"));
+            assert!(
+                block
+                    .unwrap_err()
+                    .to_string()
+                    .contains("Previous slot is not less than current slot")
+            );
         }
 
         Ok(())

rust/cardano-chain-follower/examples/follow_chains.rs

@@ -6,8 +6,8 @@
 //#![allow(clippy::unwrap_used)]
 
 use cardano_blockchain_types::{
-    hashes::TransactionId, pallas_crypto, pallas_traverse, Cip36, Fork, MetadatumLabel,
-    MultiEraBlock, Network, Point, Slot, TxnIndex,
+    Cip36, Fork, MetadatumLabel, MultiEraBlock, Network, Point, Slot, TxnIndex,
+    hashes::TransactionId, pallas_crypto, pallas_traverse,
 };
 #[cfg(feature = "mimalloc")]
 use mimalloc::MiMalloc;
@@ -22,7 +22,7 @@ static GLOBAL: MiMalloc = MiMalloc;
 use std::{env, error::Error, time::Duration};
 
 use cardano_chain_follower::{ChainFollower, ChainSyncConfig, ChainUpdate, Kind, Statistics};
-use clap::{arg, ArgAction, ArgMatches, Command};
+use clap::{ArgAction, ArgMatches, Command, arg};
 use tokio::time::Instant;
 use tracing::{error, info, level_filters::LevelFilter, warn};
 use tracing_subscriber::EnvFilter;
@@ -338,15 +338,14 @@ async fn follow_for(
             || (chain_update.immutable() != last_immutable)
             || (last_fork != chain_update.data.fork()))
             && !last_update_shown
+            && let Some(last_update) = last_update.clone()
         {
-            if let Some(last_update) = last_update.clone() {
-                info!(
-                    chain = network.to_string(),
-                    "Chain Update {}:{}",
-                    updates.saturating_sub(1),
-                    last_update
-                );
-            }
+            info!(
+                chain = network.to_string(),
+                "Chain Update {}:{}",
+                updates.saturating_sub(1),
+                last_update
+            );
         }
 
         // If these become true, we will show all blocks from the follower.
@@ -472,10 +471,8 @@ async fn follow_for(
         }
     }
 
-    if !last_update_shown {
-        if let Some(last_update) = last_update.clone() {
-            info!(chain = network.to_string(), "Last Update: {}", last_update);
-        }
+    if !last_update_shown && let Some(last_update) = last_update.clone() {
+        info!(chain = network.to_string(), "Last Update: {}", last_update);
     }
 
     if !inhibit_stats {
@@ -554,7 +551,7 @@ fn update_largest_aux(
     largest_metadata_size: &mut usize,
 ) {
     match block {
-        pallas_traverse::MultiEraBlock::AlonzoCompatible(ref b, _) => {
+        pallas_traverse::MultiEraBlock::AlonzoCompatible(b, _) => {
             b.auxiliary_data_set.iter().for_each(|(txn_idx, aux_data)| {
                 compare_and_log_aux(
                     aux_data.raw_cbor().len(),
@@ -565,7 +562,7 @@ fn update_largest_aux(
                 );
             });
         },
-        pallas_traverse::MultiEraBlock::Babbage(ref b) => {
+        pallas_traverse::MultiEraBlock::Babbage(b) => {
             b.auxiliary_data_set.iter().for_each(|(txn_idx, aux_data)| {
                 compare_and_log_aux(
                     aux_data.raw_cbor().len(),
@@ -576,7 +573,7 @@ fn update_largest_aux(
                 );
             });
         },
-        pallas_traverse::MultiEraBlock::Conway(ref b) => {
+        pallas_traverse::MultiEraBlock::Conway(b) => {
             b.auxiliary_data_set.iter().for_each(|(txn_idx, aux_data)| {
                 compare_and_log_aux(
                     aux_data.raw_cbor().len(),

rust/cardano-chain-follower/src/chain_sync.rs

@@ -7,12 +7,12 @@ use std::time::Duration;
 
 use anyhow::Context;
 use cardano_blockchain_types::{
+    Fork, MultiEraBlock, Network, Point,
     pallas_network::{
         facades,
         miniprotocols::chainsync::{self, HeaderContent, Tip},
     },
     pallas_traverse::MultiEraHeader,
-    Fork, MultiEraBlock, Network, Point,
 };
 use tokio::{
     spawn,
@@ -22,19 +22,19 @@ use tokio::{
 use tracing::{debug, error};
 
 use crate::{
+    ChainSyncConfig,
     chain_sync_live_chains::{
         get_fill_to_point, get_intersect_points, get_live_block, get_live_head_point, get_peer_tip,
         live_chain_add_block_to_tip, live_chain_backfill, live_chain_length, purge_live_chain,
     },
     chain_sync_ready::{
-        get_chain_update_tx_queue, notify_follower, wait_for_sync_ready, SyncReadyWaiter,
+        SyncReadyWaiter, get_chain_update_tx_queue, notify_follower, wait_for_sync_ready,
     },
     chain_update,
     error::{Error, Result},
     mithril_snapshot_config::MithrilUpdateMessage,
     mithril_snapshot_data::latest_mithril_snapshot_id,
     stats::{self},
-    ChainSyncConfig,
 };
 
 /// The maximum number of seconds we wait for a node to connect.
@@ -364,7 +364,7 @@ async fn persistent_reconnect(
                 // Wait a bit before trying again.
                 tokio::time::sleep(PEER_FAILURE_RECONNECT_DELAY).await;
             },
-        };
+        }
     }
 }
 

rust/cardano-chain-follower/src/chain_sync_live_chains.rs

@@ -6,7 +6,7 @@ use std::{
     time::Duration,
 };
 
-use cardano_blockchain_types::{pallas_primitives, Fork, MultiEraBlock, Network, Point, Slot};
+use cardano_blockchain_types::{Fork, MultiEraBlock, Network, Point, Slot, pallas_primitives};
 use crossbeam_skiplist::SkipMap;
 use rayon::prelude::*;
 use tracing::debug;
@@ -306,8 +306,8 @@ impl ProtectedLiveChainBlockList {
             let latest_mithril_tip = latest_mithril_snapshot_id(chain).tip();
             if !point.strict_eq(&latest_mithril_tip) {
                 return Err(Error::LiveSync(format!(
-                "First Block of Live Purge {point} MUST be last block of Mithril Snapshot {latest_mithril_tip}."
-            )));
+                    "First Block of Live Purge {point} MUST be last block of Mithril Snapshot {latest_mithril_tip}."
+                )));
             }
         }
 
@@ -328,8 +328,8 @@ impl ProtectedLiveChainBlockList {
             // Make sure the block that IS present, is the actual block, by strict equality.
             if !purge_start_block_entry.value().point().strict_eq(point) {
                 return Err(Error::LiveSync(format!(
-                "The block to purge to {point} slot is in the live chain, but its hashes do not match."
-            )));
+                    "The block to purge to {point} slot is in the live chain, but its hashes do not match."
+                )));
             }
 
             // Purge every block prior to the purge point.
@@ -372,7 +372,7 @@ impl ProtectedLiveChainBlockList {
                 intersect_points.push(entry.value().point().into());
             } else {
                 return intersect_points;
-            };
+            }
         }
 
         // Now find points based on an every increasing Slot age.

rust/cardano-chain-follower/src/chain_sync_ready.rs

@@ -6,7 +6,7 @@ use std::{sync::LazyLock, time::Duration};
 use cardano_blockchain_types::Network;
 use dashmap::DashMap;
 use tokio::{
-    sync::{broadcast, oneshot, RwLock},
+    sync::{RwLock, broadcast, oneshot},
     time::sleep,
 };
 use tracing::error;
@@ -42,13 +42,13 @@ pub(crate) fn notify_follower(
     update_sender: Option<&broadcast::Sender<chain_update::Kind>>,
     kind: &chain_update::Kind,
 ) {
-    if let Some(update_sender) = update_sender {
-        if let Err(error) = update_sender.send(kind.clone()) {
-            error!(
-                chain = chain.to_string(),
-                "Failed to broadcast the Update {kind} : {error}"
-            );
-        }
+    if let Some(update_sender) = update_sender
+        && let Err(error) = update_sender.send(kind.clone())
+    {
+        error!(
+            chain = chain.to_string(),
+            "Failed to broadcast the Update {kind} : {error}"
+        );
     }
 }