From 68801d0bca58c3735bb21549f1d1097876cf06b0 Mon Sep 17 00:00:00 2001
From: Mr-Leshiy <leshiy12345678@gmail.com>
Date: Tue, 7 Oct 2025 14:03:05 +0700
Subject: [PATCH 1/5] bump cat-ci:rust version

---
 rust/Earthfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust/Earthfile b/rust/Earthfile
index 373108a861b..3cbd5784415 100644
--- a/rust/Earthfile
+++ b/rust/Earthfile
@@ -1,6 +1,6 @@
 VERSION 0.8
 
-IMPORT github.com/input-output-hk/catalyst-ci/earthly/rust:v3.4.9 AS rust-ci
+IMPORT github.com/input-output-hk/catalyst-ci/earthly/rust:v3.5.17 AS rust-ci
 IMPORT ../ AS repo-ci
 
 COPY_SRC:

From 86f28b6467e8d93758861eab231b37f15e71a6cf Mon Sep 17 00:00:00 2001
From: Mr-Leshiy <leshiy12345678@gmail.com>
Date: Tue, 7 Oct 2025 14:09:02 +0700
Subject: [PATCH 2/5] wip

---
 rust/.cargo/config.toml                       |   4 +-
 rust/.config/nextest.toml                     |  11 ++
 rust/c509-certificate/examples/cli/main.rs    |  31 ++++--
 .../src/algorithm_identifier.rs               |  14 ++-
 .../src/attributes/attribute.rs               |  32 ++++--
 rust/c509-certificate/src/attributes/mod.rs   |  14 ++-
 rust/c509-certificate/src/big_uint.rs         |   9 +-
 rust/c509-certificate/src/c509.rs             |  14 ++-
 rust/c509-certificate/src/cert_tbs.rs         |  22 ++--
 .../src/extensions/alt_name.rs                |  18 +++-
 .../src/extensions/extension/mod.rs           |  33 ++++--
 rust/c509-certificate/src/extensions/mod.rs   |  14 ++-
 .../src/general_names/data.rs                 |   6 +-
 .../src/general_names/general_name.rs         |  23 +++-
 .../c509-certificate/src/general_names/mod.rs |  14 ++-
 .../src/general_names/other_name_hw_module.rs |  14 ++-
 rust/c509-certificate/src/helper/decode.rs    |  26 +++--
 rust/c509-certificate/src/helper/encode.rs    |  20 +++-
 .../src/issuer_sig_algo/mod.rs                |  23 +++-
 rust/c509-certificate/src/lib.rs              |  10 +-
 rust/c509-certificate/src/name/mod.rs         |  21 +++-
 rust/c509-certificate/src/oid.rs              |  23 +++-
 rust/c509-certificate/src/signing.rs          |  26 ++++-
 .../src/subject_pub_key_algo/mod.rs           |  23 +++-
 rust/c509-certificate/src/tables.rs           |  18 +++-
 rust/c509-certificate/src/time.rs             |   9 +-
 .../src/auxdata/aux_data.rs                   |   8 +-
 .../src/auxdata/block.rs                      |   5 +-
 .../src/auxdata/metadatum.rs                  |  13 ++-
 .../src/auxdata/metadatum_label.rs            |   3 +-
 .../src/auxdata/metadatum_value.rs            |   3 +-
 .../src/auxdata/scripts.rs                    |   6 +-
 .../src/cip134_uri.rs                         |   5 +-
 rust/cardano-blockchain-types/src/fork.rs     |   7 +-
 .../src/metadata/cip36/key_registration.rs    |  18 +++-
 .../src/metadata/cip36/mod.rs                 |  17 ++-
 .../metadata/cip36/registration_witness.rs    |   5 +-
 .../src/metadata/cip36/validation.rs          |   5 +-
 .../src/metadata/cip36/voting_pk.rs           |   5 +-
 .../src/multi_era_block_data.rs               |  50 +++++++--
 rust/cardano-blockchain-types/src/network.rs  |  10 +-
 rust/cardano-blockchain-types/src/point.rs    |  58 +++++++---
 rust/cardano-blockchain-types/src/slot.rs     |  12 ++-
 .../src/stake_address.rs                      |  16 ++-
 .../src/txn_witness.rs                        |  16 ++-
 .../examples/follow_chains.rs                 |  38 +++++--
 rust/cardano-chain-follower/src/chain_sync.rs |  64 ++++++++---
 .../src/chain_sync_config.rs                  |  20 +++-
 .../src/chain_sync_live_chains.rs             |  65 +++++++++---
 .../src/chain_sync_ready.rs                   |   7 +-
 .../src/chain_update.rs                       |  11 +-
 rust/cardano-chain-follower/src/follow.rs     |  26 ++++-
 .../src/mithril_query.rs                      |   4 +-
 .../src/mithril_snapshot.rs                   |  13 ++-
 .../src/mithril_snapshot_config.rs            |  19 +++-
 .../src/mithril_snapshot_data.rs              |   5 +-
 .../src/mithril_snapshot_iterator.rs          |  26 ++++-
 .../src/mithril_snapshot_sync.rs              |  69 ++++++++----
 .../src/mithril_turbo_downloader.rs           |  42 ++++++--
 .../cardano-chain-follower/src/snapshot_id.rs |  45 ++++++--
 rust/cardano-chain-follower/src/stats/mod.rs  |  80 +++++++++++---
 .../src/stats/rollback.rs                     |  19 +++-
 .../src/stats/thread/mod.rs                   |  14 ++-
 .../src/turbo_downloader/mod.rs               | 100 ++++++++++++++----
 .../src/catalyst_id/key_rotation.rs           |  10 +-
 rust/catalyst-types/src/catalyst_id/mod.rs    |  37 +++++--
 .../src/catalyst_id/role_index.rs             |  10 +-
 rust/catalyst-types/src/cbor_utils.rs         |  11 +-
 rust/catalyst-types/src/conversion.rs         |   7 +-
 rust/catalyst-types/src/hashes.rs             |  17 ++-
 rust/catalyst-types/src/problem_report.rs     |  60 +++++++++--
 rust/catalyst-types/src/uuid/mod.rs           |   7 +-
 rust/catalyst-types/src/uuid/uuid_v4.rs       |  14 ++-
 rust/catalyst-types/src/uuid/uuid_v7.rs       |  14 ++-
 rust/catalyst-voting/benches/vote_protocol.rs |   2 +-
 .../src/crypto/babystep_giantstep.rs          |  13 ++-
 .../catalyst-voting/src/crypto/ed25519/mod.rs |  16 ++-
 .../catalyst-voting/src/crypto/elgamal/mod.rs |  40 +++++--
 .../src/crypto/group/ristretto255/mod.rs      |  51 +++++++--
 rust/catalyst-voting/src/crypto/hash.rs       |  20 +++-
 .../src/crypto/zk_dl_equality.rs              |  29 +++--
 .../src/crypto/zk_unit_vector/challenges.rs   |   7 +-
 .../src/crypto/zk_unit_vector/decoding.rs     |   8 +-
 .../src/crypto/zk_unit_vector/mod.rs          |  43 ++++++--
 .../src/crypto/zk_unit_vector/polynomial.rs   |  19 +++-
 .../randomness_announcements.rs               |  10 +-
 .../src/crypto/zk_unit_vector/utils.rs        |   5 +-
 .../src/vote_protocol/tally/mod.rs            |   8 +-
 .../src/vote_protocol/tally/proof.rs          |  11 +-
 .../src/vote_protocol/voter/decoding.rs       |  13 ++-
 .../src/vote_protocol/voter/mod.rs            |  27 +++--
 .../src/vote_protocol/voter/proof.rs          |  21 ++--
 .../tests/testsuite/common/mod.rs             |   6 +-
 rust/cbork-cddl-parser/src/lib.rs             |   5 +-
 rust/cbork-cddl-parser/src/parser.rs          |   3 +-
 rust/cbork-cddl-parser/src/preprocessor.rs    |   4 +-
 rust/cbork-cddl-parser/tests/common/mod.rs    |   4 +-
 rust/cbork-utils/src/decode_helper.rs         |  33 ++++--
 rust/deny.toml                                |   7 +-
 .../examples/add-file-with-pinning.rs         |   5 +-
 .../examples/provide-content-dht.rs           |   2 +-
 rust/hermes-ipfs/examples/pubsub.rs           |   5 +-
 rust/hermes-ipfs/src/lib.rs                   |  98 +++++++++++++----
 rust/immutable-ledger/src/serialize.rs        |  59 ++++++++---
 .../src/cardano/cip509/cip509.rs              |  37 +++++--
 .../src/cardano/cip509/rbac/certs/c509.rs     |   5 +-
 .../cip509/rbac/certs/c509_metadatum.rs       |   5 +-
 .../src/cardano/cip509/rbac/certs/x509.rs     |   5 +-
 .../src/cardano/cip509/rbac/metadata.rs       |  28 +++--
 .../src/cardano/cip509/rbac/pub_key.rs        |   5 +-
 .../src/cardano/cip509/rbac/role_data.rs      |  13 ++-
 .../src/cardano/cip509/types/key_local_ref.rs |   5 +-
 .../cardano/cip509/types/payment_history.rs   |   5 +-
 .../src/cardano/cip509/types/point_data.rs    |   5 +-
 .../src/cardano/cip509/types/point_tx_idx.rs  |  10 +-
 .../src/cardano/cip509/types/role_data.rs     |  26 ++++-
 .../cardano/cip509/types/role_data_record.rs  |  32 ++++--
 .../cardano/cip509/utils/cip134_uri_set.rs    |  24 ++++-
 .../src/cardano/cip509/utils/cip19.rs         |   4 +-
 .../src/cardano/cip509/utils/extract_key.rs   |   6 +-
 .../src/cardano/cip509/validation.rs          |  52 +++++++--
 .../src/cardano/cip509/x509_chunks.rs         |  10 +-
 .../src/registration/cardano/mod.rs           |  40 +++++--
 .../src/registration/cardano/update_rbac.rs   |  23 ++--
 rust/rbac-registration/src/utils/test.rs      |   5 +-
 rust/rustfmt.toml                             |   6 +-
 rust/signed_doc/bins/mk_signed_doc.rs         |  10 +-
 rust/signed_doc/src/builder.rs                |  14 ++-
 rust/signed_doc/src/content.rs                |   7 +-
 rust/signed_doc/src/lib.rs                    |  14 ++-
 .../src/metadata/content_encoding.rs          |  15 ++-
 rust/signed_doc/src/metadata/content_type.rs  |  10 +-
 rust/signed_doc/src/metadata/document_ref.rs  |   5 +-
 rust/signed_doc/src/metadata/extra_fields.rs  |   6 +-
 rust/signed_doc/src/metadata/mod.rs           |  16 ++-
 rust/signed_doc/src/metadata/section.rs       |  14 ++-
 rust/signed_doc/src/metadata/utils.rs         |  16 ++-
 rust/signed_doc/src/providers.rs              |  25 +++--
 rust/signed_doc/src/signature/mod.rs          |  17 ++-
 rust/signed_doc/src/validator/mod.rs          |  22 ++--
 .../src/validator/rules/content_encoding.rs   |   5 +-
 .../src/validator/rules/content_type.rs       |   5 +-
 .../signed_doc/src/validator/rules/doc_ref.rs |  13 ++-
 rust/signed_doc/src/validator/rules/mod.rs    |   8 +-
 .../src/validator/rules/parameters.rs         |   8 +-
 rust/signed_doc/src/validator/rules/reply.rs  |   8 +-
 .../signed_doc/src/validator/rules/section.rs |   5 +-
 .../src/validator/rules/signature_kid.rs      |   5 +-
 .../src/validator/rules/template.rs           |  16 ++-
 rust/signed_doc/src/validator/utils.rs        |   5 +-
 rust/signed_doc/tests/common/mod.rs           |   8 +-
 rust/vote-tx-v1/src/decoding.rs               |  13 ++-
 rust/vote-tx-v1/src/lib.rs                    |  58 +++++++---
 rust/vote-tx-v2/src/encoded_cbor.rs           |   9 +-
 rust/vote-tx-v2/src/gen_tx/builder.rs         |  20 +++-
 rust/vote-tx-v2/src/gen_tx/event_map.rs       |  18 +++-
 rust/vote-tx-v2/src/gen_tx/mod.rs             |  21 +++-
 rust/vote-tx-v2/src/gen_tx/tx_body.rs         |   9 +-
 rust/vote-tx-v2/src/gen_tx/vote.rs            |   9 +-
 rust/vote-tx-v2/src/public_tx/mod.rs          |  15 ++-
 rust/vote-tx-v2/src/public_tx/vote.rs         |  18 +++-
 rust/vote-tx-v2/src/uuid.rs                   |   9 +-
 162 files changed, 2335 insertions(+), 654 deletions(-)

diff --git a/rust/.cargo/config.toml b/rust/.cargo/config.toml
index cd8aa55e3ea..317a7a8456d 100644
--- a/rust/.cargo/config.toml
+++ b/rust/.cargo/config.toml
@@ -14,7 +14,7 @@
 linker = "clang"
 rustflags = [
     "-C", "link-arg=-fuse-ld=/usr/bin/mold",
-    "-C", "target-feature=-crt-static"
+    "-C", "target-feature=+crt-static"
 ]
 
 # Should be the default to have fully static rust programs in CI
@@ -22,7 +22,7 @@ rustflags = [
 linker = "clang"
 rustflags = [
     "-C", "link-arg=-fuse-ld=/usr/bin/mold",
-    "-C", "target-feature=-crt-static"
+    "-C", "target-feature=+crt-static"
 ]
 
 [build]
diff --git a/rust/.config/nextest.toml b/rust/.config/nextest.toml
index be3673830bb..e74e1ac35e7 100644
--- a/rust/.config/nextest.toml
+++ b/rust/.config/nextest.toml
@@ -47,3 +47,14 @@ store-success-output = true
 # Note that if a description can be extracted from the output, it is always stored in the
 # <description> element.
 store-failure-output = true
+
+[test-groups]
+serial-integration = { max-threads = 1 }
+
+[[profile.default.overrides]]
+filter = 'test(/^serial::/)'
+test-group = 'serial-integration'
+
+[[profile.ci.overrides]]
+filter = 'test(/^serial::/)'
+test-group = "serial-integration"
\ No newline at end of file
diff --git a/rust/c509-certificate/examples/cli/main.rs b/rust/c509-certificate/examples/cli/main.rs
index cf80c5fc85c..e63d9e5f8cd 100644
--- a/rust/c509-certificate/examples/cli/main.rs
+++ b/rust/c509-certificate/examples/cli/main.rs
@@ -142,7 +142,9 @@ const SELF_SIGNED_INT: u8 = 2;
 
 /// A function to generate C509 certificate.
 fn generate(
-    file: &PathBuf, output: Option<PathBuf>, private_key: Option<&PrivateKey>,
+    file: &PathBuf,
+    output: Option<PathBuf>,
+    private_key: Option<&PrivateKey>,
     key_type: Option<String>,
 ) -> anyhow::Result<()> {
     let data = fs::read_to_string(file)?;
@@ -209,7 +211,10 @@ fn generate(
 }
 
 /// Write a data to a file given an output path.
-fn write_to_output_file(output: PathBuf, data: &[u8]) -> anyhow::Result<()> {
+fn write_to_output_file(
+    output: PathBuf,
+    data: &[u8],
+) -> anyhow::Result<()> {
     let mut file = File::create(output).map_err(|e| anyhow::anyhow!(e))?;
     file.write_all(data).map_err(|e| anyhow::anyhow!(e))?;
     Ok(())
@@ -219,7 +224,9 @@ fn write_to_output_file(output: PathBuf, data: &[u8]) -> anyhow::Result<()> {
 /// If self-signed is true, issuer is the same as subject.
 /// Otherwise, issuer must be present.
 fn determine_issuer(
-    self_signed: bool, issuer: Option<Vec<Attribute>>, subject: Vec<Attribute>,
+    self_signed: bool,
+    issuer: Option<Vec<Attribute>>,
+    subject: Vec<Attribute>,
 ) -> anyhow::Result<Vec<Attribute>> {
     if self_signed {
         Ok(subject)
@@ -230,7 +237,8 @@ fn determine_issuer(
 
 /// Validate the certificate type.
 fn validate_certificate_type(
-    self_signed: bool, certificate_type: Option<u8>,
+    self_signed: bool,
+    certificate_type: Option<u8>,
 ) -> anyhow::Result<()> {
     if self_signed && certificate_type.unwrap_or(SELF_SIGNED_INT) != SELF_SIGNED_INT {
         return Err(anyhow::anyhow!(
@@ -260,7 +268,10 @@ fn get_key_type(key_type: Option<String>) -> anyhow::Result<(Oid<'static>, Optio
 }
 
 /// Parse date string to u64.
-fn parse_or_default_date(date_option: Option<String>, default: u64) -> Result<u64, anyhow::Error> {
+fn parse_or_default_date(
+    date_option: Option<String>,
+    default: u64,
+) -> Result<u64, anyhow::Error> {
     match date_option {
         Some(date) => {
             DateTime::parse_from_rfc3339(&date)
@@ -284,7 +295,10 @@ fn parse_serial_number(serial_number: Option<UnwrappedBigUint>) -> UnwrappedBigU
 // -------------------verify-----------------------
 
 /// Verify the signature of the certificate given public key file path.
-fn verify(file: &PathBuf, public_key: PathBuf) -> anyhow::Result<()> {
+fn verify(
+    file: &PathBuf,
+    public_key: PathBuf,
+) -> anyhow::Result<()> {
     let cert = fs::read(file)?;
     let pk = PublicKey::from_file(public_key)?;
     match c509_certificate::verify(&cert, &pk) {
@@ -297,7 +311,10 @@ fn verify(file: &PathBuf, public_key: PathBuf) -> anyhow::Result<()> {
 // -------------------decode-----------------------
 
 /// Decode the certificate to JSON.
-fn decode(file: &PathBuf, output: Option<PathBuf>) -> anyhow::Result<()> {
+fn decode(
+    file: &PathBuf,
+    output: Option<PathBuf>,
+) -> anyhow::Result<()> {
     let cert = fs::read(file)?;
     let mut d = minicbor::Decoder::new(&cert);
     let c509 = c509_certificate::c509::C509::decode(&mut d, &mut ())?;
diff --git a/rust/c509-certificate/src/algorithm_identifier.rs b/rust/c509-certificate/src/algorithm_identifier.rs
index c30d7d32bf7..a8a7fc95c64 100644
--- a/rust/c509-certificate/src/algorithm_identifier.rs
+++ b/rust/c509-certificate/src/algorithm_identifier.rs
@@ -36,7 +36,10 @@ pub struct AlgorithmIdentifier {
 impl AlgorithmIdentifier {
     /// Create new instance of `AlgorithmIdentifier`.
     #[must_use]
-    pub fn new(oid: Oid<'static>, param: Option<String>) -> Self {
+    pub fn new(
+        oid: Oid<'static>,
+        param: Option<String>,
+    ) -> Self {
         Self {
             c509_oid: C509oid::new(oid),
             param,
@@ -58,7 +61,9 @@ impl AlgorithmIdentifier {
 
 impl Encode<()> for AlgorithmIdentifier {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         match &self.param {
             // [ algorithm: ~oid, parameters: bytes ]
@@ -77,7 +82,10 @@ impl Encode<()> for AlgorithmIdentifier {
 }
 
 impl Decode<'_, ()> for AlgorithmIdentifier {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         // [ algorithm: ~oid, parameters: bytes ]
         if decode_datatype(d, "Algorithm Identifier")? == minicbor::data::Type::Array {
             let len = decode_array_len(d, "Algorithm Identifier")?;
diff --git a/rust/c509-certificate/src/attributes/attribute.rs b/rust/c509-certificate/src/attributes/attribute.rs
index 4a179e18915..f1629ce41f4 100644
--- a/rust/c509-certificate/src/attributes/attribute.rs
+++ b/rust/c509-certificate/src/attributes/attribute.rs
@@ -63,7 +63,10 @@ impl Attribute {
     }
 
     /// Add a value to `Attribute`.
-    pub fn add_value(&mut self, value: AttributeValue) {
+    pub fn add_value(
+        &mut self,
+        value: AttributeValue,
+    ) {
         self.value.push(value);
     }
 
@@ -98,8 +101,13 @@ impl<'de> Deserialize<'de> for Attribute {
 }
 
 impl Serialize for Attribute {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where S: serde::Serializer {
+    fn serialize<S>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
         let helper = Helper {
             oid: self.registered_oid().c509_oid().oid().to_string(),
             value: self.value.clone(),
@@ -110,7 +118,9 @@ impl Serialize for Attribute {
 
 impl Encode<()> for Attribute {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         // Encode CBOR int if available
         if let Some(&oid) = self
@@ -145,7 +155,10 @@ impl Encode<()> for Attribute {
 }
 
 impl Decode<'_, ()> for Attribute {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         // Handle CBOR int
         let mut attr = if decode_datatype(d, "Attribute as OID int")? == minicbor::data::Type::U8 {
             let i = decode_helper(d, "Attribute as OID int", ctx)?;
@@ -193,7 +206,9 @@ pub enum AttributeValue {
 
 impl Encode<()> for AttributeValue {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         match self {
             AttributeValue::Text(text) => encode_helper(e, "Attribute value", ctx, text)?,
@@ -204,7 +219,10 @@ impl Encode<()> for AttributeValue {
 }
 
 impl Decode<'_, ()> for AttributeValue {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         match decode_datatype(d, "Attribute value")? {
             minicbor::data::Type::String => {
                 Ok(AttributeValue::Text(decode_helper(
diff --git a/rust/c509-certificate/src/attributes/mod.rs b/rust/c509-certificate/src/attributes/mod.rs
index e608244c444..ed16375c4d6 100644
--- a/rust/c509-certificate/src/attributes/mod.rs
+++ b/rust/c509-certificate/src/attributes/mod.rs
@@ -41,7 +41,10 @@ impl Attributes {
 
     /// Add an `Attribute` to the `Attributes`.
     /// and set `Attribute` value to support multiple value.
-    pub fn add_attribute(&mut self, attribute: Attribute) {
+    pub fn add_attribute(
+        &mut self,
+        attribute: Attribute,
+    ) {
         self.0.push(attribute.set_multi_value());
     }
 }
@@ -54,7 +57,9 @@ impl Default for Attributes {
 
 impl Encode<()> for Attributes {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         if self.0.is_empty() {
             return Err(minicbor::encode::Error::message(
@@ -74,7 +79,10 @@ impl Encode<()> for Attributes {
 }
 
 impl Decode<'_, ()> for Attributes {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         let len = decode_array_len(d, "Attributes")?;
         if len == 0 {
             return Err(minicbor::decode::Error::message("Attributes is empty"));
diff --git a/rust/c509-certificate/src/big_uint.rs b/rust/c509-certificate/src/big_uint.rs
index a6e67ad0a56..cba17bad52e 100644
--- a/rust/c509-certificate/src/big_uint.rs
+++ b/rust/c509-certificate/src/big_uint.rs
@@ -36,7 +36,9 @@ impl From<UnwrappedBigUint> for u64 {
 
 impl Encode<()> for UnwrappedBigUint {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, _ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        _ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         let bytes = self.0.to_be_bytes();
         // Trim leading zeros
@@ -52,7 +54,10 @@ impl Encode<()> for UnwrappedBigUint {
 }
 
 impl Decode<'_, ()> for UnwrappedBigUint {
-    fn decode(d: &mut Decoder<'_>, _ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        _ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         // Turn bytes into u64
         let b = decode_bytes(d, "Unwrapped big uint")?
             .iter()
diff --git a/rust/c509-certificate/src/c509.rs b/rust/c509-certificate/src/c509.rs
index 4018740e240..ca1369b998c 100644
--- a/rust/c509-certificate/src/c509.rs
+++ b/rust/c509-certificate/src/c509.rs
@@ -23,7 +23,10 @@ pub struct C509 {
 impl C509 {
     /// Create a new instance of C509 Certificate .
     #[must_use]
-    pub fn new(tbs_cert: TbsCert, issuer_signature_value: Option<Vec<u8>>) -> Self {
+    pub fn new(
+        tbs_cert: TbsCert,
+        issuer_signature_value: Option<Vec<u8>>,
+    ) -> Self {
         Self {
             tbs_cert,
             issuer_signature_value,
@@ -45,7 +48,9 @@ impl C509 {
 
 impl Encode<()> for C509 {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         self.tbs_cert.encode(e, ctx)?;
         match self.issuer_signature_value {
@@ -57,7 +62,10 @@ impl Encode<()> for C509 {
 }
 
 impl Decode<'_, ()> for C509 {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         let tbs_cert = TbsCert::decode(d, ctx)?;
         let issuer_signature_value = match decode_datatype(d, "C509 Issuer Signature value")? {
             minicbor::data::Type::Bytes => Some(decode_bytes(d, "C509 Issuer Signature value")?),
diff --git a/rust/c509-certificate/src/cert_tbs.rs b/rust/c509-certificate/src/cert_tbs.rs
index fc88dbdbfa7..695b4efcece 100644
--- a/rust/c509-certificate/src/cert_tbs.rs
+++ b/rust/c509-certificate/src/cert_tbs.rs
@@ -48,10 +48,15 @@ impl TbsCert {
     #[must_use]
     #[allow(clippy::too_many_arguments)]
     pub fn new(
-        c509_certificate_type: u8, certificate_serial_number: UnwrappedBigUint,
-        issuer_signature_algorithm: IssuerSignatureAlgorithm, issuer: Option<Name>,
-        validity_not_before: Time, validity_not_after: Time, subject: Name,
-        subject_public_key_algorithm: SubjectPubKeyAlgorithm, subject_public_key: Vec<u8>,
+        c509_certificate_type: u8,
+        certificate_serial_number: UnwrappedBigUint,
+        issuer_signature_algorithm: IssuerSignatureAlgorithm,
+        issuer: Option<Name>,
+        validity_not_before: Time,
+        validity_not_after: Time,
+        subject: Name,
+        subject_public_key_algorithm: SubjectPubKeyAlgorithm,
+        subject_public_key: Vec<u8>,
         extensions: Extensions,
     ) -> Self {
         Self {
@@ -149,7 +154,9 @@ impl TbsCert {
 
 impl Encode<()> for TbsCert {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         encode_helper(e, "Certificate type", ctx, &self.c509_certificate_type)?;
         self.certificate_serial_number.encode(e, ctx)?;
@@ -166,7 +173,10 @@ impl Encode<()> for TbsCert {
 }
 
 impl Decode<'_, ()> for TbsCert {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         let cert_type = decode_helper(d, "Certificate type", ctx)?;
         let serial_number = UnwrappedBigUint::decode(d, ctx)?;
         let issuer_signature_algorithm = IssuerSignatureAlgorithm::decode(d, ctx)?;
diff --git a/rust/c509-certificate/src/extensions/alt_name.rs b/rust/c509-certificate/src/extensions/alt_name.rs
index 0f9896c8588..f977219ca0d 100644
--- a/rust/c509-certificate/src/extensions/alt_name.rs
+++ b/rust/c509-certificate/src/extensions/alt_name.rs
@@ -36,14 +36,19 @@ impl AlternativeName {
 
 impl Encode<()> for AlternativeName {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         self.0.encode(e, ctx)
     }
 }
 
 impl Decode<'_, ()> for AlternativeName {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         GeneralNamesOrText::decode(d, ctx).map(AlternativeName::new)
     }
 }
@@ -64,7 +69,9 @@ pub enum GeneralNamesOrText {
 
 impl Encode<()> for GeneralNamesOrText {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         match self {
             GeneralNamesOrText::GeneralNames(gns) => {
@@ -88,7 +95,10 @@ impl Encode<()> for GeneralNamesOrText {
 }
 
 impl Decode<'_, ()> for GeneralNamesOrText {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         match decode_datatype(d, "Alternative Name - General Names")? {
             // If it is a string it is a GeneralNames with only 1 DNSName
             minicbor::data::Type::String => {
diff --git a/rust/c509-certificate/src/extensions/extension/mod.rs b/rust/c509-certificate/src/extensions/extension/mod.rs
index c442d7ccad6..57061923e35 100644
--- a/rust/c509-certificate/src/extensions/extension/mod.rs
+++ b/rust/c509-certificate/src/extensions/extension/mod.rs
@@ -33,7 +33,11 @@ pub struct Extension {
 impl Extension {
     /// Create a new instance of `Extension` using `OID` and value.
     #[must_use]
-    pub fn new(oid: Oid<'static>, value: ExtensionValue, critical: bool) -> Self {
+    pub fn new(
+        oid: Oid<'static>,
+        value: ExtensionValue,
+        critical: bool,
+    ) -> Self {
         Self {
             registered_oid: C509oidRegistered::new(oid, EXTENSIONS_LOOKUP.get_int_to_oid_table()),
             critical,
@@ -83,8 +87,13 @@ impl<'de> Deserialize<'de> for Extension {
 }
 
 impl Serialize for Extension {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where S: serde::Serializer {
+    fn serialize<S>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
         let helper = Helper {
             oid: self.registered_oid.c509_oid().oid().to_string(),
             value: self.value.clone(),
@@ -99,7 +108,9 @@ impl Encode<()> for Extension {
     // - (extensionID: int, extensionValue: any)
     // - (extensionID: ~oid, ? critical: true, extensionValue: bytes)
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         // Handle CBOR int based on OID mapping
         if let Some(&mapped_oid) = self
@@ -133,7 +144,10 @@ impl Encode<()> for Extension {
 }
 
 impl Decode<'_, ()> for Extension {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         match decode_datatype(d, "Extension")? {
             // Check whether OID is an int
             // Even the encoding is i16, the minicbor decoder doesn't know what type we encoded,
@@ -214,7 +228,9 @@ impl ExtensionValueTypeTrait for ExtensionValueType {
 
 impl Encode<()> for ExtensionValue {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         match self {
             ExtensionValue::Int(value) => {
@@ -239,7 +255,10 @@ impl Encode<()> for ExtensionValue {
 impl<C> Decode<'_, C> for ExtensionValue
 where C: ExtensionValueTypeTrait + Debug
 {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut C) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut C,
+    ) -> Result<Self, minicbor::decode::Error> {
         match ctx.get_type() {
             ExtensionValueType::Int => {
                 let value = decode_helper(d, "Extension value", ctx)?;
diff --git a/rust/c509-certificate/src/extensions/mod.rs b/rust/c509-certificate/src/extensions/mod.rs
index 5f1a99d579e..112123a4a04 100644
--- a/rust/c509-certificate/src/extensions/mod.rs
+++ b/rust/c509-certificate/src/extensions/mod.rs
@@ -49,7 +49,10 @@ impl Extensions {
     }
 
     /// Add an `Extension` to the `Extensions`.
-    pub fn add_extension(&mut self, extension: Extension) {
+    pub fn add_extension(
+        &mut self,
+        extension: Extension,
+    ) {
         self.0.push(extension);
     }
 }
@@ -62,7 +65,9 @@ impl Default for Extensions {
 
 impl Encode<()> for Extensions {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> 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
@@ -98,7 +103,10 @@ impl Encode<()> for Extensions {
 }
 
 impl Decode<'_, ()> for Extensions {
-    fn decode(d: &mut Decoder<'_>, _ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        _ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         // If only KeyUsage is in the extension -> will only contain an int
         if decode_datatype(d, "Extensions KeyUsage")? == minicbor::data::Type::U8
             || decode_datatype(d, "Extensions KeyUsage")? == minicbor::data::Type::I8
diff --git a/rust/c509-certificate/src/general_names/data.rs b/rust/c509-certificate/src/general_names/data.rs
index 0099a381839..45b73fe933a 100644
--- a/rust/c509-certificate/src/general_names/data.rs
+++ b/rust/c509-certificate/src/general_names/data.rs
@@ -69,7 +69,11 @@ impl IntegerToGNTable {
     }
 
     /// Add a new integer to `GeneralNameTypeRegistry` map table.
-    pub(crate) fn add(&mut self, k: i16, v: GeneralNameTypeRegistry) {
+    pub(crate) fn add(
+        &mut self,
+        k: i16,
+        v: GeneralNameTypeRegistry,
+    ) {
         self.0.add(k, v);
     }
 
diff --git a/rust/c509-certificate/src/general_names/general_name.rs b/rust/c509-certificate/src/general_names/general_name.rs
index 990bde6a82d..2e5d6b81862 100644
--- a/rust/c509-certificate/src/general_names/general_name.rs
+++ b/rust/c509-certificate/src/general_names/general_name.rs
@@ -42,7 +42,10 @@ pub struct GeneralName {
 impl GeneralName {
     /// Create a new instance of `GeneralName`.
     #[must_use]
-    pub fn new(gn_type: GeneralNameTypeRegistry, value: GeneralNameValue) -> Self {
+    pub fn new(
+        gn_type: GeneralNameTypeRegistry,
+        value: GeneralNameValue,
+    ) -> Self {
         Self { gn_type, value }
     }
 
@@ -61,7 +64,9 @@ impl GeneralName {
 
 impl Encode<()> for GeneralName {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         // Encode GeneralNameType as int
         let i = get_int_from_gn(self.gn_type).map_err(minicbor::encode::Error::message)?;
@@ -73,7 +78,10 @@ impl Encode<()> for GeneralName {
 }
 
 impl Decode<'_, ()> for GeneralName {
-    fn decode(d: &mut Decoder<'_>, _ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        _ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         if decode_datatype(d, "General Name as OID int")? == minicbor::data::Type::U8
             || decode_datatype(d, "General Name as OID int")? == minicbor::data::Type::I8
         {
@@ -158,7 +166,9 @@ impl GeneralNameValueTrait for GeneralNameValueType {
 
 impl Encode<()> for GeneralNameValue {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         match self {
             GeneralNameValue::Text(value) => {
@@ -188,7 +198,10 @@ impl Encode<()> for GeneralNameValue {
 impl<C> Decode<'_, C> for GeneralNameValue
 where C: GeneralNameValueTrait + Debug
 {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut C) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut C,
+    ) -> Result<Self, minicbor::decode::Error> {
         match ctx.get_type() {
             GeneralNameValueType::Text => {
                 let value = decode_helper(d, "General Name value", ctx)?;
diff --git a/rust/c509-certificate/src/general_names/mod.rs b/rust/c509-certificate/src/general_names/mod.rs
index 996a5a5a000..d681380287a 100644
--- a/rust/c509-certificate/src/general_names/mod.rs
+++ b/rust/c509-certificate/src/general_names/mod.rs
@@ -38,7 +38,10 @@ impl GeneralNames {
     }
 
     /// Add a new `GeneralName` to the `GeneralNames`.
-    pub fn add_general_name(&mut self, gn: GeneralName) {
+    pub fn add_general_name(
+        &mut self,
+        gn: GeneralName,
+    ) {
         self.0.push(gn);
     }
 }
@@ -51,7 +54,9 @@ impl Default for GeneralNames {
 
 impl Encode<()> for GeneralNames {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         if self.0.is_empty() {
             return Err(minicbor::encode::Error::message(
@@ -71,7 +76,10 @@ impl Encode<()> for GeneralNames {
 }
 
 impl Decode<'_, ()> for GeneralNames {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         let len = decode_array_len(d, "General Names")?;
         let mut gn = GeneralNames::new();
         for _ in 0..len / 2 {
diff --git a/rust/c509-certificate/src/general_names/other_name_hw_module.rs b/rust/c509-certificate/src/general_names/other_name_hw_module.rs
index 7e2660cc088..b9f14e5c8e4 100644
--- a/rust/c509-certificate/src/general_names/other_name_hw_module.rs
+++ b/rust/c509-certificate/src/general_names/other_name_hw_module.rs
@@ -29,7 +29,10 @@ pub struct OtherNameHardwareModuleName {
 impl OtherNameHardwareModuleName {
     /// Create a new instance of `OtherNameHardwareModuleName`.
     #[must_use]
-    pub fn new(hw_type: Oid<'static>, hw_serial_num: Vec<u8>) -> Self {
+    pub fn new(
+        hw_type: Oid<'static>,
+        hw_serial_num: Vec<u8>,
+    ) -> Self {
         Self {
             hw_type: C509oid::new(hw_type),
             hw_serial_num,
@@ -51,7 +54,9 @@ impl OtherNameHardwareModuleName {
 
 impl Encode<()> for OtherNameHardwareModuleName {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         encode_array_len(e, "OtherNameHardwareModule", 2)?;
         self.hw_type.encode(e, ctx)?;
@@ -65,7 +70,10 @@ impl Encode<()> for OtherNameHardwareModuleName {
 }
 
 impl<'a> Decode<'a, ()> for OtherNameHardwareModuleName {
-    fn decode(d: &mut Decoder<'a>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'a>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         decode_array_len(d, "OtherNameHardwareModule")?;
         let hw_type = C509oid::decode(d, ctx)?;
         let hw_serial_num = decode_bytes(d, "OtherNameHardwareModule serial number")?;
diff --git a/rust/c509-certificate/src/helper/decode.rs b/rust/c509-certificate/src/helper/decode.rs
index d43ef62e5e7..6f219560afb 100644
--- a/rust/c509-certificate/src/helper/decode.rs
+++ b/rust/c509-certificate/src/helper/decode.rs
@@ -4,9 +4,13 @@ use minicbor::{decode, Decoder};
 
 /// Generic helper function for decoding different types.
 pub(crate) fn decode_helper<'a, T, C>(
-    d: &mut Decoder<'a>, from: &str, context: &mut C,
+    d: &mut Decoder<'a>,
+    from: &str,
+    context: &mut C,
 ) -> Result<T, decode::Error>
-where T: minicbor::Decode<'a, C> {
+where
+    T: minicbor::Decode<'a, C>,
+{
     T::decode(d, context).map_err(|e| {
         decode::Error::message(format!(
             "Failed to decode {:?} in {from}: {e}",
@@ -16,7 +20,10 @@ where T: minicbor::Decode<'a, C> {
 }
 
 /// Helper function for decoding bytes.
-pub(crate) fn decode_bytes(d: &mut Decoder, from: &str) -> Result<Vec<u8>, decode::Error> {
+pub(crate) fn decode_bytes(
+    d: &mut Decoder,
+    from: &str,
+) -> Result<Vec<u8>, decode::Error> {
     d.bytes().map(<[u8]>::to_vec).map_err(|e| {
         decode::Error::message(format!(
             "Failed to decode bytes in {from}:
@@ -26,7 +33,10 @@ pub(crate) fn decode_bytes(d: &mut Decoder, from: &str) -> Result<Vec<u8>, decod
 }
 
 /// Helper function for decoding array.
-pub(crate) fn decode_array_len(d: &mut Decoder, from: &str) -> Result<u64, decode::Error> {
+pub(crate) fn decode_array_len(
+    d: &mut Decoder,
+    from: &str,
+) -> Result<u64, decode::Error> {
     d.array()
         .map_err(|e| {
             decode::Error::message(format!(
@@ -40,7 +50,10 @@ pub(crate) fn decode_array_len(d: &mut Decoder, from: &str) -> Result<u64, decod
 }
 
 /// Helper function for decoding null.
-pub(crate) fn decode_null(d: &mut Decoder, from: &str) -> Result<(), decode::Error> {
+pub(crate) fn decode_null(
+    d: &mut Decoder,
+    from: &str,
+) -> Result<(), decode::Error> {
     d.null().map_err(|e| {
         decode::Error::message(format!(
             "Failed to decode null in {from}:
@@ -51,7 +64,8 @@ pub(crate) fn decode_null(d: &mut Decoder, from: &str) -> Result<(), decode::Err
 
 /// Helper function for decoding datatype.
 pub(crate) fn decode_datatype(
-    d: &mut Decoder, from: &str,
+    d: &mut Decoder,
+    from: &str,
 ) -> Result<minicbor::data::Type, decode::Error> {
     d.datatype().map_err(|e| {
         decode::Error::message(format!(
diff --git a/rust/c509-certificate/src/helper/encode.rs b/rust/c509-certificate/src/helper/encode.rs
index 3184ce0a4cd..286b9ba329f 100644
--- a/rust/c509-certificate/src/helper/encode.rs
+++ b/rust/c509-certificate/src/helper/encode.rs
@@ -7,9 +7,14 @@ use minicbor::{
 
 /// Generic helper function for encoding different types.
 pub(crate) fn encode_helper<W: Write, C, T>(
-    e: &mut Encoder<W>, from: &str, ctx: &mut C, value: &T,
+    e: &mut Encoder<W>,
+    from: &str,
+    ctx: &mut C,
+    value: &T,
 ) -> Result<(), encode::Error<W::Error>>
-where T: minicbor::Encode<C> {
+where
+    T: minicbor::Encode<C>,
+{
     T::encode(value, e, ctx).map_err(|err| {
         encode::Error::with_message(
             err,
@@ -25,7 +30,9 @@ where T: minicbor::Encode<C> {
 
 /// Helper function for encoding bytes.
 pub(crate) fn encode_bytes<W: Write>(
-    e: &mut Encoder<W>, from: &str, value: &[u8],
+    e: &mut Encoder<W>,
+    from: &str,
+    value: &[u8],
 ) -> Result<(), encode::Error<W::Error>> {
     e.bytes(value).map_err(|err| {
         encode::Error::with_message(err, format!("Failed to encode bytes in {from}"))
@@ -35,7 +42,8 @@ pub(crate) fn encode_bytes<W: Write>(
 
 /// Helper function for encoding null.
 pub(crate) fn encode_null<W: Write>(
-    e: &mut Encoder<W>, from: &str,
+    e: &mut Encoder<W>,
+    from: &str,
 ) -> Result<(), encode::Error<W::Error>> {
     e.null().map_err(|err| {
         encode::Error::with_message(err, format!("Failed to encode null in {from}"))
@@ -45,7 +53,9 @@ pub(crate) fn encode_null<W: Write>(
 
 /// Helper function for encoding array.
 pub(crate) fn encode_array_len<W: Write>(
-    e: &mut Encoder<W>, from: &str, len: u64,
+    e: &mut Encoder<W>,
+    from: &str,
+    len: u64,
 ) -> Result<(), encode::Error<W::Error>> {
     e.array(len).map_err(|err| {
         encode::Error::with_message(err, format!("Failed to encode array in {from}"))
diff --git a/rust/c509-certificate/src/issuer_sig_algo/mod.rs b/rust/c509-certificate/src/issuer_sig_algo/mod.rs
index 3fb049d2fae..87156343539 100644
--- a/rust/c509-certificate/src/issuer_sig_algo/mod.rs
+++ b/rust/c509-certificate/src/issuer_sig_algo/mod.rs
@@ -38,7 +38,10 @@ pub struct IssuerSignatureAlgorithm {
 impl IssuerSignatureAlgorithm {
     /// Create new instance of `IssuerSignatureAlgorithm` where it registered with
     /// Issuer Signature Algorithm lookup table.
-    pub fn new(oid: Oid<'static>, param: Option<String>) -> Self {
+    pub fn new(
+        oid: Oid<'static>,
+        param: Option<String>,
+    ) -> Self {
         Self {
             registered_oid: C509oidRegistered::new(
                 oid.clone(),
@@ -82,8 +85,13 @@ impl<'de> Deserialize<'de> for IssuerSignatureAlgorithm {
 }
 
 impl Serialize for IssuerSignatureAlgorithm {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where S: serde::Serializer {
+    fn serialize<S>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
         let helper = Helper {
             oid: self.registered_oid.c509_oid().oid().to_string(),
             param: self.algo_identifier.param().clone(),
@@ -94,7 +102,9 @@ impl Serialize for IssuerSignatureAlgorithm {
 
 impl Encode<()> for IssuerSignatureAlgorithm {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         if let Some(&i) = self
             .registered_oid
@@ -111,7 +121,10 @@ impl Encode<()> for IssuerSignatureAlgorithm {
 }
 
 impl Decode<'_, ()> for IssuerSignatureAlgorithm {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         match decode_datatype(d, "Issuer Signature Algorithm")? {
             // Check i16 for -256 and -256
             minicbor::data::Type::U8 | minicbor::data::Type::I16 => {
diff --git a/rust/c509-certificate/src/lib.rs b/rust/c509-certificate/src/lib.rs
index b2292d9eaf7..c72952aa344 100644
--- a/rust/c509-certificate/src/lib.rs
+++ b/rust/c509-certificate/src/lib.rs
@@ -79,7 +79,10 @@ pub mod time;
 /// # Errors
 ///
 /// Returns an error if the generated data is invalid.
-pub fn generate(tbs_cert: &TbsCert, private_key: Option<&PrivateKey>) -> anyhow::Result<Vec<u8>> {
+pub fn generate(
+    tbs_cert: &TbsCert,
+    private_key: Option<&PrivateKey>,
+) -> anyhow::Result<Vec<u8>> {
     // Encode the TbsCert
     let encoded_tbs = {
         let mut buffer = Vec::new();
@@ -109,7 +112,10 @@ pub fn generate(tbs_cert: &TbsCert, private_key: Option<&PrivateKey>) -> anyhow:
 /// # Errors
 /// Returns an error if the `issuer_signature_value` is invalid or the signature cannot be
 /// verified.
-pub fn verify(c509: &[u8], public_key: &PublicKey) -> anyhow::Result<()> {
+pub fn verify(
+    c509: &[u8],
+    public_key: &PublicKey,
+) -> anyhow::Result<()> {
     let mut d = minicbor::Decoder::new(c509);
     let c509 = C509::decode(&mut d, &mut ())?;
     let mut encoded_tbs = Vec::new();
diff --git a/rust/c509-certificate/src/name/mod.rs b/rust/c509-certificate/src/name/mod.rs
index d5032a64fcc..9e118195ea6 100644
--- a/rust/c509-certificate/src/name/mod.rs
+++ b/rust/c509-certificate/src/name/mod.rs
@@ -57,14 +57,19 @@ impl Name {
 
 impl Encode<()> for Name {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         self.0.encode(e, ctx)
     }
 }
 
 impl Decode<'_, ()> for Name {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         NameValue::decode(d, ctx).map(Name::new)
     }
 }
@@ -86,7 +91,9 @@ pub enum NameValue {
 
 impl Encode<()> for NameValue {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         match self {
             NameValue::Attribute(attrs) => {
@@ -137,7 +144,10 @@ impl Encode<()> for NameValue {
 }
 
 impl Decode<'_, ()> for NameValue {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         match decode_datatype(d, "Name")? {
             minicbor::data::Type::Array => {
                 let len = decode_array_len(d, "Attributes")?;
@@ -166,7 +176,8 @@ impl Decode<'_, ()> for NameValue {
 
 /// Encode common name value.
 fn encode_cn_value<W: Write>(
-    e: &mut Encoder<W>, cn_value: &AttributeValue,
+    e: &mut Encoder<W>,
+    cn_value: &AttributeValue,
 ) -> Result<(), minicbor::encode::Error<W::Error>> {
     let hex_regex = Regex::new(r"^[0-9a-f]+$").map_err(minicbor::encode::Error::message)?;
     let eui64_regex =
diff --git a/rust/c509-certificate/src/oid.rs b/rust/c509-certificate/src/oid.rs
index db4524a518e..a426507f4ed 100644
--- a/rust/c509-certificate/src/oid.rs
+++ b/rust/c509-certificate/src/oid.rs
@@ -28,7 +28,10 @@ pub struct C509oidRegistered {
 
 impl C509oidRegistered {
     /// Create a new instance of `C509oidRegistered`.
-    pub(crate) fn new(oid: Oid<'static>, table: &'static IntegerToOidTable) -> Self {
+    pub(crate) fn new(
+        oid: Oid<'static>,
+        table: &'static IntegerToOidTable,
+    ) -> Self {
         Self {
             c509_oid: C509oid::new(oid),
             registration_table: table,
@@ -85,8 +88,13 @@ impl<'de> Deserialize<'de> for C509oid {
 }
 
 impl Serialize for C509oid {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where S: serde::Serializer {
+    fn serialize<S>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
         let helper = Helper {
             oid: self.0.to_string(),
         };
@@ -103,7 +111,9 @@ impl Encode<()> for C509oid {
     /// A vector of bytes containing the CBOR encoded OID.
     /// If the encoding fails, it will return an error.
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, _ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        _ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         let oid_bytes = self.0.as_bytes();
         encode_bytes(e, "C509 OID", oid_bytes)
@@ -118,7 +128,10 @@ impl Decode<'_, ()> for C509oid {
     ///
     /// A C509oid instance.
     /// If the decoding fails, it will return an error.
-    fn decode(d: &mut Decoder, _ctx: &mut ()) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut Decoder,
+        _ctx: &mut (),
+    ) -> Result<Self, decode::Error> {
         let oid_bytes = decode_bytes(d, "C509 OID")?;
         let oid = Oid::new(oid_bytes.into());
         Ok(C509oid::new(oid))
diff --git a/rust/c509-certificate/src/signing.rs b/rust/c509-certificate/src/signing.rs
index 6fc732c8ad4..b50b8b6a7d8 100644
--- a/rust/c509-certificate/src/signing.rs
+++ b/rust/c509-certificate/src/signing.rs
@@ -33,12 +33,18 @@ struct FileError {
 #[allow(dead_code)]
 impl FileError {
     /// Create a new `FileError` instance from a string location.
-    fn from_string(location: String, msg: Option<anyhow::Error>) -> Self {
+    fn from_string(
+        location: String,
+        msg: Option<anyhow::Error>,
+    ) -> Self {
         Self { location, msg }
     }
 
     /// Create a new `FileError` instance from a path location.
-    fn from_path<P: AsRef<Path>>(path: P, msg: Option<anyhow::Error>) -> Self {
+    fn from_path<P: AsRef<Path>>(
+        path: P,
+        msg: Option<anyhow::Error>,
+    ) -> Self {
         Self {
             location: path.as_ref().display().to_string(),
             msg,
@@ -47,7 +53,10 @@ impl FileError {
 }
 
 impl Display for FileError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
         let msg = format!("Cannot open or read file at {0}", self.location);
         let err = self
             .msg
@@ -78,7 +87,10 @@ impl PrivateKey {
     /// Sign the message with the current private key.
     /// Returns the signature bytes.
     #[must_use]
-    pub fn sign(&self, msg: &[u8]) -> Vec<u8> {
+    pub fn sign(
+        &self,
+        msg: &[u8],
+    ) -> Vec<u8> {
         self.0.sign(msg).to_vec()
     }
 }
@@ -128,7 +140,11 @@ impl PublicKey {
     ///
     /// # Errors
     /// Returns an error if the signature is invalid.
-    pub fn verify(&self, msg: &[u8], signature_bytes: &[u8]) -> anyhow::Result<()> {
+    pub fn verify(
+        &self,
+        msg: &[u8],
+        signature_bytes: &[u8],
+    ) -> anyhow::Result<()> {
         let signature_bytes = signature_bytes.try_into().map_err(|_| {
             anyhow::anyhow!(
                 "Invalid signature bytes size: expected {}, provided {}.",
diff --git a/rust/c509-certificate/src/subject_pub_key_algo/mod.rs b/rust/c509-certificate/src/subject_pub_key_algo/mod.rs
index b3d923bd1c7..b379a75ad57 100644
--- a/rust/c509-certificate/src/subject_pub_key_algo/mod.rs
+++ b/rust/c509-certificate/src/subject_pub_key_algo/mod.rs
@@ -39,7 +39,10 @@ pub struct SubjectPubKeyAlgorithm {
 impl SubjectPubKeyAlgorithm {
     /// Create new instance of `SubjectPubKeyAlgorithm` where it registered with
     /// Subject Public Key Algorithm lookup table.
-    pub fn new(oid: Oid<'static>, param: Option<String>) -> Self {
+    pub fn new(
+        oid: Oid<'static>,
+        param: Option<String>,
+    ) -> Self {
         Self {
             registered_oid: C509oidRegistered::new(
                 oid.clone(),
@@ -83,8 +86,13 @@ impl<'de> Deserialize<'de> for SubjectPubKeyAlgorithm {
 }
 
 impl Serialize for SubjectPubKeyAlgorithm {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where S: serde::Serializer {
+    fn serialize<S>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
         let helper = Helper {
             oid: self.registered_oid.c509_oid().oid().to_string(),
             param: self.algo_identifier.param().clone(),
@@ -95,7 +103,9 @@ impl Serialize for SubjectPubKeyAlgorithm {
 
 impl Encode<()> for SubjectPubKeyAlgorithm {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         if let Some(&i) = self
             .registered_oid
@@ -112,7 +122,10 @@ impl Encode<()> for SubjectPubKeyAlgorithm {
 }
 
 impl Decode<'_, ()> for SubjectPubKeyAlgorithm {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         // Check u8 for 0 - 28
         if decode_datatype(d, "Subject public key algorithm")? == minicbor::data::Type::U8 {
             let i = decode_helper(d, "Subject public key algorithm", ctx)?;
diff --git a/rust/c509-certificate/src/tables.rs b/rust/c509-certificate/src/tables.rs
index 67e83fde4fd..3c526115a66 100644
--- a/rust/c509-certificate/src/tables.rs
+++ b/rust/c509-certificate/src/tables.rs
@@ -15,7 +15,11 @@ pub(crate) trait TableTrait<K, V> {
     /// Create new instance of the map table.
     fn new() -> Self;
     /// Add the key-value pair to the map table.
-    fn add(&mut self, k: K, v: V);
+    fn add(
+        &mut self,
+        k: K,
+        v: V,
+    );
     /// Get the bimap of the map table.
     fn get_map(&self) -> &BiMap<K, V>;
 }
@@ -38,7 +42,11 @@ impl<T: Eq + Hash> TableTrait<i16, T> for IntTable<T> {
     }
 
     /// Add the key-value pair to the map table.
-    fn add(&mut self, k: i16, v: T) {
+    fn add(
+        &mut self,
+        k: i16,
+        v: T,
+    ) {
         self.map.insert(k, v);
     }
 
@@ -67,7 +75,11 @@ impl IntegerToOidTable {
     }
 
     /// Add the key-value pair to the map table.
-    pub(crate) fn add(&mut self, k: i16, v: Oid<'static>) {
+    pub(crate) fn add(
+        &mut self,
+        k: i16,
+        v: Oid<'static>,
+    ) {
         self.table.add(k, v);
     }
 
diff --git a/rust/c509-certificate/src/time.rs b/rust/c509-certificate/src/time.rs
index b3e74a178f9..ae6ba280d8c 100644
--- a/rust/c509-certificate/src/time.rs
+++ b/rust/c509-certificate/src/time.rs
@@ -45,7 +45,9 @@ impl From<Time> for u64 {
 
 impl Encode<()> for Time {
     fn encode<W: Write>(
-        &self, e: &mut Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         if self.0 == NO_EXP_DATE {
             encode_null(e, "Time")?;
@@ -57,7 +59,10 @@ impl Encode<()> for Time {
 }
 
 impl Decode<'_, ()> for Time {
-    fn decode(d: &mut Decoder<'_>, _ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        _ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         match decode_datatype(d, "Time")? {
             minicbor::data::Type::U8
             | minicbor::data::Type::U16
diff --git a/rust/cardano-blockchain-types/src/auxdata/aux_data.rs b/rust/cardano-blockchain-types/src/auxdata/aux_data.rs
index 55182e838af..f08981c43d5 100644
--- a/rust/cardano-blockchain-types/src/auxdata/aux_data.rs
+++ b/rust/cardano-blockchain-types/src/auxdata/aux_data.rs
@@ -22,7 +22,8 @@ pub struct TransactionAuxData {
 
 impl Decode<'_, ()> for TransactionAuxData {
     fn decode(
-        d: &mut minicbor::Decoder<'_>, _ctx: &mut (),
+        d: &mut minicbor::Decoder<'_>,
+        _ctx: &mut (),
     ) -> Result<Self, minicbor::decode::Error> {
         // Check what kind of aux data we have to deal with
         match d.datatype() {
@@ -54,7 +55,10 @@ impl Decode<'_, ()> for TransactionAuxData {
 impl TransactionAuxData {
     /// Get metadata with the given label.
     #[must_use]
-    pub fn metadata(&self, label: MetadatumLabel) -> Option<&MetadatumValue> {
+    pub fn metadata(
+        &self,
+        label: MetadatumLabel,
+    ) -> Option<&MetadatumValue> {
         self.metadata.get(label)
     }
 
diff --git a/rust/cardano-blockchain-types/src/auxdata/block.rs b/rust/cardano-blockchain-types/src/auxdata/block.rs
index e3df6a2cc2e..3d79919fefc 100644
--- a/rust/cardano-blockchain-types/src/auxdata/block.rs
+++ b/rust/cardano-blockchain-types/src/auxdata/block.rs
@@ -17,7 +17,10 @@ pub struct BlockAuxData(Arc<dashmap::ReadOnlyView<TxnIndex, TransactionAuxData>>
 impl BlockAuxData {
     /// Get `TransactionAuxData` for the given `TxnIndex` if any.
     #[must_use]
-    pub fn get(&self, txn_idx: TxnIndex) -> Option<&TransactionAuxData> {
+    pub fn get(
+        &self,
+        txn_idx: TxnIndex,
+    ) -> Option<&TransactionAuxData> {
         self.0.get(&txn_idx)
     }
 }
diff --git a/rust/cardano-blockchain-types/src/auxdata/metadatum.rs b/rust/cardano-blockchain-types/src/auxdata/metadatum.rs
index f85c16082fe..09164df11a1 100644
--- a/rust/cardano-blockchain-types/src/auxdata/metadatum.rs
+++ b/rust/cardano-blockchain-types/src/auxdata/metadatum.rs
@@ -35,13 +35,19 @@ impl Default for MetadataInner {
 impl Metadata {
     /// Does the metadata contain the label?
     #[must_use]
-    pub fn contains(&self, label: MetadatumLabel) -> bool {
+    pub fn contains(
+        &self,
+        label: MetadatumLabel,
+    ) -> bool {
         self.0.map.contains_key(&label)
     }
 
     /// Get the requested labels value
     #[must_use]
-    pub fn get(&self, label: MetadatumLabel) -> Option<&MetadatumValue> {
+    pub fn get(
+        &self,
+        label: MetadatumLabel,
+    ) -> Option<&MetadatumValue> {
         self.0.map.get(&label)
     }
 
@@ -60,7 +66,8 @@ impl Default for Metadata {
 
 impl Decode<'_, ()> for Metadata {
     fn decode(
-        d: &mut minicbor::Decoder<'_>, ctx: &mut (),
+        d: &mut minicbor::Decoder<'_>,
+        ctx: &mut (),
     ) -> Result<Self, minicbor::decode::Error> {
         let (entries, mut sequence, metadata) = match d.map() {
             Ok(Some(entries)) => {
diff --git a/rust/cardano-blockchain-types/src/auxdata/metadatum_label.rs b/rust/cardano-blockchain-types/src/auxdata/metadatum_label.rs
index 2729ae71350..607005778db 100644
--- a/rust/cardano-blockchain-types/src/auxdata/metadatum_label.rs
+++ b/rust/cardano-blockchain-types/src/auxdata/metadatum_label.rs
@@ -24,7 +24,8 @@ impl MetadatumLabel {
 
 impl Decode<'_, ()> for MetadatumLabel {
     fn decode(
-        d: &mut minicbor::Decoder<'_>, _ctx: &mut (),
+        d: &mut minicbor::Decoder<'_>,
+        _ctx: &mut (),
     ) -> Result<Self, minicbor::decode::Error> {
         let label = match d.u64() {
             Ok(key) => key,
diff --git a/rust/cardano-blockchain-types/src/auxdata/metadatum_value.rs b/rust/cardano-blockchain-types/src/auxdata/metadatum_value.rs
index a8c725204a7..67ebcfb2b28 100644
--- a/rust/cardano-blockchain-types/src/auxdata/metadatum_value.rs
+++ b/rust/cardano-blockchain-types/src/auxdata/metadatum_value.rs
@@ -11,7 +11,8 @@ pub struct MetadatumValue(Arc<Vec<u8>>);
 
 impl Decode<'_, ()> for MetadatumValue {
     fn decode(
-        d: &mut minicbor::Decoder<'_>, _ctx: &mut (),
+        d: &mut minicbor::Decoder<'_>,
+        _ctx: &mut (),
     ) -> Result<Self, minicbor::decode::Error> {
         // Get the start of the raw CBOR value we are going to extract.
         let value_start = d.position();
diff --git a/rust/cardano-blockchain-types/src/auxdata/scripts.rs b/rust/cardano-blockchain-types/src/auxdata/scripts.rs
index a681a2e24af..d82b30d397b 100644
--- a/rust/cardano-blockchain-types/src/auxdata/scripts.rs
+++ b/rust/cardano-blockchain-types/src/auxdata/scripts.rs
@@ -12,7 +12,8 @@ pub struct Script(Arc<Vec<u8>>);
 
 impl minicbor::Decode<'_, ScriptType> for Script {
     fn decode(
-        d: &mut minicbor::Decoder<'_>, ctx: &mut ScriptType,
+        d: &mut minicbor::Decoder<'_>,
+        ctx: &mut ScriptType,
     ) -> Result<Self, minicbor::decode::Error> {
         let script_type = *ctx;
 
@@ -56,7 +57,8 @@ pub struct ScriptArray(Arc<Vec<Script>>);
 
 impl minicbor::Decode<'_, ScriptType> for ScriptArray {
     fn decode(
-        d: &mut minicbor::Decoder<'_>, ctx: &mut ScriptType,
+        d: &mut minicbor::Decoder<'_>,
+        ctx: &mut ScriptType,
     ) -> Result<Self, minicbor::decode::Error> {
         let mut scripts: Vec<Script> = Vec::new();
 
diff --git a/rust/cardano-blockchain-types/src/cip134_uri.rs b/rust/cardano-blockchain-types/src/cip134_uri.rs
index 1f97d6dfe0a..536ee410ace 100644
--- a/rust/cardano-blockchain-types/src/cip134_uri.rs
+++ b/rust/cardano-blockchain-types/src/cip134_uri.rs
@@ -86,7 +86,10 @@ impl Cip0134Uri {
 }
 
 impl Display for Cip0134Uri {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut Formatter<'_>,
+    ) -> std::fmt::Result {
         write!(f, "{}", self.uri())
     }
 }
diff --git a/rust/cardano-blockchain-types/src/fork.rs b/rust/cardano-blockchain-types/src/fork.rs
index 1c72f704ae1..4eede9fe5d6 100644
--- a/rust/cardano-blockchain-types/src/fork.rs
+++ b/rust/cardano-blockchain-types/src/fork.rs
@@ -48,7 +48,7 @@ impl Fork {
             + std::cmp::PartialOrd<T>
             + num_traits::identities::Zero,
     >(
-        value: T,
+        value: T
     ) -> Self {
         let value: u64 = from_saturating(value);
         Self(value)
@@ -66,7 +66,10 @@ impl Fork {
 }
 
 impl fmt::Display for Fork {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
         match self.0 {
             0 => write!(f, "IMMUTABLE"),
             1 => write!(f, "BACKFILL"),
diff --git a/rust/cardano-blockchain-types/src/metadata/cip36/key_registration.rs b/rust/cardano-blockchain-types/src/metadata/cip36/key_registration.rs
index dc93d8e5719..81ebf4bfd7a 100644
--- a/rust/cardano-blockchain-types/src/metadata/cip36/key_registration.rs
+++ b/rust/cardano-blockchain-types/src/metadata/cip36/key_registration.rs
@@ -84,7 +84,10 @@ enum Cip36KeyRegistrationKeys {
 }
 
 impl Decode<'_, ProblemReport> for Cip36KeyRegistration {
-    fn decode(d: &mut Decoder, err_report: &mut ProblemReport) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut Decoder,
+        err_report: &mut ProblemReport,
+    ) -> Result<Self, decode::Error> {
         let map_len = decode_map_len(d, "CIP36 Key Registration")?;
 
         let mut cip36_key_registration = Cip36KeyRegistration::default();
@@ -164,7 +167,8 @@ impl Decode<'_, ProblemReport> for Cip36KeyRegistration {
 ///       verifying key, assign `voting_pk` to None.
 /// - Error if decoding failed.
 fn decode_voting_key(
-    d: &mut Decoder, err_report: &ProblemReport,
+    d: &mut Decoder,
+    err_report: &ProblemReport,
 ) -> Result<(Option<bool>, Vec<VotingPubKey>), decode::Error> {
     let mut voting_keys = Vec::new();
     #[allow(unused_assignments)]
@@ -241,7 +245,9 @@ fn decode_voting_key(
 
 /// Helper function for converting `&[u8]` to `VerifyingKey`.
 fn voting_pk_vec_to_verifying_key(
-    pub_key: &[u8], err_report: &ProblemReport, context: &str,
+    pub_key: &[u8],
+    err_report: &ProblemReport,
+    context: &str,
 ) -> Option<VerifyingKey> {
     let bytes = pub_key
         .try_into()
@@ -280,7 +286,8 @@ fn voting_pk_vec_to_verifying_key(
 /// - None if cannot converted `Vec<u8>` to `VerifyingKey`.
 /// - Error if decoding failed.
 fn decode_stake_pk(
-    d: &mut Decoder, err_report: &ProblemReport,
+    d: &mut Decoder,
+    err_report: &ProblemReport,
 ) -> Result<Option<VerifyingKey>, decode::Error> {
     let pub_key = decode_bytes(d, "CIP36 Key Registration stake public key")?;
     Ok(voting_pk_vec_to_verifying_key(
@@ -303,7 +310,8 @@ fn decode_stake_pk(
 /// - None if cannot converted `Vec<u8>` to `Address` or the address is a Byron address.
 /// - Error if decoding failed.
 fn decode_payment_addr(
-    d: &mut Decoder, err_report: &ProblemReport,
+    d: &mut Decoder,
+    err_report: &ProblemReport,
 ) -> Result<Option<Address>, decode::Error> {
     let raw_addr = decode_bytes(d, "CIP36 Key Registration payment address")?;
     // Cannot convert raw address to Address type
diff --git a/rust/cardano-blockchain-types/src/metadata/cip36/mod.rs b/rust/cardano-blockchain-types/src/metadata/cip36/mod.rs
index 26210e71869..03046a64303 100644
--- a/rust/cardano-blockchain-types/src/metadata/cip36/mod.rs
+++ b/rust/cardano-blockchain-types/src/metadata/cip36/mod.rs
@@ -45,7 +45,10 @@ pub struct Cip36 {
 }
 
 impl fmt::Display for Cip36 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
         write!(
             f,
             "Cip36 {{ network: {network}, slot: {slot:?}, txn_idx: {txn_idx:?}, is_catalyst_strict: {is_catalyst_strict}, key_registration: {key_registration:?}, registration_witness: {registration_witness:?}, validation: {{ signature: {is_valid_signature}, payment_address_network: {is_valid_payment_address_network}, voting_keys: {is_valid_voting_keys}, purpose: {is_valid_purpose} }}, err_report: {err_report} }}",
@@ -76,7 +79,10 @@ pub struct Cip36Error {
 }
 
 impl fmt::Display for Cip36Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(
+        &self,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
         let report_json = serde_json::to_string(&self.report)
             .unwrap_or_else(|_| String::from("Failed to serialize ProblemReport"));
 
@@ -109,7 +115,9 @@ impl Cip36 {
     /// or if the CIP-36 key registration or registration witness metadata cannot be
     /// decoded.
     pub fn new(
-        block: &MultiEraBlock, txn_idx: TxnIndex, is_catalyst_strict: bool,
+        block: &MultiEraBlock,
+        txn_idx: TxnIndex,
+        is_catalyst_strict: bool,
     ) -> Result<Option<Cip36>, Cip36Error> {
         // Record of errors found during decoding and validation
         let mut err_report = ProblemReport::new("CIP36 Registration Decoding and Validation");
@@ -200,7 +208,8 @@ impl Cip36 {
     /// None if there is no CIP-36 registration found in the block.
     #[must_use]
     pub fn cip36_from_block(
-        block: &MultiEraBlock, is_catalyst_strict: bool,
+        block: &MultiEraBlock,
+        is_catalyst_strict: bool,
     ) -> Option<HashMap<TxnIndex, Result<Cip36, Cip36Error>>> {
         let mut cip36_map = HashMap::new();
 
diff --git a/rust/cardano-blockchain-types/src/metadata/cip36/registration_witness.rs b/rust/cardano-blockchain-types/src/metadata/cip36/registration_witness.rs
index ee2ffbb7e6c..cd17d20e55b 100644
--- a/rust/cardano-blockchain-types/src/metadata/cip36/registration_witness.rs
+++ b/rust/cardano-blockchain-types/src/metadata/cip36/registration_witness.rs
@@ -22,7 +22,10 @@ pub(crate) struct Cip36RegistrationWitness {
 }
 
 impl Decode<'_, ProblemReport> for Cip36RegistrationWitness {
-    fn decode(d: &mut Decoder, err_report: &mut ProblemReport) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut Decoder,
+        err_report: &mut ProblemReport,
+    ) -> Result<Self, decode::Error> {
         let map_len = decode_map_len(d, "CIP36 Registration Witness")?;
 
         // Expected only 1 key in the map.
diff --git a/rust/cardano-blockchain-types/src/metadata/cip36/validation.rs b/rust/cardano-blockchain-types/src/metadata/cip36/validation.rs
index 9a906caf20c..ea804744352 100644
--- a/rust/cardano-blockchain-types/src/metadata/cip36/validation.rs
+++ b/rust/cardano-blockchain-types/src/metadata/cip36/validation.rs
@@ -24,7 +24,10 @@ pub const SIGNDATA_PREAMBLE: [u8; 4] = [0xA1, 0x19, 0xEF, 0x64];
 
 impl Cip36 {
     /// Validate the signature against the public key.
-    pub(crate) fn validate_signature(&mut self, metadata: &MetadatumValue) {
+    pub(crate) fn validate_signature(
+        &mut self,
+        metadata: &MetadatumValue,
+    ) {
         let hash = blake2b_simd::Params::new()
             .hash_length(32)
             .to_state()
diff --git a/rust/cardano-blockchain-types/src/metadata/cip36/voting_pk.rs b/rust/cardano-blockchain-types/src/metadata/cip36/voting_pk.rs
index a35ce68dd59..81114fe965f 100644
--- a/rust/cardano-blockchain-types/src/metadata/cip36/voting_pk.rs
+++ b/rust/cardano-blockchain-types/src/metadata/cip36/voting_pk.rs
@@ -14,7 +14,10 @@ pub struct VotingPubKey {
 impl VotingPubKey {
     /// Create a new voting public key.
     #[must_use]
-    pub fn new(voting_pk: Option<VerifyingKey>, weight: u32) -> Self {
+    pub fn new(
+        voting_pk: Option<VerifyingKey>,
+        weight: u32,
+    ) -> Self {
         Self { voting_pk, weight }
     }
 
diff --git a/rust/cardano-blockchain-types/src/multi_era_block_data.rs b/rust/cardano-blockchain-types/src/multi_era_block_data.rs
index 1c3e34f7912..618ffef6e48 100644
--- a/rust/cardano-blockchain-types/src/multi_era_block_data.rs
+++ b/rust/cardano-blockchain-types/src/multi_era_block_data.rs
@@ -94,7 +94,10 @@ impl MultiEraBlock {
     ///
     /// If the given bytes cannot be decoded as a multi-era block, an error is returned.
     pub fn new(
-        network: Network, raw_data: Vec<u8>, previous: &Point, fork: Fork,
+        network: Network,
+        raw_data: Vec<u8>,
+        previous: &Point,
+        fork: Fork,
     ) -> anyhow::Result<Self> {
         let builder = SelfReferencedMultiEraBlockTryBuilder {
             raw_data,
@@ -152,7 +155,10 @@ impl MultiEraBlock {
     }
 
     /// Remake the block on a new fork.
-    pub fn set_fork(&mut self, fork: Fork) {
+    pub fn set_fork(
+        &mut self,
+        fork: Fork,
+    ) {
         self.fork = fork;
     }
 
@@ -250,7 +256,9 @@ impl MultiEraBlock {
     /// - Or None if the label requested isn't present.
     #[must_use]
     pub fn txn_metadata(
-        &self, txn_idx: TxnIndex, label: MetadatumLabel,
+        &self,
+        txn_idx: TxnIndex,
+        label: MetadatumLabel,
     ) -> Option<&MetadatumValue> {
         let txn = self.inner.aux_data.get(txn_idx)?;
         txn.metadata(label)
@@ -263,7 +271,11 @@ impl MultiEraBlock {
 
     /// If the witness exists for a given transaction then return its public key.
     #[must_use]
-    pub fn witness_for_tx(&self, vkey_hash: &VKeyHash, tx_num: TxnIndex) -> Option<VerifyingKey> {
+    pub fn witness_for_tx(
+        &self,
+        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);
@@ -301,7 +313,10 @@ impl MultiEraBlock {
 }
 
 impl Display for MultiEraBlock {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
         let fork = self.fork;
         let block_data = &self.inner.data;
         let block = block_data.borrow_block();
@@ -338,7 +353,10 @@ impl Display for MultiEraBlock {
 impl PartialEq for MultiEraBlock {
     /// Compare two `MultiEraBlock` by their current points.
     /// Ignores the Hash, we only check for equality of the Slot#.
-    fn eq(&self, other: &Self) -> bool {
+    fn eq(
+        &self,
+        other: &Self,
+    ) -> bool {
         self.partial_cmp(other) == Some(Ordering::Equal)
     }
 }
@@ -348,7 +366,10 @@ impl Eq for MultiEraBlock {}
 impl PartialOrd for MultiEraBlock {
     /// Compare two `MultiEraBlock` by their points.
     /// Only checks the Slot#.
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+    fn partial_cmp(
+        &self,
+        other: &Self,
+    ) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
@@ -356,7 +377,10 @@ impl PartialOrd for MultiEraBlock {
 impl Ord for MultiEraBlock {
     /// Compare two `LiveBlocks` by their points.
     /// Only checks the Slot#.
-    fn cmp(&self, other: &Self) -> Ordering {
+    fn cmp(
+        &self,
+        other: &Self,
+    ) -> Ordering {
         self.inner.point.cmp(&other.inner.point)
     }
 }
@@ -364,7 +388,10 @@ impl Ord for MultiEraBlock {
 // Allows us to compare a MultiEraBlock against a Point directly (Just the slot#).
 impl PartialEq<Point> for MultiEraBlock {
     // Equality ONLY checks the Slot#
-    fn eq(&self, other: &Point) -> bool {
+    fn eq(
+        &self,
+        other: &Point,
+    ) -> bool {
         Some(Ordering::Equal) == self.partial_cmp(other)
     }
 }
@@ -372,7 +399,10 @@ impl PartialEq<Point> for MultiEraBlock {
 impl PartialOrd<Point> for MultiEraBlock {
     /// Compare a `MultiEraBlock` to a `Point` by their points.
     /// Only checks the Slot#.
-    fn partial_cmp(&self, other: &Point) -> Option<Ordering> {
+    fn partial_cmp(
+        &self,
+        other: &Point,
+    ) -> Option<Ordering> {
         Some(self.inner.point.cmp(other))
     }
 }
diff --git a/rust/cardano-blockchain-types/src/network.rs b/rust/cardano-blockchain-types/src/network.rs
index d0d93b49b8f..1a64f03accc 100644
--- a/rust/cardano-blockchain-types/src/network.rs
+++ b/rust/cardano-blockchain-types/src/network.rs
@@ -160,7 +160,10 @@ impl Network {
 
     /// Convert a given slot# to its Wall Time for a Blockchain network.
     #[must_use]
-    pub fn slot_to_time(self, slot: Slot) -> DateTime<Utc> {
+    pub fn slot_to_time(
+        self,
+        slot: Slot,
+    ) -> DateTime<Utc> {
         let genesis = self.genesis_values();
         let wall_clock = genesis.slot_to_wallclock(slot.into());
 
@@ -174,7 +177,10 @@ impl Network {
     ///
     /// The Slot does not have to be a valid slot present in the blockchain.
     #[must_use]
-    pub fn time_to_slot(self, time: DateTime<Utc>) -> Option<Slot> {
+    pub fn time_to_slot(
+        self,
+        time: DateTime<Utc>,
+    ) -> Option<Slot> {
         let genesis = self.genesis_values();
 
         let byron_start_time =
diff --git a/rust/cardano-blockchain-types/src/point.rs b/rust/cardano-blockchain-types/src/point.rs
index 392189a115b..16f180e5c9e 100644
--- a/rust/cardano-blockchain-types/src/point.rs
+++ b/rust/cardano-blockchain-types/src/point.rs
@@ -98,7 +98,10 @@ impl Point {
     /// let point = Point::new(slot.into(), hash.into());
     /// ```
     #[must_use]
-    pub fn new(slot: Slot, hash: Blake2b256Hash) -> Self {
+    pub fn new(
+        slot: Slot,
+        hash: Blake2b256Hash,
+    ) -> Self {
         Self(pallas::network::miniprotocols::Point::Specific(
             slot.into(),
             hash.into(),
@@ -328,7 +331,10 @@ impl Point {
     /// assert!(!point3.strict_eq(&point4));
     /// ```
     #[must_use]
-    pub fn strict_eq(&self, b: &Self) -> bool {
+    pub fn strict_eq(
+        &self,
+        b: &Self,
+    ) -> bool {
         self.0 == b.0
     }
 }
@@ -338,7 +344,10 @@ impl PartialEq<Option<Blake2b256Hash>> for Point {
     /// It returns `true` if the hashes match and `false` otherwise. If the
     /// provided hash is `None`, the function checks if the `Point` has an
     /// empty hash.
-    fn eq(&self, other: &Option<Blake2b256Hash>) -> bool {
+    fn eq(
+        &self,
+        other: &Option<Blake2b256Hash>,
+    ) -> bool {
         match other {
             Some(cmp_hash) => {
                 match self.0 {
@@ -364,13 +373,19 @@ impl PartialEq<Option<Hash<32>>> for Point {
     /// It returns `true` if the hashes match and `false` otherwise. If the
     /// provided hash is `None`, the function checks if the `Point` has an
     /// empty hash.
-    fn eq(&self, other: &Option<Hash<32>>) -> bool {
+    fn eq(
+        &self,
+        other: &Option<Hash<32>>,
+    ) -> bool {
         *self == other.map(Blake2b256Hash::from)
     }
 }
 
 impl Display for Point {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut Formatter<'_>,
+    ) -> std::result::Result<(), std::fmt::Error> {
         if *self == Self::ORIGIN {
             return write!(f, "Point @ Origin");
         } else if *self == Self::TIP {
@@ -409,7 +424,10 @@ impl From<Point> for pallas::network::miniprotocols::Point {
 impl PartialOrd for Point {
     /// Implements a partial ordering based on the slot number
     /// of two `Point` instances. It only checks the slot number for ordering.
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+    fn partial_cmp(
+        &self,
+        other: &Self,
+    ) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
@@ -417,20 +435,29 @@ impl PartialOrd for Point {
 impl Ord for Point {
     /// Implements a total ordering based on the slot number
     /// of two `Point` instances. It only checks the slot number for ordering.
-    fn cmp(&self, other: &Self) -> Ordering {
+    fn cmp(
+        &self,
+        other: &Self,
+    ) -> Ordering {
         cmp_point(&self.0, &other.0)
     }
 }
 
 impl PartialEq<u64> for Point {
-    fn eq(&self, other: &u64) -> bool {
+    fn eq(
+        &self,
+        other: &u64,
+    ) -> bool {
         self.0.slot_or_default() == *other
     }
 }
 
 impl PartialOrd<u64> for Point {
     /// Allows to compare a `Point` against a `u64`
-    fn partial_cmp(&self, other: &u64) -> Option<Ordering> {
+    fn partial_cmp(
+        &self,
+        other: &u64,
+    ) -> Option<Ordering> {
         self.0.slot_or_default().partial_cmp(other)
     }
 }
@@ -439,7 +466,10 @@ impl PartialEq<Option<Point>> for Point {
     /// Allows for direct comparison between a `Point` and an `Option<Point>`,
     /// returning `true` only if the `Option` contains a `Point` that is equal to the
     /// `self` instance.
-    fn eq(&self, other: &Option<Point>) -> bool {
+    fn eq(
+        &self,
+        other: &Option<Point>,
+    ) -> bool {
         if let Some(other) = other {
             *self == *other
         } else {
@@ -451,7 +481,10 @@ impl PartialEq<Option<Point>> for Point {
 impl PartialOrd<Option<Point>> for Point {
     /// Allows comparing a `Point` with an `Option<Point>`, where a `Point` is always
     /// considered greater than `None`.
-    fn partial_cmp(&self, other: &Option<Point>) -> Option<Ordering> {
+    fn partial_cmp(
+        &self,
+        other: &Option<Point>,
+    ) -> Option<Ordering> {
         if let Some(other) = other {
             self.partial_cmp(other)
         } else {
@@ -469,7 +502,8 @@ impl Default for Point {
 
 /// Compare Points, because Pallas does not impl `Ord` for `Point`.
 fn cmp_point(
-    a: &pallas::network::miniprotocols::Point, b: &pallas::network::miniprotocols::Point,
+    a: &pallas::network::miniprotocols::Point,
+    b: &pallas::network::miniprotocols::Point,
 ) -> Ordering {
     match a {
         pallas::network::miniprotocols::Point::Origin => {
diff --git a/rust/cardano-blockchain-types/src/slot.rs b/rust/cardano-blockchain-types/src/slot.rs
index eef0d433f5b..0aaf1c784b7 100644
--- a/rust/cardano-blockchain-types/src/slot.rs
+++ b/rust/cardano-blockchain-types/src/slot.rs
@@ -16,7 +16,7 @@ impl Slot {
     pub fn from_saturating<
         T: Copy + TryInto<u64> + Sub<Output = T> + PartialOrd<T> + num_traits::identities::Zero,
     >(
-        value: T,
+        value: T
     ) -> Self {
         let value: u64 = from_saturating(value);
         Self(value)
@@ -36,7 +36,10 @@ impl From<Slot> for u64 {
 }
 
 impl MulAssign<u64> for Slot {
-    fn mul_assign(&mut self, rhs: u64) {
+    fn mul_assign(
+        &mut self,
+        rhs: u64,
+    ) {
         self.0 = self.0.saturating_mul(rhs);
     }
 }
@@ -44,7 +47,10 @@ impl MulAssign<u64> for Slot {
 impl Sub for Slot {
     type Output = Slot;
 
-    fn sub(self, rhs: Slot) -> Self::Output {
+    fn sub(
+        self,
+        rhs: Slot,
+    ) -> Self::Output {
         Slot(self.0.saturating_sub(rhs.0))
     }
 }
diff --git a/rust/cardano-blockchain-types/src/stake_address.rs b/rust/cardano-blockchain-types/src/stake_address.rs
index d6bb646cf00..6cbae4ca2a3 100644
--- a/rust/cardano-blockchain-types/src/stake_address.rs
+++ b/rust/cardano-blockchain-types/src/stake_address.rs
@@ -27,7 +27,11 @@ impl StakeAddress {
     /// Creates a new instance from the given parameters.
     #[allow(clippy::expect_used, clippy::missing_panics_doc)]
     #[must_use]
-    pub fn new(network: Network, is_script: bool, stake_pk_hash: Blake2b224Hash) -> Self {
+    pub fn new(
+        network: Network,
+        is_script: bool,
+        stake_pk_hash: Blake2b224Hash,
+    ) -> Self {
         let network = network.into();
         let hash = stake_pk_hash.into();
         // `pallas::StakeAddress` can only be constructed from `ShelleyAddress`, so we are forced
@@ -49,7 +53,10 @@ impl StakeAddress {
 
     /// Creates `StakeAddress` from `StakeCredential`.
     #[must_use]
-    pub fn from_stake_cred(network: Network, cred: &conway::StakeCredential) -> Self {
+    pub fn from_stake_cred(
+        network: Network,
+        cred: &conway::StakeCredential,
+    ) -> Self {
         match cred {
             conway::StakeCredential::ScriptHash(h) => Self::new(network, true, (*h).into()),
             conway::StakeCredential::AddrKeyhash(h) => Self::new(network, false, (*h).into()),
@@ -125,7 +132,10 @@ impl From<StakeAddress> for Vec<u8> {
 }
 
 impl Display for StakeAddress {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut Formatter<'_>,
+    ) -> std::fmt::Result {
         // The `to_bech32` implementation returns an error if the network isn't equal to testnet
         // or mainnet. We don't allow other networks, so it is safe to unwrap, but just in case
         // return a debug representation.
diff --git a/rust/cardano-blockchain-types/src/txn_witness.rs b/rust/cardano-blockchain-types/src/txn_witness.rs
index be369f1dbc2..28f8b12b522 100644
--- a/rust/cardano-blockchain-types/src/txn_witness.rs
+++ b/rust/cardano-blockchain-types/src/txn_witness.rs
@@ -78,7 +78,11 @@ impl TxnWitness {
 
     /// Check whether the public key hash is in the given transaction number.
     #[must_use]
-    pub fn check_witness_in_tx(&self, vkey_hash: &VKeyHash, tx_num: TxnIndex) -> bool {
+    pub fn check_witness_in_tx(
+        &self,
+        vkey_hash: &VKeyHash,
+        tx_num: TxnIndex,
+    ) -> bool {
         self.0
             .get(vkey_hash)
             .is_some_and(|entry| entry.1.contains(&tx_num))
@@ -86,13 +90,19 @@ impl TxnWitness {
 
     /// Get the actual verifying key from the given public key hash.
     #[must_use]
-    pub fn get_witness_vkey(&self, vkey_hash: &VKeyHash) -> Option<VerifyingKey> {
+    pub fn get_witness_vkey(
+        &self,
+        vkey_hash: &VKeyHash,
+    ) -> Option<VerifyingKey> {
         self.0.get(vkey_hash).map(|entry| entry.0)
     }
 }
 
 impl Display for TxnWitness {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut Formatter<'_>,
+    ) -> std::fmt::Result {
         for data in &self.0 {
             let vkey_hash = data.key();
             let txn = &data.value().1;
diff --git a/rust/cardano-chain-follower/examples/follow_chains.rs b/rust/cardano-chain-follower/examples/follow_chains.rs
index d60fee07fa9..773a145e9c1 100644
--- a/rust/cardano-chain-follower/examples/follow_chains.rs
+++ b/rust/cardano-chain-follower/examples/follow_chains.rs
@@ -84,7 +84,10 @@ fn process_argument() -> (Vec<Network>, ArgMatches) {
 }
 
 /// Start syncing a particular network
-async fn start_sync_for(network: &Network, matches: ArgMatches) -> Result<(), Box<dyn Error>> {
+async fn start_sync_for(
+    network: &Network,
+    matches: ArgMatches,
+) -> Result<(), Box<dyn Error>> {
     let mut cfg = ChainSyncConfig::default_for(*network);
     let mut mithril_dl_connect_timeout = "Not Set".to_string();
     let mut mithril_dl_data_timeout = "Not Set".to_string();
@@ -149,7 +152,10 @@ const RUNNING_UPDATE_INTERVAL: u64 = 100_000;
 
 /// Try and follow a chain continuously, from Genesis until Tip.
 #[allow(clippy::too_many_lines)]
-async fn follow_for(network: Network, matches: ArgMatches) {
+async fn follow_for(
+    network: Network,
+    matches: ArgMatches,
+) {
     info!(chain = network.to_string(), "Following");
     let mut follower = ChainFollower::new(network, Point::ORIGIN, Point::TIP).await;
 
@@ -332,7 +338,10 @@ async fn follow_for(network: Network, matches: ArgMatches) {
 /// Helper function for updating the biggest metadata from a list of
 /// interested metadata label.
 fn update_largest_metadata(
-    block: &MultiEraBlock, network: Network, txn_idx: TxnIndex, largest_metadata_size: &mut usize,
+    block: &MultiEraBlock,
+    network: Network,
+    txn_idx: TxnIndex,
+    largest_metadata_size: &mut usize,
 ) {
     let labels = [
         MetadatumLabel::CIP509_RBAC,
@@ -360,7 +369,10 @@ fn update_largest_metadata(
 }
 
 /// Helper function for logging the raw box auxiliary data.
-fn raw_aux_info(block: &pallas::ledger::traverse::MultiEraBlock, network: Network) {
+fn raw_aux_info(
+    block: &pallas::ledger::traverse::MultiEraBlock,
+    network: Network,
+) {
     match block {
         pallas::ledger::traverse::MultiEraBlock::AlonzoCompatible(b, _) => {
             info!(
@@ -386,7 +398,8 @@ fn raw_aux_info(block: &pallas::ledger::traverse::MultiEraBlock, network: Networ
 
 /// Helper function for updating the largest auxiliary data.
 fn update_largest_aux(
-    block: &pallas::ledger::traverse::MultiEraBlock, network: Network,
+    block: &pallas::ledger::traverse::MultiEraBlock,
+    network: Network,
     largest_metadata_size: &mut usize,
 ) {
     match block {
@@ -429,7 +442,10 @@ fn update_largest_aux(
 
 /// Helper function for comparing and logging the largest auxiliary data.
 fn compare_and_log_aux(
-    aux_len: usize, block_no: u64, txn_idx: u32, network: Network,
+    aux_len: usize,
+    block_no: u64,
+    txn_idx: u32,
+    network: Network,
     largest_metadata_size: &mut usize,
 ) {
     if aux_len > *largest_metadata_size {
@@ -448,7 +464,10 @@ fn compare_and_log_aux(
 /// Bad CIP36 includes:
 /// - CIP36 that is valid decoded, but have problem.
 /// - CIP36 that is invalid decoded.
-fn log_bad_cip36_info(block: &MultiEraBlock, network: Network) {
+fn log_bad_cip36_info(
+    block: &MultiEraBlock,
+    network: Network,
+) {
     if let Some(map) = Cip36::cip36_from_block(block, true) {
         for (key, value) in &map {
             match value {
@@ -470,7 +489,10 @@ fn log_bad_cip36_info(block: &MultiEraBlock, network: Network) {
 }
 
 /// Function for logging bad CIP509.
-fn log_bad_cip509_info(block: &MultiEraBlock, network: Network) {
+fn log_bad_cip509_info(
+    block: &MultiEraBlock,
+    network: Network,
+) {
     for cip509 in Cip509::from_block(block, &[]) {
         if cip509.report().is_problematic() {
             info!(
diff --git a/rust/cardano-chain-follower/src/chain_sync.rs b/rust/cardano-chain-follower/src/chain_sync.rs
index 916fe9638ba..f590a3df3af 100644
--- a/rust/cardano-chain-follower/src/chain_sync.rs
+++ b/rust/cardano-chain-follower/src/chain_sync.rs
@@ -49,7 +49,8 @@ const MAX_NODE_CONNECT_RETRIES: u64 = 5;
 /// If it takes longer then 5 seconds, retry the connection.
 /// Retry 5 times before giving up.
 async fn retry_connect(
-    addr: &str, magic: u64,
+    addr: &str,
+    magic: u64,
 ) -> std::result::Result<PeerClient, pallas::network::facades::Error> {
     let mut retries = MAX_NODE_CONNECT_RETRIES;
     loop {
@@ -85,7 +86,10 @@ async fn retry_connect(
 }
 
 /// Purge the live chain, and intersect with TIP.
-async fn purge_and_intersect_tip(client: &mut PeerClient, chain: Network) -> Result<Point> {
+async fn purge_and_intersect_tip(
+    client: &mut PeerClient,
+    chain: Network,
+) -> Result<Point> {
     if let Err(error) = purge_live_chain(chain, &Point::TIP) {
         // Shouldn't happen.
         error!("failed to purge live chain: {error}");
@@ -100,7 +104,10 @@ async fn purge_and_intersect_tip(client: &mut PeerClient, chain: Network) -> Res
 }
 
 /// Resynchronize to the live tip in memory.
-async fn resync_live_tip(client: &mut PeerClient, chain: Network) -> Result<Point> {
+async fn resync_live_tip(
+    client: &mut PeerClient,
+    chain: Network,
+) -> Result<Point> {
     let sync_points = get_intersect_points(chain);
     if sync_points.is_empty() {
         return purge_and_intersect_tip(client, chain).await;
@@ -120,7 +127,11 @@ async fn resync_live_tip(client: &mut PeerClient, chain: Network) -> Result<Poin
 
 /// Fetch a single block from the Peer, and decode it.
 async fn fetch_block_from_peer(
-    peer: &mut PeerClient, chain: Network, point: Point, previous_point: Point, fork_count: Fork,
+    peer: &mut PeerClient,
+    chain: Network,
+    point: Point,
+    previous_point: Point,
+    fork_count: Fork,
 ) -> anyhow::Result<MultiEraBlock> {
     let block_data = peer
         .blockfetch()
@@ -139,7 +150,11 @@ async fn fetch_block_from_peer(
 /// Fetch the rollback block, and try and insert it into the live-chain.
 /// If its a real rollback, it will purge the chain ahead of the block automatically.
 async fn process_rollback_actual(
-    peer: &mut PeerClient, chain: Network, point: Point, tip: &Tip, fork_count: &mut Fork,
+    peer: &mut PeerClient,
+    chain: Network,
+    point: Point,
+    tip: &Tip,
+    fork_count: &mut Fork,
 ) -> anyhow::Result<Point> {
     debug!("RollBackward: {:?} {:?}", point, tip);
 
@@ -183,7 +198,11 @@ async fn process_rollback_actual(
 
 /// Process a rollback detected from the peer.
 async fn process_rollback(
-    peer: &mut PeerClient, chain: Network, point: Point, tip: &Tip, previous_point: &Point,
+    peer: &mut PeerClient,
+    chain: Network,
+    point: Point,
+    tip: &Tip,
+    previous_point: &Point,
     fork_count: &mut Fork,
 ) -> anyhow::Result<Point> {
     let rollback_slot = point.slot_or_default();
@@ -211,8 +230,12 @@ async fn process_rollback(
 
 /// Process a rollback detected from the peer.
 async fn process_next_block(
-    peer: &mut PeerClient, chain: Network, header: HeaderContent, tip: &Tip,
-    previous_point: &Point, fork_count: &mut Fork,
+    peer: &mut PeerClient,
+    chain: Network,
+    header: HeaderContent,
+    tip: &Tip,
+    previous_point: &Point,
+    fork_count: &mut Fork,
 ) -> anyhow::Result<Point> {
     // Decode the Header of the block so we know what to fetch.
     let decoded_header = MultiEraHeader::decode(
@@ -255,7 +278,9 @@ async fn process_next_block(
 ///
 /// We take ownership of the client because of that.
 async fn follow_chain(
-    peer: &mut PeerClient, chain: Network, fork_count: &mut Fork,
+    peer: &mut PeerClient,
+    chain: Network,
+    fork_count: &mut Fork,
 ) -> anyhow::Result<()> {
     let mut update_sender = get_chain_update_tx_queue(chain).await;
     let mut previous_point = Point::UNKNOWN;
@@ -313,7 +338,10 @@ async fn follow_chain(
 const PEER_FAILURE_RECONNECT_DELAY: Duration = Duration::from_secs(10);
 
 /// Do not return until we have a connection to the peer.
-async fn persistent_reconnect(addr: &str, chain: Network) -> PeerClient {
+async fn persistent_reconnect(
+    addr: &str,
+    chain: Network,
+) -> PeerClient {
     // Not yet connected to the peer.
     stats::peer_connected(chain, false, addr);
 
@@ -345,7 +373,8 @@ async fn persistent_reconnect(addr: &str, chain: Network) -> PeerClient {
 ///
 /// This only needs to be done once per chain connection.
 async fn live_sync_backfill(
-    cfg: &ChainSyncConfig, update: &MithrilUpdateMessage,
+    cfg: &ChainSyncConfig,
+    update: &MithrilUpdateMessage,
 ) -> anyhow::Result<()> {
     stats::backfill_started(cfg.chain);
 
@@ -412,7 +441,8 @@ async fn live_sync_backfill(
 
 /// Backfill and Purge the live chain, based on the Mithril Sync updates.
 async fn live_sync_backfill_and_purge(
-    cfg: ChainSyncConfig, mut rx: mpsc::Receiver<MithrilUpdateMessage>,
+    cfg: ChainSyncConfig,
+    mut rx: mpsc::Receiver<MithrilUpdateMessage>,
     mut sync_ready: SyncReadyWaiter,
 ) {
     // Wait for first Mithril Update advice, which triggers a BACKFILL of the Live Data.
@@ -515,7 +545,10 @@ async fn live_sync_backfill_and_purge(
 /// # Returns
 ///
 /// This does not return, it is a background task.
-pub(crate) async fn chain_sync(cfg: ChainSyncConfig, rx: mpsc::Receiver<MithrilUpdateMessage>) {
+pub(crate) async fn chain_sync(
+    cfg: ChainSyncConfig,
+    rx: mpsc::Receiver<MithrilUpdateMessage>,
+) {
     debug!(
         "Chain Sync for: {} from {} : Starting",
         cfg.chain, cfg.relay_address,
@@ -571,7 +604,10 @@ pub(crate) async fn chain_sync(cfg: ChainSyncConfig, rx: mpsc::Receiver<MithrilU
 }
 
 /// Is the current point aligned with what we know as tip.
-pub(crate) async fn point_at_tip(chain: Network, point: &Point) -> bool {
+pub(crate) async fn point_at_tip(
+    chain: Network,
+    point: &Point,
+) -> bool {
     let tip = get_peer_tip(chain);
 
     // We are said to be AT TIP, if the block point is greater than or equal to the tip.
diff --git a/rust/cardano-chain-follower/src/chain_sync_config.rs b/rust/cardano-chain-follower/src/chain_sync_config.rs
index f38587720e9..6de7f8f929a 100644
--- a/rust/cardano-chain-follower/src/chain_sync_config.rs
+++ b/rust/cardano-chain-follower/src/chain_sync_config.rs
@@ -75,7 +75,10 @@ impl ChainSyncConfig {
     ///
     /// * `relay`: Address to use for the blockchain relay node.
     #[must_use]
-    pub fn relay(mut self, address: String) -> Self {
+    pub fn relay(
+        mut self,
+        address: String,
+    ) -> Self {
         self.relay_address = address;
         self
     }
@@ -86,7 +89,10 @@ impl ChainSyncConfig {
     ///
     /// * `chain_update_buffer_size`: Size of the chain updates buffer.
     #[must_use]
-    pub fn chain_update_buffer_size(mut self, block_buffer_size: usize) -> Self {
+    pub fn chain_update_buffer_size(
+        mut self,
+        block_buffer_size: usize,
+    ) -> Self {
         self.chain_update_buffer_size = block_buffer_size;
         self
     }
@@ -97,7 +103,10 @@ impl ChainSyncConfig {
     ///
     /// * `window`: Size of the Immutable window.
     #[must_use]
-    pub fn immutable_slot_window(mut self, window: u64) -> Self {
+    pub fn immutable_slot_window(
+        mut self,
+        window: u64,
+    ) -> Self {
         self.immutable_slot_window = window;
         self
     }
@@ -108,7 +117,10 @@ impl ChainSyncConfig {
     ///
     /// * `cfg`: Mithril snapshot configuration.
     #[must_use]
-    pub fn mithril_cfg(mut self, cfg: MithrilSnapshotConfig) -> Self {
+    pub fn mithril_cfg(
+        mut self,
+        cfg: MithrilSnapshotConfig,
+    ) -> Self {
         self.mithril_cfg = cfg;
         self
     }
diff --git a/rust/cardano-chain-follower/src/chain_sync_live_chains.rs b/rust/cardano-chain-follower/src/chain_sync_live_chains.rs
index 5de6a000d4e..0e045578a4e 100644
--- a/rust/cardano-chain-follower/src/chain_sync_live_chains.rs
+++ b/rust/cardano-chain-follower/src/chain_sync_live_chains.rs
@@ -49,7 +49,10 @@ static PEER_TIP: LazyLock<SkipMap<Network, Point>> = LazyLock::new(|| {
 const INITIAL_SLOT_PROBE_AGE: u64 = 40;
 
 /// Set the last TIP received from the peer.
-fn update_peer_tip(chain: Network, tip: Point) {
+fn update_peer_tip(
+    chain: Network,
+    tip: Point,
+) {
     PEER_TIP.insert(chain, tip);
 }
 
@@ -73,7 +76,12 @@ impl ProtectedLiveChainBlockList {
     /// 0 = The Block immediately after the requested point.
     /// 1+ = The block that follows the block after the requested point
     /// negative = The block before the requested point.
-    fn get_block(&self, point: &Point, mut advance: i64, strict: bool) -> Option<MultiEraBlock> {
+    fn get_block(
+        &self,
+        point: &Point,
+        mut advance: i64,
+        strict: bool,
+    ) -> Option<MultiEraBlock> {
         let chain = self.0.read().ok()?;
 
         let mut this = if strict && !point.is_fuzzy() {
@@ -154,7 +162,11 @@ impl ProtectedLiveChainBlockList {
     /// The blocks MUST be contiguous and properly self referential.
     /// Note: This last condition is NOT enforced, but must be met or block chain
     /// iteration will fail.
-    fn backfill(&self, chain: Network, blocks: &[MultiEraBlock]) -> Result<()> {
+    fn backfill(
+        &self,
+        chain: Network,
+        blocks: &[MultiEraBlock],
+    ) -> Result<()> {
         let live_chain = self.0.write().map_err(|_| Error::Internal)?;
 
         // Make sure our first live block == the last mithril tip.
@@ -200,7 +212,10 @@ impl ProtectedLiveChainBlockList {
 
     /// Check if the given point is strictly in the live-chain. This means the slot and
     /// block hash MUST be present.
-    fn strict_block_lookup(live_chain: &LiveChainBlockList, point: &Point) -> bool {
+    fn strict_block_lookup(
+        live_chain: &LiveChainBlockList,
+        point: &Point,
+    ) -> bool {
         if let Some(found_block) = live_chain.get(point) {
             return found_block.value().point().strict_eq(point);
         }
@@ -211,7 +226,11 @@ impl ProtectedLiveChainBlockList {
     /// would be lost due to rollback. Will REFUSE to add a block which does NOT have
     /// a proper "previous" point defined.
     fn add_block_to_tip(
-        &self, chain: Network, block: MultiEraBlock, fork_count: &mut Fork, tip: Point,
+        &self,
+        chain: Network,
+        block: MultiEraBlock,
+        fork_count: &mut Fork,
+        tip: Point,
     ) -> Result<()> {
         let live_chain = self.0.write().map_err(|_| Error::Internal)?;
 
@@ -283,7 +302,11 @@ impl ProtectedLiveChainBlockList {
     /// Checks if the point exists in the live chain.
     /// If it does, removes all block preceding it (but not the point itself).
     /// Will refuse to purge if the point is not the TIP of the mithril chain.
-    fn purge(&self, chain: Network, point: &Point) -> Result<()> {
+    fn purge(
+        &self,
+        chain: Network,
+        point: &Point,
+    ) -> Result<()> {
         // Make sure our first live block == the last mithril tip.
         // Ensures we are properly connected to the Mithril Chain.
         // But don't check this if we are about to purge the entire chain.
@@ -388,7 +411,10 @@ impl ProtectedLiveChainBlockList {
     /// Given a known point on the live chain, and a fork count, find the best block we
     /// have.
     fn find_best_fork_block(
-        &self, point: &Point, previous_point: &Point, fork: Fork,
+        &self,
+        point: &Point,
+        previous_point: &Point,
+        fork: Fork,
     ) -> Option<(MultiEraBlock, u64)> {
         let mut rollback_depth: u64 = 0;
         let Ok(chain) = self.0.read() else {
@@ -467,7 +493,10 @@ pub(crate) fn get_live_head_point(chain: Network) -> Option<Point> {
 /// Get the Live block relative to the specified point.
 /// The starting block must exist if the search is strict.
 pub(crate) fn get_live_block(
-    chain: Network, point: &Point, advance: i64, strict: bool,
+    chain: Network,
+    point: &Point,
+    advance: i64,
+    strict: bool,
 ) -> Option<MultiEraBlock> {
     let live_chain = get_live_chain(chain);
     live_chain.get_block(point, advance, strict)
@@ -496,14 +525,20 @@ pub(crate) async fn get_fill_to_point(chain: Network) -> (Point, u64) {
 /// `rollback_count` should be set to 1 on the very first connection, after that,
 /// it is maintained by this function, and MUST not be modified elsewhere.
 pub(crate) fn live_chain_add_block_to_tip(
-    chain: Network, block: MultiEraBlock, fork: &mut Fork, tip: Point,
+    chain: Network,
+    block: MultiEraBlock,
+    fork: &mut Fork,
+    tip: Point,
 ) -> Result<()> {
     let live_chain = get_live_chain(chain);
     live_chain.add_block_to_tip(chain, block, fork, tip)
 }
 
 /// Backfill the live chain with the block set provided.
-pub(crate) fn live_chain_backfill(chain: Network, blocks: &[MultiEraBlock]) -> Result<()> {
+pub(crate) fn live_chain_backfill(
+    chain: Network,
+    blocks: &[MultiEraBlock],
+) -> Result<()> {
     let live_chain = get_live_chain(chain);
     live_chain.backfill(chain, blocks)
 }
@@ -517,7 +552,10 @@ pub(crate) fn live_chain_length(chain: Network) -> usize {
 
 /// On an immutable update, purge the live-chain up to the new immutable tip.
 /// Will error if the point is not in the Live chain.
-pub(crate) fn purge_live_chain(chain: Network, point: &Point) -> Result<()> {
+pub(crate) fn purge_live_chain(
+    chain: Network,
+    point: &Point,
+) -> Result<()> {
     let live_chain = get_live_chain(chain);
     live_chain.purge(chain, point)
 }
@@ -531,7 +569,10 @@ pub(crate) fn get_intersect_points(chain: Network) -> Vec<pallas::network::minip
 
 /// Find best block from a fork relative to a point.
 pub(crate) fn find_best_fork_block(
-    chain: Network, point: &Point, previous_point: &Point, fork: Fork,
+    chain: Network,
+    point: &Point,
+    previous_point: &Point,
+    fork: Fork,
 ) -> Option<(MultiEraBlock, u64)> {
     let live_chain = get_live_chain(chain);
     live_chain.find_best_fork_block(point, previous_point, fork)
diff --git a/rust/cardano-chain-follower/src/chain_sync_ready.rs b/rust/cardano-chain-follower/src/chain_sync_ready.rs
index 51c33f0e51b..830b1f44c0d 100644
--- a/rust/cardano-chain-follower/src/chain_sync_ready.rs
+++ b/rust/cardano-chain-follower/src/chain_sync_ready.rs
@@ -39,7 +39,8 @@ impl SyncReady {
 
 /// Sand a chain update to any subscribers that are listening.
 pub(crate) fn notify_follower(
-    chain: Network, update_sender: Option<&broadcast::Sender<chain_update::Kind>>,
+    chain: Network,
+    update_sender: Option<&broadcast::Sender<chain_update::Kind>>,
     kind: &chain_update::Kind,
 ) {
     if let Some(update_sender) = update_sender {
@@ -139,7 +140,7 @@ pub(crate) async fn block_until_sync_ready(chain: Network) {
 
 /// Get the Broadcast Receive queue for the given chain updates.
 pub(crate) async fn get_chain_update_rx_queue(
-    chain: Network,
+    chain: Network
 ) -> broadcast::Receiver<chain_update::Kind> {
     // We are safe to use `expect` here because the SYNC_READY list is exhaustively
     // initialized. Its a Serious BUG if that not True, so panic is OK.
@@ -155,7 +156,7 @@ pub(crate) async fn get_chain_update_rx_queue(
 
 /// Get the Broadcast Transmit queue for the given chain updates.
 pub(crate) async fn get_chain_update_tx_queue(
-    chain: Network,
+    chain: Network
 ) -> Option<broadcast::Sender<chain_update::Kind>> {
     // We are safe to use `expect` here because the SYNC_READY list is exhaustively
     // initialized. Its a Serious BUG if that not True, so panic is OK.
diff --git a/rust/cardano-chain-follower/src/chain_update.rs b/rust/cardano-chain-follower/src/chain_update.rs
index 4835efab948..ecef1da6123 100644
--- a/rust/cardano-chain-follower/src/chain_update.rs
+++ b/rust/cardano-chain-follower/src/chain_update.rs
@@ -30,7 +30,11 @@ pub struct ChainUpdate {
 impl ChainUpdate {
     /// Creates a new chain update.
     #[must_use]
-    pub fn new(kind: Kind, tip: bool, data: MultiEraBlock) -> Self {
+    pub fn new(
+        kind: Kind,
+        tip: bool,
+        data: MultiEraBlock,
+    ) -> Self {
         Self { kind, tip, data }
     }
 
@@ -48,7 +52,10 @@ impl ChainUpdate {
 }
 
 impl Display for ChainUpdate {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
         let block_type = self.kind.to_string();
         let mut tip: String = String::new();
         if self.tip {
diff --git a/rust/cardano-chain-follower/src/follow.rs b/rust/cardano-chain-follower/src/follow.rs
index 9acc2bc0b03..032f5b3b218 100644
--- a/rust/cardano-chain-follower/src/follow.rs
+++ b/rust/cardano-chain-follower/src/follow.rs
@@ -67,7 +67,11 @@ impl ChainFollower {
     ///
     /// To ONLY follow from TIP, set BOTH start and end to TIP.
     #[must_use]
-    pub async fn new(chain: Network, start: Point, end: Point) -> Self {
+    pub async fn new(
+        chain: Network,
+        start: Point,
+        end: Point,
+    ) -> Self {
         let rx = get_chain_update_rx_queue(chain).await;
 
         ChainFollower {
@@ -237,7 +241,10 @@ impl ChainFollower {
     }
 
     /// Update the current Point, and return `false` if this fails.
-    fn update_current(&mut self, update: &ChainUpdate) {
+    fn update_current(
+        &mut self,
+        update: &ChainUpdate,
+    ) {
         if update.kind == Kind::ImmutableBlockRollForward {
             // The ImmutableBlockRollForward includes the Mithril TIP Block.
             // Update the mithril_tip state to the point of it.
@@ -329,7 +336,10 @@ impl ChainFollower {
     ///
     /// This is a convenience function which just used `ChainFollower` to fetch a single
     /// block.
-    pub async fn get_block(chain: Network, point: Point) -> Option<ChainUpdate> {
+    pub async fn get_block(
+        chain: Network,
+        point: Point,
+    ) -> Option<ChainUpdate> {
         // Get the block from the chain.
         // This function suppose to run only once, so the end point
         // can be set to `TIP_POINT`
@@ -363,7 +373,10 @@ impl ChainFollower {
     ///
     /// `TxId` - The ID of the transaction that was queued.
     #[allow(clippy::unused_async)]
-    pub async fn post_txn(chain: Network, txn: TxBody) -> TxId {
+    pub async fn post_txn(
+        chain: Network,
+        txn: TxBody,
+    ) -> TxId {
         #[allow(clippy::no_effect_underscore_binding)]
         let _unused = chain;
         #[allow(clippy::no_effect_underscore_binding)]
@@ -378,7 +391,10 @@ impl ChainFollower {
     /// After which, it should be on the blockchain, and its the applications job to track
     /// if a transaction made it on-chain or not.
     #[allow(clippy::unused_async)]
-    pub async fn txn_sent(chain: Network, id: TxId) -> bool {
+    pub async fn txn_sent(
+        chain: Network,
+        id: TxId,
+    ) -> bool {
         #[allow(clippy::no_effect_underscore_binding)]
         let _unused = chain;
         #[allow(clippy::no_effect_underscore_binding)]
diff --git a/rust/cardano-chain-follower/src/mithril_query.rs b/rust/cardano-chain-follower/src/mithril_query.rs
index 20093924dab..e5f28d94cfd 100644
--- a/rust/cardano-chain-follower/src/mithril_query.rs
+++ b/rust/cardano-chain-follower/src/mithril_query.rs
@@ -16,7 +16,9 @@ pub(crate) type ImmutableBlockIterator = Box<dyn Iterator<Item = FallibleBlock>
 
 /// Get a mithril snapshot iterator.
 pub(crate) async fn make_mithril_iterator(
-    path: &Path, start: &Point, chain: Network,
+    path: &Path,
+    start: &Point,
+    chain: Network,
 ) -> Result<ImmutableBlockIterator> {
     let path = path.to_path_buf();
     let start = start.clone();
diff --git a/rust/cardano-chain-follower/src/mithril_snapshot.rs b/rust/cardano-chain-follower/src/mithril_snapshot.rs
index 20d0cf5432e..0a285677fbf 100644
--- a/rust/cardano-chain-follower/src/mithril_snapshot.rs
+++ b/rust/cardano-chain-follower/src/mithril_snapshot.rs
@@ -39,7 +39,10 @@ impl MithrilSnapshot {
     ///
     /// Returns true if the point exists within the Mithril snapshot for the specified
     /// network, false otherwise.
-    pub(crate) fn contains_point(&self, point: &Point) -> bool {
+    pub(crate) fn contains_point(
+        &self,
+        point: &Point,
+    ) -> bool {
         let latest_id = latest_mithril_snapshot_id(self.chain);
 
         point.slot_or_default() <= latest_id.tip().slot_or_default()
@@ -59,7 +62,8 @@ impl MithrilSnapshot {
     #[allow(clippy::indexing_slicing)]
     #[logcall("debug")]
     pub(crate) async fn try_read_blocks_from_point(
-        &self, point: &Point,
+        &self,
+        point: &Point,
     ) -> Option<MithrilSnapshotIterator> {
         let snapshot_id = latest_mithril_snapshot_id(self.chain);
         let snapshot_path = snapshot_id.immutable_path();
@@ -78,7 +82,10 @@ impl MithrilSnapshot {
     /// Read a single block from a known point.
     #[allow(clippy::indexing_slicing)]
     //#[logcall("debug")]
-    pub(crate) async fn read_block_at(&self, point: &Point) -> Option<MultiEraBlock> {
+    pub(crate) async fn read_block_at(
+        &self,
+        point: &Point,
+    ) -> Option<MultiEraBlock> {
         if let Some(iterator) = self.try_read_blocks_from_point(point).await {
             let block = iterator.next().await;
             return block;
diff --git a/rust/cardano-chain-follower/src/mithril_snapshot_config.rs b/rust/cardano-chain-follower/src/mithril_snapshot_config.rs
index a198ea9241a..3b53f687163 100644
--- a/rust/cardano-chain-follower/src/mithril_snapshot_config.rs
+++ b/rust/cardano-chain-follower/src/mithril_snapshot_config.rs
@@ -88,7 +88,10 @@ impl MithrilSnapshotConfig {
     }
 
     /// Set a custom downloader configuration.
-    pub fn with_dl_config(mut self, config: DlConfig) -> Self {
+    pub fn with_dl_config(
+        mut self,
+        config: DlConfig,
+    ) -> Self {
         self.dl_config = Some(config);
         self
     }
@@ -135,7 +138,10 @@ impl MithrilSnapshotConfig {
 
     /// Activate the tmp mithril path to a numbered snapshot path.
     /// And then remove any left over files in download or the tmp path, or old snapshots.
-    pub(crate) async fn activate(&self, snapshot_number: u64) -> io::Result<PathBuf> {
+    pub(crate) async fn activate(
+        &self,
+        snapshot_number: u64,
+    ) -> io::Result<PathBuf> {
         let new_path = self.mithril_path(snapshot_number);
         let latest_id = latest_mithril_snapshot_id(self.chain);
 
@@ -231,7 +237,9 @@ impl MithrilSnapshotConfig {
     ///
     /// This does not check if they SHOULD be de-duped, only de-dupes the files specified.
     pub(crate) fn dedup_tmp(
-        &self, tmp_file: &Path, latest_snapshot: &SnapshotData,
+        &self,
+        tmp_file: &Path,
+        latest_snapshot: &SnapshotData,
     ) -> anyhow::Result<()> {
         // Get the matching src file in the latest mithril snapshot to compare against.
         let snapshot_path = latest_snapshot.id().as_ref();
@@ -290,7 +298,10 @@ impl MithrilSnapshotConfig {
     /// Returns the path to the Numbered Snapshot Data.
     /// Will use a path relative to mithril data path.
     #[must_use]
-    pub(crate) fn mithril_path(&self, snapshot_number: u64) -> PathBuf {
+    pub(crate) fn mithril_path(
+        &self,
+        snapshot_number: u64,
+    ) -> PathBuf {
         let mut snapshot_path = self.path.clone();
         snapshot_path.push(snapshot_number.to_string());
         snapshot_path
diff --git a/rust/cardano-chain-follower/src/mithril_snapshot_data.rs b/rust/cardano-chain-follower/src/mithril_snapshot_data.rs
index 2dcdf912c61..52aa75e9e88 100644
--- a/rust/cardano-chain-follower/src/mithril_snapshot_data.rs
+++ b/rust/cardano-chain-follower/src/mithril_snapshot_data.rs
@@ -54,7 +54,10 @@ pub(crate) fn latest_mithril_snapshot_id(chain: Network) -> SnapshotId {
 }
 
 /// Update the latest snapshot data.
-pub(crate) fn update_latest_mithril_snapshot(chain: Network, snapshot_id: SnapshotId) {
+pub(crate) fn update_latest_mithril_snapshot(
+    chain: Network,
+    snapshot_id: SnapshotId,
+) {
     let snapshot_data = SnapshotData::new(snapshot_id);
 
     // Save the current snapshot
diff --git a/rust/cardano-chain-follower/src/mithril_snapshot_iterator.rs b/rust/cardano-chain-follower/src/mithril_snapshot_iterator.rs
index db1d0211859..e4abc92ce5b 100644
--- a/rust/cardano-chain-follower/src/mithril_snapshot_iterator.rs
+++ b/rust/cardano-chain-follower/src/mithril_snapshot_iterator.rs
@@ -34,7 +34,10 @@ struct MithrilSnapshotIteratorInner {
 }
 
 impl Debug for MithrilSnapshotIteratorInner {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
         write!(
             f,
             "MithrilSnapshotIteratorInner {{ chain: {:?}, start: {:?}, previous: {:?} }}",
@@ -53,7 +56,10 @@ pub(crate) struct MithrilSnapshotIterator {
 }
 
 /// Create a probe point used in iterations to find the start when its not exactly known.
-pub(crate) fn probe_point(point: &Point, distance: u64) -> Point {
+pub(crate) fn probe_point(
+    point: &Point,
+    distance: u64,
+) -> Point {
     /// Step back point to indicate origin.
     const STEP_BACK_ORIGIN: u64 = 0;
     // Now that we have the tip, step back about 4 block intervals from tip, and do a fuzzy
@@ -80,7 +86,10 @@ impl MithrilSnapshotIterator {
 
     /// Try and probe to establish the iterator from the desired point.
     async fn try_fuzzy_iterator(
-        chain: Network, path: &Path, from: &Point, search_interval: u64,
+        chain: Network,
+        path: &Path,
+        from: &Point,
+        search_interval: u64,
     ) -> Option<MithrilSnapshotIterator> {
         let point = probe_point(from, search_interval);
         let Ok(mut iterator) = make_mithril_iterator(path, &point, chain).await else {
@@ -145,7 +154,11 @@ impl MithrilSnapshotIterator {
     /// We use this when we don't know the previous point, and need to find it.
     #[allow(clippy::indexing_slicing)]
     #[logcall("debug")]
-    async fn fuzzy_iterator(chain: Network, path: &Path, from: &Point) -> MithrilSnapshotIterator {
+    async fn fuzzy_iterator(
+        chain: Network,
+        path: &Path,
+        from: &Point,
+    ) -> MithrilSnapshotIterator {
         let mut backwards_search = BACKWARD_SEARCH_SLOT_INTERVAL;
         loop {
             if let Some(iterator) =
@@ -170,7 +183,10 @@ impl MithrilSnapshotIterator {
     #[allow(clippy::indexing_slicing)]
     #[logcall(ok = "debug", err = "error")]
     pub(crate) async fn new(
-        chain: Network, path: &Path, from: &Point, previous_point: Option<Point>,
+        chain: Network,
+        path: &Path,
+        from: &Point,
+        previous_point: Option<Point>,
     ) -> Result<Self> {
         if from.is_fuzzy() || (!from.is_origin() && previous_point.is_none()) {
             return Ok(Self::fuzzy_iterator(chain, path, from).await);
diff --git a/rust/cardano-chain-follower/src/mithril_snapshot_sync.rs b/rust/cardano-chain-follower/src/mithril_snapshot_sync.rs
index f561606ebb9..8e8fa3497e8 100644
--- a/rust/cardano-chain-follower/src/mithril_snapshot_sync.rs
+++ b/rust/cardano-chain-follower/src/mithril_snapshot_sync.rs
@@ -49,7 +49,8 @@ const DOWNLOAD_ERROR_RETRY_DURATION: Duration = Duration::from_secs(2 * 60); //
 /// If there is only a single entry then the latest and chronologically next will be
 /// identical.
 async fn get_latest_snapshots(
-    client: &Client, network: Network,
+    client: &Client,
+    network: Network,
 ) -> Option<(SnapshotListItem, SnapshotListItem)> {
     // Get current latest snapshot from the aggregator
     let snapshots = match client.cardano_database().list().await {
@@ -73,7 +74,9 @@ async fn get_latest_snapshots(
 
 /// Given a particular snapshot ID, find the Actual Snapshot for it.
 async fn get_snapshot_by_id(
-    client: &Client, network: Network, snapshot_id: &SnapshotId,
+    client: &Client,
+    network: Network,
+    snapshot_id: &SnapshotId,
 ) -> Option<SnapshotListItem> {
     let snapshots = match client.cardano_database().list().await {
         Ok(s) => s,
@@ -120,7 +123,8 @@ fn create_client(cfg: &MithrilSnapshotConfig) -> Option<(Client, Arc<MithrilTurb
 
 /// Calculate how long we should wait before we check for another Mithril snapshot.
 fn calculate_sleep_duration(
-    latest_snapshot: &SnapshotListItem, previous_snapshot: &SnapshotListItem,
+    latest_snapshot: &SnapshotListItem,
+    previous_snapshot: &SnapshotListItem,
 ) -> Duration {
     // All times are relative to UTC.
     let now = Utc::now();
@@ -162,7 +166,9 @@ fn calculate_sleep_duration(
 /// Returns None if there are any issues doing this, otherwise the Snapshot.
 /// The only issues should be transient communications errors.
 async fn get_snapshot(
-    client: &Client, snapshot_item: &SnapshotListItem, network: Network,
+    client: &Client,
+    snapshot_item: &SnapshotListItem,
+    network: Network,
 ) -> Option<Snapshot> {
     let latest_digest = snapshot_item.digest.as_ref();
     let snapshot = match client.cardano_database().get(latest_digest).await {
@@ -190,7 +196,9 @@ async fn get_snapshot(
 
 /// Download and Verify the Snapshots certificate
 async fn download_and_verify_snapshot_certificate(
-    client: &Client, snapshot: &Snapshot, network: Network,
+    client: &Client,
+    snapshot: &Snapshot,
+    network: Network,
 ) -> Option<MithrilCertificate> {
     let certificate = match client
         .certificate()
@@ -250,7 +258,10 @@ pub(crate) const MITHRIL_IMMUTABLE_SUB_DIRECTORY: &str = "immutable";
 /// it in a tuple.
 #[allow(clippy::indexing_slicing)]
 //#[logcall(ok = "debug", err = "error")]
-pub(crate) async fn get_mithril_tip(chain: Network, path: &Path) -> Result<MultiEraBlock> {
+pub(crate) async fn get_mithril_tip(
+    chain: Network,
+    path: &Path,
+) -> Result<MultiEraBlock> {
     let mut path = path.to_path_buf();
     path.push(MITHRIL_IMMUTABLE_SUB_DIRECTORY);
 
@@ -279,7 +290,9 @@ pub(crate) async fn get_mithril_tip(chain: Network, path: &Path) -> Result<Multi
 
 /// Get the Snapshot Data itself from the Aggregator, and a validate Certificate.
 async fn get_mithril_snapshot_and_certificate(
-    chain: Network, client: &Client, item: &SnapshotListItem,
+    chain: Network,
+    client: &Client,
+    item: &SnapshotListItem,
 ) -> Option<(Snapshot, MithrilCertificate)> {
     debug!("Mithril Snapshot background updater for: {chain} : Download snapshot from aggregator.");
 
@@ -300,7 +313,9 @@ async fn get_mithril_snapshot_and_certificate(
 
 /// Validate that a Mithril Snapshot downloaded matches its certificate.
 async fn validate_mithril_snapshot(
-    chain: Network, certificate: &MithrilCertificate, path: &Path,
+    chain: Network,
+    certificate: &MithrilCertificate,
+    path: &Path,
 ) -> bool {
     let cert = certificate.clone();
     let mithril_path = path.to_path_buf();
@@ -343,10 +358,15 @@ async fn validate_mithril_snapshot(
 /// 1. The actual latest mithril snapshot; AND
 /// 2. It must
 async fn get_latest_validated_mithril_snapshot(
-    chain: Network, client: &Client, cfg: &MithrilSnapshotConfig,
+    chain: Network,
+    client: &Client,
+    cfg: &MithrilSnapshotConfig,
 ) -> Option<SnapshotId> {
     /// Purge a bad mithril snapshot from disk.
-    async fn purge_bad_mithril_snapshot(chain: Network, latest_mithril: &SnapshotId) {
+    async fn purge_bad_mithril_snapshot(
+        chain: Network,
+        latest_mithril: &SnapshotId,
+    ) {
         debug!("Purging Bad Mithril Snapshot: {latest_mithril}");
         if let Err(error) = remove_dir_all(&latest_mithril).await {
             // This should NOT happen because we already checked the Mithril path is fully writable.
@@ -403,7 +423,8 @@ async fn get_latest_validated_mithril_snapshot(
 
 /// Get the Mithril client and recover our existing mithril snapshot data, if any.
 async fn recover_existing_snapshot(
-    cfg: &MithrilSnapshotConfig, tx: &Sender<MithrilUpdateMessage>,
+    cfg: &MithrilSnapshotConfig,
+    tx: &Sender<MithrilUpdateMessage>,
 ) -> Option<SnapshotId> {
     // This is a Mithril Validation, so record it.
     mithril_validation_state(cfg.chain, stats::MithrilValidationState::Start);
@@ -483,7 +504,9 @@ enum SnapshotStatus {
 
 /// Check if we have a new snapshot to download, and if so, return its details.
 async fn check_snapshot_to_download(
-    chain: Network, client: &Client, current_snapshot: Option<&SnapshotId>,
+    chain: Network,
+    client: &Client,
+    current_snapshot: Option<&SnapshotId>,
 ) -> SnapshotStatus {
     debug!("Mithril Snapshot background updater for: {chain} : Getting Latest Snapshot.");
 
@@ -525,7 +548,9 @@ async fn check_snapshot_to_download(
 /// Start Mithril Validation in the background, and return a handle so we can check when
 /// it finishes.
 fn background_validate_mithril_snapshot(
-    chain: Network, certificate: MithrilCertificate, tmp_path: PathBuf,
+    chain: Network,
+    certificate: MithrilCertificate,
+    tmp_path: PathBuf,
 ) -> tokio::task::JoinHandle<bool> {
     tokio::spawn(async move {
         stats::start_thread(chain, stats::thread::name::VALIDATE_MITHRIL_SNAPSHOT, true);
@@ -570,7 +595,10 @@ fn chunk_filename_to_chunk_number(chunk: &Path) -> Option<u64> {
 }
 
 /// Remove any chunks from the chunk list which exceed the `max_chunk`.
-fn trim_chunk_list(chunk_list: &Arc<DashSet<PathBuf>>, max_chunks: u64) {
+fn trim_chunk_list(
+    chunk_list: &Arc<DashSet<PathBuf>>,
+    max_chunks: u64,
+) {
     chunk_list.retain(|entry| {
         if let Some(chunk_index) = chunk_filename_to_chunk_number(entry) {
             if chunk_index > max_chunks {
@@ -589,8 +617,11 @@ fn trim_chunk_list(chunk_list: &Arc<DashSet<PathBuf>>, max_chunks: u64) {
 
 /// Downloads and validates a snapshot from the aggregator.
 async fn download_and_validate_snapshot(
-    client: &Client, downloader: Arc<MithrilTurboDownloader>, cfg: &MithrilSnapshotConfig,
-    snapshot: &Snapshot, certificate: MithrilCertificate,
+    client: &Client,
+    downloader: Arc<MithrilTurboDownloader>,
+    cfg: &MithrilSnapshotConfig,
+    snapshot: &Snapshot,
+    certificate: MithrilCertificate,
 ) -> bool {
     debug!(
         "Mithril Snapshot background updater for: {} : Download and unpack the Mithril snapshot.",
@@ -656,7 +687,8 @@ async fn cleanup(cfg: &MithrilSnapshotConfig) {
 
 /// Sleep until its likely there has been another mithril snapshot update.
 async fn sleep_until_next_probable_update(
-    cfg: &MithrilSnapshotConfig, next_sleep: &Duration,
+    cfg: &MithrilSnapshotConfig,
+    next_sleep: &Duration,
 ) -> Duration {
     debug!(
         "Mithril Snapshot background updater for: {} : Sleeping for {}.",
@@ -694,7 +726,8 @@ macro_rules! next_iteration {
 /// This does not return, it is a background task.
 #[allow(clippy::too_many_lines)]
 pub(crate) async fn background_mithril_update(
-    cfg: MithrilSnapshotConfig, tx: Sender<MithrilUpdateMessage>,
+    cfg: MithrilSnapshotConfig,
+    tx: Sender<MithrilUpdateMessage>,
 ) {
     debug!(
         "Mithril Snapshot background updater for: {} from {} to {} : Starting",
diff --git a/rust/cardano-chain-follower/src/mithril_turbo_downloader.rs b/rust/cardano-chain-follower/src/mithril_turbo_downloader.rs
index 585e0b25929..52fdfdd9051 100644
--- a/rust/cardano-chain-follower/src/mithril_turbo_downloader.rs
+++ b/rust/cardano-chain-follower/src/mithril_turbo_downloader.rs
@@ -90,7 +90,11 @@ impl Inner {
     /// The new file is extracted to an in-memory buffer.
     /// If they compare the same, the original file is `HardLinked` to the new file name.
     /// Otherwise the new file buffer is saved to disk with the new file name.
-    fn dl_and_dedup(&self, _location: &str, _target_dir: &Path) -> MithrilResult<()> {
+    fn dl_and_dedup(
+        &self,
+        _location: &str,
+        _target_dir: &Path,
+    ) -> MithrilResult<()> {
         let mut archive = self.create_archive_extractor()?;
 
         // Iterate the files in the archive.
@@ -203,7 +207,7 @@ impl Inner {
 
     /// Create a TAR archive extractor from the downloading file and a zstd decompressor.
     fn create_archive_extractor(
-        &self,
+        &self
     ) -> MithrilResult<Archive<Decoder<'static, BufReader<BufReader<ParallelDownloadProcessor>>>>>
     {
         let Some(dl_handler) = self.dl_handler.get() else {
@@ -218,7 +222,11 @@ impl Inner {
     }
 
     /// Check if we are supposed to extract this file from the archive or not.
-    fn check_for_extract(&self, path: &Path, extract_type: EntryType) -> bool {
+    fn check_for_extract(
+        &self,
+        path: &Path,
+        extract_type: EntryType,
+    ) -> bool {
         if path.is_absolute() {
             error!(chain = %self.cfg.chain, "DeDup : Cannot extract an absolute path:  {:?}", path);
             return false;
@@ -239,7 +247,9 @@ impl Inner {
 
     /// Check if a given path from the archive is able to be deduplicated.
     fn can_deduplicate(
-        rel_file: &Path, file_size: u64, prev_file: Option<&PathBuf>,
+        rel_file: &Path,
+        file_size: u64,
+        prev_file: Option<&PathBuf>,
     ) -> MithrilResult<MemoryMapFile> {
         // Can't dedup if the current file is not de-dupable (must be immutable)
         if rel_file.starts_with("immutable") {
@@ -307,7 +317,10 @@ impl MithrilTurboDownloader {
     }
 
     /// Create directories required to exist for download to succeed.
-    async fn create_directories(&self, target_dir: &Path) -> MithrilResult<()> {
+    async fn create_directories(
+        &self,
+        target_dir: &Path,
+    ) -> MithrilResult<()> {
         if let Err(error) = create_dir_all(target_dir).await {
             let msg = format!(
                 "Target directory {} could not be created: {}",
@@ -321,7 +334,11 @@ impl MithrilTurboDownloader {
     }
 
     /// Parallel Download, Extract and Dedup the Mithril Archive.
-    async fn dl_and_dedup(&self, location: &str, target_dir: &Path) -> MithrilResult<()> {
+    async fn dl_and_dedup(
+        &self,
+        location: &str,
+        target_dir: &Path,
+    ) -> MithrilResult<()> {
         // Get a copy of the inner data to use in the sync download task.
         let inner = self.inner.clone();
         let location = location.to_owned();
@@ -362,8 +379,12 @@ fn get_file_size_sync(file: &Path) -> Option<u64> {
 #[async_trait]
 impl FileDownloader for MithrilTurboDownloader {
     async fn download_unpack(
-        &self, location: &FileDownloaderUri, file_size: u64, target_dir: &Path,
-        compression_algorithm: Option<CompressionAlgorithm>, download_event_type: DownloadEvent,
+        &self,
+        location: &FileDownloaderUri,
+        file_size: u64,
+        target_dir: &Path,
+        compression_algorithm: Option<CompressionAlgorithm>,
+        download_event_type: DownloadEvent,
     ) -> MithrilResult<()> {
         debug!(
             ?location,
@@ -413,7 +434,10 @@ impl FileDownloader for MithrilTurboDownloader {
 impl MithrilTurboDownloader {
     /// Set up the download.\
     /// Called `probe` as this used to exist in an earlier trait which was removed.
-    async fn probe(&self, location: &str) -> MithrilResult<()> {
+    async fn probe(
+        &self,
+        location: &str,
+    ) -> MithrilResult<()> {
         debug!("Probe Snapshot location='{location}'.");
         let dl_config = self.inner.cfg.dl_config.clone().unwrap_or_default();
         let dl_processor =
diff --git a/rust/cardano-chain-follower/src/snapshot_id.rs b/rust/cardano-chain-follower/src/snapshot_id.rs
index 66cf3ee2591..3b7f4a19df2 100644
--- a/rust/cardano-chain-follower/src/snapshot_id.rs
+++ b/rust/cardano-chain-follower/src/snapshot_id.rs
@@ -38,7 +38,10 @@ impl SnapshotId {
 
     /// Try and create a new `SnapshotID` from a given path.
     /// Immutable TIP must be provided.
-    pub(crate) fn new(path: &Path, tip: Point) -> Option<Self> {
+    pub(crate) fn new(
+        path: &Path,
+        tip: Point,
+    ) -> Option<Self> {
         debug!("Trying to Get SnapshotID of: {}", path.to_string_lossy());
         let immutable_file = SnapshotId::parse_path(path)?;
         debug!("Immutable File#: {}", immutable_file);
@@ -52,7 +55,10 @@ impl SnapshotId {
 
     /// Try and create a new `SnapshotID` from a given path.
     /// Includes properly getting the Immutable TIP.
-    pub(crate) async fn try_new(chain: Network, path: &Path) -> Option<Self> {
+    pub(crate) async fn try_new(
+        chain: Network,
+        path: &Path,
+    ) -> Option<Self> {
         let Ok(tip) = get_mithril_tip(chain, path).await else {
             return None;
         };
@@ -106,7 +112,10 @@ impl std::convert::AsRef<std::path::Path> for SnapshotId {
 
 impl Display for SnapshotId {
     /// Convert this `SnapshotID` to a `String`.
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> Result<(), std::fmt::Error> {
         write!(
             f,
             "{} @ Tip [{} / {:?}]",
@@ -121,7 +130,10 @@ impl Display for SnapshotId {
 impl PartialEq for SnapshotId {
     // Equality ONLY checks the Immutable File Number, not the path.
     // This is because the Filename is already the ImmutableFileNumber
-    fn eq(&self, other: &Self) -> bool {
+    fn eq(
+        &self,
+        other: &Self,
+    ) -> bool {
         self.file == other.file
     }
 }
@@ -129,7 +141,10 @@ impl PartialEq for SnapshotId {
 impl PartialOrd for SnapshotId {
     // Equality ONLY checks the Immutable File Number, not the path.
     // This is because the Filename is already the ImmutableFileNumber
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+    fn partial_cmp(
+        &self,
+        other: &Self,
+    ) -> Option<Ordering> {
         self.file.partial_cmp(&other.file)
     }
 }
@@ -138,7 +153,10 @@ impl PartialOrd for SnapshotId {
 impl PartialEq<Option<SnapshotId>> for SnapshotId {
     // Equality ONLY checks the Immutable File Number, not the path.
     // This is because the Filename is already the ImmutableFileNumber
-    fn eq(&self, other: &Option<Self>) -> bool {
+    fn eq(
+        &self,
+        other: &Option<Self>,
+    ) -> bool {
         match other {
             None => false,
             Some(other) => self == other,
@@ -149,7 +167,10 @@ impl PartialEq<Option<SnapshotId>> for SnapshotId {
 impl PartialOrd<Option<SnapshotId>> for SnapshotId {
     // Equality ONLY checks the Immutable File Number, not the path.
     // This is because the Filename is already the ImmutableFileNumber
-    fn partial_cmp(&self, other: &Option<Self>) -> Option<Ordering> {
+    fn partial_cmp(
+        &self,
+        other: &Option<Self>,
+    ) -> Option<Ordering> {
         match other {
             None => Some(Ordering::Greater), // Anything is always greater than None.
             Some(other) => self.partial_cmp(other),
@@ -161,7 +182,10 @@ impl PartialOrd<Option<SnapshotId>> for SnapshotId {
 impl PartialEq<u64> for SnapshotId {
     // Equality ONLY checks the Immutable File Number, not the path.
     // This is because the Filename is already the ImmutableFileNumber
-    fn eq(&self, other: &u64) -> bool {
+    fn eq(
+        &self,
+        other: &u64,
+    ) -> bool {
         self.file == *other
     }
 }
@@ -169,7 +193,10 @@ impl PartialEq<u64> for SnapshotId {
 impl PartialOrd<u64> for SnapshotId {
     // Equality ONLY checks the Immutable File Number, not the path.
     // This is because the Filename is already the ImmutableFileNumber
-    fn partial_cmp(&self, other: &u64) -> Option<Ordering> {
+    fn partial_cmp(
+        &self,
+        other: &u64,
+    ) -> Option<Ordering> {
         self.file.partial_cmp(other)
     }
 }
diff --git a/rust/cardano-chain-follower/src/stats/mod.rs b/rust/cardano-chain-follower/src/stats/mod.rs
index 31e1ed014a3..bdc51a25b35 100644
--- a/rust/cardano-chain-follower/src/stats/mod.rs
+++ b/rust/cardano-chain-follower/src/stats/mod.rs
@@ -122,7 +122,10 @@ impl Statistics {
 
     /// Return the statistics formatted as JSON
     #[must_use]
-    pub fn as_json(&self, pretty: bool) -> String {
+    pub fn as_json(
+        &self,
+        pretty: bool,
+    ) -> String {
         let json = if pretty {
             serde_json::to_string_pretty(self)
         } else {
@@ -140,7 +143,10 @@ impl Statistics {
 
 /// Count the invalidly deserialized blocks
 #[allow(dead_code)]
-pub(crate) fn stats_invalid_block(chain: Network, immutable: bool) {
+pub(crate) fn stats_invalid_block(
+    chain: Network,
+    immutable: bool,
+) {
     // This will actually always succeed.
     let Some(stats) = lookup_stats(chain) else {
         return;
@@ -161,7 +167,10 @@ pub(crate) fn stats_invalid_block(chain: Network, immutable: bool) {
 
 /// Count the validly deserialized blocks
 pub(crate) fn new_live_block(
-    chain: Network, total_live_blocks: u64, head_slot: Slot, tip_slot: Slot,
+    chain: Network,
+    total_live_blocks: u64,
+    head_slot: Slot,
+    tip_slot: Slot,
 ) {
     // This will actually always succeed.
     let Some(stats) = lookup_stats(chain) else {
@@ -182,7 +191,10 @@ pub(crate) fn new_live_block(
 
 /// Track the end of the current mithril update
 pub(crate) fn new_mithril_update(
-    chain: Network, mithril_tip: Slot, total_live_blocks: u64, tip_slot: Slot,
+    chain: Network,
+    mithril_tip: Slot,
+    total_live_blocks: u64,
+    tip_slot: Slot,
 ) {
     // This will actually always succeed.
     let Some(stats) = lookup_stats(chain) else {
@@ -225,7 +237,10 @@ pub(crate) fn backfill_started(chain: Network) {
 }
 
 /// When did we start the backfill.
-pub(crate) fn backfill_ended(chain: Network, backfill_size: u64) {
+pub(crate) fn backfill_ended(
+    chain: Network,
+    backfill_size: u64,
+) {
     // This will actually always succeed.
     let Some(stats) = lookup_stats(chain) else {
         return;
@@ -242,7 +257,11 @@ pub(crate) fn backfill_ended(chain: Network, backfill_size: u64) {
 }
 
 /// Track statistics about connections to the cardano peer node.
-pub(crate) fn peer_connected(chain: Network, active: bool, peer_address: &str) {
+pub(crate) fn peer_connected(
+    chain: Network,
+    active: bool,
+    peer_address: &str,
+) {
     // This will actually always succeed.
     let Some(stats) = lookup_stats(chain) else {
         return;
@@ -319,7 +338,10 @@ pub(crate) fn mithril_dl_started(chain: Network) {
 
 /// Record when DL finished, if it fails, set size to None, otherwise the size of the
 /// downloaded file.
-pub(crate) fn mithril_dl_finished(chain: Network, dl_size: Option<u64>) {
+pub(crate) fn mithril_dl_finished(
+    chain: Network,
+    dl_size: Option<u64>,
+) {
     // This will actually always succeed.
     let Some(stats) = lookup_stats(chain) else {
         return;
@@ -365,8 +387,12 @@ pub(crate) fn mithril_extract_started(chain: Network) {
 /// Record when DL finished, if it fails, set size to None, otherwise the size of the
 /// downloaded file.
 pub(crate) fn mithril_extract_finished(
-    chain: Network, extract_size: Option<u64>, deduplicated_size: u64, deduplicated_files: u64,
-    changed_files: u64, new_files: u64,
+    chain: Network,
+    extract_size: Option<u64>,
+    deduplicated_size: u64,
+    deduplicated_files: u64,
+    changed_files: u64,
+    new_files: u64,
 ) {
     // This will actually always succeed.
     let Some(stats) = lookup_stats(chain) else {
@@ -404,7 +430,10 @@ pub(crate) enum MithrilValidationState {
 }
 
 /// Record when Mithril Cert validation starts, ends or fails).
-pub(crate) fn mithril_validation_state(chain: Network, mithril_state: MithrilValidationState) {
+pub(crate) fn mithril_validation_state(
+    chain: Network,
+    mithril_state: MithrilValidationState,
+) {
     // This will actually always succeed.
     let Some(stats) = lookup_stats(chain) else {
         return;
@@ -442,7 +471,10 @@ pub(crate) enum MithrilSyncFailures {
 }
 
 /// Record when Mithril Cert validation starts, ends or fails).
-pub(crate) fn mithril_sync_failure(chain: Network, failure: MithrilSyncFailures) {
+pub(crate) fn mithril_sync_failure(
+    chain: Network,
+    failure: MithrilSyncFailures,
+) {
     // This will actually always succeed.
     let Some(stats) = lookup_stats(chain) else {
         return;
@@ -488,7 +520,11 @@ pub(crate) fn mithril_sync_failure(chain: Network, failure: MithrilSyncFailures)
 
 /// Initialize a thread statistic with the given name.
 /// If it is service thread, mark it as such.
-pub(crate) fn start_thread(chain: Network, name: &str, is_service: bool) {
+pub(crate) fn start_thread(
+    chain: Network,
+    name: &str,
+    is_service: bool,
+) {
     // This will actually always succeed.
     let Some(stats) = lookup_stats(chain) else {
         return;
@@ -506,7 +542,10 @@ pub(crate) fn start_thread(chain: Network, name: &str, is_service: bool) {
 }
 
 /// Stop the thread with the given name.
-pub(crate) fn stop_thread(chain: Network, name: &str) {
+pub(crate) fn stop_thread(
+    chain: Network,
+    name: &str,
+) {
     // This will actually always succeed.
     let Some(stats) = lookup_stats(chain) else {
         return;
@@ -524,7 +563,10 @@ pub(crate) fn stop_thread(chain: Network, name: &str) {
 }
 
 /// Resume the thread with the given name.
-pub(crate) fn resume_thread(chain: Network, name: &str) {
+pub(crate) fn resume_thread(
+    chain: Network,
+    name: &str,
+) {
     // This will actually always succeed.
     let Some(stats) = lookup_stats(chain) else {
         return;
@@ -542,7 +584,10 @@ pub(crate) fn resume_thread(chain: Network, name: &str) {
 }
 
 /// Pause the thread with the given name.
-pub(crate) fn pause_thread(chain: Network, name: &str) {
+pub(crate) fn pause_thread(
+    chain: Network,
+    name: &str,
+) {
     // This will actually always succeed.
     let Some(stats) = lookup_stats(chain) else {
         return;
@@ -561,7 +606,10 @@ pub(crate) fn pause_thread(chain: Network, name: &str) {
 
 /// Get the thread statistic with the given name.
 #[allow(dead_code)]
-pub fn thread_stat(chain: Network, name: &str) -> Option<ThreadStat> {
+pub fn thread_stat(
+    chain: Network,
+    name: &str,
+) -> Option<ThreadStat> {
     // This will actually always succeed.
     let stats = lookup_stats(chain)?;
 
diff --git a/rust/cardano-chain-follower/src/stats/rollback.rs b/rust/cardano-chain-follower/src/stats/rollback.rs
index 09ceabb542f..09c8810621c 100644
--- a/rust/cardano-chain-follower/src/stats/rollback.rs
+++ b/rust/cardano-chain-follower/src/stats/rollback.rs
@@ -65,7 +65,8 @@ static ROLLBACKS_MAP: LazyLock<RollbackMap> = LazyLock::new(|| {
 
 /// Get the actual rollback map for a chain.
 fn lookup_rollback_map(
-    chain: Network, rollback: RollbackType,
+    chain: Network,
+    rollback: RollbackType,
 ) -> Option<Arc<RwLock<RollbackRecords>>> {
     let Some(chain_rollback_map) = ROLLBACKS_MAP.get(&chain) else {
         error!("Rollback stats SHOULD BE exhaustively pre-allocated.");
@@ -83,7 +84,10 @@ fn lookup_rollback_map(
 }
 
 /// Extract the current rollback stats as a vec.
-pub(crate) fn rollbacks(chain: Network, rollback: RollbackType) -> Vec<Rollback> {
+pub(crate) fn rollbacks(
+    chain: Network,
+    rollback: RollbackType,
+) -> Vec<Rollback> {
     let Some(rollback_map) = lookup_rollback_map(chain, rollback) else {
         return Vec::new();
     };
@@ -104,7 +108,10 @@ pub(crate) fn rollbacks(chain: Network, rollback: RollbackType) -> Vec<Rollback>
 }
 
 /// Reset ALL the rollback stats for a given blockchain.
-pub(crate) fn rollbacks_reset(chain: Network, rollback: RollbackType) -> Vec<Rollback> {
+pub(crate) fn rollbacks_reset(
+    chain: Network,
+    rollback: RollbackType,
+) -> Vec<Rollback> {
     let Some(rollback_map) = lookup_rollback_map(chain, rollback) else {
         return Vec::new();
     };
@@ -120,7 +127,11 @@ pub(crate) fn rollbacks_reset(chain: Network, rollback: RollbackType) -> Vec<Rol
 }
 
 /// Count a rollback
-pub(crate) fn rollback(chain: Network, rollback: RollbackType, depth: u64) {
+pub(crate) fn rollback(
+    chain: Network,
+    rollback: RollbackType,
+    depth: u64,
+) {
     let Some(rollback_map) = lookup_rollback_map(chain, rollback) else {
         return;
     };
diff --git a/rust/cardano-chain-follower/src/stats/thread/mod.rs b/rust/cardano-chain-follower/src/stats/thread/mod.rs
index e409e516f9a..4d5ca6d4012 100644
--- a/rust/cardano-chain-follower/src/stats/thread/mod.rs
+++ b/rust/cardano-chain-follower/src/stats/thread/mod.rs
@@ -38,8 +38,13 @@ struct InnerThreadStat {
 }
 
 impl Serialize for InnerThreadStat {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where S: Serializer {
+    fn serialize<S>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         let mut state = serializer.serialize_struct("ThreadStat", 6)?;
 
         state.serialize_field("counter", &self.counter.load(Ordering::SeqCst))?;
@@ -56,7 +61,10 @@ impl Serialize for InnerThreadStat {
 }
 
 impl fmt::Debug for InnerThreadStat {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
         let latest_cpu_time = self.latest_cpu_time.lock().map_err(|_| fmt::Error)?;
         let total_cpu_time = self.total_cpu_time.lock().map_err(|_| fmt::Error)?;
 
diff --git a/rust/cardano-chain-follower/src/turbo_downloader/mod.rs b/rust/cardano-chain-follower/src/turbo_downloader/mod.rs
index ffb2bc4bc9f..7ab5b64e4f8 100644
--- a/rust/cardano-chain-follower/src/turbo_downloader/mod.rs
+++ b/rust/cardano-chain-follower/src/turbo_downloader/mod.rs
@@ -77,7 +77,11 @@ impl BalancingResolver {
     }
 
     /// Resolve the given URL with the configured resolver.
-    fn resolve(&self, url: &str, worker: usize) -> std::io::Result<Vec<SocketAddr>> {
+    fn resolve(
+        &self,
+        url: &str,
+        worker: usize,
+    ) -> std::io::Result<Vec<SocketAddr>> {
         // debug!("Resolving: {url} for {worker}");
         let addresses = if let Some(addresses) = self.cache.get(url) {
             addresses
@@ -152,41 +156,59 @@ impl DlConfig {
 
     /// Change the number of workers
     #[must_use]
-    pub fn with_workers(mut self, workers: usize) -> Self {
+    pub fn with_workers(
+        mut self,
+        workers: usize,
+    ) -> Self {
         self.workers = workers;
         self
     }
 
     /// Change the chunk size
     #[must_use]
-    pub fn with_chunk_size(mut self, chunk_size: usize) -> Self {
+    pub fn with_chunk_size(
+        mut self,
+        chunk_size: usize,
+    ) -> Self {
         self.chunk_size = chunk_size;
         self
     }
 
     /// Change the number of chunks queued ahead to workers
     #[must_use]
-    pub fn with_queue_ahead(mut self, queue_ahead: usize) -> Self {
+    pub fn with_queue_ahead(
+        mut self,
+        queue_ahead: usize,
+    ) -> Self {
         self.queue_ahead = queue_ahead;
         self
     }
 
     /// Change the connection timeout
     #[must_use]
-    pub fn with_connection_timeout(mut self, connection_timeout: Duration) -> Self {
+    pub fn with_connection_timeout(
+        mut self,
+        connection_timeout: Duration,
+    ) -> Self {
         self.connection_timeout = Some(connection_timeout);
         self
     }
 
     /// Change the data read timeout
     #[must_use]
-    pub fn with_data_read_timeout(mut self, data_read_timeout: Duration) -> Self {
+    pub fn with_data_read_timeout(
+        mut self,
+        data_read_timeout: Duration,
+    ) -> Self {
         self.data_read_timeout = Some(data_read_timeout);
         self
     }
 
     /// Resolve DNS addresses using Hickory Resolver
-    fn resolve(url: &str, worker: usize) -> std::io::Result<Vec<SocketAddr>> {
+    fn resolve(
+        url: &str,
+        worker: usize,
+    ) -> std::io::Result<Vec<SocketAddr>> {
         let Some(resolver) = RESOLVER.get() else {
             return Err(std::io::Error::other("Resolver not initialized."));
         };
@@ -199,7 +221,10 @@ impl DlConfig {
     /// Because we need multiple clients to prevent all traffic being forced onto a single
     /// connection when HTTP2 is used, the client can NOT be supplied by the user.
     /// Instead we create a new one here based on their configuration.
-    pub(crate) fn make_http_agent(&self, worker: usize) -> ureq::Agent {
+    pub(crate) fn make_http_agent(
+        &self,
+        worker: usize,
+    ) -> ureq::Agent {
         let mut agent = ureq::AgentBuilder::new();
 
         if let Some(timeout) = self.connection_timeout {
@@ -300,12 +325,18 @@ impl ParallelDownloadProcessorInner {
     }
 
     /// Get start offset of a chunk.
-    fn chunk_start(&self, chunk: usize) -> usize {
+    fn chunk_start(
+        &self,
+        chunk: usize,
+    ) -> usize {
         self.cfg.chunk_size.saturating_mul(chunk)
     }
 
     /// Get inclusive end offset of a chunk.
-    fn chunk_end(&self, chunk: usize) -> usize {
+    fn chunk_end(
+        &self,
+        chunk: usize,
+    ) -> usize {
         let start = self.chunk_start(chunk);
         if start.saturating_add(self.cfg.chunk_size) >= self.file_size {
             self.file_size.saturating_sub(1)
@@ -315,7 +346,11 @@ impl ParallelDownloadProcessorInner {
     }
 
     /// Sends a GET request to download a chunk of the file at the specified range
-    fn get_range(&self, agent: &ureq::Agent, chunk: usize) -> Result<Arc<Vec<u8>>> {
+    fn get_range(
+        &self,
+        agent: &ureq::Agent,
+        chunk: usize,
+    ) -> Result<Arc<Vec<u8>>> {
         let range_start = self.chunk_start(chunk);
         let range_end_inclusive = self.chunk_end(chunk);
         let range_header = format!("bytes={range_start}-{range_end_inclusive}");
@@ -354,7 +389,10 @@ impl ParallelDownloadProcessorInner {
     /// Queue Chunk to processor.
     ///
     /// Reorders chunks and sends to the consumer.
-    fn reorder_queue(&self, chunk: DlChunk) -> Result<()> {
+    fn reorder_queue(
+        &self,
+        chunk: DlChunk,
+    ) -> Result<()> {
         self.reorder_queue.insert(chunk.chunk_num, chunk);
         self.new_chunk_queue_tx.send(Some(()))?;
         Ok(())
@@ -373,7 +411,11 @@ impl ParallelDownloadProcessor {
     ///
     /// Can Fail IF there is no HTTP client provided or the URL does not support getting
     /// the content length.
-    pub(crate) async fn new(url: &str, mut cfg: DlConfig, chain: Network) -> Result<Self> {
+    pub(crate) async fn new(
+        url: &str,
+        mut cfg: DlConfig,
+        chain: Network,
+    ) -> Result<Self> {
         if cfg.chunk_size < MIN_CHUNK_SIZE {
             bail!(
                 "Download chunk size must be at least {} bytes",
@@ -422,7 +464,10 @@ impl ParallelDownloadProcessor {
 
     /// Starts the worker tasks, they will not start doing any work until `download` is
     /// called, which happens immediately after they are started.
-    fn start_workers(&self, chain: Network) -> Result<()> {
+    fn start_workers(
+        &self,
+        chain: Network,
+    ) -> Result<()> {
         for worker in 0..self.0.cfg.workers {
             // The channel is unbounded, because work distribution is controlled to be at most
             // `work_queue` deep per worker. And we don't want anything unexpected to
@@ -446,7 +491,9 @@ impl ParallelDownloadProcessor {
     /// Call the work queue receiver.
     /// This is a helper function to pause and resume the stats thread.
     fn call_work_queue_receiver(
-        chain: Network, worker_name: &str, work_queue: &Receiver<usize>,
+        chain: Network,
+        worker_name: &str,
+        work_queue: &Receiver<usize>,
     ) -> Result<usize, RecvError> {
         stats::pause_thread(chain, worker_name);
         let recv = work_queue.recv();
@@ -457,8 +504,11 @@ impl ParallelDownloadProcessor {
     /// The worker task - It is running in parallel and downloads chunks of the file as
     /// requested.
     fn worker(
-        params: &Arc<ParallelDownloadProcessorInner>, worker_id: usize, worker_name: &str,
-        work_queue: &crossbeam_channel::Receiver<DlWorkOrder>, chain: Network,
+        params: &Arc<ParallelDownloadProcessorInner>,
+        worker_id: usize,
+        worker_name: &str,
+        work_queue: &crossbeam_channel::Receiver<DlWorkOrder>,
+        chain: Network,
     ) {
         debug!("Worker {worker_id} started");
 
@@ -530,7 +580,11 @@ impl ParallelDownloadProcessor {
     }
 
     /// Send a work order to a worker.
-    fn send_work_order(&self, this_worker: usize, order: DlWorkOrder) -> Result<usize> {
+    fn send_work_order(
+        &self,
+        this_worker: usize,
+        order: DlWorkOrder,
+    ) -> Result<usize> {
         let next_worker = this_worker
             .checked_add(1)
             .and_then(|w| w.checked_rem(self.0.cfg.workers))
@@ -583,7 +637,10 @@ impl ParallelDownloadProcessor {
 
     /// Actual Read function, done like this so we can have a single cleanup on error or
     /// EOF.
-    fn inner_read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+    fn inner_read(
+        &mut self,
+        buf: &mut [u8],
+    ) -> std::io::Result<usize> {
         // There should only ever be one reader, the purpose of this mutex is to give us
         // mutability it should never actually block.
         let mut left_over_buffer = self
@@ -694,7 +751,10 @@ impl Drop for ParallelDownloadProcessor {
 }
 
 impl Read for ParallelDownloadProcessor {
-    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+    fn read(
+        &mut self,
+        buf: &mut [u8],
+    ) -> std::io::Result<usize> {
         let result = self.inner_read(buf);
         match result {
             Ok(0) | Err(_) => {
diff --git a/rust/catalyst-types/src/catalyst_id/key_rotation.rs b/rust/catalyst-types/src/catalyst_id/key_rotation.rs
index ba63395b1de..55fdb20b935 100644
--- a/rust/catalyst-types/src/catalyst_id/key_rotation.rs
+++ b/rust/catalyst-types/src/catalyst_id/key_rotation.rs
@@ -32,7 +32,10 @@ impl KeyRotation {
     }
 
     /// Get the key by the rotation value from the provided keys slice, if present.
-    pub fn get_key<'a, T>(&self, keys: &'a [T]) -> Option<&'a T> {
+    pub fn get_key<'a, T>(
+        &self,
+        keys: &'a [T],
+    ) -> Option<&'a T> {
         keys.get(self.0 as usize)
     }
 
@@ -71,7 +74,10 @@ impl FromStr for KeyRotation {
 }
 
 impl Display for KeyRotation {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut Formatter<'_>,
+    ) -> Result<(), std::fmt::Error> {
         write!(f, "{}", self.0)
     }
 }
diff --git a/rust/catalyst-types/src/catalyst_id/mod.rs b/rust/catalyst-types/src/catalyst_id/mod.rs
index 8557e34ef6c..e1d68ca758c 100644
--- a/rust/catalyst-types/src/catalyst_id/mod.rs
+++ b/rust/catalyst-types/src/catalyst_id/mod.rs
@@ -125,7 +125,11 @@ impl CatalystId {
 
     /// Create a new `CatalystId` for a Signing Key
     #[must_use]
-    pub fn new(network: &str, subnet: Option<&str>, role0_pk: VerifyingKey) -> Self {
+    pub fn new(
+        network: &str,
+        subnet: Option<&str>,
+        role0_pk: VerifyingKey,
+    ) -> Self {
         let inner = Arc::new(CatalystIdInner {
             username: None, // Default to Not set, use `with_username` if required.
             nonce: None,    // Default to Not set, use `with_nonce` if required.
@@ -171,7 +175,10 @@ impl CatalystId {
 
     /// Add or change the username in a Catalyst ID URI.
     #[must_use]
-    pub fn with_username(self, name: &str) -> Self {
+    pub fn with_username(
+        self,
+        name: &str,
+    ) -> Self {
         let inner = Arc::try_unwrap(self.inner).unwrap_or_else(|v| (*v).clone());
         let inner = Arc::new(CatalystIdInner {
             username: Some(name.to_string()),
@@ -213,7 +220,10 @@ impl CatalystId {
     ///   data, ensure that the nonce has been pre-validated and take appropriate action
     ///   before calling this function.
     #[must_use]
-    pub fn with_specific_nonce(self, nonce: DateTime<Utc>) -> Self {
+    pub fn with_specific_nonce(
+        self,
+        nonce: DateTime<Utc>,
+    ) -> Self {
         let secs = nonce.timestamp();
         let clamped_secs = secs.clamp(Self::MIN_NONCE, Self::MAX_NONCE);
 
@@ -369,7 +379,10 @@ impl CatalystId {
     /// assert_eq!(role, new_role);
     /// ```
     #[must_use]
-    pub fn with_role(self, role: RoleId) -> Self {
+    pub fn with_role(
+        self,
+        role: RoleId,
+    ) -> Self {
         let inner = Arc::try_unwrap(self.inner).unwrap_or_else(|v| (*v).clone());
         let inner = Arc::new(CatalystIdInner { role, ..inner });
         Self { inner }
@@ -400,7 +413,10 @@ impl CatalystId {
     /// assert_eq!(rotation, new_rotation);
     /// ```
     #[must_use]
-    pub fn with_rotation(self, rotation: KeyRotation) -> Self {
+    pub fn with_rotation(
+        self,
+        rotation: KeyRotation,
+    ) -> Self {
         let inner = Arc::try_unwrap(self.inner).unwrap_or_else(|v| (*v).clone());
         let inner = Arc::new(CatalystIdInner { rotation, ..inner });
         Self { inner }
@@ -452,7 +468,11 @@ impl CatalystId {
     /// assert!(!uri.is_nonce_in_range(chrono::Duration::hours(1), chrono::Duration::minutes(5)));
     /// ```
     #[must_use]
-    pub fn is_nonce_in_range(&self, past: Duration, future: Duration) -> bool {
+    pub fn is_nonce_in_range(
+        &self,
+        past: Duration,
+        future: Duration,
+    ) -> bool {
         if let Some(nonce) = self.nonce() {
             let now = Utc::now();
             let Some(start_time) = now.checked_sub_signed(past) else {
@@ -653,7 +673,10 @@ impl FromStr for CatalystId {
 }
 
 impl Display for CatalystId {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut Formatter<'_>,
+    ) -> Result<(), std::fmt::Error> {
         if !self.inner.id {
             write!(f, "{}://", Self::SCHEME.as_str())?;
         }
diff --git a/rust/catalyst-types/src/catalyst_id/role_index.rs b/rust/catalyst-types/src/catalyst_id/role_index.rs
index cf45dc00cfc..0b93038617c 100644
--- a/rust/catalyst-types/src/catalyst_id/role_index.rs
+++ b/rust/catalyst-types/src/catalyst_id/role_index.rs
@@ -95,13 +95,19 @@ impl FromStr for RoleId {
 }
 
 impl Display for RoleId {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut Formatter<'_>,
+    ) -> Result<(), std::fmt::Error> {
         write!(f, "{}", self.as_u8())
     }
 }
 
 impl<'a, C> minicbor::Decode<'a, C> for RoleId {
-    fn decode(d: &mut minicbor::Decoder<'a>, ctx: &mut C) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut minicbor::Decoder<'a>,
+        ctx: &mut C,
+    ) -> Result<Self, minicbor::decode::Error> {
         <u8 as minicbor::Decode<'a, C>>::decode(d, ctx).map(Self::from)
     }
 }
diff --git a/rust/catalyst-types/src/cbor_utils.rs b/rust/catalyst-types/src/cbor_utils.rs
index af6f0b2b047..2a0f64cc6b4 100644
--- a/rust/catalyst-types/src/cbor_utils.rs
+++ b/rust/catalyst-types/src/cbor_utils.rs
@@ -8,7 +8,11 @@ use crate::problem_report::ProblemReport;
 /// Adds a "duplicated field" entry to the report and returns true if the field is already
 /// present in the given found keys list.
 pub fn report_duplicated_key<T: Debug + PartialEq>(
-    found_keys: &[T], key: &T, index: u64, context: &str, report: &ProblemReport,
+    found_keys: &[T],
+    key: &T,
+    index: u64,
+    context: &str,
+    report: &ProblemReport,
 ) -> bool {
     if found_keys.contains(key) {
         report.duplicate_field(
@@ -24,7 +28,10 @@ pub fn report_duplicated_key<T: Debug + PartialEq>(
 /// Adds a "missing field" entry to the report for every required key that isn't present
 /// in the found keys list.
 pub fn report_missing_keys<T: Debug + PartialEq>(
-    found_keys: &[T], required_keys: &[T], context: &str, report: &ProblemReport,
+    found_keys: &[T],
+    required_keys: &[T],
+    context: &str,
+    report: &ProblemReport,
 ) {
     for key in required_keys {
         if !found_keys.contains(key) {
diff --git a/rust/catalyst-types/src/conversion.rs b/rust/catalyst-types/src/conversion.rs
index 89c66930e08..36cbd631ab5 100644
--- a/rust/catalyst-types/src/conversion.rs
+++ b/rust/catalyst-types/src/conversion.rs
@@ -32,7 +32,7 @@ pub fn from_saturating<
         + std::cmp::PartialOrd<T>
         + num_traits::identities::Zero,
 >(
-    value: T,
+    value: T
 ) -> R {
     match value.try_into() {
         Ok(value) => value,
@@ -71,7 +71,10 @@ pub fn vkey_from_bytes(bytes: &[u8]) -> Result<ed25519_dalek::VerifyingKey, VKey
 
 /// Zero out the last n bytes
 #[must_use]
-pub fn zero_out_last_n_bytes(data: &[u8], n: usize) -> Vec<u8> {
+pub fn zero_out_last_n_bytes(
+    data: &[u8],
+    n: usize,
+) -> Vec<u8> {
     let mut vec = data.to_vec();
     if let Some(slice) = vec.get_mut(data.len().saturating_sub(n)..) {
         slice.fill(0);
diff --git a/rust/catalyst-types/src/hashes.rs b/rust/catalyst-types/src/hashes.rs
index 9767a6989f2..f328a1fa5e9 100644
--- a/rust/catalyst-types/src/hashes.rs
+++ b/rust/catalyst-types/src/hashes.rs
@@ -133,13 +133,19 @@ impl<const BYTES: usize> TryFrom<Vec<u8>> for Blake2bHash<BYTES> {
 }
 
 impl<const BYTES: usize> fmt::Debug for Blake2bHash<BYTES> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
         f.write_str(&format!("{:?}", self.0))
     }
 }
 
 impl<const BYTES: usize> fmt::Display for Blake2bHash<BYTES> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
         f.write_str(&format!("{}", self.0))
     }
 }
@@ -155,7 +161,9 @@ impl<const BYTES: usize> FromStr for Blake2bHash<BYTES> {
 
 impl<C, const BYTES: usize> minicbor::Encode<C> for Blake2bHash<BYTES> {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut minicbor::Encoder<W>, _ctx: &mut C,
+        &self,
+        e: &mut minicbor::Encoder<W>,
+        _ctx: &mut C,
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         e.bytes(self.0.as_ref())?.ok()
     }
@@ -163,7 +171,8 @@ impl<C, const BYTES: usize> minicbor::Encode<C> for Blake2bHash<BYTES> {
 
 impl<'a, C, const BYTES: usize> minicbor::Decode<'a, C> for Blake2bHash<BYTES> {
     fn decode(
-        d: &mut minicbor::Decoder<'a>, _ctx: &mut C,
+        d: &mut minicbor::Decoder<'a>,
+        _ctx: &mut C,
     ) -> Result<Self, minicbor::decode::Error> {
         let bytes = d.bytes()?;
         bytes.try_into().map_err(|_| {
diff --git a/rust/catalyst-types/src/problem_report.rs b/rust/catalyst-types/src/problem_report.rs
index 3866a8b32b1..becdb117840 100644
--- a/rust/catalyst-types/src/problem_report.rs
+++ b/rust/catalyst-types/src/problem_report.rs
@@ -148,7 +148,11 @@ impl ProblemReport {
     }
 
     /// Add an entry to the report
-    fn add_entry(&self, kind: Kind, context: &str) {
+    fn add_entry(
+        &self,
+        kind: Kind,
+        context: &str,
+    ) {
         self.0.report.0.push(Entry {
             kind,
             context: context.to_owned(),
@@ -174,7 +178,11 @@ impl ProblemReport {
     /// let report = ProblemReport::new("RBAC Registration Decoding");
     /// report.missing_field("name", "In the JSON payload for user creation");
     /// ```
-    pub fn missing_field(&self, field_name: &str, context: &str) {
+    pub fn missing_field(
+        &self,
+        field_name: &str,
+        context: &str,
+    ) {
         self.add_entry(
             Kind::MissingField {
                 field: field_name.to_owned(),
@@ -209,7 +217,12 @@ impl ProblemReport {
     ///     "In the JSON configuration file",
     /// );
     /// ```
-    pub fn unknown_field(&self, field_name: &str, value: &str, context: &str) {
+    pub fn unknown_field(
+        &self,
+        field_name: &str,
+        value: &str,
+        context: &str,
+    ) {
         self.add_entry(
             Kind::UnknownField {
                 field: field_name.to_owned(),
@@ -249,7 +262,13 @@ impl ProblemReport {
     ///     "During user registration",
     /// );
     /// ```
-    pub fn invalid_value(&self, field_name: &str, found: &str, constraint: &str, context: &str) {
+    pub fn invalid_value(
+        &self,
+        field_name: &str,
+        found: &str,
+        constraint: &str,
+        context: &str,
+    ) {
         self.add_entry(
             Kind::InvalidValue {
                 field: field_name.to_owned(),
@@ -286,7 +305,11 @@ impl ProblemReport {
     /// report.invalid_encoding("data", "UTF-8", "ASCII", "During data import");
     /// ```
     pub fn invalid_encoding(
-        &self, field_name: &str, detected_encoding: &str, expected_encoding: &str, context: &str,
+        &self,
+        field_name: &str,
+        detected_encoding: &str,
+        expected_encoding: &str,
+        context: &str,
     ) {
         self.add_entry(
             Kind::InvalidEncoding {
@@ -324,7 +347,11 @@ impl ProblemReport {
     ///     "During contract creation",
     /// );
     /// ```
-    pub fn functional_validation(&self, explanation: &str, context: &str) {
+    pub fn functional_validation(
+        &self,
+        explanation: &str,
+        context: &str,
+    ) {
         self.add_entry(
             Kind::FunctionalValidation {
                 explanation: explanation.to_owned(),
@@ -357,7 +384,12 @@ impl ProblemReport {
     ///     "RBAC purpose",
     /// );
     /// ```
-    pub fn duplicate_field(&self, field: &str, description: &str, context: &str) {
+    pub fn duplicate_field(
+        &self,
+        field: &str,
+        description: &str,
+        context: &str,
+    ) {
         self.add_entry(
             Kind::DuplicateField {
                 field: field.to_owned(),
@@ -392,7 +424,13 @@ impl ProblemReport {
     ///     "RBAC stake address",
     /// );
     /// ```
-    pub fn conversion_error(&self, field: &str, value: &str, expected_type: &str, context: &str) {
+    pub fn conversion_error(
+        &self,
+        field: &str,
+        value: &str,
+        expected_type: &str,
+        context: &str,
+    ) {
         self.add_entry(
             Kind::ConversionError {
                 field: field.to_owned(),
@@ -430,7 +468,11 @@ impl ProblemReport {
     ///     "During contract creation",
     /// );
     /// ```
-    pub fn other(&self, description: &str, context: &str) {
+    pub fn other(
+        &self,
+        description: &str,
+        context: &str,
+    ) {
         self.add_entry(
             Kind::Other {
                 description: description.to_owned(),
diff --git a/rust/catalyst-types/src/uuid/mod.rs b/rust/catalyst-types/src/uuid/mod.rs
index 3e25737e1de..89156967fd7 100644
--- a/rust/catalyst-types/src/uuid/mod.rs
+++ b/rust/catalyst-types/src/uuid/mod.rs
@@ -53,7 +53,8 @@ fn validate_uuid_tag(tag: u64) -> Result<(), minicbor::decode::Error> {
 
 /// Decode from `CBOR` into `UUID`
 fn decode_cbor_uuid(
-    d: &mut minicbor::Decoder<'_>, ctx: &mut CborContext,
+    d: &mut minicbor::Decoder<'_>,
+    ctx: &mut CborContext,
 ) -> Result<uuid::Uuid, minicbor::decode::Error> {
     let bytes = match ctx {
         CborContext::Untagged => d.bytes()?,
@@ -82,7 +83,9 @@ fn decode_cbor_uuid(
 
 /// Encode `UUID` into `CBOR`
 fn encode_cbor_uuid<W: minicbor::encode::Write>(
-    uuid: uuid::Uuid, e: &mut minicbor::Encoder<W>, ctx: &mut CborContext,
+    uuid: uuid::Uuid,
+    e: &mut minicbor::Encoder<W>,
+    ctx: &mut CborContext,
 ) -> Result<(), minicbor::encode::Error<W::Error>> {
     if let CborContext::Tagged = ctx {
         e.tag(Tag::new(UUID_CBOR_TAG))?;
diff --git a/rust/catalyst-types/src/uuid/uuid_v4.rs b/rust/catalyst-types/src/uuid/uuid_v4.rs
index c7e2dbb8149..1d6228738b9 100644
--- a/rust/catalyst-types/src/uuid/uuid_v4.rs
+++ b/rust/catalyst-types/src/uuid/uuid_v4.rs
@@ -46,13 +46,19 @@ fn is_valid(uuid: &Uuid) -> bool {
 }
 
 impl Display for UuidV4 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut Formatter<'_>,
+    ) -> Result<(), std::fmt::Error> {
         write!(f, "{}", self.0)
     }
 }
 
 impl Decode<'_, CborContext> for UuidV4 {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut CborContext) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut CborContext,
+    ) -> Result<Self, minicbor::decode::Error> {
         let uuid = decode_cbor_uuid(d, ctx)?;
         if is_valid(&uuid) {
             Ok(Self(uuid))
@@ -66,7 +72,9 @@ impl Decode<'_, CborContext> for UuidV4 {
 
 impl Encode<CborContext> for UuidV4 {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut minicbor::Encoder<W>, ctx: &mut CborContext,
+        &self,
+        e: &mut minicbor::Encoder<W>,
+        ctx: &mut CborContext,
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         encode_cbor_uuid(self.uuid(), e, ctx)
     }
diff --git a/rust/catalyst-types/src/uuid/uuid_v7.rs b/rust/catalyst-types/src/uuid/uuid_v7.rs
index 98fbd8cda6e..f58b77dc944 100644
--- a/rust/catalyst-types/src/uuid/uuid_v7.rs
+++ b/rust/catalyst-types/src/uuid/uuid_v7.rs
@@ -46,13 +46,19 @@ fn is_valid(uuid: &Uuid) -> bool {
 }
 
 impl Display for UuidV7 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut Formatter<'_>,
+    ) -> Result<(), std::fmt::Error> {
         write!(f, "{}", self.0)
     }
 }
 
 impl Decode<'_, CborContext> for UuidV7 {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut CborContext) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut CborContext,
+    ) -> Result<Self, minicbor::decode::Error> {
         let uuid = decode_cbor_uuid(d, ctx)?;
         if is_valid(&uuid) {
             Ok(Self(uuid))
@@ -66,7 +72,9 @@ impl Decode<'_, CborContext> for UuidV7 {
 
 impl Encode<CborContext> for UuidV7 {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut minicbor::Encoder<W>, ctx: &mut CborContext,
+        &self,
+        e: &mut minicbor::Encoder<W>,
+        ctx: &mut CborContext,
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         encode_cbor_uuid(self.uuid(), e, ctx)
     }
diff --git a/rust/catalyst-voting/benches/vote_protocol.rs b/rust/catalyst-voting/benches/vote_protocol.rs
index 4c2c40f5bcf..38dea85e556 100644
--- a/rust/catalyst-voting/benches/vote_protocol.rs
+++ b/rust/catalyst-voting/benches/vote_protocol.rs
@@ -54,7 +54,7 @@ struct Choices(Vec<usize>);
 struct VotingPowers(Vec<u64>);
 
 fn rand_generate_vote_data(
-    voters_number: usize,
+    voters_number: usize
 ) -> (
     Choices,
     VotingPowers,
diff --git a/rust/catalyst-voting/src/crypto/babystep_giantstep.rs b/rust/catalyst-voting/src/crypto/babystep_giantstep.rs
index 89b8436faef..431d37e5e1b 100644
--- a/rust/catalyst-voting/src/crypto/babystep_giantstep.rs
+++ b/rust/catalyst-voting/src/crypto/babystep_giantstep.rs
@@ -40,7 +40,10 @@ impl BabyStepGiantStep {
     ///
     /// # Errors
     ///   - Maximum value and balance must be greater than zero.
-    pub fn new(max_log_value: u64, balance: Option<u64>) -> anyhow::Result<Self> {
+    pub fn new(
+        max_log_value: u64,
+        balance: Option<u64>,
+    ) -> anyhow::Result<Self> {
         let balance = balance.unwrap_or(DEFAULT_BALANCE);
 
         ensure!(
@@ -77,7 +80,10 @@ impl BabyStepGiantStep {
     ///
     /// # Errors
     ///   - Max log value exceeded.
-    pub fn discrete_log(&self, mut point: GroupElement) -> anyhow::Result<u64> {
+    pub fn discrete_log(
+        &self,
+        mut point: GroupElement,
+    ) -> anyhow::Result<u64> {
         for baby_step in 0..=self.baby_step_size {
             if let Some(x) = self.table.get(&point) {
                 let r = baby_step * self.baby_step_size + x;
@@ -106,7 +112,8 @@ mod tests {
     // range 1..1` for `log` strategy
     #[proptest]
     fn baby_step_giant_step_test(
-        #[strategy(2..10000u64)] max_log_value: u64, #[strategy(1..#max_log_value)] log: u64,
+        #[strategy(2..10000u64)] max_log_value: u64,
+        #[strategy(1..#max_log_value)] log: u64,
     ) {
         let ge = GroupElement::GENERATOR.mul(&Scalar::from(log));
 
diff --git a/rust/catalyst-voting/src/crypto/ed25519/mod.rs b/rust/catalyst-voting/src/crypto/ed25519/mod.rs
index a2066ad4ddd..4ad585c460f 100644
--- a/rust/catalyst-voting/src/crypto/ed25519/mod.rs
+++ b/rust/catalyst-voting/src/crypto/ed25519/mod.rs
@@ -42,13 +42,20 @@ pub struct PublicKey(VerifyingKey);
 pub struct Signature(Ed25519Signature);
 
 /// Sign a message using the `Ed25519` private key.
-pub fn sign(sk: &PrivateKey, msg: &[u8]) -> Signature {
+pub fn sign(
+    sk: &PrivateKey,
+    msg: &[u8],
+) -> Signature {
     Signature(sk.0.sign(msg))
 }
 
 /// Verify a `Ed25519` signature using the `Ed25519` public key.
 #[must_use]
-pub fn verify_signature(pk: &PublicKey, msg: &[u8], sig: &Signature) -> bool {
+pub fn verify_signature(
+    pk: &PublicKey,
+    msg: &[u8],
+    sig: &Signature,
+) -> bool {
     pk.0.verify_strict(msg, &sig.0).is_ok()
 }
 
@@ -77,7 +84,10 @@ mod tests {
     use super::*;
 
     #[proptest]
-    fn sign_test(private_key: PrivateKey, msg: Vec<u8>) {
+    fn sign_test(
+        private_key: PrivateKey,
+        msg: Vec<u8>,
+    ) {
         let public_key = private_key.public_key();
         let signature = sign(&private_key, &msg);
         assert!(verify_signature(&public_key, &msg, &signature));
diff --git a/rust/catalyst-voting/src/crypto/elgamal/mod.rs b/rust/catalyst-voting/src/crypto/elgamal/mod.rs
index 946adedc66e..f11f2cf3bf9 100644
--- a/rust/catalyst-voting/src/crypto/elgamal/mod.rs
+++ b/rust/catalyst-voting/src/crypto/elgamal/mod.rs
@@ -38,7 +38,11 @@ pub fn generate_public_key(secret_key: &Scalar) -> GroupElement {
 /// Given a `message` represented as a `Scalar`, return a ciphertext using the
 /// lifted `ElGamal` mechanism.
 /// Returns a ciphertext of type `Ciphertext`.
-pub fn encrypt(message: &Scalar, public_key: &GroupElement, randomness: &Scalar) -> Ciphertext {
+pub fn encrypt(
+    message: &Scalar,
+    public_key: &GroupElement,
+    randomness: &Scalar,
+) -> Ciphertext {
     let e1 = GroupElement::GENERATOR.mul(randomness);
     let e2 = &GroupElement::GENERATOR.mul(message) + &public_key.mul(randomness);
     Ciphertext(e1, e2)
@@ -46,14 +50,20 @@ pub fn encrypt(message: &Scalar, public_key: &GroupElement, randomness: &Scalar)
 
 /// Decrypt `ElGamal` `Ciphertext`, returns the original message represented as a
 /// `GroupElement`.
-pub fn decrypt(cipher: &Ciphertext, secret_key: &Scalar) -> GroupElement {
+pub fn decrypt(
+    cipher: &Ciphertext,
+    secret_key: &Scalar,
+) -> GroupElement {
     &(&cipher.0 * &secret_key.negate()) + &cipher.1
 }
 
 impl Mul<&Scalar> for &Ciphertext {
     type Output = Ciphertext;
 
-    fn mul(self, rhs: &Scalar) -> Self::Output {
+    fn mul(
+        self,
+        rhs: &Scalar,
+    ) -> Self::Output {
         Ciphertext(&self.0 * rhs, &self.1 * rhs)
     }
 }
@@ -61,7 +71,10 @@ impl Mul<&Scalar> for &Ciphertext {
 impl Add<&Ciphertext> for &Ciphertext {
     type Output = Ciphertext;
 
-    fn add(self, rhs: &Ciphertext) -> Self::Output {
+    fn add(
+        self,
+        rhs: &Ciphertext,
+    ) -> Self::Output {
         Ciphertext(&self.0 + &rhs.0, &self.1 + &rhs.1)
     }
 }
@@ -94,7 +107,12 @@ mod tests {
     use super::*;
 
     #[proptest]
-    fn ciphertext_add_test(e1: Scalar, e2: Scalar, e3: Scalar, e4: Scalar) {
+    fn ciphertext_add_test(
+        e1: Scalar,
+        e2: Scalar,
+        e3: Scalar,
+        e4: Scalar,
+    ) {
         let g1 = GroupElement::GENERATOR.mul(&e1);
         let g2 = GroupElement::GENERATOR.mul(&e2);
         let c1 = Ciphertext(g1.clone(), g2.clone());
@@ -107,7 +125,11 @@ mod tests {
     }
 
     #[proptest]
-    fn ciphertext_mul_test(e1: Scalar, e2: Scalar, e3: Scalar) {
+    fn ciphertext_mul_test(
+        e1: Scalar,
+        e2: Scalar,
+        e3: Scalar,
+    ) {
         let g1 = GroupElement::GENERATOR.mul(&e1);
         let g2 = GroupElement::GENERATOR.mul(&e2);
         let c1 = Ciphertext(g1.clone(), g2.clone());
@@ -116,7 +138,11 @@ mod tests {
     }
 
     #[proptest]
-    fn elgamal_encryption_decryption_test(secret_key: Scalar, message: Scalar, randomness: Scalar) {
+    fn elgamal_encryption_decryption_test(
+        secret_key: Scalar,
+        message: Scalar,
+        randomness: Scalar,
+    ) {
         let public_key = generate_public_key(&secret_key);
 
         let cipher = encrypt(&message, &public_key, &randomness);
diff --git a/rust/catalyst-voting/src/crypto/group/ristretto255/mod.rs b/rust/catalyst-voting/src/crypto/group/ristretto255/mod.rs
index 93ffe6ac65d..5b7f20aae3c 100644
--- a/rust/catalyst-voting/src/crypto/group/ristretto255/mod.rs
+++ b/rust/catalyst-voting/src/crypto/group/ristretto255/mod.rs
@@ -38,7 +38,10 @@ impl From<u64> for Scalar {
 }
 
 impl Hash for GroupElement {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: std::hash::Hasher>(
+        &self,
+        state: &mut H,
+    ) {
         self.0.compress().as_bytes().hash(state);
     }
 }
@@ -102,7 +105,10 @@ impl GroupElement {
 impl Mul<&GroupElement> for &Scalar {
     type Output = GroupElement;
 
-    fn mul(self, other: &GroupElement) -> GroupElement {
+    fn mul(
+        self,
+        other: &GroupElement,
+    ) -> GroupElement {
         other * self
     }
 }
@@ -110,7 +116,10 @@ impl Mul<&GroupElement> for &Scalar {
 impl Mul<&Scalar> for &GroupElement {
     type Output = GroupElement;
 
-    fn mul(self, other: &Scalar) -> GroupElement {
+    fn mul(
+        self,
+        other: &Scalar,
+    ) -> GroupElement {
         if self.0 == RISTRETTO_BASEPOINT_POINT {
             GroupElement(RISTRETTO_BASEPOINT_TABLE * &other.0)
         } else {
@@ -122,7 +131,10 @@ impl Mul<&Scalar> for &GroupElement {
 impl Mul<&Scalar> for &Scalar {
     type Output = Scalar;
 
-    fn mul(self, other: &Scalar) -> Scalar {
+    fn mul(
+        self,
+        other: &Scalar,
+    ) -> Scalar {
         Scalar(self.0 * other.0)
     }
 }
@@ -130,7 +142,10 @@ impl Mul<&Scalar> for &Scalar {
 impl Add<&GroupElement> for &GroupElement {
     type Output = GroupElement;
 
-    fn add(self, other: &GroupElement) -> GroupElement {
+    fn add(
+        self,
+        other: &GroupElement,
+    ) -> GroupElement {
         GroupElement(self.0 + other.0)
     }
 }
@@ -138,7 +153,10 @@ impl Add<&GroupElement> for &GroupElement {
 impl Add<&Scalar> for &Scalar {
     type Output = Scalar;
 
-    fn add(self, other: &Scalar) -> Scalar {
+    fn add(
+        self,
+        other: &Scalar,
+    ) -> Scalar {
         Scalar(self.0 + other.0)
     }
 }
@@ -146,7 +164,10 @@ impl Add<&Scalar> for &Scalar {
 impl Sub<&Scalar> for &Scalar {
     type Output = Scalar;
 
-    fn sub(self, other: &Scalar) -> Scalar {
+    fn sub(
+        self,
+        other: &Scalar,
+    ) -> Scalar {
         Scalar(self.0 - other.0)
     }
 }
@@ -154,7 +175,10 @@ impl Sub<&Scalar> for &Scalar {
 impl Sub<&GroupElement> for &GroupElement {
     type Output = GroupElement;
 
-    fn sub(self, other: &GroupElement) -> GroupElement {
+    fn sub(
+        self,
+        other: &GroupElement,
+    ) -> GroupElement {
         GroupElement(self.0 + (-other.0))
     }
 }
@@ -196,7 +220,11 @@ mod tests {
     use super::*;
 
     #[proptest]
-    fn scalar_arithmetic_tests(e1: Scalar, e2: Scalar, e3: Scalar) {
+    fn scalar_arithmetic_tests(
+        e1: Scalar,
+        e2: Scalar,
+        e3: Scalar,
+    ) {
         assert_eq!(&(&e1 + &e2) + &e3, &e1 + &(&e2 + &e3));
         assert_eq!(&e1 + &e2, &e2 + &e1);
         assert_eq!(&e1 + &Scalar::zero(), e1.clone());
@@ -208,7 +236,10 @@ mod tests {
     }
 
     #[proptest]
-    fn group_element_arithmetic_tests(e1: Scalar, e2: Scalar) {
+    fn group_element_arithmetic_tests(
+        e1: Scalar,
+        e2: Scalar,
+    ) {
         let ge = GroupElement::GENERATOR.mul(&e1);
         assert_eq!(&GroupElement::zero() + &ge, ge);
 
diff --git a/rust/catalyst-voting/src/crypto/hash.rs b/rust/catalyst-voting/src/crypto/hash.rs
index 7ce3fe6f0b1..465001b18bc 100644
--- a/rust/catalyst-voting/src/crypto/hash.rs
+++ b/rust/catalyst-voting/src/crypto/hash.rs
@@ -32,7 +32,10 @@ impl Default for Blake2b512Hasher {
 }
 
 impl Update for Blake2b512Hasher {
-    fn update(&mut self, data: &[u8]) {
+    fn update(
+        &mut self,
+        data: &[u8],
+    ) {
         self.0.update(data);
     }
 }
@@ -46,7 +49,10 @@ impl OutputSizeUser for Blake2b512Hasher {
 }
 
 impl FixedOutput for Blake2b512Hasher {
-    fn finalize_into(self, out: &mut Output<Self>) {
+    fn finalize_into(
+        self,
+        out: &mut Output<Self>,
+    ) {
         let hash = self.0.finalize();
         out.copy_from_slice(hash.as_bytes());
     }
@@ -79,7 +85,10 @@ impl Default for Blake2b256Hasher {
 }
 
 impl Update for Blake2b256Hasher {
-    fn update(&mut self, data: &[u8]) {
+    fn update(
+        &mut self,
+        data: &[u8],
+    ) {
         self.0.update(data);
     }
 }
@@ -93,7 +102,10 @@ impl OutputSizeUser for Blake2b256Hasher {
 }
 
 impl FixedOutput for Blake2b256Hasher {
-    fn finalize_into(self, out: &mut Output<Self>) {
+    fn finalize_into(
+        self,
+        out: &mut Output<Self>,
+    ) {
         let hash = self.0.finalize();
         out.copy_from_slice(hash.as_bytes());
     }
diff --git a/rust/catalyst-voting/src/crypto/zk_dl_equality.rs b/rust/catalyst-voting/src/crypto/zk_dl_equality.rs
index 21d3e807d01..4d3686d4844 100644
--- a/rust/catalyst-voting/src/crypto/zk_dl_equality.rs
+++ b/rust/catalyst-voting/src/crypto/zk_dl_equality.rs
@@ -23,8 +23,12 @@ pub struct DleqProof(Scalar, Scalar);
 
 /// Generates a DLEQ proof.
 pub fn generate_dleq_proof(
-    base_1: &GroupElement, base_2: &GroupElement, point_1: &GroupElement, point_2: &GroupElement,
-    dlog: &Scalar, randomness: &Scalar,
+    base_1: &GroupElement,
+    base_2: &GroupElement,
+    point_1: &GroupElement,
+    point_2: &GroupElement,
+    dlog: &Scalar,
+    randomness: &Scalar,
 ) -> DleqProof {
     let a_1 = base_1 * randomness;
     let a_2 = base_2 * randomness;
@@ -38,7 +42,10 @@ pub fn generate_dleq_proof(
 /// Verify a DLEQ proof.
 #[must_use]
 pub fn verify_dleq_proof(
-    proof: &DleqProof, base_1: &GroupElement, base_2: &GroupElement, point_1: &GroupElement,
+    proof: &DleqProof,
+    base_1: &GroupElement,
+    base_2: &GroupElement,
+    point_1: &GroupElement,
     point_2: &GroupElement,
 ) -> bool {
     let a_1 = &(base_1 * &proof.1) - &(point_1 * &proof.0);
@@ -51,8 +58,12 @@ pub fn verify_dleq_proof(
 /// Calculates the challenge value.
 /// Its a hash value represented as `Scalar` of all provided elements.
 fn calculate_challenge(
-    base_1: &GroupElement, base_2: &GroupElement, point_1: &GroupElement, point_2: &GroupElement,
-    a_1: &GroupElement, a_2: &GroupElement,
+    base_1: &GroupElement,
+    base_2: &GroupElement,
+    point_1: &GroupElement,
+    point_2: &GroupElement,
+    a_1: &GroupElement,
+    a_2: &GroupElement,
 ) -> Scalar {
     let blake2b_hasher = Blake2b512Hasher::new()
         .chain_update(base_1.to_bytes())
@@ -74,7 +85,13 @@ mod tests {
     use super::*;
 
     #[proptest(cases = 10)]
-    fn zk_dleq_test(e1: Scalar, e2: Scalar, dlog1: Scalar, dlog2: Scalar, randomness: Scalar) {
+    fn zk_dleq_test(
+        e1: Scalar,
+        e2: Scalar,
+        dlog1: Scalar,
+        dlog2: Scalar,
+        randomness: Scalar,
+    ) {
         let base_1 = GroupElement::GENERATOR.mul(&e1);
         let base_2 = GroupElement::GENERATOR.mul(&e2);
 
diff --git a/rust/catalyst-voting/src/crypto/zk_unit_vector/challenges.rs b/rust/catalyst-voting/src/crypto/zk_unit_vector/challenges.rs
index 35632a68f0c..4d720d1ee62 100644
--- a/rust/catalyst-voting/src/crypto/zk_unit_vector/challenges.rs
+++ b/rust/catalyst-voting/src/crypto/zk_unit_vector/challenges.rs
@@ -9,7 +9,9 @@ use crate::crypto::{
 
 /// Calculates the first challenge hash.
 pub(crate) fn calculate_first_challenge_hash(
-    commitment_key: &GroupElement, public_key: &GroupElement, ciphertexts: &[Ciphertext],
+    commitment_key: &GroupElement,
+    public_key: &GroupElement,
+    ciphertexts: &[Ciphertext],
     announcements: &[Announcement],
 ) -> Blake2b512Hasher {
     let mut hash = Blake2b512Hasher::new()
@@ -29,7 +31,8 @@ pub(crate) fn calculate_first_challenge_hash(
 
 /// Calculates the second challenge hash.
 pub(crate) fn calculate_second_challenge_hash(
-    mut com_1_hash: Blake2b512Hasher, ciphertexts: &[Ciphertext],
+    mut com_1_hash: Blake2b512Hasher,
+    ciphertexts: &[Ciphertext],
 ) -> Blake2b512Hasher {
     for c in ciphertexts {
         com_1_hash.update(c.first().to_bytes());
diff --git a/rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs b/rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs
index 45dacd1c9b4..6f743e655aa 100644
--- a/rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs
+++ b/rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs
@@ -23,7 +23,10 @@ impl UnitVectorProof {
     ///   - Cannot decode ciphertext value.
     ///   - Cannot decode response randomness value.
     ///   - Cannot decode scalar value.
-    pub fn from_bytes<R: Read>(reader: &mut R, len: usize) -> anyhow::Result<Self> {
+    pub fn from_bytes<R: Read>(
+        reader: &mut R,
+        len: usize,
+    ) -> anyhow::Result<Self> {
         let ann = (0..len)
             .map(|i| {
                 let bytes = read_array(reader)?;
@@ -159,7 +162,8 @@ mod tests {
 
     #[proptest]
     fn proof_to_bytes_from_bytes_test(
-        #[strategy(0..5usize)] _size: usize, #[any(#_size)] p1: UnitVectorProof,
+        #[strategy(0..5usize)] _size: usize,
+        #[any(#_size)] p1: UnitVectorProof,
     ) {
         let bytes = p1.to_bytes();
         assert_eq!(bytes.len(), p1.bytes_size());
diff --git a/rust/catalyst-voting/src/crypto/zk_unit_vector/mod.rs b/rust/catalyst-voting/src/crypto/zk_unit_vector/mod.rs
index 5a6a7881c64..d9266477179 100644
--- a/rust/catalyst-voting/src/crypto/zk_unit_vector/mod.rs
+++ b/rust/catalyst-voting/src/crypto/zk_unit_vector/mod.rs
@@ -46,9 +46,12 @@ pub struct UnitVectorProof(
 /// Pls make sure that you are providing a correct arguments, otherwise
 /// the proof will be invalid.
 pub fn generate_unit_vector_proof<R: CryptoRngCore>(
-    unit_vector: &[Scalar], mut ciphertexts: Vec<Ciphertext>,
-    mut encryption_randomness: Vec<Scalar>, public_key: &GroupElement,
-    commitment_key: &GroupElement, rng: &mut R,
+    unit_vector: &[Scalar],
+    mut ciphertexts: Vec<Ciphertext>,
+    mut encryption_randomness: Vec<Scalar>,
+    public_key: &GroupElement,
+    commitment_key: &GroupElement,
+    rng: &mut R,
 ) -> UnitVectorProof {
     let i = unit_vector
         .iter()
@@ -106,7 +109,11 @@ pub fn generate_unit_vector_proof<R: CryptoRngCore>(
 /// Generates `D_l` and `R_l` elements
 #[allow(clippy::indexing_slicing)]
 fn generate_dl_and_rl<R: CryptoRngCore>(
-    log_n: u32, ch_1: &Scalar, public_key: &GroupElement, polynomials: &[Polynomial], rng: &mut R,
+    log_n: u32,
+    ch_1: &Scalar,
+    public_key: &GroupElement,
+    polynomials: &[Polynomial],
+    rng: &mut R,
 ) -> (Vec<Ciphertext>, Vec<Scalar>) {
     let r_l: Vec<_> = (0..log_n).map(|_| Scalar::random(rng)).collect();
 
@@ -132,7 +139,11 @@ fn generate_dl_and_rl<R: CryptoRngCore>(
 
 /// Generate response element `R`
 fn generate_response(
-    log_n: u32, ch_1: &Scalar, ch_2: &Scalar, encryption_randomness: &[Scalar], r_l: &[Scalar],
+    log_n: u32,
+    ch_1: &Scalar,
+    ch_2: &Scalar,
+    encryption_randomness: &[Scalar],
+    r_l: &[Scalar],
 ) -> Scalar {
     // exp_ch_2 == `ch_2^(log_2(N))`
     let exp_ch_2 = (0..log_n).fold(Scalar::one(), |exp, _| exp.mul(ch_2));
@@ -161,7 +172,9 @@ fn generate_response(
 /// Verify a unit vector proof.
 #[must_use]
 pub fn verify_unit_vector_proof(
-    proof: &UnitVectorProof, mut ciphertexts: Vec<Ciphertext>, public_key: &GroupElement,
+    proof: &UnitVectorProof,
+    mut ciphertexts: Vec<Ciphertext>,
+    public_key: &GroupElement,
     commitment_key: &GroupElement,
 ) -> bool {
     let m = ciphertexts.len();
@@ -183,7 +196,11 @@ pub fn verify_unit_vector_proof(
 }
 
 /// Check the first part of the proof
-fn check_1(proof: &UnitVectorProof, ch_2: &Scalar, commitment_key: &GroupElement) -> bool {
+fn check_1(
+    proof: &UnitVectorProof,
+    ch_2: &Scalar,
+    commitment_key: &GroupElement,
+) -> bool {
     proof.0.iter().zip(proof.2.iter()).all(|(an, rand)| {
         let right = &an.i.mul(ch_2) + &an.b;
         let left = &GroupElement::GENERATOR.mul(&rand.z) + &commitment_key.mul(&rand.w);
@@ -199,7 +216,11 @@ fn check_1(proof: &UnitVectorProof, ch_2: &Scalar, commitment_key: &GroupElement
 
 /// Check the second part of the proof
 fn check_2(
-    proof: &UnitVectorProof, log_n: u32, ch_1: &Scalar, ch_2: &Scalar, ciphertexts: &[Ciphertext],
+    proof: &UnitVectorProof,
+    log_n: u32,
+    ch_1: &Scalar,
+    ch_2: &Scalar,
+    ciphertexts: &[Ciphertext],
     public_key: &GroupElement,
 ) -> bool {
     let left = encrypt(&Scalar::zero(), public_key, &proof.3);
@@ -279,7 +300,8 @@ mod tests {
 
     #[proptest(cases = 10)]
     fn zk_unit_vector_test(
-        secret_key: Scalar, commitment_key: GroupElement,
+        secret_key: Scalar,
+        commitment_key: GroupElement,
         #[strategy(1..10_usize)] unit_vector_size: usize,
         #[strategy(0..#unit_vector_size)] unit_vector_index: usize,
     ) {
@@ -329,7 +351,8 @@ mod tests {
 
     #[proptest(cases = 10)]
     fn not_a_unit_vector_test(
-        secret_key: Scalar, commitment_key: GroupElement,
+        secret_key: Scalar,
+        commitment_key: GroupElement,
         #[any(size_range(1..10_usize).lift())] random_vector: Vec<Scalar>,
     ) {
         let mut rng = OsRng;
diff --git a/rust/catalyst-voting/src/crypto/zk_unit_vector/polynomial.rs b/rust/catalyst-voting/src/crypto/zk_unit_vector/polynomial.rs
index 2d336807634..56a1dfccda2 100644
--- a/rust/catalyst-voting/src/crypto/zk_unit_vector/polynomial.rs
+++ b/rust/catalyst-voting/src/crypto/zk_unit_vector/polynomial.rs
@@ -25,7 +25,11 @@ impl Deref for Polynomial {
 impl Polynomial {
     /// Multiplication of a current polynomial on a degree-1 polynomial `a * x + b`.
     #[allow(clippy::indexing_slicing)]
-    fn pol_mul(&mut self, a: &Scalar, b: &Scalar) {
+    fn pol_mul(
+        &mut self,
+        a: &Scalar,
+        b: &Scalar,
+    ) {
         self.0.push(&self.0[self.0.len() - 1] * a);
         for i in (1..self.0.len() - 1).rev() {
             self.0[i] = &(&self.0[i] * b) + &(&self.0[i - 1] * a);
@@ -34,14 +38,19 @@ impl Polynomial {
     }
 
     /// Multiplication of a current polynomial on scalar.
-    fn scalar_mul(&mut self, a: &Scalar) {
+    fn scalar_mul(
+        &mut self,
+        a: &Scalar,
+    ) {
         self.0.iter_mut().for_each(|v| *v = v.mul(a));
     }
 }
 
 /// Generate the polynomial according to the step 7 of this [spec](https://input-output-hk.github.io/catalyst-libs/architecture/08_concepts/catalyst_voting/crypto/#prover)
 pub(crate) fn generate_polynomial(
-    i: usize, j: usize, randomness: &[BlindingRandomness],
+    i: usize,
+    j: usize,
+    randomness: &[BlindingRandomness],
 ) -> Polynomial {
     let mut pol = randomness.iter().map(|r| &r.betta).enumerate().fold(
         // `0 * x + 1`
@@ -69,7 +78,9 @@ pub(crate) fn generate_polynomial(
 
 /// Calculate the polynomial value
 pub(crate) fn calculate_polynomial_val(
-    j: usize, x: &Scalar, randomness: &[ResponseRandomness],
+    j: usize,
+    x: &Scalar,
+    randomness: &[ResponseRandomness],
 ) -> Scalar {
     let val = randomness
         .iter()
diff --git a/rust/catalyst-voting/src/crypto/zk_unit_vector/randomness_announcements.rs b/rust/catalyst-voting/src/crypto/zk_unit_vector/randomness_announcements.rs
index 615b8b48c33..13ec823c757 100644
--- a/rust/catalyst-voting/src/crypto/zk_unit_vector/randomness_announcements.rs
+++ b/rust/catalyst-voting/src/crypto/zk_unit_vector/randomness_announcements.rs
@@ -40,7 +40,9 @@ pub struct Announcement {
 
 impl Announcement {
     pub(crate) fn new(
-        i_bit: bool, rand: &BlindingRandomness, commitment_key: &GroupElement,
+        i_bit: bool,
+        rand: &BlindingRandomness,
+        commitment_key: &GroupElement,
     ) -> Self {
         let i = if i_bit {
             &GroupElement::GENERATOR + &commitment_key.mul(&rand.alpha)
@@ -67,7 +69,11 @@ pub struct ResponseRandomness {
 }
 
 impl ResponseRandomness {
-    pub(crate) fn new(i_bit: bool, rand: &BlindingRandomness, com_2: &Scalar) -> Self {
+    pub(crate) fn new(
+        i_bit: bool,
+        rand: &BlindingRandomness,
+        com_2: &Scalar,
+    ) -> Self {
         let z = if i_bit {
             com_2 + &rand.betta
         } else {
diff --git a/rust/catalyst-voting/src/crypto/zk_unit_vector/utils.rs b/rust/catalyst-voting/src/crypto/zk_unit_vector/utils.rs
index 415201f7f5d..537e3fcab65 100644
--- a/rust/catalyst-voting/src/crypto/zk_unit_vector/utils.rs
+++ b/rust/catalyst-voting/src/crypto/zk_unit_vector/utils.rs
@@ -3,7 +3,10 @@
 /// Calculates the `bit_index`-th bit of the `val`.
 /// `val` is represented in little-endian format.
 #[inline]
-pub(crate) fn get_bit(val: usize, bit_index: usize) -> bool {
+pub(crate) fn get_bit(
+    val: usize,
+    bit_index: usize,
+) -> bool {
     ((val.to_le() >> bit_index) & 1) == 1
 }
 
diff --git a/rust/catalyst-voting/src/vote_protocol/tally/mod.rs b/rust/catalyst-voting/src/vote_protocol/tally/mod.rs
index 6613d6de757..02490307fa3 100644
--- a/rust/catalyst-voting/src/vote_protocol/tally/mod.rs
+++ b/rust/catalyst-voting/src/vote_protocol/tally/mod.rs
@@ -54,7 +54,9 @@ impl DecryptionTallySetup {
 ///   - Invalid encrypted vote at index `i`. Does not have a ciphertext for the voting
 ///     option `voting_option`.
 pub fn tally(
-    voting_option: usize, votes: &[EncryptedVote], voting_powers: &[u64],
+    voting_option: usize,
+    votes: &[EncryptedVote],
+    voting_powers: &[u64],
 ) -> anyhow::Result<EncryptedTally> {
     ensure!(
         votes.len() == voting_powers.len(),
@@ -97,7 +99,9 @@ pub fn tally(
 ///     tally result.
 #[allow(clippy::module_name_repetitions)]
 pub fn decrypt_tally(
-    tally_result: &EncryptedTally, secret_key: &ElectionSecretKey, setup: &DecryptionTallySetup,
+    tally_result: &EncryptedTally,
+    secret_key: &ElectionSecretKey,
+    setup: &DecryptionTallySetup,
 ) -> anyhow::Result<u64> {
     let ge = decrypt(&tally_result.0, &secret_key.0);
 
diff --git a/rust/catalyst-voting/src/vote_protocol/tally/proof.rs b/rust/catalyst-voting/src/vote_protocol/tally/proof.rs
index fbc8a16f303..fe17fe5c312 100644
--- a/rust/catalyst-voting/src/vote_protocol/tally/proof.rs
+++ b/rust/catalyst-voting/src/vote_protocol/tally/proof.rs
@@ -22,7 +22,9 @@ pub struct TallyProof(DleqProof);
 /// More detailed described [here](https://input-output-hk.github.io/catalyst-libs/architecture/08_concepts/catalyst_voting/crypto/#tally-proof)
 #[allow(clippy::module_name_repetitions)]
 pub fn generate_tally_proof<R: CryptoRngCore>(
-    encrypted_tally: &EncryptedTally, secret_key: &ElectionSecretKey, rng: &mut R,
+    encrypted_tally: &EncryptedTally,
+    secret_key: &ElectionSecretKey,
+    rng: &mut R,
 ) -> TallyProof {
     let randomness = Scalar::random(rng);
     let e1 = encrypted_tally.0.first();
@@ -44,7 +46,8 @@ pub fn generate_tally_proof<R: CryptoRngCore>(
 /// More detailed described [here](https://input-output-hk.github.io/catalyst-libs/architecture/08_concepts/catalyst_voting/crypto/#tally-proof)
 #[allow(clippy::module_name_repetitions)]
 pub fn generate_tally_proof_with_default_rng(
-    encrypted_tally: &EncryptedTally, secret_key: &ElectionSecretKey,
+    encrypted_tally: &EncryptedTally,
+    secret_key: &ElectionSecretKey,
 ) -> TallyProof {
     generate_tally_proof(encrypted_tally, secret_key, &mut default_rng())
 }
@@ -54,7 +57,9 @@ pub fn generate_tally_proof_with_default_rng(
 #[must_use]
 #[allow(clippy::module_name_repetitions)]
 pub fn verify_tally_proof(
-    encrypted_tally: &EncryptedTally, tally: u64, public_key: &ElectionPublicKey,
+    encrypted_tally: &EncryptedTally,
+    tally: u64,
+    public_key: &ElectionPublicKey,
     proof: &TallyProof,
 ) -> bool {
     let tally = Scalar::from(tally);
diff --git a/rust/catalyst-voting/src/vote_protocol/voter/decoding.rs b/rust/catalyst-voting/src/vote_protocol/voter/decoding.rs
index 8924d52513d..c746a140545 100644
--- a/rust/catalyst-voting/src/vote_protocol/voter/decoding.rs
+++ b/rust/catalyst-voting/src/vote_protocol/voter/decoding.rs
@@ -21,7 +21,10 @@ impl EncryptedVote {
     ///
     /// # Errors
     ///   - Cannot decode ciphertext.
-    pub fn from_bytes<R: Read>(reader: &mut R, size: usize) -> anyhow::Result<Self> {
+    pub fn from_bytes<R: Read>(
+        reader: &mut R,
+        size: usize,
+    ) -> anyhow::Result<Self> {
         let ciphertexts = (0..size)
             .map(|i| {
                 let bytes = read_array(reader)?;
@@ -66,7 +69,10 @@ impl VoterProof {
     ///   - Cannot decode ciphertext value.
     ///   - Cannot decode response randomness value.
     ///   - Cannot decode scalar value.
-    pub fn from_bytes<R: Read>(reader: &mut R, len: usize) -> anyhow::Result<Self> {
+    pub fn from_bytes<R: Read>(
+        reader: &mut R,
+        len: usize,
+    ) -> anyhow::Result<Self> {
         UnitVectorProof::from_bytes(reader, len).map(Self)
     }
 
@@ -87,7 +93,8 @@ mod tests {
 
     #[proptest]
     fn encrypted_vote_to_bytes_from_bytes_test(
-        #[strategy(0..5usize)] _size: usize, #[any(#_size)] vote1: EncryptedVote,
+        #[strategy(0..5usize)] _size: usize,
+        #[any(#_size)] vote1: EncryptedVote,
     ) {
         let bytes = vote1.to_bytes();
         assert_eq!(bytes.len(), vote1.bytes_size());
diff --git a/rust/catalyst-voting/src/vote_protocol/voter/mod.rs b/rust/catalyst-voting/src/vote_protocol/voter/mod.rs
index 6277dbd3641..ebfc5778755 100644
--- a/rust/catalyst-voting/src/vote_protocol/voter/mod.rs
+++ b/rust/catalyst-voting/src/vote_protocol/voter/mod.rs
@@ -36,14 +36,20 @@ pub struct EncryptionRandomness(Vec<Scalar>);
 
 impl EncryptionRandomness {
     /// Randomly generate the `EncryptionRandomness`.
-    fn random<R: CryptoRngCore>(rng: &mut R, voting_options: usize) -> Self {
+    fn random<R: CryptoRngCore>(
+        rng: &mut R,
+        voting_options: usize,
+    ) -> Self {
         Self((0..voting_options).map(|_| Scalar::random(rng)).collect())
     }
 }
 
 impl EncryptedVote {
     /// Get the ciphertext to the corresponding `voting_option`.
-    pub(crate) fn get_ciphertext_for_choice(&self, voting_option: usize) -> Option<&Ciphertext> {
+    pub(crate) fn get_ciphertext_for_choice(
+        &self,
+        voting_option: usize,
+    ) -> Option<&Ciphertext> {
         self.0.get(voting_option)
     }
 }
@@ -55,7 +61,10 @@ impl Vote {
     /// # Errors
     ///   - Invalid voting choice, the value of `choice`, should be less than the number
     ///     of `voting_options`.
-    pub fn new(choice: usize, voting_options: usize) -> anyhow::Result<Vote> {
+    pub fn new(
+        choice: usize,
+        voting_options: usize,
+    ) -> anyhow::Result<Vote> {
         ensure!(choice < voting_options,"Invalid voting choice, the value of choice: {choice}, should be less than the number of voting options: {voting_options}." );
 
         Ok(Vote {
@@ -91,7 +100,9 @@ impl Vote {
 ///   - `EncryptedVoteError`
 #[must_use]
 pub fn encrypt_vote<R: CryptoRngCore>(
-    vote: &Vote, public_key: &ElectionPublicKey, rng: &mut R,
+    vote: &Vote,
+    public_key: &ElectionPublicKey,
+    rng: &mut R,
 ) -> (EncryptedVote, EncryptionRandomness) {
     let randomness = EncryptionRandomness::random(rng, vote.voting_options);
 
@@ -109,7 +120,8 @@ pub fn encrypt_vote<R: CryptoRngCore>(
 /// More detailed described [here](https://input-output-hk.github.io/catalyst-libs/architecture/08_concepts/catalyst_voting/crypto/#vote-encryption)
 #[must_use]
 pub fn encrypt_vote_with_default_rng(
-    vote: &Vote, public_key: &ElectionPublicKey,
+    vote: &Vote,
+    public_key: &ElectionPublicKey,
 ) -> (EncryptedVote, EncryptionRandomness) {
     encrypt_vote(vote, public_key, &mut default_rng())
 }
@@ -121,7 +133,10 @@ pub fn encrypt_vote_with_default_rng(
 ///
 /// # Errors
 ///   - Invalid encrypted vote, not a valid unit vector.
-pub fn decrypt_vote(vote: &EncryptedVote, secret_key: &ElectionSecretKey) -> anyhow::Result<Vote> {
+pub fn decrypt_vote(
+    vote: &EncryptedVote,
+    secret_key: &ElectionSecretKey,
+) -> anyhow::Result<Vote> {
     // Assuming that the provided encrypted vote is a correctly encoded unit vector,
     // the maximum log value is `1`.
     let setup = BabyStepGiantStep::new(1, None)?;
diff --git a/rust/catalyst-voting/src/vote_protocol/voter/proof.rs b/rust/catalyst-voting/src/vote_protocol/voter/proof.rs
index 2c68a7f3ff1..0635d62d1d4 100644
--- a/rust/catalyst-voting/src/vote_protocol/voter/proof.rs
+++ b/rust/catalyst-voting/src/vote_protocol/voter/proof.rs
@@ -52,8 +52,12 @@ impl VoterProofCommitment {
 ///     `randomness` must be equal with each other.
 #[allow(clippy::module_name_repetitions)]
 pub fn generate_voter_proof<R: CryptoRngCore>(
-    vote: &Vote, encrypted_vote: EncryptedVote, randomness: EncryptionRandomness,
-    public_key: &ElectionPublicKey, commitment: &VoterProofCommitment, rng: &mut R,
+    vote: &Vote,
+    encrypted_vote: EncryptedVote,
+    randomness: EncryptionRandomness,
+    public_key: &ElectionPublicKey,
+    commitment: &VoterProofCommitment,
+    rng: &mut R,
 ) -> anyhow::Result<VoterProof> {
     ensure!(
         vote.voting_options == encrypted_vote.0.len() && vote.voting_options == randomness.0.len(),
@@ -83,8 +87,11 @@ pub fn generate_voter_proof<R: CryptoRngCore>(
 ///     `randomness` must be equal with each other.
 #[allow(clippy::module_name_repetitions)]
 pub fn generate_voter_proof_with_default_rng(
-    vote: &Vote, encrypted_vote: EncryptedVote, randomness: EncryptionRandomness,
-    public_key: &ElectionPublicKey, commitment: &VoterProofCommitment,
+    vote: &Vote,
+    encrypted_vote: EncryptedVote,
+    randomness: EncryptionRandomness,
+    public_key: &ElectionPublicKey,
+    commitment: &VoterProofCommitment,
 ) -> anyhow::Result<VoterProof> {
     generate_voter_proof(
         vote,
@@ -101,8 +108,10 @@ pub fn generate_voter_proof_with_default_rng(
 #[must_use]
 #[allow(clippy::module_name_repetitions)]
 pub fn verify_voter_proof(
-    encrypted_vote: EncryptedVote, public_key: &ElectionPublicKey,
-    commitment: &VoterProofCommitment, proof: &VoterProof,
+    encrypted_vote: EncryptedVote,
+    public_key: &ElectionPublicKey,
+    commitment: &VoterProofCommitment,
+    proof: &VoterProof,
 ) -> bool {
     verify_unit_vector_proof(&proof.0, encrypted_vote.0, &public_key.0, &commitment.0)
 }
diff --git a/rust/cbork-abnf-parser/tests/testsuite/common/mod.rs b/rust/cbork-abnf-parser/tests/testsuite/common/mod.rs
index b86d16f9722..4c7a9584ef5 100644
--- a/rust/cbork-abnf-parser/tests/testsuite/common/mod.rs
+++ b/rust/cbork-abnf-parser/tests/testsuite/common/mod.rs
@@ -4,7 +4,11 @@ use cbork_abnf_parser::{
 };
 
 /// # Panics
-pub(crate) fn check_tests_rule(rule_type: Rule, passes: &[&str], fails: &[&str]) {
+pub(crate) fn check_tests_rule(
+    rule_type: Rule,
+    passes: &[&str],
+    fails: &[&str],
+) {
     for test in passes {
         let parse = ABNFTestParser::parse(rule_type, test);
         assert!(parse.is_ok());
diff --git a/rust/cbork-cddl-parser/src/lib.rs b/rust/cbork-cddl-parser/src/lib.rs
index 8d8d163c2a4..618e351b418 100644
--- a/rust/cbork-cddl-parser/src/lib.rs
+++ b/rust/cbork-cddl-parser/src/lib.rs
@@ -20,7 +20,10 @@ pub enum Extension {
 /// This function may return an error in the following cases:
 ///
 /// - If there is an issue with parsing the CDDL input.
-pub fn validate_cddl(input: &mut String, extension: &Extension) -> anyhow::Result<()> {
+pub fn validate_cddl(
+    input: &mut String,
+    extension: &Extension,
+) -> anyhow::Result<()> {
     let ast = parser::parse_cddl(input, extension)?;
     let _ast = preprocessor::process_ast(ast)?;
     Ok(())
diff --git a/rust/cbork-cddl-parser/src/parser.rs b/rust/cbork-cddl-parser/src/parser.rs
index ae4b16ed2bf..24c607532f5 100644
--- a/rust/cbork-cddl-parser/src/parser.rs
+++ b/rust/cbork-cddl-parser/src/parser.rs
@@ -66,7 +66,8 @@ pub(crate) enum Ast<'a> {
 ///
 /// - If there is an issue with parsing the CDDL input.
 pub(crate) fn parse_cddl<'a>(
-    input: &'a mut String, extension: &Extension,
+    input: &'a mut String,
+    extension: &Extension,
 ) -> anyhow::Result<Ast<'a>> {
     input.push_str("\n\n");
     input.push_str(POSTLUDE);
diff --git a/rust/cbork-cddl-parser/src/preprocessor.rs b/rust/cbork-cddl-parser/src/preprocessor.rs
index b20cc849de6..3aa2f828e90 100644
--- a/rust/cbork-cddl-parser/src/preprocessor.rs
+++ b/rust/cbork-cddl-parser/src/preprocessor.rs
@@ -29,7 +29,9 @@ pub(crate) fn process_ast(ast: Ast) -> anyhow::Result<Ast> {
 
 /// Process the root rule of the AST and filter out all non `expected_rule` rules.
 fn process_root_and_filter<R: RuleType>(
-    ast: Vec<Pair<'_, R>>, root_rule: R, expected_rule: R,
+    ast: Vec<Pair<'_, R>>,
+    root_rule: R,
+    expected_rule: R,
 ) -> anyhow::Result<Vec<Pair<'_, R>>> {
     let mut ast_iter = ast.into_iter();
     let ast_root = ast_iter.next().ok_or(anyhow!("Empty AST."))?;
diff --git a/rust/cbork-cddl-parser/tests/common/mod.rs b/rust/cbork-cddl-parser/tests/common/mod.rs
index 768c246916f..e0926d9bff4 100644
--- a/rust/cbork-cddl-parser/tests/common/mod.rs
+++ b/rust/cbork-cddl-parser/tests/common/mod.rs
@@ -19,7 +19,9 @@ pub struct CDDLTestParser;
 
 /// # Panics
 pub(crate) fn check_tests_rule(
-    rule_type: Rule, passes: &[impl AsRef<str>], fails: &[impl AsRef<str>],
+    rule_type: Rule,
+    passes: &[impl AsRef<str>],
+    fails: &[impl AsRef<str>],
 ) {
     for test in passes {
         let parse = CDDLTestParser::parse(rule_type, test.as_ref());
diff --git a/rust/cbork-utils/src/decode_helper.rs b/rust/cbork-utils/src/decode_helper.rs
index 1a8ab480f1e..75c0235e975 100644
--- a/rust/cbork-utils/src/decode_helper.rs
+++ b/rust/cbork-utils/src/decode_helper.rs
@@ -8,9 +8,13 @@ use minicbor::{data::Tag, decode, Decoder};
 ///
 /// Error if the decoding fails.
 pub fn decode_helper<'a, T, C>(
-    d: &mut Decoder<'a>, from: &str, context: &mut C,
+    d: &mut Decoder<'a>,
+    from: &str,
+    context: &mut C,
 ) -> Result<T, decode::Error>
-where T: minicbor::Decode<'a, C> {
+where
+    T: minicbor::Decode<'a, C>,
+{
     T::decode(d, context).map_err(|e| {
         decode::Error::message(format!(
             "Failed to decode {:?} in {from}: {e}",
@@ -24,7 +28,10 @@ where T: minicbor::Decode<'a, C> {
 /// # Errors
 ///
 /// Error if the decoding fails.
-pub fn decode_bytes(d: &mut Decoder, from: &str) -> Result<Vec<u8>, decode::Error> {
+pub fn decode_bytes(
+    d: &mut Decoder,
+    from: &str,
+) -> Result<Vec<u8>, decode::Error> {
     d.bytes().map(<[u8]>::to_vec).map_err(|e| {
         decode::Error::message(format!(
             "Failed to decode bytes in {from}:
@@ -38,7 +45,10 @@ pub fn decode_bytes(d: &mut Decoder, from: &str) -> Result<Vec<u8>, decode::Erro
 /// # Errors
 ///
 /// Error if the decoding fails.
-pub fn decode_array_len(d: &mut Decoder, from: &str) -> Result<u64, decode::Error> {
+pub fn decode_array_len(
+    d: &mut Decoder,
+    from: &str,
+) -> Result<u64, decode::Error> {
     d.array()
         .map_err(|e| {
             decode::Error::message(format!(
@@ -56,7 +66,10 @@ pub fn decode_array_len(d: &mut Decoder, from: &str) -> Result<u64, decode::Erro
 /// # Errors
 ///
 /// Error if the decoding fails.
-pub fn decode_map_len(d: &mut Decoder, from: &str) -> Result<u64, decode::Error> {
+pub fn decode_map_len(
+    d: &mut Decoder,
+    from: &str,
+) -> Result<u64, decode::Error> {
     d.map()
         .map_err(|e| decode::Error::message(format!("Failed to decode map in {from}: {e}")))?
         .ok_or(decode::Error::message(format!(
@@ -69,7 +82,10 @@ pub fn decode_map_len(d: &mut Decoder, from: &str) -> Result<u64, decode::Error>
 /// # Errors
 ///
 /// Error if the decoding fails.
-pub fn decode_tag(d: &mut Decoder, from: &str) -> Result<Tag, decode::Error> {
+pub fn decode_tag(
+    d: &mut Decoder,
+    from: &str,
+) -> Result<Tag, decode::Error> {
     d.tag()
         .map_err(|e| decode::Error::message(format!("Failed to decode tag in {from}: {e}")))
 }
@@ -79,7 +95,10 @@ pub fn decode_tag(d: &mut Decoder, from: &str) -> Result<Tag, decode::Error> {
 /// # Errors
 ///
 /// Error if the decoding fails.
-pub fn decode_any<'d>(d: &mut Decoder<'d>, from: &str) -> Result<&'d [u8], decode::Error> {
+pub fn decode_any<'d>(
+    d: &mut Decoder<'d>,
+    from: &str,
+) -> Result<&'d [u8], decode::Error> {
     let start = d.position();
     d.skip()?;
     let end = d.position();
diff --git a/rust/deny.toml b/rust/deny.toml
index d69e5b55657..e2c3708be92 100644
--- a/rust/deny.toml
+++ b/rust/deny.toml
@@ -16,7 +16,10 @@ targets = [
 
 [advisories]
 version = 2
-ignore = []
+ignore = [
+    "RUSTSEC-2025-0067",
+    "RUSTSEC-2025-0068",
+]
 
 [bans]
 multiple-versions = "warn"
@@ -126,4 +129,4 @@ license-files = [{ path = "LICENSE", hash = 0xbd0eed23 }]
 #[[licenses.clarify]]
 #crate = "rustls-webpki"
 #expression = "ISC"
-#license-files = [{ path = "LICENSE", hash = 0x001c7e6c }]
+#license-files = [{ path = "LICENSE", hash = 0x001c7e6c }]
\ No newline at end of file
diff --git a/rust/hermes-ipfs/examples/add-file-with-pinning.rs b/rust/hermes-ipfs/examples/add-file-with-pinning.rs
index 517502326d0..87b189a9ea4 100644
--- a/rust/hermes-ipfs/examples/add-file-with-pinning.rs
+++ b/rust/hermes-ipfs/examples/add-file-with-pinning.rs
@@ -3,7 +3,10 @@
 use hermes_ipfs::{Cid, HermesIpfs};
 
 /// Print helper
-async fn print_cid_pinned(hermes_ipfs: &HermesIpfs, cid: &Cid) -> anyhow::Result<()> {
+async fn print_cid_pinned(
+    hermes_ipfs: &HermesIpfs,
+    cid: &Cid,
+) -> anyhow::Result<()> {
     let is_pinned = hermes_ipfs.is_pinned(cid).await?;
     println!("* Is CID pinned?: {is_pinned:?}");
     Ok(())
diff --git a/rust/hermes-ipfs/examples/provide-content-dht.rs b/rust/hermes-ipfs/examples/provide-content-dht.rs
index 63cf9747526..3239313c30e 100644
--- a/rust/hermes-ipfs/examples/provide-content-dht.rs
+++ b/rust/hermes-ipfs/examples/provide-content-dht.rs
@@ -5,7 +5,7 @@ use hermes_ipfs::{HermesIpfs, IpfsPath};
 
 /// Connect Node A, upload file and provide CID by adding to DHT
 async fn connect_node_a_upload_and_provide(
-    file_content: Vec<u8>,
+    file_content: Vec<u8>
 ) -> anyhow::Result<(HermesIpfs, IpfsPath)> {
     let hermes_ipfs = HermesIpfs::start().await?;
     println!("***************************************");
diff --git a/rust/hermes-ipfs/examples/pubsub.rs b/rust/hermes-ipfs/examples/pubsub.rs
index 58a8253387b..29d9e67c918 100644
--- a/rust/hermes-ipfs/examples/pubsub.rs
+++ b/rust/hermes-ipfs/examples/pubsub.rs
@@ -156,7 +156,10 @@ impl PeerLine {
 }
 
 impl std::fmt::Display for PeerLine {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
         write!(f, "NODE {self:?}")
     }
 }
diff --git a/rust/hermes-ipfs/src/lib.rs b/rust/hermes-ipfs/src/lib.rs
index 9bfbd78f8b2..442dddc5f23 100644
--- a/rust/hermes-ipfs/src/lib.rs
+++ b/rust/hermes-ipfs/src/lib.rs
@@ -68,7 +68,10 @@ impl IpfsBuilder {
     /// Set the storage type for the IPFS node to local disk.
     ///
     /// ## Parameters
-    pub fn set_disk_storage<T: Into<std::path::PathBuf>>(self, storage_path: T) -> Self {
+    pub fn set_disk_storage<T: Into<std::path::PathBuf>>(
+        self,
+        storage_path: T,
+    ) -> Self {
         Self(
             self.0
                 .set_repo(&rust_ipfs::repo::Repo::new_fs(storage_path.into())),
@@ -77,7 +80,10 @@ impl IpfsBuilder {
 
     #[must_use]
     /// Set the transport configuration for the IPFS node.
-    pub fn set_transport_configuration(self, transport: rust_ipfs::p2p::TransportConfig) -> Self {
+    pub fn set_transport_configuration(
+        self,
+        transport: rust_ipfs::p2p::TransportConfig,
+    ) -> Self {
         Self(self.0.set_transport_configuration(transport))
     }
 
@@ -148,7 +154,10 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns an error if the file fails to upload.
-    pub async fn add_ipfs_file(&self, ipfs_file: AddIpfsFile) -> anyhow::Result<IpfsPath> {
+    pub async fn add_ipfs_file(
+        &self,
+        ipfs_file: AddIpfsFile,
+    ) -> anyhow::Result<IpfsPath> {
         let ipfs_path = self.node.add_unixfs(ipfs_file).await?;
         Ok(ipfs_path)
     }
@@ -166,7 +175,10 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns an error if the file fails to download.
-    pub async fn get_ipfs_file(&self, ipfs_path: GetIpfsFile) -> anyhow::Result<Vec<u8>> {
+    pub async fn get_ipfs_file(
+        &self,
+        ipfs_path: GetIpfsFile,
+    ) -> anyhow::Result<Vec<u8>> {
         let stream_bytes = self.node.cat_unixfs(ipfs_path).await?;
         Ok(stream_bytes.to_vec())
     }
@@ -180,7 +192,10 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns an error if pinning fails.
-    pub async fn insert_pin(&self, cid: &Cid) -> anyhow::Result<()> {
+    pub async fn insert_pin(
+        &self,
+        cid: &Cid,
+    ) -> anyhow::Result<()> {
         self.node.insert_pin(cid).await
     }
 
@@ -205,7 +220,10 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns an error if checking pin fails.
-    pub async fn is_pinned(&self, cid: &Cid) -> anyhow::Result<bool> {
+    pub async fn is_pinned(
+        &self,
+        cid: &Cid,
+    ) -> anyhow::Result<bool> {
         self.node.is_pinned(cid).await
     }
 
@@ -237,7 +255,10 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns an error if removing pin fails.
-    pub async fn remove_pin(&self, cid: &Cid) -> anyhow::Result<()> {
+    pub async fn remove_pin(
+        &self,
+        cid: &Cid,
+    ) -> anyhow::Result<()> {
         self.node.remove_pin(cid).recursive().await
     }
 
@@ -256,7 +277,10 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns error if peer info cannot be retrieved.
-    pub async fn identity(&self, peer_id: Option<PeerId>) -> anyhow::Result<PeerId> {
+    pub async fn identity(
+        &self,
+        peer_id: Option<PeerId>,
+    ) -> anyhow::Result<PeerId> {
         self.node.identity(peer_id).await.map(|p| p.peer_id)
     }
 
@@ -270,7 +294,11 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns error if unable to add peer.
-    pub async fn add_peer(&self, peer_id: PeerId, addr: Multiaddr) -> anyhow::Result<()> {
+    pub async fn add_peer(
+        &self,
+        peer_id: PeerId,
+        addr: Multiaddr,
+    ) -> anyhow::Result<()> {
         self.node.add_peer((peer_id, addr)).await
     }
 
@@ -300,7 +328,10 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns error if unable to set DHT mode
-    pub async fn dht_mode(&self, mode: DhtMode) -> anyhow::Result<()> {
+    pub async fn dht_mode(
+        &self,
+        mode: DhtMode,
+    ) -> anyhow::Result<()> {
         self.node.dht_mode(mode).await
     }
 
@@ -317,7 +348,10 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns error if unable to add DAG content.
-    pub async fn dag_put(&self, ipld: Ipld) -> anyhow::Result<Cid> {
+    pub async fn dag_put(
+        &self,
+        ipld: Ipld,
+    ) -> anyhow::Result<Cid> {
         self.node.put_dag(ipld).await
     }
 
@@ -334,7 +368,10 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns error if unable to get DAG content.
-    pub async fn dag_get<T: Into<IpfsPath>>(&self, path: T) -> Result<Ipld, ResolveError> {
+    pub async fn dag_get<T: Into<IpfsPath>>(
+        &self,
+        path: T,
+    ) -> Result<Ipld, ResolveError> {
         self.node.get_dag(path).await
     }
 
@@ -353,7 +390,9 @@ impl HermesIpfs {
     ///
     /// Returns error if unable to add content to DHT
     pub async fn dht_put(
-        &self, key: impl AsRef<[u8]>, value: impl Into<Vec<u8>>,
+        &self,
+        key: impl AsRef<[u8]>,
+        value: impl Into<Vec<u8>>,
     ) -> anyhow::Result<()> {
         self.node.dht_put(key, value, Quorum::One).await
     }
@@ -371,7 +410,10 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns error if unable to get content from DHT
-    pub async fn dht_get(&self, key: impl AsRef<[u8]>) -> anyhow::Result<Vec<u8>> {
+    pub async fn dht_get(
+        &self,
+        key: impl AsRef<[u8]>,
+    ) -> anyhow::Result<Vec<u8>> {
         let record_stream = self.node.dht_get(key).await?;
         pin_mut!(record_stream);
         let record = record_stream
@@ -394,7 +436,10 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns error if unable to add address to bootstrap nodes
-    pub async fn add_bootstrap(&self, address: Multiaddr) -> anyhow::Result<Multiaddr> {
+    pub async fn add_bootstrap(
+        &self,
+        address: Multiaddr,
+    ) -> anyhow::Result<Multiaddr> {
         self.node.add_bootstrap(address).await
     }
 
@@ -425,7 +470,8 @@ impl HermesIpfs {
     ///
     /// Returns error if unable to retrieve pubsub swarm events.
     pub async fn pubsub_events(
-        &self, topic: impl Into<Option<String>>,
+        &self,
+        topic: impl Into<Option<String>>,
     ) -> anyhow::Result<BoxStream<'static, PubsubEvent>> {
         self.node.pubsub_events(topic).await
     }
@@ -444,7 +490,8 @@ impl HermesIpfs {
     ///
     /// Returns error if unable to subscribe to pubsub topic.
     pub async fn pubsub_subscribe(
-        &self, topic: impl Into<String>,
+        &self,
+        topic: impl Into<String>,
     ) -> anyhow::Result<SubscriptionStream> {
         self.node.pubsub_subscribe(topic).await
     }
@@ -462,7 +509,10 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns error if unable to unsubscribe from pubsub topic.
-    pub async fn pubsub_unsubscribe(&self, topic: impl Into<String>) -> anyhow::Result<bool> {
+    pub async fn pubsub_unsubscribe(
+        &self,
+        topic: impl Into<String>,
+    ) -> anyhow::Result<bool> {
         self.node.pubsub_unsubscribe(topic).await
     }
 
@@ -481,7 +531,9 @@ impl HermesIpfs {
     ///
     /// Returns error if unable to publish to a pubsub topic.
     pub async fn pubsub_publish(
-        &self, topic: impl Into<String>, message: Vec<u8>,
+        &self,
+        topic: impl Into<String>,
+        message: Vec<u8>,
     ) -> anyhow::Result<MessageId> {
         self.node
             .pubsub_publish(topic, message)
@@ -502,7 +554,10 @@ impl HermesIpfs {
     /// ## Errors
     ///
     /// Returns error if unable to ban peer.
-    pub async fn ban_peer(&self, peer: PeerId) -> anyhow::Result<()> {
+    pub async fn ban_peer(
+        &self,
+        peer: PeerId,
+    ) -> anyhow::Result<()> {
         self.node.ban_peer(peer).await
     }
 }
@@ -594,7 +649,8 @@ impl FromStr for GetIpfsFile {
 
 /// Handle stream of messages from the IPFS pubsub topic
 pub fn subscription_stream_task(
-    stream: SubscriptionStream, handler: fn(PubsubMessage),
+    stream: SubscriptionStream,
+    handler: fn(PubsubMessage),
 ) -> tokio::task::JoinHandle<()> {
     tokio::spawn(async move {
         pin_mut!(stream);
diff --git a/rust/immutable-ledger/src/serialize.rs b/rust/immutable-ledger/src/serialize.rs
index c385fde9cd1..d8640d2bc4c 100644
--- a/rust/immutable-ledger/src/serialize.rs
+++ b/rust/immutable-ledger/src/serialize.rs
@@ -92,7 +92,9 @@ impl Block {
     /// New block
     #[must_use]
     pub fn new(
-        block_header: BlockHeader, block_data: BlockData, validator_sigs: Signatures,
+        block_header: BlockHeader,
+        block_data: BlockData,
+        validator_sigs: Signatures,
     ) -> Self {
         Self {
             block_header,
@@ -137,7 +139,7 @@ impl Block {
     ///
     /// Returns an error if decoding fails.
     pub fn from_bytes(
-        encoded_block: &[u8],
+        encoded_block: &[u8]
     ) -> anyhow::Result<(BlockHeader, BlockData, Signatures)> {
         // Decoded block hdr
         let (block_hdr, block_hdr_size, _) = BlockHeader::from_bytes(encoded_block)?;
@@ -173,7 +175,10 @@ impl Block {
     /// ## Errors
     ///
     /// Returns an error if validation fails.
-    pub fn validate(&self, previous_block: Option<Block>) -> anyhow::Result<()> {
+    pub fn validate(
+        &self,
+        previous_block: Option<Block>,
+    ) -> anyhow::Result<()> {
         if let Some(previous_block) = previous_block {
             // Standard block
             let hashed_previous_block = match self.block_header.previous_block_hash.0 {
@@ -320,9 +325,14 @@ impl BlockHeader {
     #[must_use]
     #[allow(clippy::too_many_arguments)]
     pub fn new(
-        chain_id: Uuid, height: i64, block_time_stamp: i64,
-        previous_block_hash: (HashFunction, Vec<u8>), ledger_type: Uuid, purpose_id: Uuid,
-        validator: Vec<Kid>, metadata: Vec<u8>,
+        chain_id: Uuid,
+        height: i64,
+        block_time_stamp: i64,
+        previous_block_hash: (HashFunction, Vec<u8>),
+        ledger_type: Uuid,
+        purpose_id: Uuid,
+        validator: Vec<Kid>,
+        metadata: Vec<u8>,
     ) -> Self {
         Self {
             chain_id,
@@ -396,7 +406,7 @@ impl BlockHeader {
     ///
     /// Returns an error decoding fails
     pub fn from_bytes(
-        block: &[u8],
+        block: &[u8]
     ) -> anyhow::Result<(
         BlockHeader,
         BlockHeaderSize,
@@ -510,7 +520,10 @@ impl GenesisPreviousHash {
     /// Create previous block id
     #[must_use]
     pub fn new(
-        chain_id: Uuid, block_time_stamp: i64, ledger_type: Uuid, purpose_id: Uuid,
+        chain_id: Uuid,
+        block_time_stamp: i64,
+        ledger_type: Uuid,
+        purpose_id: Uuid,
         validator: Vec<Kid>,
     ) -> Self {
         Self {
@@ -526,7 +539,10 @@ impl GenesisPreviousHash {
     /// ## Errors
     ///
     /// Returns an error encoding fails
-    pub fn to_bytes(&self, hasher: &HashFunction) -> anyhow::Result<Vec<u8>> {
+    pub fn to_bytes(
+        &self,
+        hasher: &HashFunction,
+    ) -> anyhow::Result<Vec<u8>> {
         /// # of elements in genesis to prev hash
         const GENESIS_TO_PREV_HASH_SIZE: u64 = 5;
 
@@ -569,7 +585,10 @@ impl GenesisPreviousHash {
     /// ## Errors
     ///
     /// Returns an error if hashing fails
-    pub fn hash(&self, hasher: &HashFunction) -> anyhow::Result<Vec<u8>> {
+    pub fn hash(
+        &self,
+        hasher: &HashFunction,
+    ) -> anyhow::Result<Vec<u8>> {
         let encoding = self.to_bytes(hasher)?;
 
         // get hash of genesis_to_prev_hash
@@ -598,7 +617,10 @@ mod tests {
 
     #[proptest]
     fn block_header_encoding(
-        prev_block_hash: Vec<u8>, metadata: Vec<u8>, block_height: i64, block_timestamp: i64,
+        prev_block_hash: Vec<u8>,
+        metadata: Vec<u8>,
+        block_height: i64,
+        block_timestamp: i64,
     ) {
         let kid_a: [u8; 16] = hex::decode("00112233445566778899aabbccddeeff")
             .unwrap()
@@ -642,7 +664,10 @@ mod tests {
 
     #[proptest]
     fn block_encoding(
-        prev_block_hash: Vec<u8>, metadata: Vec<u8>, block_height: i64, block_timestamp: i64,
+        prev_block_hash: Vec<u8>,
+        metadata: Vec<u8>,
+        block_height: i64,
+        block_timestamp: i64,
         block_data_bytes: Vec<u8>,
     ) {
         // validators
@@ -733,7 +758,11 @@ mod tests {
 
     #[proptest]
     #[allow(clippy::zero_prefixed_literal)]
-    fn validate_block_test(prev_block_hash: Vec<u8>, metadata: Vec<u8>, block_data_bytes: Vec<u8>) {
+    fn validate_block_test(
+        prev_block_hash: Vec<u8>,
+        metadata: Vec<u8>,
+        block_data_bytes: Vec<u8>,
+    ) {
         // PREVIOUS BLOCK
         //
         //
@@ -818,7 +847,9 @@ mod tests {
 
     #[proptest]
     fn genesis_encoding_and_validation(
-        invalid_prev_block_hash: Vec<u8>, metadata: Vec<u8>, block_data_bytes: Vec<u8>,
+        invalid_prev_block_hash: Vec<u8>,
+        metadata: Vec<u8>,
+        block_data_bytes: Vec<u8>,
     ) {
         // validators
         let validator_secret_key_bytes: [u8; SECRET_KEY_LENGTH] = [
diff --git a/rust/rbac-registration/src/cardano/cip509/cip509.rs b/rust/rbac-registration/src/cardano/cip509/cip509.rs
index a7d497e1a8f..6f354d9dd7b 100644
--- a/rust/rbac-registration/src/cardano/cip509/cip509.rs
+++ b/rust/rbac-registration/src/cardano/cip509/cip509.rs
@@ -121,7 +121,9 @@ impl Cip509 {
     /// An error is only returned if the data is completely corrupted. In all other cases
     /// the `Cip509` structure contains fully or partially decoded data.
     pub fn new(
-        block: &MultiEraBlock, index: TxnIndex, track_payment_addresses: &[ShelleyAddress],
+        block: &MultiEraBlock,
+        index: TxnIndex,
+        track_payment_addresses: &[ShelleyAddress],
     ) -> Result<Option<Self>, anyhow::Error> {
         // Find the transaction and decode the relevant data.
         let txns = block.txs();
@@ -189,7 +191,8 @@ impl Cip509 {
 
     /// Returns a list of Cip509 instances from all the transactions of the given block.
     pub fn from_block(
-        block: &MultiEraBlock, track_payment_addresses: &[ShelleyAddress],
+        block: &MultiEraBlock,
+        track_payment_addresses: &[ShelleyAddress],
     ) -> Vec<Self> {
         let mut result = Vec::new();
 
@@ -223,7 +226,10 @@ impl Cip509 {
 
     /// Returns a role data for the given role if it is present.
     #[must_use]
-    pub fn role_data(&self, role: RoleId) -> Option<&RoleData> {
+    pub fn role_data(
+        &self,
+        role: RoleId,
+    ) -> Option<&RoleData> {
         self.metadata.as_ref().and_then(|m| m.role_data.get(&role))
     }
 
@@ -326,7 +332,10 @@ impl Cip509 {
 }
 
 impl Decode<'_, DecodeContext<'_, '_>> for Cip509 {
-    fn decode(d: &mut Decoder, decode_context: &mut DecodeContext) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut Decoder,
+        decode_context: &mut DecodeContext,
+    ) -> Result<Self, decode::Error> {
         let context = "Decoding Cip509";
 
         // It is ok to return error here because we were unable to decode anything, but everywhere
@@ -450,7 +459,9 @@ impl Decode<'_, DecodeContext<'_, '_>> for Cip509 {
 
 /// Records the payment history for the given set of addresses.
 fn payment_history(
-    txn: &conway::MintedTx, track_payment_addresses: &[ShelleyAddress], origin: &PointTxnIdx,
+    txn: &conway::MintedTx,
+    track_payment_addresses: &[ShelleyAddress],
+    origin: &PointTxnIdx,
     report: &ProblemReport,
 ) -> HashMap<ShelleyAddress, Vec<Payment>> {
     let hash = MultiEraTx::Conway(Box::new(Cow::Borrowed(txn))).hash();
@@ -501,7 +512,9 @@ fn payment_history(
 
 /// Decodes purpose.
 fn decode_purpose(
-    d: &mut Decoder, context: &str, report: &ProblemReport,
+    d: &mut Decoder,
+    context: &str,
+    report: &ProblemReport,
 ) -> Result<Option<UuidV4>, ()> {
     let bytes = match decode_bytes(d, "Cip509 purpose") {
         Ok(v) => v,
@@ -532,7 +545,9 @@ fn decode_purpose(
 
 /// Decodes input hash.
 fn decode_input_hash(
-    d: &mut Decoder, context: &str, report: &ProblemReport,
+    d: &mut Decoder,
+    context: &str,
+    report: &ProblemReport,
 ) -> Result<Option<TxInputHash>, ()> {
     let bytes = match decode_bytes(d, "Cip509 txn inputs hash") {
         Ok(v) => v,
@@ -561,7 +576,9 @@ fn decode_input_hash(
 
 /// Decodes previous transaction id.
 fn decode_previous_transaction_id(
-    d: &mut Decoder, context: &str, report: &ProblemReport,
+    d: &mut Decoder,
+    context: &str,
+    report: &ProblemReport,
 ) -> Result<Option<TransactionId>, ()> {
     let bytes = match decode_bytes(d, "Cip509 previous transaction id") {
         Ok(v) => v,
@@ -590,7 +607,9 @@ fn decode_previous_transaction_id(
 
 /// Decodes validation signature.
 fn decode_validation_signature(
-    d: &mut Decoder, context: &str, report: &ProblemReport,
+    d: &mut Decoder,
+    context: &str,
+    report: &ProblemReport,
 ) -> Result<Option<ValidationSignature>, ()> {
     let bytes = match decode_bytes(d, "Cip509 validation signature") {
         Ok(v) => v,
diff --git a/rust/rbac-registration/src/cardano/cip509/rbac/certs/c509.rs b/rust/rbac-registration/src/cardano/cip509/rbac/certs/c509.rs
index d16dfe1642d..ac916045807 100644
--- a/rust/rbac-registration/src/cardano/cip509/rbac/certs/c509.rs
+++ b/rust/rbac-registration/src/cardano/cip509/rbac/certs/c509.rs
@@ -23,7 +23,10 @@ pub enum C509Cert {
 }
 
 impl Decode<'_, ProblemReport> for C509Cert {
-    fn decode(d: &mut Decoder, _report: &mut ProblemReport) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut Decoder,
+        _report: &mut ProblemReport,
+    ) -> Result<Self, decode::Error> {
         match d.datatype()? {
             minicbor::data::Type::Tag => {
                 let tag = decode_tag(d, "C509Cert")?;
diff --git a/rust/rbac-registration/src/cardano/cip509/rbac/certs/c509_metadatum.rs b/rust/rbac-registration/src/cardano/cip509/rbac/certs/c509_metadatum.rs
index 7720867c7a3..58ca5d85f11 100644
--- a/rust/rbac-registration/src/cardano/cip509/rbac/certs/c509_metadatum.rs
+++ b/rust/rbac-registration/src/cardano/cip509/rbac/certs/c509_metadatum.rs
@@ -15,7 +15,10 @@ pub struct C509CertInMetadatumReference {
 }
 
 impl Decode<'_, ()> for C509CertInMetadatumReference {
-    fn decode(d: &mut Decoder, ctx: &mut ()) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut Decoder,
+        ctx: &mut (),
+    ) -> Result<Self, decode::Error> {
         let txn_output_field: u8 =
             decode_helper(d, "txn output field in C509CertInMetadatumReference", ctx)?;
         let txn_output_index: u64 =
diff --git a/rust/rbac-registration/src/cardano/cip509/rbac/certs/x509.rs b/rust/rbac-registration/src/cardano/cip509/rbac/certs/x509.rs
index 954eceed78b..be97976d2a4 100644
--- a/rust/rbac-registration/src/cardano/cip509/rbac/certs/x509.rs
+++ b/rust/rbac-registration/src/cardano/cip509/rbac/certs/x509.rs
@@ -21,7 +21,10 @@ pub enum X509DerCert {
 }
 
 impl Decode<'_, ProblemReport> for X509DerCert {
-    fn decode(d: &mut Decoder, _report: &mut ProblemReport) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut Decoder,
+        _report: &mut ProblemReport,
+    ) -> Result<Self, decode::Error> {
         match d.datatype()? {
             minicbor::data::Type::Tag => {
                 let tag = decode_tag(d, "X509DerCert")?;
diff --git a/rust/rbac-registration/src/cardano/cip509/rbac/metadata.rs b/rust/rbac-registration/src/cardano/cip509/rbac/metadata.rs
index 3359f1e5728..88f63d19117 100644
--- a/rust/rbac-registration/src/cardano/cip509/rbac/metadata.rs
+++ b/rust/rbac-registration/src/cardano/cip509/rbac/metadata.rs
@@ -77,7 +77,10 @@ pub enum Cip509RbacMetadataInt {
 }
 
 impl Decode<'_, DecodeContext<'_, '_>> for Cip509RbacMetadata {
-    fn decode(d: &mut Decoder, decode_context: &mut DecodeContext) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut Decoder,
+        decode_context: &mut DecodeContext,
+    ) -> Result<Self, decode::Error> {
         let context = "Decoding Cip509RbacMetadata";
 
         let map_len = decode_map_len(d, context)?;
@@ -186,9 +189,13 @@ impl Decode<'_, DecodeContext<'_, '_>> for Cip509RbacMetadata {
 
 /// Decodes an array of type T.
 fn decode_array<'b, T>(
-    d: &mut Decoder<'b>, context: &str, report: &mut ProblemReport,
+    d: &mut Decoder<'b>,
+    context: &str,
+    report: &mut ProblemReport,
 ) -> Option<Vec<T>>
-where T: Decode<'b, ProblemReport> {
+where
+    T: Decode<'b, ProblemReport>,
+{
     let len = match decode_array_len(d, context) {
         Ok(v) => v,
         Err(e) => {
@@ -218,7 +225,10 @@ where T: Decode<'b, ProblemReport> {
 }
 
 /// Decode an array of revocation list.
-fn decode_revocation_list(d: &mut Decoder, report: &ProblemReport) -> Option<Vec<CertKeyHash>> {
+fn decode_revocation_list(
+    d: &mut Decoder,
+    report: &ProblemReport,
+) -> Option<Vec<CertKeyHash>> {
     let context = "Cip509RbacMetadata revocation list";
     let len = match decode_array_len(d, context) {
         Ok(v) => v,
@@ -261,7 +271,11 @@ fn decode_revocation_list(d: &mut Decoder, report: &ProblemReport) -> Option<Vec
 }
 
 /// Adds report entries if duplicated roles are found.
-fn report_duplicated_roles(data: &[CborRoleData], context: &str, report: &ProblemReport) {
+fn report_duplicated_roles(
+    data: &[CborRoleData],
+    context: &str,
+    report: &ProblemReport,
+) {
     let mut roles = HashSet::new();
     for role in data {
         let Some(number) = role.number else {
@@ -275,7 +289,9 @@ fn report_duplicated_roles(data: &[CborRoleData], context: &str, report: &Proble
 
 /// Decodes and converts a role data.
 fn decode_role_data(
-    d: &mut Decoder, context: &str, decode_context: &mut DecodeContext,
+    d: &mut Decoder,
+    context: &str,
+    decode_context: &mut DecodeContext,
 ) -> Option<HashMap<RoleId, RoleData>> {
     let roles = decode_array(d, "Cip509RbacMetadata role set", decode_context.report)?;
     report_duplicated_roles(&roles, context, decode_context.report);
diff --git a/rust/rbac-registration/src/cardano/cip509/rbac/pub_key.rs b/rust/rbac-registration/src/cardano/cip509/rbac/pub_key.rs
index d5c7cf79e76..6f3c3f5f14e 100644
--- a/rust/rbac-registration/src/cardano/cip509/rbac/pub_key.rs
+++ b/rust/rbac-registration/src/cardano/cip509/rbac/pub_key.rs
@@ -20,7 +20,10 @@ pub enum SimplePublicKeyType {
 }
 
 impl Decode<'_, ProblemReport> for SimplePublicKeyType {
-    fn decode(d: &mut Decoder, _report: &mut ProblemReport) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut Decoder,
+        _report: &mut ProblemReport,
+    ) -> Result<Self, decode::Error> {
         match d.datatype()? {
             minicbor::data::Type::Tag => {
                 let tag = decode_tag(d, "SimplePublicKeyType")?;
diff --git a/rust/rbac-registration/src/cardano/cip509/rbac/role_data.rs b/rust/rbac-registration/src/cardano/cip509/rbac/role_data.rs
index 541e72e6365..87fed1d5a0c 100644
--- a/rust/rbac-registration/src/cardano/cip509/rbac/role_data.rs
+++ b/rust/rbac-registration/src/cardano/cip509/rbac/role_data.rs
@@ -51,7 +51,10 @@ pub enum RoleDataInt {
 }
 
 impl Decode<'_, ProblemReport> for CborRoleData {
-    fn decode(d: &mut Decoder, report: &mut ProblemReport) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut Decoder,
+        report: &mut ProblemReport,
+    ) -> Result<Self, decode::Error> {
         let context = "Decoding role data";
         let map_len = decode_map_len(d, "RoleData")?;
 
@@ -138,7 +141,9 @@ impl Decode<'_, ProblemReport> for CborRoleData {
 
 /// Decodes a signing key.
 fn decode_signing_key(
-    d: &mut Decoder, context: &str, report: &mut ProblemReport,
+    d: &mut Decoder,
+    context: &str,
+    report: &mut ProblemReport,
 ) -> Result<Option<KeyLocalRef>, ()> {
     if let Err(e) = decode_array_len(d, "RoleSigningKey") {
         report.other(&format!("{e:?}"), context);
@@ -159,7 +164,9 @@ fn decode_signing_key(
 
 /// Decodes an encryption key.
 fn decode_encryption_key(
-    d: &mut Decoder, context: &str, report: &mut ProblemReport,
+    d: &mut Decoder,
+    context: &str,
+    report: &mut ProblemReport,
 ) -> Result<Option<KeyLocalRef>, ()> {
     if let Err(e) = decode_array_len(d, "RoleEncryptionKey") {
         report.other(&format!("{e:?}"), context);
diff --git a/rust/rbac-registration/src/cardano/cip509/types/key_local_ref.rs b/rust/rbac-registration/src/cardano/cip509/types/key_local_ref.rs
index a05b0b10c1b..38bc11f0335 100644
--- a/rust/rbac-registration/src/cardano/cip509/types/key_local_ref.rs
+++ b/rust/rbac-registration/src/cardano/cip509/types/key_local_ref.rs
@@ -29,7 +29,10 @@ pub enum LocalRefInt {
 }
 
 impl Decode<'_, ProblemReport> for KeyLocalRef {
-    fn decode(d: &mut Decoder, report: &mut ProblemReport) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut Decoder,
+        report: &mut ProblemReport,
+    ) -> Result<Self, decode::Error> {
         let local_ref =
             LocalRefInt::from_repr(decode_helper(d, "LocalRef in KeyLocalRef", &mut ())?)
                 .ok_or(decode::Error::message("Invalid local reference"))?;
diff --git a/rust/rbac-registration/src/cardano/cip509/types/payment_history.rs b/rust/rbac-registration/src/cardano/cip509/types/payment_history.rs
index 8371bcc4248..d40c492b7fb 100644
--- a/rust/rbac-registration/src/cardano/cip509/types/payment_history.rs
+++ b/rust/rbac-registration/src/cardano/cip509/types/payment_history.rs
@@ -28,7 +28,10 @@ pub struct Payment {
 impl Payment {
     /// Create an instance of payment history.
     pub(crate) fn new(
-        point_tx_idx: PointTxnIdx, tx_hash: Hash<32>, output_index: u16, value: Value,
+        point_tx_idx: PointTxnIdx,
+        tx_hash: Hash<32>,
+        output_index: u16,
+        value: Value,
     ) -> Self {
         Payment {
             point_tx_idx,
diff --git a/rust/rbac-registration/src/cardano/cip509/types/point_data.rs b/rust/rbac-registration/src/cardano/cip509/types/point_data.rs
index 645d647141c..10780ce2679 100644
--- a/rust/rbac-registration/src/cardano/cip509/types/point_data.rs
+++ b/rust/rbac-registration/src/cardano/cip509/types/point_data.rs
@@ -16,7 +16,10 @@ pub struct PointData<T> {
 impl<T> PointData<T> {
     /// Creates an instance of point and transaction index with data.
     #[must_use]
-    pub fn new(point_txn_index: PointTxnIdx, data: T) -> Self {
+    pub fn new(
+        point_txn_index: PointTxnIdx,
+        data: T,
+    ) -> Self {
         Self {
             point_txn_index,
             data,
diff --git a/rust/rbac-registration/src/cardano/cip509/types/point_tx_idx.rs b/rust/rbac-registration/src/cardano/cip509/types/point_tx_idx.rs
index 86a1de59b67..f4c66fedfd0 100644
--- a/rust/rbac-registration/src/cardano/cip509/types/point_tx_idx.rs
+++ b/rust/rbac-registration/src/cardano/cip509/types/point_tx_idx.rs
@@ -14,13 +14,19 @@ pub struct PointTxnIdx {
 impl PointTxnIdx {
     /// Creates an instance of point and transaction index.
     #[must_use]
-    pub fn new(point: Point, txn_index: TxnIndex) -> Self {
+    pub fn new(
+        point: Point,
+        txn_index: TxnIndex,
+    ) -> Self {
         Self { point, txn_index }
     }
 
     /// Creates an instance of `PointTxnIdx` from the given block and index.
     #[must_use]
-    pub fn from_block(block: &MultiEraBlock, txn_index: TxnIndex) -> Self {
+    pub fn from_block(
+        block: &MultiEraBlock,
+        txn_index: TxnIndex,
+    ) -> Self {
         Self::new(block.point(), txn_index)
     }
 
diff --git a/rust/rbac-registration/src/cardano/cip509/types/role_data.rs b/rust/rbac-registration/src/cardano/cip509/types/role_data.rs
index 57816a0efcf..1337e25232e 100644
--- a/rust/rbac-registration/src/cardano/cip509/types/role_data.rs
+++ b/rust/rbac-registration/src/cardano/cip509/types/role_data.rs
@@ -32,7 +32,11 @@ pub struct RoleData {
 impl RoleData {
     /// Create an instance of role data.
     #[must_use]
-    pub fn new(data: CborRoleData, txn: &conway::MintedTx, report: &ProblemReport) -> Self {
+    pub fn new(
+        data: CborRoleData,
+        txn: &conway::MintedTx,
+        report: &ProblemReport,
+    ) -> Self {
         let payment_key = if data.number == Some(RoleId::Role0) && data.payment_key.is_none() {
             report.other(
                 "Missing payment key in role0",
@@ -80,19 +84,28 @@ impl RoleData {
     }
 
     /// Sets a new value for the signing key.
-    pub fn set_signing_key(&mut self, key: Option<KeyLocalRef>) {
+    pub fn set_signing_key(
+        &mut self,
+        key: Option<KeyLocalRef>,
+    ) {
         self.signing_key = key;
     }
 
     /// Sets a new value for the encryption key.
-    pub fn set_encryption_key(&mut self, key: Option<KeyLocalRef>) {
+    pub fn set_encryption_key(
+        &mut self,
+        key: Option<KeyLocalRef>,
+    ) {
         self.encryption_key = key;
     }
 }
 
 /// Converts the payment key from the form encoded in CBOR role data to `ShelleyAddress`.
 fn convert_payment_key(
-    index: Option<u16>, txn: &conway::MintedTx, context: &str, report: &ProblemReport,
+    index: Option<u16>,
+    txn: &conway::MintedTx,
+    context: &str,
+    report: &ProblemReport,
 ) -> Option<ShelleyAddress> {
     let index: usize = index?.into();
 
@@ -142,7 +155,10 @@ fn convert_payment_key(
 
 /// Helper function for validating payment output key.
 fn validate_payment_output(
-    output_address: &[u8], witness: &TxnWitness, context: &str, report: &ProblemReport,
+    output_address: &[u8],
+    witness: &TxnWitness,
+    context: &str,
+    report: &ProblemReport,
 ) {
     let Some(key) = extract_key_hash(output_address) else {
         report.other("Failed to extract payment key hash from address", context);
diff --git a/rust/rbac-registration/src/cardano/cip509/types/role_data_record.rs b/rust/rbac-registration/src/cardano/cip509/types/role_data_record.rs
index b7c70b55050..05feac55cb0 100644
--- a/rust/rbac-registration/src/cardano/cip509/types/role_data_record.rs
+++ b/rust/rbac-registration/src/cardano/cip509/types/role_data_record.rs
@@ -37,25 +37,39 @@ impl RoleDataRecord {
 
     /// Add a signing key data to the signing key list. The vector index is used to
     /// indicate the key rotation.
-    pub(crate) fn add_signing_key(&mut self, data: CertOrPk, point_tx_idx: &PointTxnIdx) {
+    pub(crate) fn add_signing_key(
+        &mut self,
+        data: CertOrPk,
+        point_tx_idx: &PointTxnIdx,
+    ) {
         self.signing_keys
             .push(PointData::new(point_tx_idx.clone(), data));
     }
 
     /// Add an encryption key data to the encryption key list. The vector index is used to
     /// indicate the key rotation.
-    pub(crate) fn add_encryption_key(&mut self, data: CertOrPk, point_tx_idx: &PointTxnIdx) {
+    pub(crate) fn add_encryption_key(
+        &mut self,
+        data: CertOrPk,
+        point_tx_idx: &PointTxnIdx,
+    ) {
         self.encryption_keys
             .push(PointData::new(point_tx_idx.clone(), data));
     }
 
     /// Add a payment key to the payment key list.
-    pub(crate) fn add_payment_key(&mut self, data: PointData<ShelleyAddress>) {
+    pub(crate) fn add_payment_key(
+        &mut self,
+        data: PointData<ShelleyAddress>,
+    ) {
         self.payment_keys.push(data);
     }
 
     /// Add extended data to the extended data list.
-    pub(crate) fn add_extended_data(&mut self, data: PointData<HashMap<u8, Vec<u8>>>) {
+    pub(crate) fn add_extended_data(
+        &mut self,
+        data: PointData<HashMap<u8, Vec<u8>>>,
+    ) {
         self.extended_data.push(data);
     }
 
@@ -87,7 +101,10 @@ impl RoleDataRecord {
     /// The first signing key is at rotation 0, the second at rotation 1, and so on.
     /// Returns `None` if the given key rotation does not exist.
     #[must_use]
-    pub fn signing_key_from_rotation(&self, rotation: &KeyRotation) -> Option<&CertOrPk> {
+    pub fn signing_key_from_rotation(
+        &self,
+        rotation: &KeyRotation,
+    ) -> Option<&CertOrPk> {
         rotation.get_key(&self.signing_keys).map(PointData::data)
     }
 
@@ -95,7 +112,10 @@ impl RoleDataRecord {
     /// The first encryption key is at rotation 0, the second at rotation 1, and so on.
     /// Returns `None` if the given key rotation does not exist.
     #[must_use]
-    pub fn encryption_key_from_rotation(&self, rotation: &KeyRotation) -> Option<&CertOrPk> {
+    pub fn encryption_key_from_rotation(
+        &self,
+        rotation: &KeyRotation,
+    ) -> Option<&CertOrPk> {
         rotation.get_key(&self.encryption_keys).map(PointData::data)
     }
 }
diff --git a/rust/rbac-registration/src/cardano/cip509/utils/cip134_uri_set.rs b/rust/rbac-registration/src/cardano/cip509/utils/cip134_uri_set.rs
index 69ed737db7e..5559954f316 100644
--- a/rust/rbac-registration/src/cardano/cip509/utils/cip134_uri_set.rs
+++ b/rust/rbac-registration/src/cardano/cip509/utils/cip134_uri_set.rs
@@ -46,7 +46,9 @@ impl Cip0134UriSet {
     /// Creates a new `Cip0134UriSet` instance from the given certificates.
     #[must_use]
     pub fn new(
-        x509_certs: &[X509DerCert], c509_certs: &[C509Cert], report: &ProblemReport,
+        x509_certs: &[X509DerCert],
+        c509_certs: &[C509Cert],
+        report: &ProblemReport,
     ) -> Self {
         let x_uris = extract_x509_uris(x509_certs, report);
         let c_uris = extract_c509_uris(c509_certs, report);
@@ -73,7 +75,10 @@ impl Cip0134UriSet {
 
     /// Returns a list of stake addresses by the given index.
     #[must_use]
-    pub fn stake_addresses(&self, index: usize) -> HashSet<StakeAddress> {
+    pub fn stake_addresses(
+        &self,
+        index: usize,
+    ) -> HashSet<StakeAddress> {
         let mut result = HashSet::new();
 
         if let Some(uris) = self.x_uris().get(&index) {
@@ -105,7 +110,10 @@ impl Cip0134UriSet {
     /// 2: [uri_4]
     /// ```
     #[must_use]
-    pub fn update(self, metadata: &Cip509RbacMetadata) -> Self {
+    pub fn update(
+        self,
+        metadata: &Cip509RbacMetadata,
+    ) -> Self {
         if self == metadata.certificate_uris {
             // Nothing to update.
             return self;
@@ -156,7 +164,10 @@ impl Cip0134UriSet {
 }
 
 /// Iterates over X509 certificates and extracts CIP-0134 URIs.
-fn extract_x509_uris(certificates: &[X509DerCert], report: &ProblemReport) -> UrisMap {
+fn extract_x509_uris(
+    certificates: &[X509DerCert],
+    report: &ProblemReport,
+) -> UrisMap {
     let mut result = UrisMap::new();
     let context = "Extracting URIs from X509 certificates in Cip509 metadata";
 
@@ -212,7 +223,10 @@ fn extract_x509_uris(certificates: &[X509DerCert], report: &ProblemReport) -> Ur
 }
 
 /// Iterates over C509 certificates and extracts CIP-0134 URIs.
-fn extract_c509_uris(certificates: &[C509Cert], report: &ProblemReport) -> UrisMap {
+fn extract_c509_uris(
+    certificates: &[C509Cert],
+    report: &ProblemReport,
+) -> UrisMap {
     let mut result = UrisMap::new();
     let context = "Extracting URIs from C509 certificates in Cip509 metadata";
 
diff --git a/rust/rbac-registration/src/cardano/cip509/utils/cip19.rs b/rust/rbac-registration/src/cardano/cip509/utils/cip19.rs
index b238f5d094d..1e15e3aac29 100644
--- a/rust/rbac-registration/src/cardano/cip509/utils/cip19.rs
+++ b/rust/rbac-registration/src/cardano/cip509/utils/cip19.rs
@@ -11,7 +11,9 @@ pub(crate) fn extract_key_hash(key: &[u8]) -> Option<VKeyHash> {
 
 /// Compare the given public key bytes with the transaction witness set.
 pub(crate) fn compare_key_hash(
-    pk_addrs: &[VKeyHash], witness: &TxnWitness, txn_idx: TxnIndex,
+    pk_addrs: &[VKeyHash],
+    witness: &TxnWitness,
+    txn_idx: TxnIndex,
 ) -> anyhow::Result<()> {
     if pk_addrs.is_empty() {
         bail!("No public key addresses provided");
diff --git a/rust/rbac-registration/src/cardano/cip509/utils/extract_key.rs b/rust/rbac-registration/src/cardano/cip509/utils/extract_key.rs
index 182129f125e..4cdca326cc8 100644
--- a/rust/rbac-registration/src/cardano/cip509/utils/extract_key.rs
+++ b/rust/rbac-registration/src/cardano/cip509/utils/extract_key.rs
@@ -45,7 +45,11 @@ pub enum Error {
 
 impl Error {
     /// Shortcut function to report `Self` into a [`ProblemReport`].
-    pub fn report_problem(&self, context: &str, report: &ProblemReport) {
+    pub fn report_problem(
+        &self,
+        context: &str,
+        report: &ProblemReport,
+    ) {
         match self {
             Error::UnsupportedSignatureAlgo { oid } => {
                 report.invalid_value(
diff --git a/rust/rbac-registration/src/cardano/cip509/validation.rs b/rust/rbac-registration/src/cardano/cip509/validation.rs
index b7dba58eb95..88c54ba7699 100644
--- a/rust/rbac-registration/src/cardano/cip509/validation.rs
+++ b/rust/rbac-registration/src/cardano/cip509/validation.rs
@@ -45,7 +45,9 @@ pub(crate) const URI: u8 = 134;
 
 /// Checks that hashing transactions inputs produces the value equal to the given one.
 pub fn validate_txn_inputs_hash(
-    hash: &TxInputHash, transaction: &conway::MintedTx, report: &ProblemReport,
+    hash: &TxInputHash,
+    transaction: &conway::MintedTx,
+    report: &ProblemReport,
 ) {
     let context = "Cip509 transaction input hash validation";
 
@@ -83,7 +85,9 @@ pub fn validate_txn_inputs_hash(
 
 /// Checks that the given transaction auxiliary data hash is correct.
 pub fn validate_aux(
-    raw_aux_data: &[u8], auxiliary_data_hash: Option<&Bytes>, report: &ProblemReport,
+    raw_aux_data: &[u8],
+    auxiliary_data_hash: Option<&Bytes>,
+    report: &ProblemReport,
 ) {
     let context = "Cip509 auxiliary data validation";
 
@@ -114,7 +118,9 @@ pub fn validate_aux(
 /// Checks that all public keys extracted from x509 and c509 certificates are present in
 /// the witness set of the transaction.
 pub fn validate_stake_public_key(
-    transaction: &conway::MintedTx, uris: Option<&Cip0134UriSet>, report: &ProblemReport,
+    transaction: &conway::MintedTx,
+    uris: Option<&Cip0134UriSet>,
+    report: &ProblemReport,
 ) {
     let context = "Cip509 stake public key validation";
 
@@ -167,7 +173,10 @@ fn extract_stake_addresses(uris: Option<&Cip0134UriSet>) -> Vec<VKeyHash> {
 
 /// Validate self-signed certificates.
 /// All certificates should be self-signed and support only ED25519 signature.
-pub fn validate_self_sign_cert(metadata: &Cip509RbacMetadata, report: &ProblemReport) {
+pub fn validate_self_sign_cert(
+    metadata: &Cip509RbacMetadata,
+    report: &ProblemReport,
+) {
     let context = "Cip509 self-signed certificate validation";
 
     for (index, cert) in metadata.c509_certs.iter().enumerate() {
@@ -184,7 +193,12 @@ pub fn validate_self_sign_cert(metadata: &Cip509RbacMetadata, report: &ProblemRe
 }
 
 /// Validate C509 certificate that it is a self-signed.
-fn validate_c509_self_signed_cert(c: &C509, index: usize, report: &ProblemReport, context: &str) {
+fn validate_c509_self_signed_cert(
+    c: &C509,
+    index: usize,
+    report: &ProblemReport,
+    context: &str,
+) {
     // Self-sign certificate must be type 2
     if c.tbs_cert().c509_certificate_type() != 2 {
         report.invalid_value(
@@ -243,7 +257,12 @@ fn validate_c509_self_signed_cert(c: &C509, index: usize, report: &ProblemReport
 }
 
 /// Validate X509 certificate that it is a self-signed.
-fn validate_x509_self_signed_cert(c: &X509, index: usize, report: &ProblemReport, context: &str) {
+fn validate_x509_self_signed_cert(
+    c: &X509,
+    index: usize,
+    report: &ProblemReport,
+    context: &str,
+) {
     let pk = match x509_key(c) {
         Ok(pk) => pk,
         Err(e) => {
@@ -296,7 +315,9 @@ fn validate_x509_self_signed_cert(c: &X509, index: usize, report: &ProblemReport
 /// Checks the role data.
 #[allow(clippy::similar_names)]
 pub fn validate_role_data(
-    metadata: &Cip509RbacMetadata, subnet: Network, report: &ProblemReport,
+    metadata: &Cip509RbacMetadata,
+    subnet: Network,
+    report: &ProblemReport,
 ) -> Option<CatalystId> {
     let context = "Role data validation";
 
@@ -401,7 +422,10 @@ pub fn validate_role_data(
 
 /// Checks that the role 0 data is correct.
 fn validate_role_0(
-    role: &RoleData, metadata: &Cip509RbacMetadata, subnet: Network, context: &str,
+    role: &RoleData,
+    metadata: &Cip509RbacMetadata,
+    subnet: Network,
+    context: &str,
     report: &ProblemReport,
 ) -> Option<CatalystId> {
     if let Some(key) = role.encryption_key() {
@@ -468,14 +492,22 @@ fn validate_role_0(
 }
 
 /// Extracts `VerifyingKey` from the given `X509` certificate.
-fn x509_cert_key(cert: &X509, context: &str, report: &ProblemReport) -> Option<VerifyingKey> {
+fn x509_cert_key(
+    cert: &X509,
+    context: &str,
+    report: &ProblemReport,
+) -> Option<VerifyingKey> {
     x509_key(cert)
         .inspect_err(|err| err.report_problem(context, report))
         .ok()
 }
 
 /// Extracts `VerifyingKey` from the given `C509` certificate.
-fn c509_cert_key(cert: &C509, context: &str, report: &ProblemReport) -> Option<VerifyingKey> {
+fn c509_cert_key(
+    cert: &C509,
+    context: &str,
+    report: &ProblemReport,
+) -> Option<VerifyingKey> {
     c509_key(cert)
         .inspect_err(|err| err.report_problem(context, report))
         .ok()
diff --git a/rust/rbac-registration/src/cardano/cip509/x509_chunks.rs b/rust/rbac-registration/src/cardano/cip509/x509_chunks.rs
index 92a8d56d940..0b0a95c243e 100644
--- a/rust/rbac-registration/src/cardano/cip509/x509_chunks.rs
+++ b/rust/rbac-registration/src/cardano/cip509/x509_chunks.rs
@@ -40,7 +40,10 @@ impl From<X509Chunks> for Option<Cip509RbacMetadata> {
 }
 
 impl Decode<'_, DecodeContext<'_, '_>> for X509Chunks {
-    fn decode(d: &mut Decoder, decode_context: &mut DecodeContext) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut Decoder,
+        decode_context: &mut DecodeContext,
+    ) -> Result<Self, decode::Error> {
         // Determine the algorithm
         let algorithm: u8 = decode_helper(d, "algorithm in X509Chunks", &mut ())?;
         let Some(algorithm) = CompressionAlgorithm::from_repr(algorithm) else {
@@ -84,7 +87,10 @@ impl Decode<'_, DecodeContext<'_, '_>> for X509Chunks {
 }
 
 /// Decompress the data using the given algorithm.
-fn decompress(d: &mut Decoder, algorithm: &CompressionAlgorithm) -> anyhow::Result<Vec<u8>> {
+fn decompress(
+    d: &mut Decoder,
+    algorithm: &CompressionAlgorithm,
+) -> anyhow::Result<Vec<u8>> {
     let chunk_len = decode_array_len(d, "decompression in X509Chunks")?;
     // Vector containing the concatenated chunks
     let mut concat_chunk = vec![];
diff --git a/rust/rbac-registration/src/registration/cardano/mod.rs b/rust/rbac-registration/src/registration/cardano/mod.rs
index b968bf89fe3..a8beab9a88d 100644
--- a/rust/rbac-registration/src/registration/cardano/mod.rs
+++ b/rust/rbac-registration/src/registration/cardano/mod.rs
@@ -63,7 +63,10 @@ impl RegistrationChain {
     /// # Errors
     ///
     /// Returns an error if data is invalid
-    pub fn update(&self, cip509: Cip509) -> anyhow::Result<Self> {
+    pub fn update(
+        &self,
+        cip509: Cip509,
+    ) -> anyhow::Result<Self> {
         let latest_signing_pk = self.get_latest_signing_pk_for_role(&RoleId::Role0);
         let new_inner = if let Some((signing_pk, _)) = latest_signing_pk {
             self.inner.update(cip509, signing_pk)?
@@ -161,7 +164,8 @@ impl RegistrationChain {
     /// Returns the public key and the rotation,`None` if not found.
     #[must_use]
     pub fn get_latest_signing_pk_for_role(
-        &self, role: &RoleId,
+        &self,
+        role: &RoleId,
     ) -> Option<(VerifyingKey, KeyRotation)> {
         self.inner.role_data_record.get(role).and_then(|rdr| {
             rdr.signing_keys().last().and_then(|key| {
@@ -176,7 +180,8 @@ impl RegistrationChain {
     /// Returns the public key and the rotation, `None` if not found.
     #[must_use]
     pub fn get_latest_encryption_pk_for_role(
-        &self, role: &RoleId,
+        &self,
+        role: &RoleId,
     ) -> Option<(VerifyingKey, KeyRotation)> {
         self.inner.role_data_record.get(role).and_then(|rdr| {
             rdr.encryption_keys().last().and_then(|key| {
@@ -191,7 +196,9 @@ impl RegistrationChain {
     /// Returns the public key, `None` if not found.
     #[must_use]
     pub fn get_signing_pk_for_role_at_rotation(
-        &self, role: &RoleId, rotation: &KeyRotation,
+        &self,
+        role: &RoleId,
+        rotation: &KeyRotation,
     ) -> Option<VerifyingKey> {
         self.inner.role_data_record.get(role).and_then(|rdr| {
             rdr.signing_key_from_rotation(rotation)
@@ -203,7 +210,9 @@ impl RegistrationChain {
     /// Returns the public key, `None` if not found.
     #[must_use]
     pub fn get_encryption_pk_for_role_at_rotation(
-        &self, role: &RoleId, rotation: &KeyRotation,
+        &self,
+        role: &RoleId,
+        rotation: &KeyRotation,
     ) -> Option<VerifyingKey> {
         self.inner.role_data_record.get(role).and_then(|rdr| {
             rdr.encryption_key_from_rotation(rotation)
@@ -215,7 +224,9 @@ impl RegistrationChain {
     /// given rotation.
     #[must_use]
     pub fn get_singing_key_cert_or_key_for_role_at_rotation(
-        &self, role: &RoleId, rotation: &KeyRotation,
+        &self,
+        role: &RoleId,
+        rotation: &KeyRotation,
     ) -> Option<&CertOrPk> {
         self.inner
             .role_data_record
@@ -227,7 +238,9 @@ impl RegistrationChain {
     /// with given rotation.
     #[must_use]
     pub fn get_encryption_key_cert_or_key_for_role_at_rotation(
-        &self, role: &RoleId, rotation: &KeyRotation,
+        &self,
+        role: &RoleId,
+        rotation: &KeyRotation,
     ) -> Option<&CertOrPk> {
         self.inner
             .role_data_record
@@ -399,7 +412,11 @@ impl RegistrationChainInner {
     /// # Errors
     ///
     /// Returns an error if data is invalid
-    fn update(&self, cip509: Cip509, signing_pk: VerifyingKey) -> anyhow::Result<Self> {
+    fn update(
+        &self,
+        cip509: Cip509,
+        signing_pk: VerifyingKey,
+    ) -> anyhow::Result<Self> {
         let context = "Registration Chain update";
         let mut new_inner = self.clone();
 
@@ -486,8 +503,11 @@ impl RegistrationChainInner {
 /// Perform a check on the validation signature.
 /// The auxiliary data should be sign with the latest signing public key.
 fn check_validation_signature(
-    validation_signature: Option<ValidationSignature>, raw_aux_data: &[u8],
-    signing_pk: VerifyingKey, report: &ProblemReport, context: &str,
+    validation_signature: Option<ValidationSignature>,
+    raw_aux_data: &[u8],
+    signing_pk: VerifyingKey,
+    report: &ProblemReport,
+    context: &str,
 ) -> anyhow::Result<()> {
     let context = &format!("Check Validation Signature in {context}");
     // Note that the validation signature can be in the range of 1 - 64 bytes
diff --git a/rust/rbac-registration/src/registration/cardano/update_rbac.rs b/rust/rbac-registration/src/registration/cardano/update_rbac.rs
index 9194a929bc9..6c940755e92 100644
--- a/rust/rbac-registration/src/registration/cardano/update_rbac.rs
+++ b/rust/rbac-registration/src/registration/cardano/update_rbac.rs
@@ -16,7 +16,8 @@ use crate::cardano::cip509::{
 /// Update x509 certificates in the registration chain.
 pub(crate) fn update_x509_certs(
     x509_cert_map: &mut HashMap<usize, Vec<PointData<Option<X509Certificate>>>>,
-    x509_certs: Vec<X509DerCert>, point_tx_idx: &PointTxnIdx,
+    x509_certs: Vec<X509DerCert>,
+    point_tx_idx: &PointTxnIdx,
 ) {
     for (idx, cert) in x509_certs.into_iter().enumerate() {
         match cert {
@@ -52,7 +53,8 @@ pub(crate) fn update_x509_certs(
 
 /// Update c509 certificates in the registration chain.
 pub(crate) fn update_c509_certs(
-    c509_cert_map: &mut HashMap<usize, Vec<PointData<Option<C509>>>>, c509_certs: Vec<C509Cert>,
+    c509_cert_map: &mut HashMap<usize, Vec<PointData<Option<C509>>>>,
+    c509_certs: Vec<C509Cert>,
     point_tx_idx: &PointTxnIdx,
 ) {
     for (idx, cert) in c509_certs.into_iter().enumerate() {
@@ -94,7 +96,8 @@ pub(crate) fn update_c509_certs(
 /// Update public keys in the registration chain.
 pub(crate) fn update_public_keys(
     pub_key_map: &mut HashMap<usize, Vec<PointData<Option<VerifyingKey>>>>,
-    pub_keys: Vec<SimplePublicKeyType>, point_tx_idx: &PointTxnIdx,
+    pub_keys: Vec<SimplePublicKeyType>,
+    point_tx_idx: &PointTxnIdx,
 ) {
     for (idx, cert) in pub_keys.into_iter().enumerate() {
         match cert {
@@ -127,7 +130,8 @@ pub(crate) fn update_public_keys(
 
 /// Process the revocation list.
 pub(crate) fn revocations_list(
-    revocation_list: Vec<CertKeyHash>, point_tx_idx: &PointTxnIdx,
+    revocation_list: Vec<CertKeyHash>,
+    point_tx_idx: &PointTxnIdx,
 ) -> Vec<PointData<CertKeyHash>> {
     let mut revocations = Vec::new();
     for item in revocation_list {
@@ -141,7 +145,8 @@ pub(crate) fn revocations_list(
 pub(crate) fn update_role_data(
     registration: &Cip509RbacMetadata,
     role_data_history: &mut HashMap<RoleId, Vec<PointData<RoleData>>>,
-    role_data_record: &mut HashMap<RoleId, RoleDataRecord>, point_tx_idx: &PointTxnIdx,
+    role_data_record: &mut HashMap<RoleId, RoleDataRecord>,
+    point_tx_idx: &PointTxnIdx,
 ) {
     for (number, data) in registration.clone().role_data {
         // Update role data history, put the whole role data
@@ -180,7 +185,9 @@ pub(crate) fn update_role_data(
 
 /// Update signing key.
 pub(crate) fn update_signing_key(
-    signing_key: &KeyLocalRef, record: &mut RoleDataRecord, point_tx_idx: &PointTxnIdx,
+    signing_key: &KeyLocalRef,
+    record: &mut RoleDataRecord,
+    point_tx_idx: &PointTxnIdx,
     registration: &Cip509RbacMetadata,
 ) {
     let index = signing_key.key_offset;
@@ -232,7 +239,9 @@ pub(crate) fn update_signing_key(
 
 /// Update encryption key.
 pub(crate) fn update_encryption_key(
-    encryption_key: &KeyLocalRef, record: &mut RoleDataRecord, point_tx_idx: &PointTxnIdx,
+    encryption_key: &KeyLocalRef,
+    record: &mut RoleDataRecord,
+    point_tx_idx: &PointTxnIdx,
     registration: &Cip509RbacMetadata,
 ) {
     let index = encryption_key.key_offset;
diff --git a/rust/rbac-registration/src/utils/test.rs b/rust/rbac-registration/src/utils/test.rs
index 4c8ce372140..d512748b734 100644
--- a/rust/rbac-registration/src/utils/test.rs
+++ b/rust/rbac-registration/src/utils/test.rs
@@ -33,7 +33,10 @@ impl BlockTestData {
     /// Asserts that the problem report doesn't contain errors and all fields have
     /// expected values.
     #[track_caller]
-    pub fn assert_valid(&self, cip509: &Cip509) {
+    pub fn assert_valid(
+        &self,
+        cip509: &Cip509,
+    ) {
         assert!(!cip509.report().is_problematic(), "{:?}", cip509.report());
 
         let origin = cip509.origin();
diff --git a/rust/rustfmt.toml b/rust/rustfmt.toml
index 905bde2d0bd..b9340a42544 100644
--- a/rust/rustfmt.toml
+++ b/rust/rustfmt.toml
@@ -35,7 +35,7 @@ match_block_trailing_comma = true
 max_width = 100
 
 # Comments:
-normalize_comments = true
+normalize_comments = false
 normalize_doc_attributes = false
 wrap_comments = true
 comment_width = 90      # small excess is okay but prefer 80
@@ -51,7 +51,7 @@ imports_granularity = "Crate"
 
 # Arguments:
 use_small_heuristics = "Default"
-fn_params_layout = "Compressed"
+fn_params_layout = "Vertical"
 overflow_delimited_expr = true
 where_single_line = true
 
@@ -65,4 +65,4 @@ condense_wildcard_suffixes = true
 hex_literal_case = "Upper"
 
 # Ignored files:
-ignore = []
+ignore = []
\ No newline at end of file
diff --git a/rust/signed_doc/bins/mk_signed_doc.rs b/rust/signed_doc/bins/mk_signed_doc.rs
index 6912a9397e4..1f07c94ebb2 100644
--- a/rust/signed_doc/bins/mk_signed_doc.rs
+++ b/rust/signed_doc/bins/mk_signed_doc.rs
@@ -120,7 +120,10 @@ fn inspect_signed_doc(cose_bytes: &[u8]) -> anyhow::Result<()> {
     Ok(())
 }
 
-fn save_signed_doc(signed_doc: CatalystSignedDocument, path: &PathBuf) -> anyhow::Result<()> {
+fn save_signed_doc(
+    signed_doc: CatalystSignedDocument,
+    path: &PathBuf,
+) -> anyhow::Result<()> {
     let mut bytes: Vec<u8> = Vec::new();
     minicbor::encode(signed_doc, &mut bytes).context("Failed to encode document")?;
 
@@ -138,7 +141,10 @@ where T: for<'de> serde::Deserialize<'de> {
     Ok(json)
 }
 
-fn write_bytes_to_file(bytes: &[u8], output: &PathBuf) -> anyhow::Result<()> {
+fn write_bytes_to_file(
+    bytes: &[u8],
+    output: &PathBuf,
+) -> anyhow::Result<()> {
     File::create(output)?
         .write_all(bytes)
         .context(format!("Failed to write to file {}", output.display()))
diff --git a/rust/signed_doc/src/builder.rs b/rust/signed_doc/src/builder.rs
index 6efdca778dd..0715c9df9bb 100644
--- a/rust/signed_doc/src/builder.rs
+++ b/rust/signed_doc/src/builder.rs
@@ -35,7 +35,10 @@ impl Builder {
     ///
     /// # Errors
     /// - Fails if it is invalid metadata fields JSON object.
-    pub fn with_json_metadata(mut self, json: serde_json::Value) -> anyhow::Result<Self> {
+    pub fn with_json_metadata(
+        mut self,
+        json: serde_json::Value,
+    ) -> anyhow::Result<Self> {
         let metadata = serde_json::from_value(json)?;
         self.0.metadata = Metadata::from_metadata_fields(metadata, &self.0.report);
         Ok(self)
@@ -43,7 +46,10 @@ impl Builder {
 
     /// Set decoded (original) document content bytes
     #[must_use]
-    pub fn with_decoded_content(mut self, content: Vec<u8>) -> Self {
+    pub fn with_decoded_content(
+        mut self,
+        content: Vec<u8>,
+    ) -> Self {
         self.0.content = Content::from_decoded(content);
         self
     }
@@ -56,7 +62,9 @@ impl Builder {
     /// content, due to malformed data, or when the signed document cannot be
     /// converted into `coset::CoseSign`.
     pub fn add_signature(
-        mut self, sign_fn: impl FnOnce(Vec<u8>) -> Vec<u8>, kid: &CatalystId,
+        mut self,
+        sign_fn: impl FnOnce(Vec<u8>) -> Vec<u8>,
+        kid: &CatalystId,
     ) -> anyhow::Result<Self> {
         let cose_sign = self
             .0
diff --git a/rust/signed_doc/src/content.rs b/rust/signed_doc/src/content.rs
index 506ba1f7daa..7f70ec97c64 100644
--- a/rust/signed_doc/src/content.rs
+++ b/rust/signed_doc/src/content.rs
@@ -17,7 +17,9 @@ impl Content {
     /// verifies a Document's content, that it is correctly encoded and it corresponds and
     /// parsed to the specified type
     pub(crate) fn from_encoded(
-        mut data: Vec<u8>, content_encoding: Option<ContentEncoding>, report: &ProblemReport,
+        mut data: Vec<u8>,
+        content_encoding: Option<ContentEncoding>,
+        report: &ProblemReport,
     ) -> Self {
         if let Some(content_encoding) = content_encoding {
             if let Ok(decoded_data) = content_encoding.decode(&data) {
@@ -57,7 +59,8 @@ impl Content {
     ///  - Missing Document content
     ///  - Failed to encode content.
     pub(crate) fn encoded_bytes(
-        &self, content_encoding: Option<ContentEncoding>,
+        &self,
+        content_encoding: Option<ContentEncoding>,
     ) -> anyhow::Result<Vec<u8>> {
         let content = self.decoded_bytes()?;
         if let Some(content_encoding) = content_encoding {
diff --git a/rust/signed_doc/src/lib.rs b/rust/signed_doc/src/lib.rs
index c5d5779733a..413354a8c6b 100644
--- a/rust/signed_doc/src/lib.rs
+++ b/rust/signed_doc/src/lib.rs
@@ -59,7 +59,10 @@ pub struct CatalystSignedDocument {
 }
 
 impl Display for CatalystSignedDocument {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut Formatter<'_>,
+    ) -> Result<(), std::fmt::Error> {
         writeln!(f, "{}", self.inner.metadata)?;
         writeln!(f, "Payload Size: {} bytes", self.inner.content.size())?;
         writeln!(f, "Signature Information")?;
@@ -220,7 +223,10 @@ impl InnerCatalystSignedDocument {
 }
 
 impl Decode<'_, ()> for CatalystSignedDocument {
-    fn decode(d: &mut Decoder<'_>, _ctx: &mut ()) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        _ctx: &mut (),
+    ) -> Result<Self, decode::Error> {
         let start = d.position();
         d.skip()?;
         let end = d.position();
@@ -259,7 +265,9 @@ impl Decode<'_, ()> for CatalystSignedDocument {
 
 impl Encode<()> for CatalystSignedDocument {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut encode::Encoder<W>, _ctx: &mut (),
+        &self,
+        e: &mut encode::Encoder<W>,
+        _ctx: &mut (),
     ) -> Result<(), encode::Error<W::Error>> {
         let cose_sign = self.as_cose_sign().map_err(encode::Error::message)?;
         let cose_bytes = cose_sign.to_tagged_vec().map_err(|e| {
diff --git a/rust/signed_doc/src/metadata/content_encoding.rs b/rust/signed_doc/src/metadata/content_encoding.rs
index d47f696e7ff..e492b271bbd 100644
--- a/rust/signed_doc/src/metadata/content_encoding.rs
+++ b/rust/signed_doc/src/metadata/content_encoding.rs
@@ -19,7 +19,10 @@ impl ContentEncoding {
     ///
     /// # Errors
     /// Returns compression failure
-    pub fn encode(self, mut payload: &[u8]) -> anyhow::Result<Vec<u8>> {
+    pub fn encode(
+        self,
+        mut payload: &[u8],
+    ) -> anyhow::Result<Vec<u8>> {
         match self {
             Self::Brotli => {
                 let brotli_params = brotli::enc::BrotliEncoderParams::default();
@@ -34,7 +37,10 @@ impl ContentEncoding {
     ///
     /// # Errors
     ///  Returns decompression failure
-    pub fn decode(self, mut payload: &[u8]) -> anyhow::Result<Vec<u8>> {
+    pub fn decode(
+        self,
+        mut payload: &[u8],
+    ) -> anyhow::Result<Vec<u8>> {
         match self {
             Self::Brotli => {
                 let mut buf = Vec::new();
@@ -46,7 +52,10 @@ impl ContentEncoding {
 }
 
 impl Display for ContentEncoding {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut Formatter<'_>,
+    ) -> Result<(), std::fmt::Error> {
         match self {
             Self::Brotli => write!(f, "br"),
         }
diff --git a/rust/signed_doc/src/metadata/content_type.rs b/rust/signed_doc/src/metadata/content_type.rs
index b72cb4b9c22..6a4e31e7708 100644
--- a/rust/signed_doc/src/metadata/content_type.rs
+++ b/rust/signed_doc/src/metadata/content_type.rs
@@ -20,7 +20,10 @@ pub enum ContentType {
 
 impl ContentType {
     /// Validates the provided `content` bytes to be a defined `ContentType`.
-    pub(crate) fn validate(self, content: &[u8]) -> anyhow::Result<()> {
+    pub(crate) fn validate(
+        self,
+        content: &[u8],
+    ) -> anyhow::Result<()> {
         match self {
             Self::Json => {
                 if let Err(e) = serde_json::from_slice::<serde_json::Value>(content) {
@@ -38,7 +41,10 @@ impl ContentType {
 }
 
 impl Display for ContentType {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut Formatter<'_>,
+    ) -> Result<(), std::fmt::Error> {
         match self {
             Self::Cbor => write!(f, "application/cbor"),
             Self::Json => write!(f, "application/json"),
diff --git a/rust/signed_doc/src/metadata/document_ref.rs b/rust/signed_doc/src/metadata/document_ref.rs
index 00e0bba2416..33a3b2c48bf 100644
--- a/rust/signed_doc/src/metadata/document_ref.rs
+++ b/rust/signed_doc/src/metadata/document_ref.rs
@@ -16,7 +16,10 @@ pub struct DocumentRef {
 }
 
 impl Display for DocumentRef {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
         write!(f, "id: {}, ver: {}", self.id, self.ver)
     }
 }
diff --git a/rust/signed_doc/src/metadata/extra_fields.rs b/rust/signed_doc/src/metadata/extra_fields.rs
index d002b422102..d477da8d56d 100644
--- a/rust/signed_doc/src/metadata/extra_fields.rs
+++ b/rust/signed_doc/src/metadata/extra_fields.rs
@@ -91,7 +91,8 @@ impl ExtraFields {
 
     /// Fill the COSE header `ExtraFields` data into the header builder.
     pub(super) fn fill_cose_header_fields(
-        &self, mut builder: coset::HeaderBuilder,
+        &self,
+        mut builder: coset::HeaderBuilder,
     ) -> anyhow::Result<coset::HeaderBuilder> {
         if let Some(doc_ref) = &self.doc_ref {
             builder = builder.text_value(REF_KEY.to_string(), Value::try_from(*doc_ref)?);
@@ -123,7 +124,8 @@ impl ExtraFields {
 
     /// Converting COSE Protected Header to `ExtraFields`.
     pub(crate) fn from_protected_header(
-        protected: &ProtectedHeader, error_report: &ProblemReport,
+        protected: &ProtectedHeader,
+        error_report: &ProblemReport,
     ) -> Self {
         /// Context for problem report messages during decoding from COSE protected
         /// header.
diff --git a/rust/signed_doc/src/metadata/mod.rs b/rust/signed_doc/src/metadata/mod.rs
index bbbdb1677d7..5f3e57fd581 100644
--- a/rust/signed_doc/src/metadata/mod.rs
+++ b/rust/signed_doc/src/metadata/mod.rs
@@ -108,7 +108,10 @@ impl Metadata {
     }
 
     /// Build `Metadata` object from the metadata fields, doing all necessary validation.
-    pub(crate) fn from_metadata_fields(metadata: InnerMetadata, report: &ProblemReport) -> Self {
+    pub(crate) fn from_metadata_fields(
+        metadata: InnerMetadata,
+        report: &ProblemReport,
+    ) -> Self {
         if metadata.doc_type.is_none() {
             report.missing_field("type", "Missing type field in COSE protected header");
         }
@@ -131,7 +134,8 @@ impl Metadata {
 
     /// Converting COSE Protected Header to Metadata.
     pub(crate) fn from_protected_header(
-        protected: &coset::ProtectedHeader, report: &ProblemReport,
+        protected: &coset::ProtectedHeader,
+        report: &ProblemReport,
     ) -> Self {
         let metadata = InnerMetadata::from_protected_header(protected, report);
         Self::from_metadata_fields(metadata, report)
@@ -142,7 +146,8 @@ impl InnerMetadata {
     /// Converting COSE Protected Header to Metadata fields, collecting decoding report
     /// issues.
     pub(crate) fn from_protected_header(
-        protected: &coset::ProtectedHeader, report: &ProblemReport,
+        protected: &coset::ProtectedHeader,
+        report: &ProblemReport,
     ) -> Self {
         /// Context for problem report messages during decoding from COSE protected
         /// header.
@@ -214,7 +219,10 @@ impl InnerMetadata {
 }
 
 impl Display for Metadata {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut Formatter<'_>,
+    ) -> Result<(), std::fmt::Error> {
         writeln!(f, "Metadata {{")?;
         writeln!(f, "  type: {:?},", self.0.doc_type)?;
         writeln!(f, "  id: {:?},", self.0.id)?;
diff --git a/rust/signed_doc/src/metadata/section.rs b/rust/signed_doc/src/metadata/section.rs
index 01e6a02a1b8..37787e8623f 100644
--- a/rust/signed_doc/src/metadata/section.rs
+++ b/rust/signed_doc/src/metadata/section.rs
@@ -10,14 +10,22 @@ use serde::{Deserialize, Serialize};
 pub struct Section(jsonpath_rust::JsonPath<serde_json::Value>);
 
 impl Display for Section {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
         self.0.fmt(f)
     }
 }
 
 impl Serialize for Section {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where S: serde::Serializer {
+    fn serialize<S>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
         self.to_string().serialize(serializer)
     }
 }
diff --git a/rust/signed_doc/src/metadata/utils.rs b/rust/signed_doc/src/metadata/utils.rs
index 0e54f10c439..dfca0f2455d 100644
--- a/rust/signed_doc/src/metadata/utils.rs
+++ b/rust/signed_doc/src/metadata/utils.rs
@@ -8,7 +8,8 @@ use coset::{CborSerializable, Label, ProtectedHeader};
 
 /// Find a value for a predicate in the protected header.
 pub(crate) fn cose_protected_header_find(
-    protected: &coset::ProtectedHeader, mut predicate: impl FnMut(&coset::Label) -> bool,
+    protected: &coset::ProtectedHeader,
+    mut predicate: impl FnMut(&coset::Label) -> bool,
 ) -> Option<&coset::cbor::Value> {
     protected
         .header
@@ -20,9 +21,14 @@ pub(crate) fn cose_protected_header_find(
 
 /// Tries to decode field by the `field_name` from the COSE protected header
 pub(crate) fn decode_document_field_from_protected_header<T>(
-    protected: &ProtectedHeader, field_name: &str, report_content: &str, report: &ProblemReport,
+    protected: &ProtectedHeader,
+    field_name: &str,
+    report_content: &str,
+    report: &ProblemReport,
 ) -> Option<T>
-where T: for<'a> TryFrom<&'a coset::cbor::Value> {
+where
+    T: for<'a> TryFrom<&'a coset::cbor::Value>,
+{
     if let Some(cbor_doc_field) =
         cose_protected_header_find(protected, |key| key == &Label::Text(field_name.to_string()))
     {
@@ -79,7 +85,7 @@ impl TryFrom<CborUuidV7> for coset::cbor::Value {
 ///
 /// This is used to encode `UuidV4` and `UuidV7` types.
 fn encode_cbor_uuid<T: minicbor::encode::Encode<CborContext>>(
-    value: T,
+    value: T
 ) -> anyhow::Result<coset::cbor::Value> {
     let mut cbor_bytes = Vec::new();
     minicbor::encode_with(value, &mut cbor_bytes, &mut CborContext::Tagged)
@@ -92,7 +98,7 @@ fn encode_cbor_uuid<T: minicbor::encode::Encode<CborContext>>(
 ///
 /// This is used to decode `UuidV4` and `UuidV7` types.
 fn decode_cbor_uuid<T: for<'a> minicbor::decode::Decode<'a, CborContext>>(
-    value: &coset::cbor::Value,
+    value: &coset::cbor::Value
 ) -> anyhow::Result<T> {
     let mut cbor_bytes = Vec::new();
     coset::cbor::ser::into_writer(value, &mut cbor_bytes)
diff --git a/rust/signed_doc/src/providers.rs b/rust/signed_doc/src/providers.rs
index 9fd41d1c63c..7068be3a4d0 100644
--- a/rust/signed_doc/src/providers.rs
+++ b/rust/signed_doc/src/providers.rs
@@ -11,7 +11,8 @@ use crate::{CatalystSignedDocument, DocumentRef};
 pub trait VerifyingKeyProvider {
     /// Try to get `VerifyingKey`
     fn try_get_key(
-        &self, kid: &CatalystId,
+        &self,
+        kid: &CatalystId,
     ) -> impl Future<Output = anyhow::Result<Option<VerifyingKey>>>;
 }
 
@@ -19,7 +20,8 @@ pub trait VerifyingKeyProvider {
 pub trait CatalystSignedDocumentProvider: Send + Sync {
     /// Try to get `CatalystSignedDocument`
     fn try_get_doc(
-        &self, doc_ref: &DocumentRef,
+        &self,
+        doc_ref: &DocumentRef,
     ) -> impl Future<Output = anyhow::Result<Option<CatalystSignedDocument>>> + Send;
 
     /// Returns a future threshold value, which is used in the validation of the `ver`
@@ -54,7 +56,10 @@ pub mod tests {
         ///
         /// # Errors
         ///  - Missing document id
-        pub fn add_document(&mut self, doc: CatalystSignedDocument) -> anyhow::Result<()> {
+        pub fn add_document(
+            &mut self,
+            doc: CatalystSignedDocument,
+        ) -> anyhow::Result<()> {
             self.0.insert(doc.doc_id()?.uuid(), doc);
             Ok(())
         }
@@ -62,7 +67,8 @@ pub mod tests {
 
     impl CatalystSignedDocumentProvider for TestCatalystSignedDocumentProvider {
         async fn try_get_doc(
-            &self, doc_ref: &DocumentRef,
+            &self,
+            doc_ref: &DocumentRef,
         ) -> anyhow::Result<Option<CatalystSignedDocument>> {
             Ok(self.0.get(&doc_ref.id.uuid()).cloned())
         }
@@ -82,13 +88,20 @@ pub mod tests {
 
     impl TestVerifyingKeyProvider {
         /// Inserts public key into the `TestVerifyingKeyProvider`
-        pub fn add_pk(&mut self, kid: CatalystId, pk: VerifyingKey) {
+        pub fn add_pk(
+            &mut self,
+            kid: CatalystId,
+            pk: VerifyingKey,
+        ) {
             self.0.insert(kid, pk);
         }
     }
 
     impl VerifyingKeyProvider for TestVerifyingKeyProvider {
-        async fn try_get_key(&self, kid: &CatalystId) -> anyhow::Result<Option<VerifyingKey>> {
+        async fn try_get_key(
+            &self,
+            kid: &CatalystId,
+        ) -> anyhow::Result<Option<VerifyingKey>> {
             Ok(self.0.get(kid).copied())
         }
     }
diff --git a/rust/signed_doc/src/signature/mod.rs b/rust/signed_doc/src/signature/mod.rs
index 31dec15b51a..a120993c84d 100644
--- a/rust/signed_doc/src/signature/mod.rs
+++ b/rust/signed_doc/src/signature/mod.rs
@@ -15,7 +15,10 @@ pub struct Signature {
 
 impl Signature {
     /// Convert COSE Signature to `Signature`.
-    pub(crate) fn from_cose_sig(signature: CoseSignature, report: &ProblemReport) -> Option<Self> {
+    pub(crate) fn from_cose_sig(
+        signature: CoseSignature,
+        report: &ProblemReport,
+    ) -> Option<Self> {
         match CatalystId::try_from(signature.protected.header.key_id.as_ref()) {
             Ok(kid) if kid.is_uri() => Some(Self { kid, signature }),
             Ok(kid) => {
@@ -61,7 +64,7 @@ impl Signatures {
 
     /// Iterator of COSE signatures object with kids.
     pub(crate) fn cose_signatures_with_kids(
-        &self,
+        &self
     ) -> impl Iterator<Item = (&CoseSignature, &CatalystId)> + use<'_> {
         self.0.iter().map(|sig| (&sig.signature, &sig.kid))
     }
@@ -72,7 +75,10 @@ impl Signatures {
     }
 
     /// Add a `Signature` object into the list
-    pub(crate) fn push(&mut self, sign: Signature) {
+    pub(crate) fn push(
+        &mut self,
+        sign: Signature,
+    ) {
         self.0.push(sign);
     }
 
@@ -89,7 +95,10 @@ impl Signatures {
     }
 
     /// Convert list of COSE Signature to `Signatures`.
-    pub(crate) fn from_cose_sig_list(cose_sigs: &[CoseSignature], report: &ProblemReport) -> Self {
+    pub(crate) fn from_cose_sig_list(
+        cose_sigs: &[CoseSignature],
+        report: &ProblemReport,
+    ) -> Self {
         let res = cose_sigs
             .iter()
             .cloned()
diff --git a/rust/signed_doc/src/validator/mod.rs b/rust/signed_doc/src/validator/mod.rs
index 167f56cfa2a..5e508e7d418 100644
--- a/rust/signed_doc/src/validator/mod.rs
+++ b/rust/signed_doc/src/validator/mod.rs
@@ -152,9 +152,12 @@ fn document_rules_init() -> HashMap<Uuid, Rules> {
 /// # Errors
 /// If `provider` returns error, fails fast throwing that error.
 pub async fn validate<Provider>(
-    doc: &CatalystSignedDocument, provider: &Provider,
+    doc: &CatalystSignedDocument,
+    provider: &Provider,
 ) -> anyhow::Result<bool>
-where Provider: CatalystSignedDocumentProvider {
+where
+    Provider: CatalystSignedDocumentProvider,
+{
     let Ok(doc_type) = doc.doc_type() else {
         doc.report().missing_field(
             "type",
@@ -187,9 +190,12 @@ where Provider: CatalystSignedDocumentProvider {
 /// 3. If `provider.future_threshold()` not `None`, document `id` cannot be too far behind
 ///    (`past_threshold` arg) from `SystemTime::now()` based on the provide threshold
 fn validate_id_and_ver<Provider>(
-    doc: &CatalystSignedDocument, provider: &Provider,
+    doc: &CatalystSignedDocument,
+    provider: &Provider,
 ) -> anyhow::Result<bool>
-where Provider: CatalystSignedDocumentProvider {
+where
+    Provider: CatalystSignedDocumentProvider,
+{
     let id = doc.doc_id().ok();
     let ver = doc.doc_ver().ok();
     if id.is_none() {
@@ -282,7 +288,8 @@ where Provider: CatalystSignedDocumentProvider {
 /// # Errors
 /// If `provider` returns error, fails fast throwing that error.
 pub async fn validate_signatures(
-    doc: &CatalystSignedDocument, provider: &impl VerifyingKeyProvider,
+    doc: &CatalystSignedDocument,
+    provider: &impl VerifyingKeyProvider,
 ) -> anyhow::Result<bool> {
     let Ok(cose_sign) = doc.as_cose_sign() else {
         doc.report().other(
@@ -319,7 +326,10 @@ pub async fn validate_signatures(
 
 /// A single signature validation function
 async fn validate_signature<Provider>(
-    cose_sign: &CoseSign, signature: &CoseSignature, kid: &CatalystId, provider: &Provider,
+    cose_sign: &CoseSign,
+    signature: &CoseSignature,
+    kid: &CatalystId,
+    provider: &Provider,
     report: &ProblemReport,
 ) -> anyhow::Result<bool>
 where
diff --git a/rust/signed_doc/src/validator/rules/content_encoding.rs b/rust/signed_doc/src/validator/rules/content_encoding.rs
index f75bcf81e3e..e771cd03f50 100644
--- a/rust/signed_doc/src/validator/rules/content_encoding.rs
+++ b/rust/signed_doc/src/validator/rules/content_encoding.rs
@@ -13,7 +13,10 @@ pub(crate) struct ContentEncodingRule {
 impl ContentEncodingRule {
     /// Field validation rule
     #[allow(clippy::unused_async)]
-    pub(crate) async fn check(&self, doc: &CatalystSignedDocument) -> anyhow::Result<bool> {
+    pub(crate) async fn check(
+        &self,
+        doc: &CatalystSignedDocument,
+    ) -> anyhow::Result<bool> {
         if let Some(content_encoding) = doc.doc_content_encoding() {
             if content_encoding != self.exp {
                 doc.report().invalid_value(
diff --git a/rust/signed_doc/src/validator/rules/content_type.rs b/rust/signed_doc/src/validator/rules/content_type.rs
index 26aa702fa7c..48adedaa832 100644
--- a/rust/signed_doc/src/validator/rules/content_type.rs
+++ b/rust/signed_doc/src/validator/rules/content_type.rs
@@ -12,7 +12,10 @@ pub(crate) struct ContentTypeRule {
 impl ContentTypeRule {
     /// Field validation rule
     #[allow(clippy::unused_async)]
-    pub(crate) async fn check(&self, doc: &CatalystSignedDocument) -> anyhow::Result<bool> {
+    pub(crate) async fn check(
+        &self,
+        doc: &CatalystSignedDocument,
+    ) -> anyhow::Result<bool> {
         let Ok(content_type) = doc.doc_content_type() else {
             doc.report().missing_field(
                 "content-type",
diff --git a/rust/signed_doc/src/validator/rules/doc_ref.rs b/rust/signed_doc/src/validator/rules/doc_ref.rs
index 53fec6825fe..7e7d477203a 100644
--- a/rust/signed_doc/src/validator/rules/doc_ref.rs
+++ b/rust/signed_doc/src/validator/rules/doc_ref.rs
@@ -26,9 +26,13 @@ pub(crate) enum RefRule {
 impl RefRule {
     /// Field validation rule
     pub(crate) async fn check<Provider>(
-        &self, doc: &CatalystSignedDocument, provider: &Provider,
+        &self,
+        doc: &CatalystSignedDocument,
+        provider: &Provider,
     ) -> anyhow::Result<bool>
-    where Provider: CatalystSignedDocumentProvider {
+    where
+        Provider: CatalystSignedDocumentProvider,
+    {
         if let Self::Specified {
             exp_ref_type,
             optional,
@@ -63,7 +67,10 @@ impl RefRule {
 
 /// A generic implementation of the referenced document validation.
 pub(crate) fn referenced_doc_check(
-    ref_doc: &CatalystSignedDocument, exp_ref_type: Uuid, field_name: &str, report: &ProblemReport,
+    ref_doc: &CatalystSignedDocument,
+    exp_ref_type: Uuid,
+    field_name: &str,
+    report: &ProblemReport,
 ) -> bool {
     let Ok(ref_doc_type) = ref_doc.doc_type() else {
         report.missing_field("type", "Referenced document must have type field");
diff --git a/rust/signed_doc/src/validator/rules/mod.rs b/rust/signed_doc/src/validator/rules/mod.rs
index 165dcb043ac..1819c4ac410 100644
--- a/rust/signed_doc/src/validator/rules/mod.rs
+++ b/rust/signed_doc/src/validator/rules/mod.rs
@@ -46,9 +46,13 @@ pub(crate) struct Rules {
 impl Rules {
     /// All field validation rules check
     pub(crate) async fn check<Provider>(
-        &self, doc: &CatalystSignedDocument, provider: &Provider,
+        &self,
+        doc: &CatalystSignedDocument,
+        provider: &Provider,
     ) -> anyhow::Result<bool>
-    where Provider: CatalystSignedDocumentProvider {
+    where
+        Provider: CatalystSignedDocumentProvider,
+    {
         let rules = [
             self.content_type.check(doc).boxed(),
             self.content_encoding.check(doc).boxed(),
diff --git a/rust/signed_doc/src/validator/rules/parameters.rs b/rust/signed_doc/src/validator/rules/parameters.rs
index 488f9cbae81..3b104b13628 100644
--- a/rust/signed_doc/src/validator/rules/parameters.rs
+++ b/rust/signed_doc/src/validator/rules/parameters.rs
@@ -26,9 +26,13 @@ pub(crate) enum ParametersRule {
 impl ParametersRule {
     /// Field validation rule
     pub(crate) async fn check<Provider>(
-        &self, doc: &CatalystSignedDocument, provider: &Provider,
+        &self,
+        doc: &CatalystSignedDocument,
+        provider: &Provider,
     ) -> anyhow::Result<bool>
-    where Provider: CatalystSignedDocumentProvider {
+    where
+        Provider: CatalystSignedDocumentProvider,
+    {
         if let Self::Specified {
             exp_parameters_type,
             optional,
diff --git a/rust/signed_doc/src/validator/rules/reply.rs b/rust/signed_doc/src/validator/rules/reply.rs
index 5ac256667db..b9c9e52e871 100644
--- a/rust/signed_doc/src/validator/rules/reply.rs
+++ b/rust/signed_doc/src/validator/rules/reply.rs
@@ -25,9 +25,13 @@ pub(crate) enum ReplyRule {
 impl ReplyRule {
     /// Field validation rule
     pub(crate) async fn check<Provider>(
-        &self, doc: &CatalystSignedDocument, provider: &Provider,
+        &self,
+        doc: &CatalystSignedDocument,
+        provider: &Provider,
     ) -> anyhow::Result<bool>
-    where Provider: CatalystSignedDocumentProvider {
+    where
+        Provider: CatalystSignedDocumentProvider,
+    {
         if let Self::Specified {
             exp_reply_type,
             optional,
diff --git a/rust/signed_doc/src/validator/rules/section.rs b/rust/signed_doc/src/validator/rules/section.rs
index b31b7fe0fb5..5c1663a0518 100644
--- a/rust/signed_doc/src/validator/rules/section.rs
+++ b/rust/signed_doc/src/validator/rules/section.rs
@@ -17,7 +17,10 @@ pub(crate) enum SectionRule {
 impl SectionRule {
     /// Field validation rule
     #[allow(clippy::unused_async)]
-    pub(crate) async fn check(&self, doc: &CatalystSignedDocument) -> anyhow::Result<bool> {
+    pub(crate) async fn check(
+        &self,
+        doc: &CatalystSignedDocument,
+    ) -> anyhow::Result<bool> {
         if let Self::Specified { optional } = self {
             if doc.doc_meta().section().is_none() && !optional {
                 doc.report()
diff --git a/rust/signed_doc/src/validator/rules/signature_kid.rs b/rust/signed_doc/src/validator/rules/signature_kid.rs
index 2e45517b8e3..8c10bdda6ac 100644
--- a/rust/signed_doc/src/validator/rules/signature_kid.rs
+++ b/rust/signed_doc/src/validator/rules/signature_kid.rs
@@ -13,7 +13,10 @@ pub(crate) struct SignatureKidRule {
 impl SignatureKidRule {
     /// Field validation rule
     #[allow(clippy::unused_async)]
-    pub(crate) async fn check(&self, doc: &CatalystSignedDocument) -> anyhow::Result<bool> {
+    pub(crate) async fn check(
+        &self,
+        doc: &CatalystSignedDocument,
+    ) -> anyhow::Result<bool> {
         let contains_exp_role = doc.kids().iter().enumerate().all(|(i, kid)| {
             let (role_index, _) = kid.role_and_rotation();
             let res = self.exp.contains(&role_index);
diff --git a/rust/signed_doc/src/validator/rules/template.rs b/rust/signed_doc/src/validator/rules/template.rs
index 0d5b0c9aaab..e30dd3a2a48 100644
--- a/rust/signed_doc/src/validator/rules/template.rs
+++ b/rust/signed_doc/src/validator/rules/template.rs
@@ -37,9 +37,13 @@ pub(crate) enum ContentRule {
 impl ContentRule {
     /// Field validation rule
     pub(crate) async fn check<Provider>(
-        &self, doc: &CatalystSignedDocument, provider: &Provider,
+        &self,
+        doc: &CatalystSignedDocument,
+        provider: &Provider,
     ) -> anyhow::Result<bool>
-    where Provider: CatalystSignedDocumentProvider {
+    where
+        Provider: CatalystSignedDocumentProvider,
+    {
         if let Self::Templated { exp_template_type } = self {
             let Some(template_ref) = doc.doc_meta().template() else {
                 doc.report()
@@ -110,7 +114,8 @@ impl ContentRule {
 /// Validate a provided `doc` against the `template` content's Json schema, assuming that
 /// the `doc` content is JSON.
 fn templated_json_schema_check(
-    doc: &CatalystSignedDocument, template_doc: &CatalystSignedDocument,
+    doc: &CatalystSignedDocument,
+    template_doc: &CatalystSignedDocument,
 ) -> bool {
     let Ok(template_content) = template_doc.doc_content().decoded_bytes() else {
         doc.report().missing_field(
@@ -141,7 +146,10 @@ fn templated_json_schema_check(
 }
 
 /// Validating the document's content against the provided schema
-fn content_schema_check(doc: &CatalystSignedDocument, schema: &ContentSchema) -> bool {
+fn content_schema_check(
+    doc: &CatalystSignedDocument,
+    schema: &ContentSchema,
+) -> bool {
     let Ok(doc_content) = doc.doc_content().decoded_bytes() else {
         doc.report()
             .missing_field("payload", "Document must have a content");
diff --git a/rust/signed_doc/src/validator/utils.rs b/rust/signed_doc/src/validator/utils.rs
index 4b25a9bbfaf..47f5b1847c2 100644
--- a/rust/signed_doc/src/validator/utils.rs
+++ b/rust/signed_doc/src/validator/utils.rs
@@ -7,7 +7,10 @@ use crate::{providers::CatalystSignedDocumentProvider, CatalystSignedDocument, D
 /// A helper validation document function, which validates a document from the
 /// `ValidationDataProvider`.
 pub(crate) async fn validate_provided_doc<Provider, Validator>(
-    doc_ref: &DocumentRef, provider: &Provider, report: &ProblemReport, validator: Validator,
+    doc_ref: &DocumentRef,
+    provider: &Provider,
+    report: &ProblemReport,
+    validator: Validator,
 ) -> anyhow::Result<bool>
 where
     Provider: CatalystSignedDocumentProvider,
diff --git a/rust/signed_doc/tests/common/mod.rs b/rust/signed_doc/tests/common/mod.rs
index d7ea84150b0..77450a88e93 100644
--- a/rust/signed_doc/tests/common/mod.rs
+++ b/rust/signed_doc/tests/common/mod.rs
@@ -28,7 +28,7 @@ pub fn test_metadata() -> (UuidV7, UuidV4, serde_json::Value) {
 }
 
 pub fn create_dummy_key_pair(
-    role_index: RoleId,
+    role_index: RoleId
 ) -> anyhow::Result<(
     ed25519_dalek::SigningKey,
     ed25519_dalek::VerifyingKey,
@@ -45,7 +45,7 @@ pub fn create_dummy_key_pair(
 }
 
 pub fn create_dummy_doc(
-    doc_type_id: Uuid,
+    doc_type_id: Uuid
 ) -> anyhow::Result<(CatalystSignedDocument, UuidV7, UuidV7)> {
     let empty_json = serde_json::to_vec(&serde_json::json!({}))?;
 
@@ -72,7 +72,9 @@ pub fn create_signing_key() -> ed25519_dalek::SigningKey {
 }
 
 pub fn create_dummy_signed_doc(
-    metadata: serde_json::Value, content: Vec<u8>, with_role_index: RoleId,
+    metadata: serde_json::Value,
+    content: Vec<u8>,
+    with_role_index: RoleId,
 ) -> anyhow::Result<(
     CatalystSignedDocument,
     ed25519_dalek::VerifyingKey,
diff --git a/rust/vote-tx-v1/src/decoding.rs b/rust/vote-tx-v1/src/decoding.rs
index 2f33c2d7d18..1650b1edecd 100644
--- a/rust/vote-tx-v1/src/decoding.rs
+++ b/rust/vote-tx-v1/src/decoding.rs
@@ -32,7 +32,10 @@ impl Tx {
     /// Write the bytes of the `Tx` body to provided `buf`.
     #[allow(clippy::cast_possible_truncation)]
     pub(super) fn tx_body_decode(
-        vote_plan_id: &[u8; 32], proposal_index: u8, vote: &VotePayload, public_key: &PublicKey,
+        vote_plan_id: &[u8; 32],
+        proposal_index: u8,
+        vote: &VotePayload,
+        public_key: &PublicKey,
         buf: &mut Vec<u8>,
     ) {
         buf.extend_from_slice(vote_plan_id);
@@ -227,7 +230,9 @@ mod tests {
 
     #[proptest]
     fn tx_public_to_bytes_from_bytes_test(
-        vote_plan_id: [u8; 32], proposal_index: u8, #[strategy(1u8..5)] voting_options: u8,
+        vote_plan_id: [u8; 32],
+        proposal_index: u8,
+        #[strategy(1u8..5)] voting_options: u8,
         #[strategy(0..#voting_options)] choice: u8,
     ) {
         let mut rng = OsRng;
@@ -300,7 +305,9 @@ mod tests {
 
     #[proptest]
     fn tx_private_to_bytes_from_bytes_test(
-        vote_plan_id: [u8; 32], proposal_index: u8, #[strategy(1u8..5)] voting_options: u8,
+        vote_plan_id: [u8; 32],
+        proposal_index: u8,
+        #[strategy(1u8..5)] voting_options: u8,
         #[strategy(0..#voting_options)] choice: u8,
     ) {
         let mut rng = OsRng;
diff --git a/rust/vote-tx-v1/src/lib.rs b/rust/vote-tx-v1/src/lib.rs
index 55c4bdce642..5874c4944b2 100644
--- a/rust/vote-tx-v1/src/lib.rs
+++ b/rust/vote-tx-v1/src/lib.rs
@@ -97,7 +97,10 @@ impl Tx {
     /// # Errors
     ///   - Invalid voting choice
     pub fn new_public(
-        vote_plan_id: [u8; 32], proposal_index: u8, voting_options: u8, choice: u8,
+        vote_plan_id: [u8; 32],
+        proposal_index: u8,
+        voting_options: u8,
+        choice: u8,
         users_private_key: &PrivateKey,
     ) -> anyhow::Result<Self> {
         let vote = VotePayload::new_public(choice, voting_options)?;
@@ -116,8 +119,13 @@ impl Tx {
     /// # Errors
     ///   - Invalid voting choice
     pub fn new_private<R: CryptoRngCore>(
-        vote_plan_id: [u8; 32], proposal_index: u8, voting_options: u8, choice: u8,
-        election_public_key: &ElectionPublicKey, users_private_key: &PrivateKey, rng: &mut R,
+        vote_plan_id: [u8; 32],
+        proposal_index: u8,
+        voting_options: u8,
+        choice: u8,
+        election_public_key: &ElectionPublicKey,
+        users_private_key: &PrivateKey,
+        rng: &mut R,
     ) -> anyhow::Result<Self> {
         let vote = VotePayload::new_private(
             &vote_plan_id,
@@ -142,8 +150,12 @@ impl Tx {
     /// # Errors
     ///   - Invalid voting choice
     pub fn new_private_with_default_rng(
-        vote_plan_id: [u8; 32], proposal_index: u8, voting_options: u8, choice: u8,
-        election_public_key: &ElectionPublicKey, users_private_key: &PrivateKey,
+        vote_plan_id: [u8; 32],
+        proposal_index: u8,
+        voting_options: u8,
+        choice: u8,
+        election_public_key: &ElectionPublicKey,
+        users_private_key: &PrivateKey,
     ) -> anyhow::Result<Self> {
         Self::new_private(
             vote_plan_id,
@@ -185,7 +197,10 @@ impl Tx {
     /// # Errors
     ///   - Not a private vote
     #[allow(clippy::cast_possible_truncation)]
-    pub fn private_choice(&self, secret_key: &ElectionSecretKey) -> anyhow::Result<u8> {
+    pub fn private_choice(
+        &self,
+        secret_key: &ElectionSecretKey,
+    ) -> anyhow::Result<u8> {
         if let VotePayload::Private(vote, _) = &self.vote {
             let vote = decrypt_vote(vote, secret_key)?;
             let choice = vote.choice() as u8;
@@ -218,7 +233,10 @@ impl Tx {
     ///
     /// # Errors
     ///   - Invalid proof
-    pub fn verify_proof(&self, election_public_key: &ElectionPublicKey) -> anyhow::Result<()> {
+    pub fn verify_proof(
+        &self,
+        election_public_key: &ElectionPublicKey,
+    ) -> anyhow::Result<()> {
         if let VotePayload::Private(encrypted_vote, proof) = &self.vote {
             let vote_plan_id_hash = Blake2b512Hasher::new().chain_update(self.vote_plan_id);
             let commitment = VoterProofCommitment::from_hash(vote_plan_id_hash);
@@ -237,7 +255,10 @@ impl Tx {
 
     /// Generate transaction signature
     fn sign(
-        vote_plan_id: &[u8; 32], proposal_index: u8, vote: &VotePayload, private_key: &PrivateKey,
+        vote_plan_id: &[u8; 32],
+        proposal_index: u8,
+        vote: &VotePayload,
+        private_key: &PrivateKey,
     ) -> Signature {
         let bytes = Self::bytes_to_sign(
             vote_plan_id,
@@ -251,7 +272,10 @@ impl Tx {
     /// Generate bytes to be signed.
     /// A Blake2b256 hash of the transaction body
     fn bytes_to_sign(
-        vote_plan_id: &[u8; 32], proposal_index: u8, vote: &VotePayload, public_key: &PublicKey,
+        vote_plan_id: &[u8; 32],
+        proposal_index: u8,
+        vote: &VotePayload,
+        public_key: &PublicKey,
     ) -> Vec<u8> {
         let mut bytes = Vec::new();
         Self::tx_body_decode(vote_plan_id, proposal_index, vote, public_key, &mut bytes);
@@ -264,7 +288,10 @@ impl Tx {
 
 #[allow(clippy::missing_docs_in_private_items)]
 impl VotePayload {
-    fn new_public(choice: u8, proposal_voting_options: u8) -> anyhow::Result<Self> {
+    fn new_public(
+        choice: u8,
+        proposal_voting_options: u8,
+    ) -> anyhow::Result<Self> {
         // Try to make a `Vote` just for applying underlying validation, which must be the same
         // even for public vote
         Vote::new(choice.into(), proposal_voting_options.into())?;
@@ -272,8 +299,11 @@ impl VotePayload {
     }
 
     fn new_private<R: CryptoRngCore>(
-        vote_plan_id: &[u8; 32], choice: u8, proposal_voting_options: u8,
-        election_public_key: &ElectionPublicKey, rng: &mut R,
+        vote_plan_id: &[u8; 32],
+        choice: u8,
+        proposal_voting_options: u8,
+        election_public_key: &ElectionPublicKey,
+        rng: &mut R,
     ) -> anyhow::Result<Self> {
         let vote = Vote::new(choice.into(), proposal_voting_options.into())?;
 
@@ -306,7 +336,9 @@ mod tests {
 
     #[proptest]
     fn tx_test(
-        vote_plan_id: [u8; 32], proposal_index: u8, #[strategy(1u8..5)] voting_options: u8,
+        vote_plan_id: [u8; 32],
+        proposal_index: u8,
+        #[strategy(1u8..5)] voting_options: u8,
         #[strategy(0..#voting_options)] choice: u8,
     ) {
         let users_private_key = PrivateKey::random_with_default_rng();
diff --git a/rust/vote-tx-v2/src/encoded_cbor.rs b/rust/vote-tx-v2/src/encoded_cbor.rs
index 981fc12737c..2c23730648b 100644
--- a/rust/vote-tx-v2/src/encoded_cbor.rs
+++ b/rust/vote-tx-v2/src/encoded_cbor.rs
@@ -15,7 +15,10 @@ where T: for<'a> Cbor<'a>;
 impl<T> Decode<'_, ()> for EncodedCbor<T>
 where T: for<'a> Cbor<'a>
 {
-    fn decode(d: &mut Decoder<'_>, (): &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        (): &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         let tag = d.tag()?;
         if ENCODED_CBOR_TAG != tag.as_u64() {
             return Err(minicbor::decode::Error::message(format!(
@@ -33,7 +36,9 @@ impl<T> Encode<()> for EncodedCbor<T>
 where T: for<'a> Cbor<'a>
 {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut minicbor::Encoder<W>, (): &mut (),
+        &self,
+        e: &mut minicbor::Encoder<W>,
+        (): &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         e.tag(Tag::new(ENCODED_CBOR_TAG))?;
         let cbor_bytes = self
diff --git a/rust/vote-tx-v2/src/gen_tx/builder.rs b/rust/vote-tx-v2/src/gen_tx/builder.rs
index ab6cf9e264a..baa1a0af4dd 100644
--- a/rust/vote-tx-v2/src/gen_tx/builder.rs
+++ b/rust/vote-tx-v2/src/gen_tx/builder.rs
@@ -36,7 +36,10 @@ where
 {
     /// Creates a new `GeneralizedTxBuilder` struct
     #[must_use]
-    pub fn new(vote_type: Uuid, voter_data: VoterData<VoterDataT>) -> Self {
+    pub fn new(
+        vote_type: Uuid,
+        voter_data: VoterData<VoterDataT>,
+    ) -> Self {
         let event = EventMap::default();
         let votes = Vec::default();
         let sign_builder = coset::CoseSignBuilder::new().protected(cose_protected_header());
@@ -52,8 +55,14 @@ where
     /// Adds an `EventMap` entry to the `event` field.
     ///
     /// # Errors
-    pub fn with_event<ValueT>(mut self, key: EventKey, value: ValueT) -> anyhow::Result<Self>
-    where ValueT: for<'a> Cbor<'a> + Clone {
+    pub fn with_event<ValueT>(
+        mut self,
+        key: EventKey,
+        value: ValueT,
+    ) -> anyhow::Result<Self>
+    where
+        ValueT: for<'a> Cbor<'a> + Clone,
+    {
         let value = value.to_bytes()?;
         self.event.0.push((key, value));
         Ok(self)
@@ -64,7 +73,10 @@ where
     /// # Errors
     ///   - `choices` array must has at least one entry-
     pub fn with_vote(
-        mut self, choices: Vec<ChoiceT>, proof: ProofT, prop_id: PropIdT,
+        mut self,
+        choices: Vec<ChoiceT>,
+        proof: ProofT,
+        prop_id: PropIdT,
     ) -> anyhow::Result<Self> {
         ensure!(
             !choices.is_empty(),
diff --git a/rust/vote-tx-v2/src/gen_tx/event_map.rs b/rust/vote-tx-v2/src/gen_tx/event_map.rs
index 91b6947c4ae..65135a964bb 100644
--- a/rust/vote-tx-v2/src/gen_tx/event_map.rs
+++ b/rust/vote-tx-v2/src/gen_tx/event_map.rs
@@ -18,7 +18,10 @@ pub enum EventKey {
 }
 
 impl Decode<'_, ()> for EventMap {
-    fn decode(d: &mut Decoder<'_>, (): &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        (): &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         let Some(len) = d.map()? else {
             return Err(minicbor::decode::Error::message(
                 "must be a defined sized map",
@@ -42,7 +45,9 @@ impl Decode<'_, ()> for EventMap {
 
 impl Encode<()> for EventMap {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut Encoder<W>, (): &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        (): &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         e.map(self.0.len() as u64)?;
 
@@ -59,7 +64,10 @@ impl Encode<()> for EventMap {
 }
 
 impl Decode<'_, ()> for EventKey {
-    fn decode(d: &mut Decoder<'_>, (): &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        (): &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         let pos = d.position();
         // try to decode as int
         if let Ok(i) = d.int() {
@@ -75,7 +83,9 @@ impl Decode<'_, ()> for EventKey {
 
 impl Encode<()> for EventKey {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut Encoder<W>, (): &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        (): &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         match self {
             EventKey::Int(i) => e.int(*i)?,
diff --git a/rust/vote-tx-v2/src/gen_tx/mod.rs b/rust/vote-tx-v2/src/gen_tx/mod.rs
index 3a48b60fc7f..fed0d288ac4 100644
--- a/rust/vote-tx-v2/src/gen_tx/mod.rs
+++ b/rust/vote-tx-v2/src/gen_tx/mod.rs
@@ -41,7 +41,10 @@ where
     PropIdT: for<'a> Cbor<'a>,
     VoterDataT: for<'a> Cbor<'a>,
 {
-    fn decode(d: &mut Decoder<'_>, (): &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        (): &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         let Some(GENERALIZED_TX_LEN) = d.array()? else {
             return Err(minicbor::decode::Error::message(format!(
                 "must be a defined sized array with {GENERALIZED_TX_LEN} entries"
@@ -81,7 +84,9 @@ where
     VoterDataT: for<'a> Cbor<'a>,
 {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut Encoder<W>, (): &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        (): &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         e.array(GENERALIZED_TX_LEN)?;
         self.tx_body.encode(e, &mut ())?;
@@ -204,7 +209,9 @@ mod tests {
 
     #[proptest]
     fn generalized_tx_with_empty_votes_from_bytes_to_bytes_test(
-        vote_type: Vec<u8>, event: Vec<(PropEventKey, u64)>, voter_data: Vec<u8>,
+        vote_type: Vec<u8>,
+        event: Vec<(PropEventKey, u64)>,
+        voter_data: Vec<u8>,
     ) {
         let event: Vec<_> = event
             .into_iter()
@@ -233,7 +240,9 @@ mod tests {
 
     #[proptest]
     fn generalized_tx_with_empty_choices_from_bytes_to_bytes_test(
-        vote_type: Vec<u8>, votes: Vec<PropVote>, event: Vec<(PropEventKey, u64)>,
+        vote_type: Vec<u8>,
+        votes: Vec<PropVote>,
+        event: Vec<(PropEventKey, u64)>,
         voter_data: Vec<u8>,
     ) {
         let event: Vec<_> = event
@@ -272,7 +281,9 @@ mod tests {
 
     #[proptest]
     fn generalized_tx_with_wrong_signature_from_bytes_to_bytes_test(
-        vote_type: Vec<u8>, votes: Vec<PropVote>, event: Vec<(PropEventKey, u64)>,
+        vote_type: Vec<u8>,
+        votes: Vec<PropVote>,
+        event: Vec<(PropEventKey, u64)>,
         voter_data: Vec<u8>,
     ) {
         let event: Vec<_> = event
diff --git a/rust/vote-tx-v2/src/gen_tx/tx_body.rs b/rust/vote-tx-v2/src/gen_tx/tx_body.rs
index c129a3e15c3..a5c3720783f 100644
--- a/rust/vote-tx-v2/src/gen_tx/tx_body.rs
+++ b/rust/vote-tx-v2/src/gen_tx/tx_body.rs
@@ -38,7 +38,10 @@ where
     PropIdT: for<'a> Cbor<'a>,
     VoterDataT: for<'a> Cbor<'a>,
 {
-    fn decode(d: &mut Decoder<'_>, (): &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        (): &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         let Some(TX_BODY_LEN) = d.array()? else {
             return Err(minicbor::decode::Error::message(format!(
                 "must be a defined sized array with {TX_BODY_LEN} entries"
@@ -72,7 +75,9 @@ where
     VoterDataT: for<'a> Cbor<'a>,
 {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut Encoder<W>, (): &mut (),
+        &self,
+        e: &mut Encoder<W>,
+        (): &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         e.array(TX_BODY_LEN)?;
         self.vote_type.encode(e, &mut ())?;
diff --git a/rust/vote-tx-v2/src/gen_tx/vote.rs b/rust/vote-tx-v2/src/gen_tx/vote.rs
index cd5c3c56eea..37f41028df2 100644
--- a/rust/vote-tx-v2/src/gen_tx/vote.rs
+++ b/rust/vote-tx-v2/src/gen_tx/vote.rs
@@ -36,7 +36,10 @@ where
     ProofT: for<'a> Cbor<'a>,
     PropIdT: for<'a> Cbor<'a>,
 {
-    fn decode(d: &mut Decoder<'_>, (): &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        (): &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         let Some(VOTE_LEN) = d.array()? else {
             return Err(minicbor::decode::Error::message(format!(
                 "must be a defined sized array with {VOTE_LEN} entries"
@@ -66,7 +69,9 @@ where
     PropIdT: for<'a> Cbor<'a>,
 {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut minicbor::Encoder<W>, (): &mut (),
+        &self,
+        e: &mut minicbor::Encoder<W>,
+        (): &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         e.array(VOTE_LEN)?;
         self.choices.encode(e, &mut ())?;
diff --git a/rust/vote-tx-v2/src/public_tx/mod.rs b/rust/vote-tx-v2/src/public_tx/mod.rs
index af2262c5851..8e4a72db2d2 100644
--- a/rust/vote-tx-v2/src/public_tx/mod.rs
+++ b/rust/vote-tx-v2/src/public_tx/mod.rs
@@ -36,7 +36,10 @@ where VoteDataT: for<'a> Cbor<'a>
 impl<VoteDataT> Decode<'_, ()> for PublicTx<VoteDataT>
 where VoteDataT: for<'a> Cbor<'a>
 {
-    fn decode(d: &mut minicbor::Decoder<'_>, (): &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut minicbor::Decoder<'_>,
+        (): &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         let gen_tx = GeneralizedTx::decode(d, &mut ())?;
         Ok(Self(gen_tx))
     }
@@ -46,7 +49,9 @@ impl<VoteDataT> Encode<()> for PublicTx<VoteDataT>
 where VoteDataT: for<'a> Cbor<'a>
 {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut minicbor::Encoder<W>, ctx: &mut (),
+        &self,
+        e: &mut minicbor::Encoder<W>,
+        ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         self.0.encode(e, ctx)
     }
@@ -62,8 +67,10 @@ mod tests {
 
     #[proptest]
     fn public_tx_from_bytes_to_bytes_test(
-        vote_type: Vec<u8>, voter_data: Vec<u8>,
-        #[any(size_range(1..10_usize).lift())] choices: Vec<u64>, prop_id: Vec<u8>,
+        vote_type: Vec<u8>,
+        voter_data: Vec<u8>,
+        #[any(size_range(1..10_usize).lift())] choices: Vec<u64>,
+        prop_id: Vec<u8>,
     ) {
         let gen_tx_builder = GeneralizedTxBuilder::<Choice, Proof, PropId, _>::new(
             Uuid(vote_type),
diff --git a/rust/vote-tx-v2/src/public_tx/vote.rs b/rust/vote-tx-v2/src/public_tx/vote.rs
index 35f4fa89b51..32e4e7b28a8 100644
--- a/rust/vote-tx-v2/src/public_tx/vote.rs
+++ b/rust/vote-tx-v2/src/public_tx/vote.rs
@@ -16,7 +16,10 @@ pub struct Proof;
 pub type PropId = Uuid;
 
 impl Decode<'_, ()> for Choice {
-    fn decode(d: &mut minicbor::Decoder<'_>, (): &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut minicbor::Decoder<'_>,
+        (): &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         let choice = d.u64()?;
         Ok(Self(choice))
     }
@@ -24,14 +27,19 @@ impl Decode<'_, ()> for Choice {
 
 impl Encode<()> for Choice {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut minicbor::Encoder<W>, (): &mut (),
+        &self,
+        e: &mut minicbor::Encoder<W>,
+        (): &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         self.0.encode(e, &mut ())
     }
 }
 
 impl Decode<'_, ()> for Proof {
-    fn decode(d: &mut minicbor::Decoder<'_>, (): &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut minicbor::Decoder<'_>,
+        (): &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         d.undefined()?;
         Ok(Self)
     }
@@ -39,7 +47,9 @@ impl Decode<'_, ()> for Proof {
 
 impl Encode<()> for Proof {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut minicbor::Encoder<W>, (): &mut (),
+        &self,
+        e: &mut minicbor::Encoder<W>,
+        (): &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         e.undefined()?;
         Ok(())
diff --git a/rust/vote-tx-v2/src/uuid.rs b/rust/vote-tx-v2/src/uuid.rs
index 6bb3b5d5170..11e02f958dc 100644
--- a/rust/vote-tx-v2/src/uuid.rs
+++ b/rust/vote-tx-v2/src/uuid.rs
@@ -10,7 +10,10 @@ const UUID_TAG: u64 = 37;
 pub struct Uuid(pub Vec<u8>);
 
 impl Decode<'_, ()> for Uuid {
-    fn decode(d: &mut Decoder<'_>, (): &mut ()) -> Result<Self, minicbor::decode::Error> {
+    fn decode(
+        d: &mut Decoder<'_>,
+        (): &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
         let tag = d.tag()?;
         if UUID_TAG != tag.as_u64() {
             return Err(minicbor::decode::Error::message(format!(
@@ -25,7 +28,9 @@ impl Decode<'_, ()> for Uuid {
 
 impl Encode<()> for Uuid {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut minicbor::Encoder<W>, (): &mut (),
+        &self,
+        e: &mut minicbor::Encoder<W>,
+        (): &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         e.tag(Tag::new(UUID_TAG))?;
         e.bytes(&self.0)?;

From ae400ab7c7868accb5e306878db7dc2a2fe8f62f Mon Sep 17 00:00:00 2001
From: Mr-Leshiy <leshiy12345678@gmail.com>
Date: Tue, 7 Oct 2025 14:22:57 +0700
Subject: [PATCH 3/5] fix cardano-chain-follower

---
 rust/cardano-chain-follower/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust/cardano-chain-follower/Cargo.toml b/rust/cardano-chain-follower/Cargo.toml
index 5342db757c1..8a7e340764d 100644
--- a/rust/cardano-chain-follower/Cargo.toml
+++ b/rust/cardano-chain-follower/Cargo.toml
@@ -15,7 +15,7 @@ pallas = { version = "0.33.0" }
 pallas-hardano = { version = "0.33.0" }
 pallas-crypto = { version = "0.33.0" }
 
-mithril-client = { version = "0.12.2", default-features = false, features = [
+mithril-client = { version = "=0.12.2", default-features = false, features = [
     "full",
     "num-integer-backend",
 ] }

From b9bd95143b0e7ded7988c97c7d09509b4c971d04 Mon Sep 17 00:00:00 2001
From: Mr-Leshiy <leshiy12345678@gmail.com>
Date: Tue, 7 Oct 2025 15:13:45 +0700
Subject: [PATCH 4/5] fix clippy

---
 rust/c509-certificate/examples/cli/main.rs         |  2 +-
 .../src/auxdata/scripts.rs                         |  2 +-
 .../src/mithril_snapshot_config.rs                 | 12 ++++++++----
 .../src/mithril_turbo_downloader.rs                |  2 +-
 .../src/turbo_downloader/mod.rs                    | 12 ++++--------
 .../src/crypto/babystep_giantstep.rs               |  1 +
 .../src/crypto/zk_unit_vector/decoding.rs          |  1 +
 .../src/crypto/zk_unit_vector/mod.rs               |  1 +
 .../src/vote_protocol/voter/decoding.rs            |  1 +
 rust/hermes-ipfs/Cargo.toml                        | 14 ++++----------
 rust/immutable-ledger/src/serialize.rs             |  2 +-
 .../src/cardano/cip509/utils/cip19.rs              |  5 +----
 .../src/cardano/cip509/validation.rs               |  2 +-
 rust/rust-toolchain.toml                           |  2 +-
 rust/signed_doc/tests/comment.rs                   |  6 +++---
 rust/signed_doc/tests/proposal.rs                  |  6 +++---
 rust/signed_doc/tests/submission.rs                |  6 +++---
 17 files changed, 36 insertions(+), 41 deletions(-)

diff --git a/rust/c509-certificate/examples/cli/main.rs b/rust/c509-certificate/examples/cli/main.rs
index e63d9e5f8cd..0f48f58a6a7 100644
--- a/rust/c509-certificate/examples/cli/main.rs
+++ b/rust/c509-certificate/examples/cli/main.rs
@@ -364,7 +364,7 @@ fn time_to_string(time: u64) -> anyhow::Result<String> {
     // Attempt to convert the timestamp and handle errors if they occur
     let timestamp: i64 = time
         .try_into()
-        .map_err(|e| anyhow::anyhow!("Failed to convert time: {:?}", e))?;
+        .map_err(|e| anyhow::anyhow!("Failed to convert time: {e:?}"))?;
 
     // Convert the timestamp to a DateTime and handle any potential errors
     let datetime = DateTime::from_timestamp(timestamp, 0)
diff --git a/rust/cardano-blockchain-types/src/auxdata/scripts.rs b/rust/cardano-blockchain-types/src/auxdata/scripts.rs
index d82b30d397b..751ff06d942 100644
--- a/rust/cardano-blockchain-types/src/auxdata/scripts.rs
+++ b/rust/cardano-blockchain-types/src/auxdata/scripts.rs
@@ -100,7 +100,7 @@ impl TryFrom<u64> for ScriptType {
 
     fn try_from(value: u64) -> Result<Self, Self::Error> {
         match value {
-            0 => Err(anyhow!("Invalid script type: {}", value)),
+            0 => Err(anyhow!("Invalid script type: {value}")),
             1 => Ok(Self::Native),
             _ => Ok(Self::Plutus(value.saturating_sub(1))),
         }
diff --git a/rust/cardano-chain-follower/src/mithril_snapshot_config.rs b/rust/cardano-chain-follower/src/mithril_snapshot_config.rs
index 3b53f687163..4ed01cede2b 100644
--- a/rust/cardano-chain-follower/src/mithril_snapshot_config.rs
+++ b/rust/cardano-chain-follower/src/mithril_snapshot_config.rs
@@ -247,7 +247,7 @@ impl MithrilSnapshotConfig {
 
         let Ok(relative_file) = tmp_file.strip_prefix(&tmp_path) else {
             error!("Failed to get relative path of file.");
-            bail!("Failed to strip prefix: {tmp_path:?}");
+            bail!("Failed to strip prefix: {}", tmp_file.to_string_lossy());
         };
 
         // IF we make it here, the files are identical, so we can de-dup them safely.
@@ -259,7 +259,7 @@ impl MithrilSnapshotConfig {
                     tmp_file.to_string_lossy(),
                     error
                 );
-                bail!("Failed to remove tmp file: {tmp_file:?}");
+                bail!("Failed to remove tmp file: {}", tmp_file.to_string_lossy());
             }
         }
 
@@ -268,7 +268,11 @@ impl MithrilSnapshotConfig {
         // Hardlink the src file to the tmp file.
         if let Some(parent) = tmp_file.parent() {
             if let Err(error) = std::fs::create_dir_all(parent) {
-                error!("Error creating parent dir {parent:?} for tmp file {tmp_file:?}: {error}");
+                error!(
+                    "Error creating parent dir {} for tmp file {}: {error}",
+                    parent.to_string_lossy(),
+                    tmp_file.to_string_lossy()
+                );
             }
         }
         if let Err(error) = std::fs::hard_link(src_file, tmp_file) {
@@ -278,7 +282,7 @@ impl MithrilSnapshotConfig {
                 tmp_file.to_string_lossy(),
                 error
             );
-            bail!("Failed to link src file: {src_file:?}");
+            bail!("Failed to link src file: {}", src_file.to_string_lossy());
         }
 
         // And if we made it here, file was successfully de-duped.  YAY.
diff --git a/rust/cardano-chain-follower/src/mithril_turbo_downloader.rs b/rust/cardano-chain-follower/src/mithril_turbo_downloader.rs
index 52fdfdd9051..b1e72f19340 100644
--- a/rust/cardano-chain-follower/src/mithril_turbo_downloader.rs
+++ b/rust/cardano-chain-follower/src/mithril_turbo_downloader.rs
@@ -397,7 +397,7 @@ impl FileDownloader for MithrilTurboDownloader {
 
         // We only support full downloads for now.
         if !matches!(download_event_type, DownloadEvent::Full { .. }) {
-            bail!("Unsupported Download Event Type: {:?}", download_event_type);
+            bail!("Unsupported Download Event Type: {download_event_type:?}");
         }
 
         let location = location.as_str();
diff --git a/rust/cardano-chain-follower/src/turbo_downloader/mod.rs b/rust/cardano-chain-follower/src/turbo_downloader/mod.rs
index 7ab5b64e4f8..f397aa42b06 100644
--- a/rust/cardano-chain-follower/src/turbo_downloader/mod.rs
+++ b/rust/cardano-chain-follower/src/turbo_downloader/mod.rs
@@ -417,10 +417,7 @@ impl ParallelDownloadProcessor {
         chain: Network,
     ) -> Result<Self> {
         if cfg.chunk_size < MIN_CHUNK_SIZE {
-            bail!(
-                "Download chunk size must be at least {} bytes",
-                MIN_CHUNK_SIZE
-            );
+            bail!("Download chunk size must be at least {MIN_CHUNK_SIZE} bytes");
         }
         let file_size = get_content_length_async(url).await?;
 
@@ -595,7 +592,7 @@ impl ParallelDownloadProcessor {
                 let queue = worker_queue.value();
                 queue.send(order)?;
             } else {
-                bail!("Expected a work queue for worker: {:?}", this_worker);
+                bail!("Expected a work queue for worker: {this_worker:?}");
             }
         } else {
             // No more work, so remove the work queue from the map.
@@ -779,7 +776,7 @@ async fn get_content_length_async(url: &str) -> Result<usize> {
         Ok(result) => result,
         Err(error) => {
             error!("get_content_length failed");
-            Err(anyhow::anyhow!("get_content_length failed: {}", error))
+            Err(anyhow::anyhow!("get_content_length failed: {error}"))
         },
     }
 }
@@ -799,8 +796,7 @@ fn get_content_length(url: &str) -> Result<usize> {
     if let Some(accept_ranges) = response.header(ACCEPT_RANGES.as_str()) {
         if accept_ranges != "bytes" {
             bail!(
-                "Server doesn't support HTTP range byte requests (Accept-Ranges = {})",
-                accept_ranges
+                "Server doesn't support HTTP range byte requests (Accept-Ranges = {accept_ranges})"
             );
         }
     } else {
diff --git a/rust/catalyst-voting/src/crypto/babystep_giantstep.rs b/rust/catalyst-voting/src/crypto/babystep_giantstep.rs
index 431d37e5e1b..db922d4ef57 100644
--- a/rust/catalyst-voting/src/crypto/babystep_giantstep.rs
+++ b/rust/catalyst-voting/src/crypto/babystep_giantstep.rs
@@ -110,6 +110,7 @@ mod tests {
 
     // Starting `max_log_value` from 2 allows to eliminate possible `Invalid use of empty
     // range 1..1` for `log` strategy
+    #[allow(clippy::explicit_deref_methods)]
     #[proptest]
     fn baby_step_giant_step_test(
         #[strategy(2..10000u64)] max_log_value: u64,
diff --git a/rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs b/rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs
index 6f743e655aa..bcbbc7fe914 100644
--- a/rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs
+++ b/rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs
@@ -160,6 +160,7 @@ mod tests {
 
     use super::*;
 
+    #[allow(clippy::explicit_deref_methods)]
     #[proptest]
     fn proof_to_bytes_from_bytes_test(
         #[strategy(0..5usize)] _size: usize,
diff --git a/rust/catalyst-voting/src/crypto/zk_unit_vector/mod.rs b/rust/catalyst-voting/src/crypto/zk_unit_vector/mod.rs
index d9266477179..9990e7a8dc2 100644
--- a/rust/catalyst-voting/src/crypto/zk_unit_vector/mod.rs
+++ b/rust/catalyst-voting/src/crypto/zk_unit_vector/mod.rs
@@ -298,6 +298,7 @@ mod tests {
         ones == 1 && zeros == vector.len() - 1
     }
 
+    #[allow(clippy::explicit_deref_methods)]
     #[proptest(cases = 10)]
     fn zk_unit_vector_test(
         secret_key: Scalar,
diff --git a/rust/catalyst-voting/src/vote_protocol/voter/decoding.rs b/rust/catalyst-voting/src/vote_protocol/voter/decoding.rs
index c746a140545..b935ac446a7 100644
--- a/rust/catalyst-voting/src/vote_protocol/voter/decoding.rs
+++ b/rust/catalyst-voting/src/vote_protocol/voter/decoding.rs
@@ -91,6 +91,7 @@ mod tests {
 
     use super::*;
 
+    #[allow(clippy::explicit_deref_methods)]
     #[proptest]
     fn encrypted_vote_to_bytes_from_bytes_test(
         #[strategy(0..5usize)] _size: usize,
diff --git a/rust/hermes-ipfs/Cargo.toml b/rust/hermes-ipfs/Cargo.toml
index dca8c10dc6f..079bf81ce36 100644
--- a/rust/hermes-ipfs/Cargo.toml
+++ b/rust/hermes-ipfs/Cargo.toml
@@ -14,24 +14,18 @@ workspace = true
 
 [dependencies]
 anyhow = "1.0.95"
-derive_more = {version = "1.0.0", features = ["from","into","display"] }
+derive_more = {version = "2.0.1", features = ["from","into","display"] }
 ipld-core = { version = "0.4.1", features = ["serde"]}
 # A fork of crates-io version with updated dependencies (`libp2p` and `ring` in particular).
-rust-ipfs = { version = "0.15.0", git = "https://github.com/dariusc93/rust-ipfs" }
+# rev-26b99cb as at July 30, 2025
+rust-ipfs = { version = "0.15.0", git = "https://github.com/dariusc93/rust-ipfs", rev = "26b99cb" }
 tokio = "1.46.0"
-# Its a transitive dependency of the "rust-ipfs" crate,
-# could be removed after bumped to the rustc compiler 1.87
-yamux = "=0.13.5"
 
 [dev-dependencies]
 # Dependencies used by examples
 clap = { version = "4.5.23", features = ["derive"] }
-dirs = "5.0.1"
+dirs = "6.0.0"
 lipsum = "0.9.1"
 rand = "0.8.5"
 rustyline-async = "0.4.5"
 tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
-
-[package.metadata.cargo-machete]
-# remove that after fixing issues with latest crates
-ignored = ["yamux"]
diff --git a/rust/immutable-ledger/src/serialize.rs b/rust/immutable-ledger/src/serialize.rs
index d8640d2bc4c..795e196ffa8 100644
--- a/rust/immutable-ledger/src/serialize.rs
+++ b/rust/immutable-ledger/src/serialize.rs
@@ -437,7 +437,7 @@ impl BlockHeader {
         let prev_block_hash_type = match hash_function.as_u64() {
             BLAKE3_CBOR_TAG => HashFunction::Blake3,
             BLAKE_2B_CBOR_TAG => HashFunction::Blake2b,
-            _ => bail!(format!("Invalid hash function type {:?}", hash_function)),
+            _ => bail!(format!("Invalid hash function type {hash_function:?}")),
         };
 
         let prev_block_hash = cbor_decoder
diff --git a/rust/rbac-registration/src/cardano/cip509/utils/cip19.rs b/rust/rbac-registration/src/cardano/cip509/utils/cip19.rs
index 1e15e3aac29..9929886f19a 100644
--- a/rust/rbac-registration/src/cardano/cip509/utils/cip19.rs
+++ b/rust/rbac-registration/src/cardano/cip509/utils/cip19.rs
@@ -22,10 +22,7 @@ pub(crate) fn compare_key_hash(
     pk_addrs.iter().try_for_each(|pk_addr| {
         // Key hash not found in the transaction witness set
         if !witness.check_witness_in_tx(pk_addr, txn_idx) {
-            bail!(
-                "Public key hash not found in transaction witness set given {:?}",
-                pk_addr
-            );
+            bail!("Public key hash not found in transaction witness set given {pk_addr:?}");
         }
 
         Ok(())
diff --git a/rust/rbac-registration/src/cardano/cip509/validation.rs b/rust/rbac-registration/src/cardano/cip509/validation.rs
index 88c54ba7699..3fcb13b48cc 100644
--- a/rust/rbac-registration/src/cardano/cip509/validation.rs
+++ b/rust/rbac-registration/src/cardano/cip509/validation.rs
@@ -125,7 +125,7 @@ pub fn validate_stake_public_key(
     let context = "Cip509 stake public key validation";
 
     let transaction = MultiEraTx::Conway(Box::new(Cow::Borrowed(transaction)));
-    let witness = match TxnWitness::new(&[transaction.clone()]) {
+    let witness = match TxnWitness::new(std::slice::from_ref(&transaction)) {
         Ok(w) => w,
         Err(e) => {
             report.other(&format!("Failed to create TxWitness: {e:?}"), context);
diff --git a/rust/rust-toolchain.toml b/rust/rust-toolchain.toml
index 17b9824d906..e9026cc826d 100644
--- a/rust/rust-toolchain.toml
+++ b/rust/rust-toolchain.toml
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "1.88"
+channel = "1.89"
 profile = "default"
\ No newline at end of file
diff --git a/rust/signed_doc/tests/comment.rs b/rust/signed_doc/tests/comment.rs
index 4bce4ff5d68..001a5a16a24 100644
--- a/rust/signed_doc/tests/comment.rs
+++ b/rust/signed_doc/tests/comment.rs
@@ -7,7 +7,7 @@ mod common;
 
 // not going to fix this tests for this feature branch.
 // its going to be covered as `cat-gateway` integration tests.
-#[allow(dead_code)]
+#[allow(dead_code, clippy::unwrap_used)]
 async fn test_valid_comment_doc() {
     let (proposal_doc, proposal_doc_id, proposal_doc_ver) =
         common::create_dummy_doc(doc_types::PROPOSAL_DOCUMENT_UUID_TYPE).unwrap();
@@ -47,7 +47,7 @@ async fn test_valid_comment_doc() {
 
 // not going to fix this tests for this feature branch.
 // its going to be covered as `cat-gateway` integration tests.
-#[allow(dead_code)]
+#[allow(dead_code, clippy::unwrap_used)]
 async fn test_valid_comment_doc_with_reply() {
     let empty_json = serde_json::to_vec(&serde_json::json!({})).unwrap();
 
@@ -112,7 +112,7 @@ async fn test_valid_comment_doc_with_reply() {
 
 // not going to fix this tests for this feature branch.
 // its going to be covered as `cat-gateway` integration tests.
-#[allow(dead_code)]
+#[allow(dead_code, clippy::unwrap_used)]
 async fn test_invalid_comment_doc() {
     let (proposal_doc, ..) =
         common::create_dummy_doc(doc_types::PROPOSAL_DOCUMENT_UUID_TYPE).unwrap();
diff --git a/rust/signed_doc/tests/proposal.rs b/rust/signed_doc/tests/proposal.rs
index 13a0fa77ee3..5fa5b3de522 100644
--- a/rust/signed_doc/tests/proposal.rs
+++ b/rust/signed_doc/tests/proposal.rs
@@ -7,7 +7,7 @@ mod common;
 
 // not going to fix this tests for this feature branch.
 // its going to be covered as `cat-gateway` integration tests.
-#[allow(dead_code)]
+#[allow(dead_code, clippy::unwrap_used)]
 async fn test_valid_proposal_doc() {
     let (template_doc, template_doc_id, template_doc_ver) =
         common::create_dummy_doc(doc_types::PROPOSAL_TEMPLATE_UUID_TYPE).unwrap();
@@ -39,7 +39,7 @@ async fn test_valid_proposal_doc() {
 
 // not going to fix this tests for this feature branch.
 // its going to be covered as `cat-gateway` integration tests.
-#[allow(dead_code)]
+#[allow(dead_code, clippy::unwrap_used)]
 async fn test_valid_proposal_doc_with_empty_provider() {
     // dummy template doc to dummy provider
     let template_doc_id = UuidV7::new();
@@ -72,7 +72,7 @@ async fn test_valid_proposal_doc_with_empty_provider() {
 
 // not going to fix this tests for this feature branch.
 // its going to be covered as `cat-gateway` integration tests.
-#[allow(dead_code)]
+#[allow(dead_code, clippy::unwrap_used)]
 async fn test_invalid_proposal_doc() {
     let uuid_v7 = UuidV7::new();
     let (doc, ..) = common::create_dummy_signed_doc(
diff --git a/rust/signed_doc/tests/submission.rs b/rust/signed_doc/tests/submission.rs
index 946e3a12094..d1169aa0bca 100644
--- a/rust/signed_doc/tests/submission.rs
+++ b/rust/signed_doc/tests/submission.rs
@@ -7,7 +7,7 @@ mod common;
 
 // not going to fix this tests for this feature branch.
 // its going to be covered as `cat-gateway` integration tests.
-#[allow(dead_code)]
+#[allow(dead_code, clippy::unwrap_used)]
 async fn test_valid_submission_action() {
     let (proposal_doc, proposal_doc_id, proposal_doc_ver) =
         common::create_dummy_doc(doc_types::PROPOSAL_DOCUMENT_UUID_TYPE).unwrap();
@@ -41,7 +41,7 @@ async fn test_valid_submission_action() {
 
 // not going to fix this tests for this feature branch.
 // its going to be covered as `cat-gateway` integration tests.
-#[allow(dead_code)]
+#[allow(dead_code, clippy::unwrap_used)]
 async fn test_valid_submission_action_with_empty_provider() {
     let proposal_doc_id = UuidV7::new();
     let proposal_doc_ver = UuidV7::new();
@@ -76,7 +76,7 @@ async fn test_valid_submission_action_with_empty_provider() {
 
 // not going to fix this tests for this feature branch.
 // its going to be covered as `cat-gateway` integration tests.
-#[allow(dead_code)]
+#[allow(dead_code, clippy::unwrap_used)]
 async fn test_invalid_submission_action() {
     let uuid_v7 = UuidV7::new();
     // missing `ref` field

From b773a80b48d86161b99637407ff3d13a472ed216 Mon Sep 17 00:00:00 2001
From: Mr-Leshiy <leshiy12345678@gmail.com>
Date: Tue, 7 Oct 2025 15:20:08 +0700
Subject: [PATCH 5/5] fix clippy

---
 .../src/chain_sync_config.rs                       |  9 +++------
 .../src/mithril_snapshot_config.rs                 | 14 +++++---------
 rust/catalyst-voting/benches/vote_protocol.rs      |  3 ++-
 .../src/crypto/babystep_giantstep.rs               |  3 ++-
 .../src/crypto/zk_unit_vector/decoding.rs          |  3 ++-
 .../src/crypto/zk_unit_vector/mod.rs               |  2 ++
 .../src/vote_protocol/voter/decoding.rs            |  3 ++-
 rust/catalyst-voting/tests/voting_test.rs          |  1 +
 rust/vote-tx-v1/src/decoding.rs                    |  2 ++
 rust/vote-tx-v1/src/lib.rs                         |  2 ++
 rust/vote-tx-v2/src/gen_tx/mod.rs                  |  3 +++
 11 files changed, 26 insertions(+), 19 deletions(-)

diff --git a/rust/cardano-chain-follower/src/chain_sync_config.rs b/rust/cardano-chain-follower/src/chain_sync_config.rs
index 6de7f8f929a..940a8ec2974 100644
--- a/rust/cardano-chain-follower/src/chain_sync_config.rs
+++ b/rust/cardano-chain-follower/src/chain_sync_config.rs
@@ -145,12 +145,9 @@ impl ChainSyncConfig {
         stats::sync_started(self.chain);
 
         // Start the Chain Sync - IFF its not already running.
-        let lock_entry = match SYNC_JOIN_HANDLE_MAP.get(&self.chain) {
-            None => {
-                error!("Join Map improperly initialized: Missing {}!!", self.chain);
-                return Err(Error::Internal); // Should not get here.
-            },
-            Some(entry) => entry,
+        let Some(lock_entry) = SYNC_JOIN_HANDLE_MAP.get(&self.chain) else {
+            error!("Join Map improperly initialized: Missing {}!!", self.chain);
+            return Err(Error::Internal); // Should not get here.
         };
         let mut locked_handle = lock_entry.value().lock().await;
 
diff --git a/rust/cardano-chain-follower/src/mithril_snapshot_config.rs b/rust/cardano-chain-follower/src/mithril_snapshot_config.rs
index 4ed01cede2b..9b6959b0319 100644
--- a/rust/cardano-chain-follower/src/mithril_snapshot_config.rs
+++ b/rust/cardano-chain-follower/src/mithril_snapshot_config.rs
@@ -407,12 +407,9 @@ impl MithrilSnapshotConfig {
         );
 
         // Start the Mithril Sync - IFF its not already running.
-        let lock_entry = match SYNC_JOIN_HANDLE_MAP.get(&self.chain) {
-            None => {
-                error!("Join Map improperly initialized: Missing {}!!", self.chain);
-                return Err(Error::Internal); // Should not get here.
-            },
-            Some(entry) => entry,
+        let Some(lock_entry) = SYNC_JOIN_HANDLE_MAP.get(&self.chain) else {
+            error!("Join Map improperly initialized: Missing {}!!", self.chain);
+            return Err(Error::Internal); // Should not get here.
         };
         let mut locked_handle = lock_entry.value().lock().await;
 
@@ -463,9 +460,8 @@ fn check_writable(path: &Path) -> bool {
     }
 
     // Can't read the directory for any reason, so can't write to the directory.
-    let path_iterator = match path.read_dir() {
-        Err(_) => return false,
-        Ok(entries) => entries,
+    let Ok(path_iterator) = path.read_dir() else {
+        return false;
     };
 
     // Recursively check the contents of the directory
diff --git a/rust/catalyst-voting/benches/vote_protocol.rs b/rust/catalyst-voting/benches/vote_protocol.rs
index 38dea85e556..64077920c0e 100644
--- a/rust/catalyst-voting/benches/vote_protocol.rs
+++ b/rust/catalyst-voting/benches/vote_protocol.rs
@@ -8,7 +8,8 @@
     missing_docs,
     clippy::missing_docs_in_private_items,
     clippy::unwrap_used,
-    clippy::similar_names
+    clippy::similar_names,
+    clippy::explicit_deref_methods
 )]
 
 use catalyst_voting::{
diff --git a/rust/catalyst-voting/src/crypto/babystep_giantstep.rs b/rust/catalyst-voting/src/crypto/babystep_giantstep.rs
index db922d4ef57..7b589d7250c 100644
--- a/rust/catalyst-voting/src/crypto/babystep_giantstep.rs
+++ b/rust/catalyst-voting/src/crypto/babystep_giantstep.rs
@@ -102,6 +102,8 @@ impl BabyStepGiantStep {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::explicit_deref_methods)]
+
     use std::ops::Mul;
 
     use test_strategy::proptest;
@@ -110,7 +112,6 @@ mod tests {
 
     // Starting `max_log_value` from 2 allows to eliminate possible `Invalid use of empty
     // range 1..1` for `log` strategy
-    #[allow(clippy::explicit_deref_methods)]
     #[proptest]
     fn baby_step_giant_step_test(
         #[strategy(2..10000u64)] max_log_value: u64,
diff --git a/rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs b/rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs
index bcbbc7fe914..364e2b07f8d 100644
--- a/rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs
+++ b/rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs
@@ -156,11 +156,12 @@ impl ResponseRandomness {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::explicit_deref_methods)]
+
     use test_strategy::proptest;
 
     use super::*;
 
-    #[allow(clippy::explicit_deref_methods)]
     #[proptest]
     fn proof_to_bytes_from_bytes_test(
         #[strategy(0..5usize)] _size: usize,
diff --git a/rust/catalyst-voting/src/crypto/zk_unit_vector/mod.rs b/rust/catalyst-voting/src/crypto/zk_unit_vector/mod.rs
index 9990e7a8dc2..9e3ab8b83c2 100644
--- a/rust/catalyst-voting/src/crypto/zk_unit_vector/mod.rs
+++ b/rust/catalyst-voting/src/crypto/zk_unit_vector/mod.rs
@@ -286,6 +286,8 @@ mod arbitrary_impl {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::explicit_deref_methods)]
+
     use proptest::sample::size_range;
     use rand_core::OsRng;
     use test_strategy::proptest;
diff --git a/rust/catalyst-voting/src/vote_protocol/voter/decoding.rs b/rust/catalyst-voting/src/vote_protocol/voter/decoding.rs
index b935ac446a7..fb11f273d6e 100644
--- a/rust/catalyst-voting/src/vote_protocol/voter/decoding.rs
+++ b/rust/catalyst-voting/src/vote_protocol/voter/decoding.rs
@@ -85,13 +85,14 @@ impl VoterProof {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::explicit_deref_methods)]
+
     use std::io::Cursor;
 
     use test_strategy::proptest;
 
     use super::*;
 
-    #[allow(clippy::explicit_deref_methods)]
     #[proptest]
     fn encrypted_vote_to_bytes_from_bytes_test(
         #[strategy(0..5usize)] _size: usize,
diff --git a/rust/catalyst-voting/tests/voting_test.rs b/rust/catalyst-voting/tests/voting_test.rs
index 1e699bd4b8b..dad2adeab20 100644
--- a/rust/catalyst-voting/tests/voting_test.rs
+++ b/rust/catalyst-voting/tests/voting_test.rs
@@ -1,4 +1,5 @@
 //! A general voting integration test, which performs a full voting procedure.
+#![allow(clippy::explicit_deref_methods)]
 
 use catalyst_voting::vote_protocol::{
     committee::ElectionSecretKey,
diff --git a/rust/vote-tx-v1/src/decoding.rs b/rust/vote-tx-v1/src/decoding.rs
index 1650b1edecd..b933daa5a92 100644
--- a/rust/vote-tx-v1/src/decoding.rs
+++ b/rust/vote-tx-v1/src/decoding.rs
@@ -220,6 +220,8 @@ impl Tx {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::explicit_deref_methods)]
+
     use catalyst_voting::{
         crypto::{ed25519::PrivateKey, rng::rand_core::OsRng},
         vote_protocol::committee::ElectionSecretKey,
diff --git a/rust/vote-tx-v1/src/lib.rs b/rust/vote-tx-v1/src/lib.rs
index 5874c4944b2..7dfdb5f1ed8 100644
--- a/rust/vote-tx-v1/src/lib.rs
+++ b/rust/vote-tx-v1/src/lib.rs
@@ -327,6 +327,8 @@ impl VotePayload {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::explicit_deref_methods)]
+
     use catalyst_voting::{
         crypto::ed25519::PrivateKey, vote_protocol::committee::ElectionSecretKey,
     };
diff --git a/rust/vote-tx-v2/src/gen_tx/mod.rs b/rust/vote-tx-v2/src/gen_tx/mod.rs
index fed0d288ac4..9986a5b4c50 100644
--- a/rust/vote-tx-v2/src/gen_tx/mod.rs
+++ b/rust/vote-tx-v2/src/gen_tx/mod.rs
@@ -126,6 +126,8 @@ fn cose_protected_header() -> coset::Header {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::explicit_deref_methods)]
+
     use proptest::{prelude::any_with, sample::size_range};
     use proptest_derive::Arbitrary;
     use test_strategy::proptest;
@@ -157,6 +159,7 @@ mod tests {
         }
     }
 
+    #[allow(clippy::explicit_deref_methods)]
     #[proptest]
     fn generalized_tx_from_bytes_to_bytes_test(
         vote_type: Vec<u8>,