diff --git a/.github/workflows/fuzz.yml b/.github/workflows/fuzz.yml
index f3b806e88..1b8fd9770 100644
--- a/.github/workflows/fuzz.yml
+++ b/.github/workflows/fuzz.yml
@@ -11,7 +11,7 @@ on:
 jobs:
   fuzz:
     if: ${{ !github.event.act }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
@@ -50,7 +50,7 @@ jobs:
           key: cache-${{ matrix.target }}-${{ hashFiles('**/Cargo.toml','**/Cargo.lock') }}
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.80
+          toolchain: 1.85
           override: true
           profile: minimal
       - name: fuzz
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 78e0620de..d4ca35356 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -26,7 +26,7 @@ jobs:
               AS_DEPENDENCY: true
               DO_NO_STD: false
               DO_DOCS: true
-          - rust: 1.80.0
+          - rust: 1.85.0
             env:
               AS_DEPENDENCY: true
     steps:
@@ -99,7 +99,7 @@ jobs:
             - rust: nightly
               env:
                 RUSTFMTCHK: false
-            - rust: 1.29.0
+            - rust: 1.85.0
               env:
                 PIN_VERSIONS: true
       steps:
diff --git a/dash/Cargo.toml b/dash/Cargo.toml
index f54b115a5..7de35a51a 100644
--- a/dash/Cargo.toml
+++ b/dash/Cargo.toml
@@ -15,7 +15,7 @@ categories = ["cryptography::cryptocurrencies"]
 keywords = [ "crypto", "dash" ]
 readme = "../README.md"
 exclude = ["tests", "contrib"]
-edition = "2021"
+edition = "2024"
 
 # Please don't forget to add relevant features to docs.rs below
 [features]
@@ -48,13 +48,13 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [dependencies]
 internals = { path = "../internals", package = "dashcore-private" }
-bech32 = { version = "0.9.0", default-features = false }
+bech32 = { version = "0.9.1", default-features = false }
 dashcore_hashes = { path = "../hashes", default-features = false }
 secp256k1 = { default-features = false, features = ["hashes"], version= "0.30.0" }
-core2 = { version = "0.3.0", optional = true, features = ["alloc"], default-features = false }
-rustversion = { version="1.0.9"}
+core2 = { version = "0.4.0", optional = true, features = ["alloc"], default-features = false }
+rustversion = { version="1.0.20"}
 # Do NOT use this as a feature! Use the `serde` feature instead.
-actual-serde = { package = "serde", version = "1.0.103", default-features = false, features = [ "derive", "alloc" ], optional = true }
+actual-serde = { package = "serde", version = "1.0.219", default-features = false, features = [ "derive", "alloc" ], optional = true }
 
 base64-compat = { version = "1.0.0", optional = true }
 bitcoinconsensus = { version = "0.20.2-0.5.0", default-features = false, optional = true }
@@ -62,24 +62,20 @@ hex_lit = "0.1.1"
 anyhow = { version= "1.0" }
 hex = { version= "0.4" }
 bincode = { version= "=2.0.0-rc.3", optional = true }
-bitflags = "2.6.0"
+bitflags = "2.9.0"
 blsful = { version = "3.0.0-pre8", optional = true }
-serde_repr = "0.1.19"
-strum = { version = "0.26", features = ["derive"] }
-lazy_static = "1.5.0"
 ed25519-dalek = { version = "2.1", features = ["rand_core"], optional = true }
-blake3 = "1.5"
-thiserror = "1"
+blake3 = "1.8.1"
+thiserror = "2"
 # version 1.3.5 is 0bb5c5b03249c463debb5cef5f7e52ee66f3aaab
 bls-signatures = { git = "https://github.com/dashpay/bls-signatures", rev = "0bb5c5b03249c463debb5cef5f7e52ee66f3aaab", optional = true }
 
 [dev-dependencies]
-serde_json = "1.0.96"
-serde_test = "1.0.19"
-serde_derive = "1.0.103"
+serde_json = "1.0.140"
+serde_test = "1.0.177"
+serde_derive = "1.0.219"
 secp256k1 = { features = [ "recovery", "rand", "hashes" ], version="0.30.0" }
-bip39 = "2.0.0"
-bincode_test = {package = "bincode", version= "1.3.3" }
+bincode = { version= "=2.0.0-rc.3" }
 assert_matches = "1.5.0"
 dashcore = { path = ".", features = ["core-block-hash-use-x11", "message_verification", "quorum_validation", "signer"] }
 
diff --git a/dash/embedded/Cargo.toml b/dash/embedded/Cargo.toml
index 32adaa275..b044baddd 100644
--- a/dash/embedded/Cargo.toml
+++ b/dash/embedded/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 authors = ["Riccardo Casatta <riccardo@casatta.it>", "Dev Random <c1.devrandom@niftybox.net>"]
-edition = "2018"
+edition = "2024"
 readme = "README.md"
 name = "embedded"
 version = "0.1.0"
diff --git a/dash/examples/bip32.rs b/dash/examples/bip32.rs
index edbab561b..648c348ef 100644
--- a/dash/examples/bip32.rs
+++ b/dash/examples/bip32.rs
@@ -3,12 +3,12 @@ extern crate dashcore;
 use std::str::FromStr;
 use std::{env, process};
 
+use dashcore::PublicKey;
 use dashcore::address::Address;
 use dashcore::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey};
 use dashcore::hashes::hex::FromHex;
-use dashcore::secp256k1::ffi::types::AlignedType;
 use dashcore::secp256k1::Secp256k1;
-use dashcore::PublicKey;
+use dashcore::secp256k1::ffi::types::AlignedType;
 
 fn main() {
     // This example derives root xprv from a 32-byte seed,
diff --git a/dash/examples/handshake.rs b/dash/examples/handshake.rs
index 4ded0077a..dc6c6ef60 100644
--- a/dash/examples/handshake.rs
+++ b/dash/examples/handshake.rs
@@ -5,7 +5,7 @@ use std::net::{IpAddr, Ipv4Addr, Shutdown, SocketAddr, TcpStream};
 use std::time::{SystemTime, UNIX_EPOCH};
 use std::{env, process};
 
-use dashcore::consensus::{encode, Decodable};
+use dashcore::consensus::{Decodable, encode};
 use dashcore::network::{address, constants, message, message_network};
 use dashcore::secp256k1;
 use dashcore::secp256k1::rand::Rng;
@@ -90,7 +90,7 @@ fn build_version_message(address: SocketAddr) -> message::NetworkMessage {
     let addr_from = address::Address::new(&my_address, constants::ServiceFlags::NONE);
 
     // "Node random nonce, randomly generated every time a version packet is sent. This nonce is used to detect connections to self."
-    let nonce: u64 = secp256k1::rand::thread_rng().gen();
+    let nonce: u64 = rand::thread_rng().r#gen();
 
     // "User Agent (0x00 if string is 0 bytes long)"
     let user_agent = String::from("rust-example");
diff --git a/dash/examples/taproot-psbt.rs b/dash/examples/taproot-psbt.rs
index 42d168e83..c87b69317 100644
--- a/dash/examples/taproot-psbt.rs
+++ b/dash/examples/taproot-psbt.rs
@@ -88,8 +88,8 @@ use dashcore::secp256k1::Secp256k1;
 use dashcore::sighash::{self, SighashCache, TapSighash, TapSighashType};
 use dashcore::taproot::{self, LeafVersion, TapLeafHash, TaprootBuilder, TaprootSpendInfo};
 use dashcore::{
-    absolute, script, Address, Amount, Network, OutPoint, ScriptBuf, Transaction, TxIn, TxOut,
-    Witness,
+    Address, Amount, Network, OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Witness, absolute,
+    script,
 };
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
diff --git a/dash/src/address.rs b/dash/src/address.rs
index c854cd397..d82f2a5ad 100644
--- a/dash/src/address.rs
+++ b/dash/src/address.rs
@@ -47,7 +47,7 @@ use core::marker::PhantomData;
 use core::str::FromStr;
 
 use bech32;
-use hashes::{sha256, Hash, HashEngine};
+use hashes::{Hash, HashEngine, sha256};
 use internals::write_err;
 use secp256k1::{Secp256k1, Verification, XOnlyPublicKey};
 
@@ -862,7 +862,7 @@ impl<V: NetworkValidation> Address<V> {
         match self.payload() {
             Payload::PubkeyHash(_) => Some(AddressType::P2pkh),
             Payload::ScriptHash(_) => Some(AddressType::P2sh),
-            Payload::WitnessProgram(ref prog) => {
+            Payload::WitnessProgram(prog) => {
                 // BIP-141 p2wpkh or p2wsh addresses.
                 match prog.version() {
                     WitnessVersion::V0 => match prog.program().len() {
diff --git a/dash/src/amount.rs b/dash/src/amount.rs
index 1863e0e9e..c2becd5e9 100644
--- a/dash/src/amount.rs
+++ b/dash/src/amount.rs
@@ -1378,7 +1378,7 @@ pub mod serde {
             use core::fmt;
             use core::marker::PhantomData;
 
-            use serde::{de, Deserializer, Serializer};
+            use serde::{Deserializer, Serializer, de};
 
             use crate::amount::serde::SerdeAmountForOpt;
 
@@ -1445,7 +1445,7 @@ pub mod serde {
             use core::fmt;
             use core::marker::PhantomData;
 
-            use serde::{de, Deserializer, Serializer};
+            use serde::{Deserializer, Serializer, de};
 
             use crate::amount::serde::SerdeAmountForOpt;
 
diff --git a/dash/src/base58.rs b/dash/src/base58.rs
index 4e1f9a2cc..23ac1c714 100644
--- a/dash/src/base58.rs
+++ b/dash/src/base58.rs
@@ -23,7 +23,7 @@
 
 use core::{fmt, iter, slice, str};
 
-use hashes::{hex, sha256d, Hash};
+use hashes::{Hash, hex, sha256d};
 use secp256k1;
 
 use crate::key;
@@ -455,8 +455,7 @@ mod tests {
         coinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoin"
                 .as_bytes(),
         );
-        let exp =
-            "ZqC5ZdfpZRi7fjA8hbhX5pEE96MdH9hEaC1YouxscPtbJF16qVWksHWR4wwvx7MotFcs2ChbJqK8KJ9X\
+        let exp = "ZqC5ZdfpZRi7fjA8hbhX5pEE96MdH9hEaC1YouxscPtbJF16qVWksHWR4wwvx7MotFcs2ChbJqK8KJ9X\
         wZznwWn1JFDhhTmGo9v6GjAVikzCsBWZehu7bm22xL8b5zBR5AsBygYRwbFJsNwNkjpyFuDKwmsUTKvkULCvucPJrN5\
         QUdxpGakhqkZFL7RU4yT";
         assert_eq!(&res, exp);
diff --git a/dash/src/bip152.rs b/dash/src/bip152.rs
index 0777850ed..ff3839868 100644
--- a/dash/src/bip152.rs
+++ b/dash/src/bip152.rs
@@ -10,13 +10,13 @@ use core::{convert, fmt, mem};
 #[cfg(feature = "std")]
 use std::error;
 
-use hashes::{sha256, siphash24, Hash};
+use hashes::{Hash, sha256, siphash24};
 use internals::impl_array_newtype;
 
 use crate::consensus::encode::{self, Decodable, Encodable, VarInt};
 use crate::internal_macros::{impl_bytes_newtype, impl_consensus_encoding};
 use crate::prelude::*;
-use crate::{block, io, Block, BlockHash, Transaction};
+use crate::{Block, BlockHash, Transaction, block, io};
 
 /// A BIP-152 error
 #[derive(Clone, PartialEq, Eq, Debug, Copy, PartialOrd, Ord, Hash)]
@@ -381,10 +381,10 @@ mod test {
     use super::*;
     use crate::blockdata::locktime::absolute;
     use crate::blockdata::script::ScriptBuf;
+    use crate::blockdata::transaction::Transaction;
     use crate::blockdata::transaction::outpoint::OutPoint;
     use crate::blockdata::transaction::txin::TxIn;
     use crate::blockdata::transaction::txout::TxOut;
-    use crate::blockdata::transaction::Transaction;
     use crate::blockdata::witness::Witness;
     use crate::consensus::encode::{deserialize, serialize};
     use crate::hash_types::{TxMerkleNode, Txid};
diff --git a/dash/src/bip158.rs b/dash/src/bip158.rs
index 242579434..7377f4735 100644
--- a/dash/src/bip158.rs
+++ b/dash/src/bip158.rs
@@ -43,7 +43,7 @@ use core::cmp::{self, Ordering};
 use core::convert::TryInto;
 use core::fmt::{self, Display, Formatter};
 
-use hashes::{siphash24, Hash};
+use hashes::{Hash, siphash24};
 use internals::write_err;
 
 use crate::blockdata::block::Block;
@@ -601,10 +601,10 @@ mod test {
     use serde_json::Value;
 
     use super::*;
+    use crate::ScriptBuf;
     use crate::consensus::encode::deserialize;
     use crate::hash_types::BlockHash;
     use crate::internal_macros::hex;
-    use crate::ScriptBuf;
 
     #[ignore]
     #[test]
@@ -649,23 +649,27 @@ mod test {
             assert_eq!(test_filter.content, filter.content);
 
             let block_hash = &block.block_hash();
-            assert!(filter
-                .match_all(
-                    block_hash,
-                    &mut txmap.iter().filter_map(|(_, s)| if !s.is_empty() {
-                        Some(s.as_bytes())
-                    } else {
-                        None
-                    })
-                )
-                .unwrap());
+            assert!(
+                filter
+                    .match_all(
+                        block_hash,
+                        &mut txmap.iter().filter_map(|(_, s)| if !s.is_empty() {
+                            Some(s.as_bytes())
+                        } else {
+                            None
+                        })
+                    )
+                    .unwrap()
+            );
 
             for script in txmap.values() {
                 let query = [script];
                 if !script.is_empty() {
-                    assert!(filter
-                        .match_any(block_hash, &mut query.iter().map(|s| s.as_bytes()))
-                        .unwrap());
+                    assert!(
+                        filter
+                            .match_any(block_hash, &mut query.iter().map(|s| s.as_bytes()))
+                            .unwrap()
+                    );
                 }
             }
 
@@ -708,16 +712,20 @@ mod test {
         {
             let query = [hex!("abcdef"), hex!("eeeeee")];
             let reader = GcsFilterReader::new(0, 0, M, P);
-            assert!(reader
-                .match_any(&mut bytes.as_slice(), &mut query.iter().map(|v| v.as_slice()))
-                .unwrap());
+            assert!(
+                reader
+                    .match_any(&mut bytes.as_slice(), &mut query.iter().map(|v| v.as_slice()))
+                    .unwrap()
+            );
         }
         {
             let query = [hex!("abcdef"), hex!("123456")];
             let reader = GcsFilterReader::new(0, 0, M, P);
-            assert!(!reader
-                .match_any(&mut bytes.as_slice(), &mut query.iter().map(|v| v.as_slice()))
-                .unwrap());
+            assert!(
+                !reader
+                    .match_any(&mut bytes.as_slice(), &mut query.iter().map(|v| v.as_slice()))
+                    .unwrap()
+            );
         }
         {
             let reader = GcsFilterReader::new(0, 0, M, P);
@@ -725,9 +733,11 @@ mod test {
             for p in &patterns {
                 query.push(p.clone());
             }
-            assert!(reader
-                .match_all(&mut bytes.as_slice(), &mut query.iter().map(|v| v.as_slice()))
-                .unwrap());
+            assert!(
+                reader
+                    .match_all(&mut bytes.as_slice(), &mut query.iter().map(|v| v.as_slice()))
+                    .unwrap()
+            );
         }
         {
             let reader = GcsFilterReader::new(0, 0, M, P);
@@ -736,9 +746,11 @@ mod test {
                 query.push(p.clone());
             }
             query.push(hex!("abcdef"));
-            assert!(!reader
-                .match_all(&mut bytes.as_slice(), &mut query.iter().map(|v| v.as_slice()))
-                .unwrap());
+            assert!(
+                !reader
+                    .match_all(&mut bytes.as_slice(), &mut query.iter().map(|v| v.as_slice()))
+                    .unwrap()
+            );
         }
     }
 
diff --git a/dash/src/bip32.rs b/dash/src/bip32.rs
index e42c83c54..3841f23f4 100644
--- a/dash/src/bip32.rs
+++ b/dash/src/bip32.rs
@@ -28,7 +28,7 @@ use core::str::FromStr;
 #[cfg(feature = "std")]
 use std::error;
 
-use hashes::{hex as hashesHex, sha512, Hash, HashEngine, Hmac, HmacEngine};
+use hashes::{Hash, HashEngine, Hmac, HmacEngine, hex as hashesHex, sha512};
 use internals::impl_array_newtype;
 use secp256k1::{self, Secp256k1, XOnlyPublicKey};
 #[cfg(feature = "serde")]
diff --git a/dash/src/blockdata/block.rs b/dash/src/blockdata/block.rs
index 88006a563..0f7da7319 100644
--- a/dash/src/blockdata/block.rs
+++ b/dash/src/blockdata/block.rs
@@ -16,14 +16,14 @@ use hashes::{Hash, HashEngine};
 use super::Weight;
 use crate::blockdata::script;
 use crate::blockdata::transaction::Transaction;
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::error::Error::{self, BlockBadProofOfWork, BlockBadTarget};
 pub use crate::hash_types::BlockHash;
 use crate::hash_types::{TxMerkleNode, WitnessCommitment, WitnessMerkleNode, Wtxid};
 use crate::internal_macros::impl_consensus_encoding;
 use crate::pow::{CompactTarget, Target, Work};
 use crate::prelude::*;
-use crate::{io, merkle_tree, VarInt};
+use crate::{VarInt, io, merkle_tree};
 
 /// Bitcoin block header.
 ///
@@ -671,11 +671,11 @@ mod tests {
 
 #[cfg(bench)]
 mod benches {
-    use test::{black_box, Bencher};
+    use test::{Bencher, black_box};
 
     use super::Block;
-    use crate::consensus::{deserialize, Decodable, Encodable};
     use crate::EmptyWrite;
+    use crate::consensus::{Decodable, Encodable, deserialize};
 
     #[bench]
     pub fn bench_stream_reader(bh: &mut Bencher) {
diff --git a/dash/src/blockdata/constants.rs b/dash/src/blockdata/constants.rs
index 54a299e38..3c86ca8b0 100644
--- a/dash/src/blockdata/constants.rs
+++ b/dash/src/blockdata/constants.rs
@@ -10,7 +10,7 @@
 
 use core::default::Default;
 
-use hashes::{sha256d, Hash};
+use hashes::{Hash, sha256d};
 use hex_lit::hex;
 use internals::impl_array_newtype;
 
@@ -18,10 +18,10 @@ use crate::blockdata::block::{self, Block};
 use crate::blockdata::locktime::absolute;
 use crate::blockdata::opcodes::all::*;
 use crate::blockdata::script;
+use crate::blockdata::transaction::Transaction;
 use crate::blockdata::transaction::outpoint::OutPoint;
 use crate::blockdata::transaction::txin::TxIn;
 use crate::blockdata::transaction::txout::TxOut;
-use crate::blockdata::transaction::Transaction;
 use crate::blockdata::witness::Witness;
 use crate::internal_macros::impl_bytes_newtype;
 use crate::network::constants::Network;
@@ -215,88 +215,88 @@ mod test {
 
     #[test]
     fn bitcoin_genesis_first_transaction() {
-        let gen = bitcoin_genesis_tx();
+        let genesis_tx = bitcoin_genesis_tx();
 
-        assert_eq!(gen.version, 1);
-        assert_eq!(gen.input.len(), 1);
-        assert_eq!(gen.input[0].previous_output.txid, Hash::all_zeros());
-        assert_eq!(gen.input[0].previous_output.vout, 0xFFFFFFFF);
+        assert_eq!(genesis_tx.version, 1);
+        assert_eq!(genesis_tx.input.len(), 1);
+        assert_eq!(genesis_tx.input[0].previous_output.txid, Hash::all_zeros());
+        assert_eq!(genesis_tx.input[0].previous_output.vout, 0xFFFFFFFF);
         assert_eq!(
-            serialize(&gen.input[0].script_sig),
+            serialize(&genesis_tx.input[0].script_sig),
             hex!(
                 "4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73"
             )
         );
 
-        assert_eq!(gen.input[0].sequence, u32::MAX);
-        assert_eq!(gen.output.len(), 1);
+        assert_eq!(genesis_tx.input[0].sequence, u32::MAX);
+        assert_eq!(genesis_tx.output.len(), 1);
         assert_eq!(
-            serialize(&gen.output[0].script_pubkey),
+            serialize(&genesis_tx.output[0].script_pubkey),
             hex!(
                 "434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac"
             )
         );
-        assert_eq!(gen.output[0].value, 50 * COIN_VALUE);
-        assert_eq!(gen.lock_time, 0);
+        assert_eq!(genesis_tx.output[0].value, 50 * COIN_VALUE);
+        assert_eq!(genesis_tx.lock_time, 0);
 
         assert_eq!(
-            gen.wtxid().to_string(),
+            genesis_tx.wtxid().to_string(),
             "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
         );
     }
 
     #[test]
     fn bitcoin_genesis_full_block() {
-        let gen = genesis_block(Network::Dash);
+        let genesis_block = genesis_block(Network::Dash);
 
-        assert_eq!(gen.header.version, block::Version::ONE);
-        assert_eq!(gen.header.prev_blockhash, Hash::all_zeros());
+        assert_eq!(genesis_block.header.version, block::Version::ONE);
+        assert_eq!(genesis_block.header.prev_blockhash, Hash::all_zeros());
         assert_eq!(
-            gen.header.merkle_root.to_string(),
+            genesis_block.header.merkle_root.to_string(),
             "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
         );
 
-        assert_eq!(gen.header.time, 1231006505);
-        assert_eq!(gen.header.bits, CompactTarget::from_consensus(0x1d00ffff));
-        assert_eq!(gen.header.nonce, 2083236893);
+        assert_eq!(genesis_block.header.time, 1231006505);
+        assert_eq!(genesis_block.header.bits, CompactTarget::from_consensus(0x1d00ffff));
+        assert_eq!(genesis_block.header.nonce, 2083236893);
         assert_eq!(
-            gen.header.block_hash().to_string(),
+            genesis_block.header.block_hash().to_string(),
             "043815c00a2a17f25adba30162593aa70504195bb7dae6e3a755276033bd0dd9"
         );
     }
 
     #[test]
     fn testnet_genesis_full_block() {
-        let gen = genesis_block(Network::Testnet);
-        assert_eq!(gen.header.version, block::Version::ONE);
-        assert_eq!(gen.header.prev_blockhash, Hash::all_zeros());
+        let genesis_block = genesis_block(Network::Testnet);
+        assert_eq!(genesis_block.header.version, block::Version::ONE);
+        assert_eq!(genesis_block.header.prev_blockhash, Hash::all_zeros());
         assert_eq!(
-            gen.header.merkle_root.to_string(),
+            genesis_block.header.merkle_root.to_string(),
             "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
         );
-        assert_eq!(gen.header.time, 1296688602);
-        assert_eq!(gen.header.bits, CompactTarget::from_consensus(0x1d00ffff));
-        assert_eq!(gen.header.nonce, 414098458);
+        assert_eq!(genesis_block.header.time, 1296688602);
+        assert_eq!(genesis_block.header.bits, CompactTarget::from_consensus(0x1d00ffff));
+        assert_eq!(genesis_block.header.nonce, 414098458);
         assert_eq!(
-            gen.header.block_hash().to_string(),
+            genesis_block.header.block_hash().to_string(),
             "10eeca342c70bb609386864b9c375acd464aca61705728852054ec7bb71cdcf0"
         );
     }
 
     #[test]
     fn devnet_genesis_full_block() {
-        let gen = genesis_block(Network::Devnet);
-        assert_eq!(gen.header.version, block::Version::ONE);
-        assert_eq!(gen.header.prev_blockhash, Hash::all_zeros());
+        let genesis_block = genesis_block(Network::Devnet);
+        assert_eq!(genesis_block.header.version, block::Version::ONE);
+        assert_eq!(genesis_block.header.prev_blockhash, Hash::all_zeros());
         assert_eq!(
-            gen.header.merkle_root.to_string(),
+            genesis_block.header.merkle_root.to_string(),
             "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
         );
-        assert_eq!(gen.header.time, 1598918400);
-        assert_eq!(gen.header.bits, CompactTarget::from_consensus(0x1e0377ae));
-        assert_eq!(gen.header.nonce, 52613770);
+        assert_eq!(genesis_block.header.time, 1598918400);
+        assert_eq!(genesis_block.header.bits, CompactTarget::from_consensus(0x1e0377ae));
+        assert_eq!(genesis_block.header.nonce, 52613770);
         assert_eq!(
-            gen.header.block_hash().to_string(),
+            genesis_block.header.block_hash().to_string(),
             "a47755be7925966f83b5b1a4ccd1ca691dc5ebf0fab3e0062eee288817d70c58"
         );
     }
diff --git a/dash/src/blockdata/fee_rate.rs b/dash/src/blockdata/fee_rate.rs
index 18a3a0e7b..d2c5bb2aa 100644
--- a/dash/src/blockdata/fee_rate.rs
+++ b/dash/src/blockdata/fee_rate.rs
@@ -4,8 +4,8 @@ use core::fmt;
 use core::ops::{Div, Mul};
 
 use super::Weight;
-use crate::prelude::*;
 use crate::Amount;
+use crate::prelude::*;
 
 /// Represents fee rate.
 ///
diff --git a/dash/src/blockdata/script/borrowed.rs b/dash/src/blockdata/script/borrowed.rs
index 7c626856d..5d8f57d71 100644
--- a/dash/src/blockdata/script/borrowed.rs
+++ b/dash/src/blockdata/script/borrowed.rs
@@ -16,7 +16,7 @@ use crate::blockdata::opcodes::{self};
 #[cfg(feature = "bitcoinconsensus")]
 use crate::blockdata::script::Error;
 use crate::blockdata::script::{
-    bytes_to_asm_fmt, Builder, Instruction, InstructionIndices, Instructions, ScriptBuf,
+    Builder, Instruction, InstructionIndices, Instructions, ScriptBuf, bytes_to_asm_fmt,
 };
 use crate::consensus::Encodable;
 use crate::hash_types::{ScriptHash, WScriptHash};
diff --git a/dash/src/blockdata/script/builder.rs b/dash/src/blockdata/script/builder.rs
index 2770387a8..b304aceda 100644
--- a/dash/src/blockdata/script/builder.rs
+++ b/dash/src/blockdata/script/builder.rs
@@ -11,7 +11,7 @@ use secp256k1::XOnlyPublicKey;
 use crate::blockdata::locktime::absolute;
 use crate::blockdata::opcodes::all::*;
 use crate::blockdata::opcodes::{self};
-use crate::blockdata::script::{opcode_to_verify, write_scriptint, PushBytes, Script, ScriptBuf};
+use crate::blockdata::script::{PushBytes, Script, ScriptBuf, opcode_to_verify, write_scriptint};
 use crate::key::PublicKey;
 use crate::prelude::*;
 
diff --git a/dash/src/blockdata/script/instruction.rs b/dash/src/blockdata/script/instruction.rs
index 140d99dd4..1c0cb9bad 100644
--- a/dash/src/blockdata/script/instruction.rs
+++ b/dash/src/blockdata/script/instruction.rs
@@ -4,7 +4,7 @@
 use core::convert::TryInto;
 
 use crate::blockdata::opcodes;
-use crate::blockdata::script::{read_uint_iter, Error, PushBytes, Script, ScriptBuf, UintError};
+use crate::blockdata::script::{Error, PushBytes, Script, ScriptBuf, UintError, read_uint_iter};
 
 /// A "parsed opcode" which allows iterating over a [`Script`] in a more sensible way.
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
diff --git a/dash/src/blockdata/script/mod.rs b/dash/src/blockdata/script/mod.rs
index 14b41382f..e01c8c91d 100644
--- a/dash/src/blockdata/script/mod.rs
+++ b/dash/src/blockdata/script/mod.rs
@@ -61,10 +61,10 @@ use serde;
 
 use crate::blockdata::opcodes::all::*;
 use crate::blockdata::opcodes::{self};
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::hash_types::{ScriptHash, WScriptHash};
 use crate::prelude::*;
-use crate::{io, OutPoint};
+use crate::{OutPoint, io};
 
 mod borrowed;
 mod builder;
diff --git a/dash/src/blockdata/script/owned.rs b/dash/src/blockdata/script/owned.rs
index 903a867f3..f7276ccf4 100644
--- a/dash/src/blockdata/script/owned.rs
+++ b/dash/src/blockdata/script/owned.rs
@@ -12,7 +12,7 @@ use secp256k1::{Secp256k1, Verification};
 use crate::address::{WitnessProgram, WitnessVersion};
 use crate::blockdata::opcodes::all::*;
 use crate::blockdata::opcodes::{self};
-use crate::blockdata::script::{opcode_to_verify, Builder, Instruction, PushBytes, Script};
+use crate::blockdata::script::{Builder, Instruction, PushBytes, Script, opcode_to_verify};
 use crate::hash_types::{PubkeyHash, ScriptHash, WPubkeyHash, WScriptHash};
 use crate::key::{PublicKey, TapTweak, TweakedPublicKey, UntweakedPublicKey};
 use crate::prelude::*;
diff --git a/dash/src/blockdata/script/tests.rs b/dash/src/blockdata/script/tests.rs
index 57b244d8c..a80291cd4 100644
--- a/dash/src/blockdata/script/tests.rs
+++ b/dash/src/blockdata/script/tests.rs
@@ -350,22 +350,30 @@ fn provably_unspendable_test() {
     assert!(!ScriptBuf::from_hex("410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac").unwrap().is_provably_unspendable());
     assert!(!ScriptBuf::from_hex("4104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac").unwrap().is_provably_unspendable());
     // p2pkhash
-    assert!(!ScriptBuf::from_hex("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac")
-        .unwrap()
-        .is_provably_unspendable());
-    assert!(ScriptBuf::from_hex("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87")
-        .unwrap()
-        .is_provably_unspendable());
+    assert!(
+        !ScriptBuf::from_hex("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac")
+            .unwrap()
+            .is_provably_unspendable()
+    );
+    assert!(
+        ScriptBuf::from_hex("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87")
+            .unwrap()
+            .is_provably_unspendable()
+    );
 }
 
 #[test]
 fn op_return_test() {
-    assert!(ScriptBuf::from_hex("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87")
-        .unwrap()
-        .is_op_return());
-    assert!(!ScriptBuf::from_hex("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac")
-        .unwrap()
-        .is_op_return());
+    assert!(
+        ScriptBuf::from_hex("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87")
+            .unwrap()
+            .is_op_return()
+    );
+    assert!(
+        !ScriptBuf::from_hex("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac")
+            .unwrap()
+            .is_op_return()
+    );
     assert!(!ScriptBuf::from_hex("").unwrap().is_op_return());
 }
 
@@ -438,34 +446,42 @@ fn script_buf_collect() {
 #[test]
 fn script_p2sh_p2p2k_template() {
     // random outputs I picked out of the mempool
-    assert!(ScriptBuf::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac")
-        .unwrap()
-        .is_p2pkh());
-    assert!(!ScriptBuf::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac")
-        .unwrap()
-        .is_p2sh());
-    assert!(!ScriptBuf::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ad")
-        .unwrap()
-        .is_p2pkh());
+    assert!(
+        ScriptBuf::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac")
+            .unwrap()
+            .is_p2pkh()
+    );
+    assert!(
+        !ScriptBuf::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac")
+            .unwrap()
+            .is_p2sh()
+    );
+    assert!(
+        !ScriptBuf::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ad")
+            .unwrap()
+            .is_p2pkh()
+    );
     assert!(!ScriptBuf::from_hex("").unwrap().is_p2pkh());
-    assert!(ScriptBuf::from_hex("a914acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87")
-        .unwrap()
-        .is_p2sh());
-    assert!(!ScriptBuf::from_hex("a914acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87")
-        .unwrap()
-        .is_p2pkh());
-    assert!(!ScriptBuf::from_hex("a314acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87")
-        .unwrap()
-        .is_p2sh());
+    assert!(
+        ScriptBuf::from_hex("a914acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87").unwrap().is_p2sh()
+    );
+    assert!(
+        !ScriptBuf::from_hex("a914acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87").unwrap().is_p2pkh()
+    );
+    assert!(
+        !ScriptBuf::from_hex("a314acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87").unwrap().is_p2sh()
+    );
 }
 
 #[test]
 fn script_p2pk() {
-    assert!(ScriptBuf::from_hex(
-        "21021aeaf2f8638a129a3156fbe7e5ef635226b0bafd495ff03afe2c843d7e3a4b51ac"
-    )
-    .unwrap()
-    .is_p2pk());
+    assert!(
+        ScriptBuf::from_hex(
+            "21021aeaf2f8638a129a3156fbe7e5ef635226b0bafd495ff03afe2c843d7e3a4b51ac"
+        )
+        .unwrap()
+        .is_p2pk()
+    );
     assert!(ScriptBuf::from_hex("410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac").unwrap().is_p2pk());
 }
 
@@ -618,18 +634,15 @@ fn defult_dust_value_tests() {
 
 #[test]
 #[cfg(feature = "serde")]
-fn test_script_serde_human_and_not() {
+fn test_script_serde_human() {
     let script = ScriptBuf::from(vec![0u8, 1u8, 2u8]);
 
     // Serialize
     let json = serde_json::to_string(&script).unwrap();
     assert_eq!(json, "\"000102\"");
-    let bincode = bincode_test::serialize(&script).unwrap();
-    assert_eq!(bincode, [3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2]); // bincode adds u64 for length, serde_cbor use varint
 
     // Deserialize
     assert_eq!(script, serde_json::from_str::<ScriptBuf>(&json).unwrap());
-    assert_eq!(script, bincode_test::deserialize::<ScriptBuf>(&bincode).unwrap());
 }
 
 #[test]
diff --git a/dash/src/blockdata/transaction/hash_type.rs b/dash/src/blockdata/transaction/hash_type.rs
index fc2832a95..220eb6bda 100644
--- a/dash/src/blockdata/transaction/hash_type.rs
+++ b/dash/src/blockdata/transaction/hash_type.rs
@@ -189,10 +189,10 @@ impl ::std::error::Error for SighashTypeParseError {}
 mod tests {
     use core::str::FromStr;
 
-    use hashes::hex::FromHex;
     use hashes::Hash;
+    use hashes::hex::FromHex;
 
-    use crate::blockdata::transaction::{hash_type, UINT256_ONE};
+    use crate::blockdata::transaction::{UINT256_ONE, hash_type};
     use crate::consensus::encode::deserialize;
     use crate::sighash::{LegacySighash, SighashCache};
     use crate::transaction::hash_type::EcdsaSighashType;
diff --git a/dash/src/blockdata/transaction/mod.rs b/dash/src/blockdata/transaction/mod.rs
index 99662ac0a..4cf3e42f3 100644
--- a/dash/src/blockdata/transaction/mod.rs
+++ b/dash/src/blockdata/transaction/mod.rs
@@ -36,7 +36,7 @@ use core::default::Default;
 
 #[cfg(feature = "bincode")]
 use bincode::{Decode, Encode};
-use hashes::{sha256d, Hash};
+use hashes::{Hash, sha256d};
 
 use crate::blockdata::constants::WITNESS_SCALE_FACTOR;
 #[cfg(feature = "bitcoinconsensus")]
@@ -48,12 +48,12 @@ use crate::blockdata::transaction::txin::TxIn;
 use crate::blockdata::transaction::txout::TxOut;
 use crate::blockdata::witness::Witness;
 use crate::consensus::encode::VarInt;
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::hash_types::{InputsHash, Txid, Wtxid};
 use crate::prelude::*;
 use crate::sighash::LegacySighash;
 pub use crate::transaction::outpoint::*;
-use crate::{io, ScriptBuf, Weight};
+use crate::{ScriptBuf, Weight, io};
 
 /// Used for signature hash for invalid use of SIGHASH_SINGLE.
 const UINT256_ONE: [u8; 32] = [
@@ -1230,14 +1230,16 @@ mod tests {
         let re_use = double_spending.input[0].clone();
         double_spending.input.push(re_use);
 
-        assert!(double_spending
-            .verify(|point: &OutPoint| {
-                if let Some(tx) = spent2.remove(&point.txid) {
-                    return tx.output.get(point.vout as usize).cloned();
-                }
-                None
-            })
-            .is_err());
+        assert!(
+            double_spending
+                .verify(|point: &OutPoint| {
+                    if let Some(tx) = spent2.remove(&point.txid) {
+                        return tx.output.get(point.vout as usize).cloned();
+                    }
+                    None
+                })
+                .is_err()
+        );
 
         // test that we get a failure if we corrupt a signature
         let mut witness: Vec<_> = spending.input[1].witness.to_vec();
@@ -1303,10 +1305,10 @@ mod tests {
 
 #[cfg(all(test, feature = "unstable"))]
 mod benches {
-    use consensus::{deserialize, Encodable};
-    use hashes::hex::FromHex;
-    use test::{black_box, Bencher};
     use EmptyWrite;
+    use consensus::{Encodable, deserialize};
+    use hashes::hex::FromHex;
+    use test::{Bencher, black_box};
 
     use super::Transaction;
 
diff --git a/dash/src/blockdata/transaction/outpoint.rs b/dash/src/blockdata/transaction/outpoint.rs
index 0779764e7..3c3e5b54e 100644
--- a/dash/src/blockdata/transaction/outpoint.rs
+++ b/dash/src/blockdata/transaction/outpoint.rs
@@ -28,7 +28,7 @@ use std::error;
 use bincode::{Decode, Encode};
 use hashes::{self, Hash};
 
-use crate::consensus::{deserialize, encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, deserialize, encode};
 use crate::hash_types::Txid;
 use crate::io;
 
@@ -229,8 +229,8 @@ mod tests {
     use core::str::FromStr;
 
     use super::*;
-    use crate::internal_macros::hex;
     use crate::Transaction;
+    use crate::internal_macros::hex;
 
     #[test]
     fn test_outpoint() {
diff --git a/dash/src/blockdata/transaction/special_transaction/asset_lock.rs b/dash/src/blockdata/transaction/special_transaction/asset_lock.rs
index 834da2b1e..3bce7f420 100644
--- a/dash/src/blockdata/transaction/special_transaction/asset_lock.rs
+++ b/dash/src/blockdata/transaction/special_transaction/asset_lock.rs
@@ -25,10 +25,10 @@
 #[cfg(feature = "bincode")]
 use bincode::{Decode, Encode};
 
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::prelude::*;
 use crate::transaction::txout::TxOut;
-use crate::{io, VarInt};
+use crate::{VarInt, io};
 
 /// An Asset Lock payload. This is contained as the payload of an asset lock special transaction.
 /// The Asset Lock Special transaction and this payload is described in the Asset Lock DIP2X
diff --git a/dash/src/blockdata/transaction/special_transaction/asset_unlock/qualified_asset_unlock.rs b/dash/src/blockdata/transaction/special_transaction/asset_unlock/qualified_asset_unlock.rs
index fb9499569..cad0ae1d2 100644
--- a/dash/src/blockdata/transaction/special_transaction/asset_unlock/qualified_asset_unlock.rs
+++ b/dash/src/blockdata/transaction/special_transaction/asset_unlock/qualified_asset_unlock.rs
@@ -26,15 +26,15 @@
 use bincode::{Decode, Encode};
 use hashes::Hash;
 
+use crate::blockdata::transaction::special_transaction::SpecialTransactionBasePayloadEncodable;
 use crate::blockdata::transaction::special_transaction::asset_unlock::request_info::AssetUnlockRequestInfo;
 use crate::blockdata::transaction::special_transaction::asset_unlock::unqualified_asset_unlock::AssetUnlockBasePayload;
-use crate::blockdata::transaction::special_transaction::SpecialTransactionBasePayloadEncodable;
 use crate::bls_sig_utils::BLSSignature;
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::hash_types::SpecialTransactionPayloadHash;
-use crate::transaction::special_transaction::asset_unlock::unqualified_asset_unlock::AssetUnlockBaseTransactionInfo;
 use crate::transaction::special_transaction::TransactionPayload;
-use crate::{consensus, io, Transaction, TxIn};
+use crate::transaction::special_transaction::asset_unlock::unqualified_asset_unlock::AssetUnlockBaseTransactionInfo;
+use crate::{Transaction, TxIn, consensus, io};
 
 // Asset unlock tx size is constant since it has zero inputs and single output only
 pub const ASSET_UNLOCK_TX_SIZE: usize = 190;
@@ -145,19 +145,19 @@ mod tests {
 
     use hashes::Hash;
     use hex::FromHex;
-    use internals::hex::display::DisplayHex;
     use internals::hex::Case;
+    use internals::hex::display::DisplayHex;
 
     use crate::bls_sig_utils::BLSSignature;
     use crate::consensus::Encodable;
     use crate::hash_types::QuorumHash;
+    use crate::transaction::special_transaction::TransactionPayload;
     use crate::transaction::special_transaction::asset_unlock::qualified_asset_unlock::{
-        build_asset_unlock_tx, AssetUnlockPayload, ASSET_UNLOCK_TX_SIZE,
+        ASSET_UNLOCK_TX_SIZE, AssetUnlockPayload, build_asset_unlock_tx,
     };
     use crate::transaction::special_transaction::asset_unlock::request_info::AssetUnlockRequestInfo;
     use crate::transaction::special_transaction::asset_unlock::unqualified_asset_unlock::AssetUnlockBasePayload;
-    use crate::transaction::special_transaction::TransactionPayload;
-    use crate::{consensus, ScriptBuf, Transaction, TxOut};
+    use crate::{ScriptBuf, Transaction, TxOut, consensus};
 
     #[test]
     fn size() {
diff --git a/dash/src/blockdata/transaction/special_transaction/asset_unlock/request_info.rs b/dash/src/blockdata/transaction/special_transaction/asset_unlock/request_info.rs
index 8aec84406..852692b1f 100644
--- a/dash/src/blockdata/transaction/special_transaction/asset_unlock/request_info.rs
+++ b/dash/src/blockdata/transaction/special_transaction/asset_unlock/request_info.rs
@@ -23,7 +23,7 @@ use std::mem::size_of;
 #[cfg(feature = "bincode")]
 use bincode::{Decode, Encode};
 
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::hash_types::QuorumHash;
 use crate::io;
 use crate::prelude::*;
diff --git a/dash/src/blockdata/transaction/special_transaction/asset_unlock/unqualified_asset_unlock.rs b/dash/src/blockdata/transaction/special_transaction/asset_unlock/unqualified_asset_unlock.rs
index 33f2656f0..05c15e6ba 100644
--- a/dash/src/blockdata/transaction/special_transaction/asset_unlock/unqualified_asset_unlock.rs
+++ b/dash/src/blockdata/transaction/special_transaction/asset_unlock/unqualified_asset_unlock.rs
@@ -27,11 +27,11 @@ use bincode::{Decode, Encode};
 
 use crate::blockdata::transaction::special_transaction::TransactionType;
 use crate::blockdata::transaction::special_transaction::TransactionType::AssetUnlock;
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::hash_types::{PubkeyHash, ScriptHash};
 use crate::prelude::*;
 use crate::transaction::TxOut;
-use crate::{io, ScriptBuf, TxIn, VarInt};
+use crate::{ScriptBuf, TxIn, VarInt, io};
 
 /// An Asset Unlock Base payload. This is the base payload of the Asset Unlock. In order to make
 /// it a full payload the request info should be added.
diff --git a/dash/src/blockdata/transaction/special_transaction/coinbase.rs b/dash/src/blockdata/transaction/special_transaction/coinbase.rs
index 6c1ca3842..604eef96f 100644
--- a/dash/src/blockdata/transaction/special_transaction/coinbase.rs
+++ b/dash/src/blockdata/transaction/special_transaction/coinbase.rs
@@ -23,7 +23,7 @@ use bincode::{Decode, Encode};
 
 use crate::bls_sig_utils::BLSSignature;
 use crate::consensus::encode::{compact_size_len, read_compact_size, write_compact_size};
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::hash_types::{MerkleRootMasternodeList, MerkleRootQuorums};
 use crate::io;
 use crate::io::{Error, ErrorKind};
diff --git a/dash/src/blockdata/transaction/special_transaction/mod.rs b/dash/src/blockdata/transaction/special_transaction/mod.rs
index c90ac9472..d2921da13 100644
--- a/dash/src/blockdata/transaction/special_transaction/mod.rs
+++ b/dash/src/blockdata/transaction/special_transaction/mod.rs
@@ -26,14 +26,6 @@ use core::fmt::{Debug, Display, Formatter};
 #[cfg(feature = "bincode")]
 use bincode::{Decode, Encode};
 
-use crate::blockdata::transaction::special_transaction::asset_lock::AssetLockPayload;
-use crate::blockdata::transaction::special_transaction::asset_unlock::qualified_asset_unlock::AssetUnlockPayload;
-use crate::blockdata::transaction::special_transaction::coinbase::CoinbasePayload;
-use crate::blockdata::transaction::special_transaction::provider_registration::ProviderRegistrationPayload;
-use crate::blockdata::transaction::special_transaction::provider_update_registrar::ProviderUpdateRegistrarPayload;
-use crate::blockdata::transaction::special_transaction::provider_update_revocation::ProviderUpdateRevocationPayload;
-use crate::blockdata::transaction::special_transaction::provider_update_service::ProviderUpdateServicePayload;
-use crate::blockdata::transaction::special_transaction::quorum_commitment::QuorumCommitmentPayload;
 use crate::blockdata::transaction::special_transaction::TransactionPayload::{
     AssetLockPayloadType, AssetUnlockPayloadType, CoinbasePayloadType,
     ProviderRegistrationPayloadType, ProviderUpdateRegistrarPayloadType,
@@ -44,8 +36,16 @@ use crate::blockdata::transaction::special_transaction::TransactionType::{
     AssetLock, AssetUnlock, Classic, Coinbase, ProviderRegistration, ProviderUpdateRegistrar,
     ProviderUpdateRevocation, ProviderUpdateService, QuorumCommitment,
 };
+use crate::blockdata::transaction::special_transaction::asset_lock::AssetLockPayload;
+use crate::blockdata::transaction::special_transaction::asset_unlock::qualified_asset_unlock::AssetUnlockPayload;
+use crate::blockdata::transaction::special_transaction::coinbase::CoinbasePayload;
+use crate::blockdata::transaction::special_transaction::provider_registration::ProviderRegistrationPayload;
+use crate::blockdata::transaction::special_transaction::provider_update_registrar::ProviderUpdateRegistrarPayload;
+use crate::blockdata::transaction::special_transaction::provider_update_revocation::ProviderUpdateRevocationPayload;
+use crate::blockdata::transaction::special_transaction::provider_update_service::ProviderUpdateServicePayload;
+use crate::blockdata::transaction::special_transaction::quorum_commitment::QuorumCommitmentPayload;
 use crate::consensus::encode::VarInt;
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::hash_types::SpecialTransactionPayloadHash;
 use crate::io;
 
diff --git a/dash/src/blockdata/transaction/special_transaction/provider_registration.rs b/dash/src/blockdata/transaction/special_transaction/provider_registration.rs
index 5329867e8..fd892dc54 100644
--- a/dash/src/blockdata/transaction/special_transaction/provider_registration.rs
+++ b/dash/src/blockdata/transaction/special_transaction/provider_registration.rs
@@ -44,10 +44,10 @@ use internals::hex::Case::Lower;
 use crate::address::Payload;
 use crate::blockdata::transaction::special_transaction::SpecialTransactionBasePayloadEncodable;
 use crate::bls_sig_utils::BLSPublicKey;
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::hash_types::{InputsHash, PubkeyHash, SpecialTransactionPayloadHash};
 use crate::prelude::*;
-use crate::{io, Address, Network, OutPoint, ScriptBuf, VarInt};
+use crate::{Address, Network, OutPoint, ScriptBuf, VarInt, io};
 
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash, Copy)]
 #[cfg_attr(feature = "bincode", derive(Encode, Decode))]
@@ -264,7 +264,7 @@ mod tests {
     use hashes::Hash;
 
     use crate::bls_sig_utils::BLSPublicKey;
-    use crate::consensus::{deserialize, Encodable};
+    use crate::consensus::{Encodable, deserialize};
     use crate::hash_types::InputsHash;
     use crate::hashes::hex::FromHex;
     use crate::internal_macros::hex;
@@ -275,17 +275,16 @@ mod tests {
 
     use std::net::IpAddr;
 
-    use super::*;
-    use crate::sign_message::signed_msg_hash;
-    use crate::signer::sign_hash;
-    use crate::transaction::special_transaction::SpecialTransactionBasePayloadEncodable;
-    use crate::transaction::TransactionPayload::ProviderRegistrationPayloadType;
     use crate::Network;
     use crate::PrivateKey;
     use crate::Transaction;
     use crate::TxIn;
     use crate::TxOut;
     use crate::Witness;
+    use crate::sign_message::signed_msg_hash;
+    use crate::signer::sign_hash;
+    use crate::transaction::TransactionPayload::ProviderRegistrationPayloadType;
+    use crate::transaction::special_transaction::SpecialTransactionBasePayloadEncodable;
     use std::str::FromStr;
 
     #[test]
diff --git a/dash/src/blockdata/transaction/special_transaction/provider_update_registrar.rs b/dash/src/blockdata/transaction/special_transaction/provider_update_registrar.rs
index ae6523895..fe2084c7d 100644
--- a/dash/src/blockdata/transaction/special_transaction/provider_update_registrar.rs
+++ b/dash/src/blockdata/transaction/special_transaction/provider_update_registrar.rs
@@ -35,10 +35,10 @@ use hashes::Hash;
 
 use crate::blockdata::transaction::special_transaction::SpecialTransactionBasePayloadEncodable;
 use crate::bls_sig_utils::BLSPublicKey;
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::hash_types::{InputsHash, PubkeyHash, SpecialTransactionPayloadHash, Txid};
 use crate::prelude::*;
-use crate::{io, ScriptBuf, VarInt};
+use crate::{ScriptBuf, VarInt, io};
 
 /// A Provider Update Registrar Payload used in a Provider Update Registrar Special Transaction.
 /// This is used to update the base aspects a Masternode on the network.
@@ -129,11 +129,11 @@ mod tests {
 
     use crate::blockdata::transaction::special_transaction::SpecialTransactionBasePayloadEncodable;
     use crate::bls_sig_utils::BLSPublicKey;
-    use crate::consensus::{deserialize, Encodable};
+    use crate::consensus::{Encodable, deserialize};
     use crate::hash_types::InputsHash;
     use crate::internal_macros::hex;
-    use crate::transaction::special_transaction::provider_update_registrar::ProviderUpdateRegistrarPayload;
     use crate::transaction::special_transaction::TransactionPayload::ProviderUpdateRegistrarPayloadType;
+    use crate::transaction::special_transaction::provider_update_registrar::ProviderUpdateRegistrarPayload;
     use crate::{Network, PubkeyHash, ScriptBuf, Transaction, Txid};
 
     #[test]
diff --git a/dash/src/blockdata/transaction/special_transaction/provider_update_revocation.rs b/dash/src/blockdata/transaction/special_transaction/provider_update_revocation.rs
index b16d260a9..5e9fe3b4e 100644
--- a/dash/src/blockdata/transaction/special_transaction/provider_update_revocation.rs
+++ b/dash/src/blockdata/transaction/special_transaction/provider_update_revocation.rs
@@ -42,7 +42,7 @@ use hashes::Hash;
 
 use crate::blockdata::transaction::special_transaction::SpecialTransactionBasePayloadEncodable;
 use crate::bls_sig_utils::BLSSignature;
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::hash_types::{InputsHash, SpecialTransactionPayloadHash, Txid};
 use crate::io;
 
@@ -116,11 +116,11 @@ impl Decodable for ProviderUpdateRevocationPayload {
 mod tests {
     use hashes::Hash;
 
+    use crate::Txid;
     use crate::bls_sig_utils::BLSSignature;
     use crate::consensus::Encodable;
     use crate::hash_types::InputsHash;
     use crate::transaction::special_transaction::provider_update_revocation::ProviderUpdateRevocationPayload;
-    use crate::Txid;
 
     #[test]
     fn size() {
diff --git a/dash/src/blockdata/transaction/special_transaction/provider_update_service.rs b/dash/src/blockdata/transaction/special_transaction/provider_update_service.rs
index ae7018bd5..0dbd644b3 100644
--- a/dash/src/blockdata/transaction/special_transaction/provider_update_service.rs
+++ b/dash/src/blockdata/transaction/special_transaction/provider_update_service.rs
@@ -40,9 +40,9 @@ use hashes::Hash;
 
 use crate::blockdata::transaction::special_transaction::SpecialTransactionBasePayloadEncodable;
 use crate::bls_sig_utils::BLSSignature;
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::hash_types::{InputsHash, SpecialTransactionPayloadHash, Txid};
-use crate::{io, ScriptBuf, VarInt};
+use crate::{ScriptBuf, VarInt, io};
 
 /// A Provider Update Service Payload used in a Provider Update Service Special Transaction.
 /// This is used to update the operational aspects a Masternode on the network.
@@ -128,11 +128,11 @@ mod tests {
 
     use hashes::Hash;
 
-    use crate::blockdata::transaction::special_transaction::provider_update_service::ProviderUpdateServicePayload;
     use crate::blockdata::transaction::special_transaction::SpecialTransactionBasePayloadEncodable;
     use crate::blockdata::transaction::special_transaction::TransactionPayload::ProviderUpdateServicePayloadType;
+    use crate::blockdata::transaction::special_transaction::provider_update_service::ProviderUpdateServicePayload;
     use crate::bls_sig_utils::BLSSignature;
-    use crate::consensus::{deserialize, Encodable};
+    use crate::consensus::{Encodable, deserialize};
     use crate::hash_types::InputsHash;
     use crate::internal_macros::hex;
     use crate::{Network, ScriptBuf, Transaction, Txid};
diff --git a/dash/src/blockdata/transaction/special_transaction/quorum_commitment.rs b/dash/src/blockdata/transaction/special_transaction/quorum_commitment.rs
index 3d93b7d96..c9cc5f26b 100644
--- a/dash/src/blockdata/transaction/special_transaction/quorum_commitment.rs
+++ b/dash/src/blockdata/transaction/special_transaction/quorum_commitment.rs
@@ -25,7 +25,7 @@ use crate::consensus::encode::{
     compact_size_len, fixed_bitset_len, read_compact_size, read_fixed_bitset, write_compact_size,
     write_fixed_bitset,
 };
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::hash_types::{QuorumHash, QuorumVVecHash};
 use crate::io;
 use crate::prelude::*;
@@ -224,7 +224,7 @@ mod tests {
     use hashes::Hash;
 
     use crate::bls_sig_utils::{BLSPublicKey, BLSSignature};
-    use crate::consensus::{deserialize, serialize, Encodable};
+    use crate::consensus::{Encodable, deserialize, serialize};
     use crate::hash_types::{QuorumHash, QuorumVVecHash};
     use crate::network::message::{NetworkMessage, RawNetworkMessage};
     use crate::sml::llmq_type::LLMQType;
diff --git a/dash/src/blockdata/transaction/txin.rs b/dash/src/blockdata/transaction/txin.rs
index b722d20d1..7debc835a 100644
--- a/dash/src/blockdata/transaction/txin.rs
+++ b/dash/src/blockdata/transaction/txin.rs
@@ -24,9 +24,9 @@
 use bincode::{Decode, Encode};
 
 use crate::blockdata::script::ScriptBuf;
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::transaction::outpoint::OutPoint;
-use crate::{io, Witness};
+use crate::{Witness, io};
 
 /// A transaction input, which defines old coins to be consumed
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
diff --git a/dash/src/blockdata/witness.rs b/dash/src/blockdata/witness.rs
index d4bc86445..9023dac76 100644
--- a/dash/src/blockdata/witness.rs
+++ b/dash/src/blockdata/witness.rs
@@ -501,9 +501,9 @@ mod test {
     use secp256k1::ecdsa;
 
     use super::*;
+    use crate::Transaction;
     use crate::consensus::{deserialize, serialize};
     use crate::internal_macros::hex;
-    use crate::Transaction;
 
     fn append_u32_vec(mut v: Vec<u8>, n: &[u32]) -> Vec<u8> {
         for &num in n {
@@ -691,23 +691,6 @@ mod test {
         assert!(deserialize::<Witness>(&bytes).is_err()); // OversizedVectorAllocation
     }
 
-    #[cfg(feature = "serde")]
-    #[test]
-    fn test_serde_bincode() {
-        use bincode_test;
-
-        let old_witness_format = vec![vec![0u8], vec![2]];
-        let new_witness_format = Witness::from_slice(&old_witness_format);
-
-        let old = bincode_test::serialize(&old_witness_format).unwrap();
-        let new = bincode_test::serialize(&new_witness_format).unwrap();
-
-        assert_eq!(old, new);
-
-        let back: Witness = bincode_test::deserialize(&new).unwrap();
-        assert_eq!(new_witness_format, back);
-    }
-
     #[cfg(feature = "serde")]
     #[test]
     fn test_serde_human() {
@@ -726,7 +709,7 @@ mod test {
 
 #[cfg(bench)]
 mod benches {
-    use test::{black_box, Bencher};
+    use test::{Bencher, black_box};
 
     use super::Witness;
 
diff --git a/dash/src/consensus/encode.rs b/dash/src/consensus/encode.rs
index ba6004347..1e90ac141 100644
--- a/dash/src/consensus/encode.rs
+++ b/dash/src/consensus/encode.rs
@@ -36,7 +36,7 @@ use std::io::Write;
 
 #[cfg(feature = "core-block-hash-use-x11")]
 use hashes::hash_x11;
-use hashes::{hash160, sha256, sha256d, Hash};
+use hashes::{Hash, hash160, sha256, sha256d};
 use internals::write_err;
 
 use crate::bip152::{PrefilledTransaction, ShortId};
@@ -56,11 +56,11 @@ use crate::network::{
 use crate::prelude::*;
 use crate::sml::masternode_list_entry::MasternodeListEntry;
 use crate::taproot::TapLeafHash;
-use crate::transaction::special_transaction::quorum_commitment::QuorumEntry;
 use crate::transaction::special_transaction::TransactionType;
+use crate::transaction::special_transaction::quorum_commitment::QuorumEntry;
 use crate::transaction::txin::TxIn;
 use crate::transaction::txout::TxOut;
-use crate::{address, OutPoint, ProTxHash, ScriptBuf};
+use crate::{OutPoint, ProTxHash, ScriptBuf, address};
 
 /// Encoding error.
 #[derive(Debug)]
@@ -122,34 +122,34 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Error::Io(ref e) => write_err!(f, "IO error"; e),
+            Error::Io(e) => write_err!(f, "IO error"; e),
             Error::OversizedVectorAllocation {
-                requested: ref r,
-                max: ref m,
+                requested: r,
+                max: m,
             } => {
                 write!(f, "allocation of oversized vector: requested {}, maximum {}", r, m)
             }
             Error::InvalidChecksum {
-                expected: ref e,
-                actual: ref a,
+                expected: e,
+                actual: a,
             } => {
                 write!(f, "invalid checksum: expected {:x}, actual {:x}", e.as_hex(), a.as_hex())
             }
             Error::NonMinimalVarInt => write!(f, "non-minimal varint"),
-            Error::ParseFailed(ref s) => write!(f, "parse failed: {}", s),
-            Error::UnsupportedSegwitFlag(ref swflag) => {
+            Error::ParseFailed(s) => write!(f, "parse failed: {}", s),
+            Error::UnsupportedSegwitFlag(swflag) => {
                 write!(f, "unsupported segwit version: {}", swflag)
             }
-            Error::UnknownSpecialTransactionType(ref stt) => {
+            Error::UnknownSpecialTransactionType(stt) => {
                 write!(f, "unknown special transaction type: {}", stt)
             }
             Error::WrongSpecialTransactionPayloadConversion {
-                expected: ref e,
-                actual: ref a,
+                expected: e,
+                actual: a,
             } => {
                 write!(f, "wrong special transaction payload conversion expected: {} got: {}", e, a)
             }
-            Error::NonStandardScriptPayout(ref script) => {
+            Error::NonStandardScriptPayout(script) => {
                 write!(f, "non standard script payout: {}", script.to_hex_string())
             }
             Error::InvalidVectorSize {
@@ -158,8 +158,8 @@ impl fmt::Display for Error {
             } => {
                 write!(f, "invalid vector size error expected: {} got: {}", expected, actual)
             }
-            Error::Hex(ref e) => write!(f, "hex error {}", e),
-            Error::Address(ref e) => write!(f, "address error {}", e),
+            Error::Hex(e) => write!(f, "hex error {}", e),
+            Error::Address(e) => write!(f, "address error {}", e),
             Error::InvalidEnumValue {
                 max,
                 received,
@@ -1143,9 +1143,9 @@ mod tests {
     use core::mem::{self, discriminant};
 
     use super::*;
-    use crate::consensus::{deserialize_partial, Decodable, Encodable};
+    use crate::consensus::{Decodable, Encodable, deserialize_partial};
     #[cfg(feature = "std")]
-    use crate::network::{message_blockdata::Inventory, Address};
+    use crate::network::{Address, message_blockdata::Inventory};
     use crate::{TxIn, TxOut};
 
     #[test]
@@ -1413,11 +1413,13 @@ mod tests {
         assert_eq!(deserialize(&[3u8, 2, 3, 4]).ok(), Some(vec![2u8, 3, 4]));
         assert!((deserialize(&[4u8, 2, 3, 4, 5, 6]) as Result<Vec<u8>, _>).is_err());
         // found by cargo fuzz
-        assert!(deserialize::<Vec<u64>>(&[
-            0xff, 0xff, 0xff, 0xff, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b,
-            0x6b, 0x6b, 0xa, 0xa, 0x3a
-        ])
-        .is_err());
+        assert!(
+            deserialize::<Vec<u64>>(&[
+                0xff, 0xff, 0xff, 0xff, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b,
+                0x6b, 0x6b, 0xa, 0xa, 0x3a
+            ])
+            .is_err()
+        );
 
         let rand_io_err = Error::Io(io::Error::new(io::ErrorKind::Other, ""));
 
@@ -1484,12 +1486,12 @@ mod tests {
     #[test]
     #[cfg(feature = "rand-std")]
     fn serialization_round_trips() {
-        use secp256k1::rand::{thread_rng, Rng};
+        use secp256k1::rand::{Rng, thread_rng};
 
         macro_rules! round_trip {
             ($($val_type:ty),*) => {
                 $(
-                    let r: $val_type = thread_rng().gen();
+                    let r: $val_type = thread_rng().r#gen();
                     assert_eq!(deserialize::<$val_type>(&serialize(&r)).unwrap(), r);
                 )*
             };
diff --git a/dash/src/consensus/mod.rs b/dash/src/consensus/mod.rs
index 8e73fa7c6..d66f31b70 100644
--- a/dash/src/consensus/mod.rs
+++ b/dash/src/consensus/mod.rs
@@ -24,6 +24,6 @@ pub mod params;
 pub mod serde;
 
 pub use self::encode::{
-    deserialize, deserialize_partial, serialize, Decodable, Encodable, ReadExt, WriteExt,
+    Decodable, Encodable, ReadExt, WriteExt, deserialize, deserialize_partial, serialize,
 };
 pub use self::params::Params;
diff --git a/dash/src/consensus/params.rs b/dash/src/consensus/params.rs
index 6abc71afe..7befc3f1a 100644
--- a/dash/src/consensus/params.rs
+++ b/dash/src/consensus/params.rs
@@ -21,8 +21,8 @@
 //! chains (such as mainnet, testnet).
 //!
 
-use crate::network::constants::Network;
 use crate::Work;
+use crate::network::constants::Network;
 
 /// Parameters that influence chain consensus.
 #[non_exhaustive]
diff --git a/dash/src/consensus/serde.rs b/dash/src/consensus/serde.rs
index 4f67ea81b..387cda972 100644
--- a/dash/src/consensus/serde.rs
+++ b/dash/src/consensus/serde.rs
@@ -504,7 +504,9 @@ impl<E: fmt::Debug, I: Iterator<Item = Result<u8, E>>> IterReader<E, I> {
             }
             (Err(ConsensusError::Io(io_error)), Some(de_error))
                 if io_error.kind() == io::ErrorKind::Other && io_error.source().is_none() =>
-                Err(DecodeError::Other(de_error)),
+            {
+                Err(DecodeError::Other(de_error))
+            }
             (Err(consensus_error), None) => Err(DecodeError::Consensus(consensus_error)),
             (Err(ConsensusError::Io(io_error)), de_error) => panic!(
                 "Unexpected IO error {:?} returned from {}::consensus_decode(), deserialization error: {:?}",
diff --git a/dash/src/crypto/key.rs b/dash/src/crypto/key.rs
index ef4d5b81e..aae0485db 100644
--- a/dash/src/crypto/key.rs
+++ b/dash/src/crypto/key.rs
@@ -25,9 +25,9 @@ use core::ops;
 use core::str::FromStr;
 
 use hashes::hex::FromHex;
-use hashes::{hash160, hex, Hash};
+use hashes::{Hash, hash160, hex};
 use internals::write_err;
-pub use secp256k1::{self, constants, Keypair, Parity, Secp256k1, Verification, XOnlyPublicKey};
+pub use secp256k1::{self, Keypair, Parity, Secp256k1, Verification, XOnlyPublicKey, constants};
 
 use crate::hash_types::{PubkeyHash, WPubkeyHash};
 use crate::network::constants::Network;
@@ -62,20 +62,20 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Error::Base58(ref e) => write_err!(f, "key base58 error"; e),
-            Error::Secp256k1(ref e) => write_err!(f, "key secp256k1 error"; e),
-            Error::InvalidKeyPrefix(ref b) => write!(f, "key prefix invalid: {}", b),
-            Error::Hex(ref e) => write_err!(f, "key hex decoding error"; e),
+            Error::Base58(e) => write_err!(f, "key base58 error"; e),
+            Error::Secp256k1(e) => write_err!(f, "key secp256k1 error"; e),
+            Error::InvalidKeyPrefix(b) => write!(f, "key prefix invalid: {}", b),
+            Error::Hex(e) => write_err!(f, "key hex decoding error"; e),
             Error::InvalidHexLength(got) => {
                 write!(f, "PublicKey hex should be 66 or 130 digits long, got: {}", got)
             }
-            Error::NotSupported(ref string) => {
+            Error::NotSupported(string) => {
                 write!(f, "{}", string.as_str())
             }
             #[cfg(feature = "bls-signatures")]
-            Error::BLSError(ref string) => write!(f, "{}", string.as_str()),
+            Error::BLSError(string) => write!(f, "{}", string.as_str()),
             #[cfg(feature = "ed25519-dalek")]
-            Error::Ed25519Dalek(ref string) => write!(f, "{}", string.as_str()),
+            Error::Ed25519Dalek(string) => write!(f, "{}", string.as_str()),
         }
     }
 }
@@ -895,7 +895,7 @@ mod tests {
     #[cfg(feature = "serde")]
     #[test]
     fn test_key_serde() {
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
 
         static KEY_WIF: &str = "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy";
         static PK_STR: &str = "039b6347398505f5ec93826dc61c19f47c66c0283ee9be980e29ce325a0f4679ef";
diff --git a/dash/src/crypto/sighash.rs b/dash/src/crypto/sighash.rs
index 2ee6e2282..d3c352e0d 100644
--- a/dash/src/crypto/sighash.rs
+++ b/dash/src/crypto/sighash.rs
@@ -14,18 +14,18 @@
 use core::borrow::{Borrow, BorrowMut};
 use core::{fmt, str};
 
-use hashes::{hash_newtype, sha256, sha256d, sha256t_hash_newtype, Hash};
+use hashes::{Hash, hash_newtype, sha256, sha256d, sha256t_hash_newtype};
 
 use crate::blockdata::transaction::txin::TxIn;
 use crate::blockdata::transaction::txout::TxOut;
 use crate::blockdata::transaction::{EncodeSigningDataResult, Transaction};
 use crate::blockdata::witness::Witness;
-use crate::consensus::{encode, Encodable};
+use crate::consensus::{Encodable, encode};
 use crate::error::impl_std_error;
 use crate::io;
 use crate::prelude::*;
 use crate::script::{Script, ScriptBuf};
-use crate::taproot::{LeafVersion, TapLeafHash, TAPROOT_ANNEX_PREFIX};
+use crate::taproot::{LeafVersion, TAPROOT_ANNEX_PREFIX, TapLeafHash};
 
 /// Used for signature hash for invalid use of SIGHASH_SINGLE.
 #[rustfmt::skip]
@@ -255,12 +255,18 @@ impl fmt::Display for Error {
 
         match self {
             Io(error_kind) => write!(f, "writer errored: {:?}", error_kind),
-            IndexOutOfInputsBounds { index, inputs_size } => write!(
+            IndexOutOfInputsBounds {
+                index,
+                inputs_size,
+            } => write!(
                 f,
                 "Requested index ({}) is greater or equal than the number of transaction inputs ({})",
                 index, inputs_size
             ),
-            SingleWithoutCorrespondingOutput { index, outputs_size } => write!(
+            SingleWithoutCorrespondingOutput {
+                index,
+                outputs_size,
+            } => write!(
                 f,
                 "SIGHASH_SINGLE for input ({}) haven't a corresponding output (#outputs:{})",
                 index, outputs_size
@@ -1195,8 +1201,6 @@ mod tests {
     use crate::network::constants::Network;
     use crate::taproot::TapLeafHash;
 
-    extern crate serde_json;
-
     #[test]
     fn sighash_single_bug() {
         const SIGHASH_SINGLE: u32 = 3;
diff --git a/dash/src/dip9.rs b/dash/src/dip9.rs
index 0ca8621af..1d80237b8 100644
--- a/dash/src/dip9.rs
+++ b/dash/src/dip9.rs
@@ -22,8 +22,8 @@ pub enum DerivationPathReference {
 use bitflags::bitflags;
 use secp256k1::Secp256k1;
 
-use crate::bip32::{ChildNumber, DerivationPath, Error, ExtendedPrivKey, ExtendedPubKey};
 use crate::Network;
+use crate::bip32::{ChildNumber, DerivationPath, Error, ExtendedPrivKey, ExtendedPubKey};
 
 bitflags! {
     #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
diff --git a/dash/src/ephemerealdata/chain_lock.rs b/dash/src/ephemerealdata/chain_lock.rs
index a861989ce..84cb28cb0 100644
--- a/dash/src/ephemerealdata/chain_lock.rs
+++ b/dash/src/ephemerealdata/chain_lock.rs
@@ -16,7 +16,7 @@ use crate::consensus::Encodable;
 use crate::hash_types::QuorumSigningSignId;
 use crate::internal_macros::impl_consensus_encoding;
 use crate::sml::llmq_type::LLMQType;
-use crate::{io, BlockHash, QuorumHash, QuorumSigningRequestId, VarInt};
+use crate::{BlockHash, QuorumHash, QuorumSigningRequestId, VarInt, io};
 
 const CL_REQUEST_ID_PREFIX: &str = "clsig";
 
diff --git a/dash/src/ephemerealdata/instant_lock.rs b/dash/src/ephemerealdata/instant_lock.rs
index a046bf09d..21b1f61ff 100644
--- a/dash/src/ephemerealdata/instant_lock.rs
+++ b/dash/src/ephemerealdata/instant_lock.rs
@@ -15,7 +15,7 @@ use crate::consensus::Encodable;
 use crate::hash_types::{CycleHash, QuorumSigningRequestId, QuorumSigningSignId};
 use crate::internal_macros::impl_consensus_encoding;
 use crate::sml::llmq_type::LLMQType;
-use crate::{io, OutPoint, QuorumHash, Txid, VarInt};
+use crate::{OutPoint, QuorumHash, Txid, VarInt, io};
 
 const IS_LOCK_REQUEST_ID_PREFIX: &str = "islock";
 
diff --git a/dash/src/hash_types.rs b/dash/src/hash_types.rs
index dc4866889..76b204919 100644
--- a/dash/src/hash_types.rs
+++ b/dash/src/hash_types.rs
@@ -73,7 +73,7 @@ mod newtypes {
     #[cfg(feature = "core-block-hash-use-x11")]
     use hashes::hash_x11;
     use hashes::hex::Error;
-    use hashes::{hash160, hash_newtype, hash_newtype_no_ord, sha256, sha256d, Hash};
+    use hashes::{Hash, hash_newtype, hash_newtype_no_ord, hash160, sha256, sha256d};
 
     use crate::alloc::string::ToString;
     use crate::prelude::String;
diff --git a/dash/src/internal_macros.rs b/dash/src/internal_macros.rs
index f41d7c7db..55fb282a4 100644
--- a/dash/src/internal_macros.rs
+++ b/dash/src/internal_macros.rs
@@ -79,14 +79,14 @@ macro_rules! impl_bytes_newtype {
 
         impl core::fmt::LowerHex for $t {
             fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-                use internals::hex::{display, Case};
+                use internals::hex::{Case, display};
                 display::fmt_hex_exact!(f, $len, &self.0, Case::Lower)
             }
         }
 
         impl core::fmt::UpperHex for $t {
             fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-                use internals::hex::{display, Case};
+                use internals::hex::{Case, display};
                 display::fmt_hex_exact!(f, $len, &self.0, Case::Upper)
             }
         }
diff --git a/dash/src/merkle_tree/block.rs b/dash/src/merkle_tree/block.rs
index a831d572f..ad04239f3 100644
--- a/dash/src/merkle_tree/block.rs
+++ b/dash/src/merkle_tree/block.rs
@@ -612,7 +612,7 @@ mod tests {
                 // Generate `att / 2` random bits
                 let rand_bits = match att / 2 {
                     0 => 0,
-                    bits => rng.gen::<u64>() >> (64 - bits),
+                    bits => rng.r#gen::<u64>() >> (64 - bits),
                 };
                 let include = rand_bits == 0;
                 matches[j] = include;
@@ -760,7 +760,7 @@ mod tests {
         /// Flip one bit in one of the hashes - this should break the authentication
         fn damage(&mut self, rng: &mut ThreadRng) {
             let n = rng.gen_range(0..self.hashes.len());
-            let bit = rng.gen::<u8>();
+            let bit = rng.r#gen::<u8>();
             let hashes = &mut self.hashes;
             let mut hash = hashes[n].to_byte_array();
             hash[(bit >> 3) as usize] ^= 1 << (bit & 7);
diff --git a/dash/src/network/constants.rs b/dash/src/network/constants.rs
index 59e859bd6..f325af732 100644
--- a/dash/src/network/constants.rs
+++ b/dash/src/network/constants.rs
@@ -54,7 +54,7 @@ use crate::consensus::encode::{self, Decodable, Encodable};
 use crate::constants::ChainHash;
 use crate::error::impl_std_error;
 use crate::prelude::{String, ToOwned};
-use crate::{io, BlockHash};
+use crate::{BlockHash, io};
 
 /// Version of the protocol as appearing in network message headers
 /// This constant is used to signal to other peers which features you support.
diff --git a/dash/src/network/message.rs b/dash/src/network/message.rs
index 5bba61b59..331383fa9 100644
--- a/dash/src/network/message.rs
+++ b/dash/src/network/message.rs
@@ -584,10 +584,10 @@ impl Decodable for RawNetworkMessage {
 mod test {
     use std::net::Ipv4Addr;
 
+    use hashes::Hash as HashTrait;
     #[cfg(feature = "core-block-hash-use-x11")]
     use hashes::hash_x11::Hash as X11Hash;
     use hashes::sha256d::Hash;
-    use hashes::Hash as HashTrait;
 
     use super::message_network::{Reject, RejectReason, VersionMessage};
     use super::{CommandString, NetworkMessage, RawNetworkMessage, *};
diff --git a/dash/src/network/message_bloom.rs b/dash/src/network/message_bloom.rs
index 0b94b5ef5..65295971d 100644
--- a/dash/src/network/message_bloom.rs
+++ b/dash/src/network/message_bloom.rs
@@ -5,7 +5,7 @@
 
 use std::io;
 
-use crate::consensus::{encode, Decodable, Encodable, ReadExt};
+use crate::consensus::{Decodable, Encodable, ReadExt, encode};
 use crate::internal_macros::impl_consensus_encoding;
 
 /// `filterload` message sets the current bloom filter
diff --git a/dash/src/network/message_network.rs b/dash/src/network/message_network.rs
index 2b186cb97..4c6c708a5 100644
--- a/dash/src/network/message_network.rs
+++ b/dash/src/network/message_network.rs
@@ -26,7 +26,7 @@ use hashes::hash_x11 as hashType;
 #[cfg(not(feature = "core-block-hash-use-x11"))]
 use hashes::sha256d as hashType;
 
-use crate::consensus::{encode, Decodable, Encodable, ReadExt};
+use crate::consensus::{Decodable, Encodable, ReadExt, encode};
 use crate::internal_macros::impl_consensus_encoding;
 use crate::io;
 use crate::network::address::Address;
diff --git a/dash/src/network/message_qrinfo.rs b/dash/src/network/message_qrinfo.rs
index 6416e5e0d..8b6720486 100644
--- a/dash/src/network/message_qrinfo.rs
+++ b/dash/src/network/message_qrinfo.rs
@@ -4,12 +4,12 @@ use std::{fmt, io};
 #[cfg(feature = "bincode")]
 use bincode::{Decode, Encode};
 
+use crate::BlockHash;
 use crate::consensus::encode::{read_compact_size, read_fixed_bitset, write_fixed_bitset};
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::internal_macros::impl_consensus_encoding;
 use crate::network::message_sml::MnListDiff;
 use crate::transaction::special_transaction::quorum_commitment::QuorumEntry;
-use crate::BlockHash;
 
 /// The `getqrinfo` message requests a `qrinfo` message that provides the information
 /// required to verify quorum details for quorums formed using the quorum rotation process.
@@ -309,8 +309,6 @@ mod tests {
     use std::fs::File;
     use std::io::{self, Read};
 
-    use assert_matches::assert_matches;
-
     use crate::consensus::deserialize;
     use crate::network::message::{NetworkMessage, RawNetworkMessage};
 
diff --git a/dash/src/pow.rs b/dash/src/pow.rs
index 62fd8a5d3..914e7652d 100644
--- a/dash/src/pow.rs
+++ b/dash/src/pow.rs
@@ -7,15 +7,15 @@
 //! functions here are designed to be fast, by that we mean it is safe to use them to check headers.
 //!
 
+use bincode::{Decode, Encode};
 use core::fmt::{self, LowerHex, UpperHex};
 use core::ops::{Add, Div, Mul, Not, Rem, Shl, Shr, Sub};
-
 #[cfg(all(test, mutate))]
 use mutagen::mutate;
 
-use crate::consensus::encode::{self, Decodable, Encodable};
 #[cfg(doc)]
 use crate::consensus::Params;
+use crate::consensus::encode::{self, Decodable, Encodable};
 use crate::hash_types::BlockHash;
 use crate::io::{self, Read, Write};
 use crate::prelude::String;
@@ -320,7 +320,7 @@ impl Decodable for CompactTarget {
 
 /// Big-endian 256 bit integer type.
 // (high, low): u.0 contains the high bits, u.1 contains the low bits.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Encode, Decode)]
 struct U256(u128, u128);
 
 impl U256 {
@@ -1509,8 +1509,10 @@ mod tests {
             assert_eq!(::serde_json::to_string(&uint).unwrap(), json);
             assert_eq!(::serde_json::from_str::<U256>(&json).unwrap(), uint);
 
-            let bin_encoded = bincode_test::serialize(&uint).unwrap();
-            let bin_decoded: U256 = bincode_test::deserialize(&bin_encoded).unwrap();
+            let config = bincode::config::standard();
+
+            let bin_encoded = bincode::encode_to_vec(&uint, config).unwrap();
+            let bin_decoded: U256 = bincode::decode_from_slice(&bin_encoded, config).unwrap().0;
             assert_eq!(bin_decoded, uint);
         };
 
@@ -1532,18 +1534,24 @@ mod tests {
             "deadbeeaa69b455cd41bb662a69b4550a69b455cd41bb662a69b4555deadbeef",
         );
 
-        assert!(::serde_json::from_str::<U256>(
-            "\"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffg\""
-        )
-        .is_err()); // invalid char
-        assert!(::serde_json::from_str::<U256>(
-            "\"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
-        )
-        .is_err()); // invalid length
-        assert!(::serde_json::from_str::<U256>(
-            "\"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
-        )
-        .is_err()); // invalid length
+        assert!(
+            ::serde_json::from_str::<U256>(
+                "\"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffg\""
+            )
+            .is_err()
+        ); // invalid char
+        assert!(
+            ::serde_json::from_str::<U256>(
+                "\"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
+            )
+            .is_err()
+        ); // invalid length
+        assert!(
+            ::serde_json::from_str::<U256>(
+                "\"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
+            )
+            .is_err()
+        ); // invalid length
     }
 
     #[test]
diff --git a/dash/src/psbt/map/global.rs b/dash/src/psbt/map/global.rs
index 62d8a26d6..328a2ed7c 100644
--- a/dash/src/psbt/map/global.rs
+++ b/dash/src/psbt/map/global.rs
@@ -5,11 +5,11 @@ use core::convert::TryFrom;
 use crate::bip32::{ChildNumber, DerivationPath, ExtendedPubKey, Fingerprint};
 use crate::blockdata::transaction::Transaction;
 use crate::consensus::encode::MAX_VEC_SIZE;
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 use crate::io::{self, Cursor, Read};
 use crate::prelude::*;
 use crate::psbt::map::Map;
-use crate::psbt::{raw, Error, PartiallySignedTransaction};
+use crate::psbt::{Error, PartiallySignedTransaction, raw};
 use crate::transaction::special_transaction::TransactionType;
 
 /// Type: Unsigned Transaction PSBT_GLOBAL_UNSIGNED_TX = 0x00
diff --git a/dash/src/psbt/map/input.rs b/dash/src/psbt/map/input.rs
index 02a45d2b6..e5b1ada63 100644
--- a/dash/src/psbt/map/input.rs
+++ b/dash/src/psbt/map/input.rs
@@ -9,15 +9,15 @@ use secp256k1::XOnlyPublicKey;
 
 use crate::bip32::KeySource;
 use crate::blockdata::script::ScriptBuf;
-use crate::blockdata::transaction::txout::TxOut;
 use crate::blockdata::transaction::Transaction;
+use crate::blockdata::transaction::txout::TxOut;
 use crate::blockdata::witness::Witness;
 use crate::crypto::key::PublicKey;
 use crate::crypto::{ecdsa, taproot};
 use crate::prelude::*;
 use crate::psbt::map::Map;
 use crate::psbt::serialize::Deserialize;
-use crate::psbt::{self, error, raw, Error};
+use crate::psbt::{self, Error, error, raw};
 use crate::sighash::{
     self, EcdsaSighashType, NonStandardSighashType, SighashTypeParseError, TapSighashType,
 };
diff --git a/dash/src/psbt/map/output.rs b/dash/src/psbt/map/output.rs
index b4a7f1aaf..e32097386 100644
--- a/dash/src/psbt/map/output.rs
+++ b/dash/src/psbt/map/output.rs
@@ -9,7 +9,7 @@ use crate::bip32::KeySource;
 use crate::blockdata::script::ScriptBuf;
 use crate::prelude::*;
 use crate::psbt::map::Map;
-use crate::psbt::{raw, Error};
+use crate::psbt::{Error, raw};
 use crate::taproot::{TapLeafHash, TapTree};
 
 /// Type: Redeem ScriptBuf PSBT_OUT_REDEEM_SCRIPT = 0x00
diff --git a/dash/src/psbt/mod.rs b/dash/src/psbt/mod.rs
index b5c567125..5e265f958 100644
--- a/dash/src/psbt/mod.rs
+++ b/dash/src/psbt/mod.rs
@@ -14,16 +14,16 @@ use std::collections::{HashMap, HashSet};
 use internals::write_err;
 use secp256k1::{Message, Secp256k1, Signing};
 
+use crate::Amount;
 use crate::bip32::{self, ExtendedPrivKey, ExtendedPubKey, KeySource};
 use crate::blockdata::script::ScriptBuf;
-use crate::blockdata::transaction::txout::TxOut;
 use crate::blockdata::transaction::Transaction;
+use crate::blockdata::transaction::txout::TxOut;
 use crate::crypto::ecdsa;
 use crate::crypto::key::{PrivateKey, PublicKey};
 use crate::prelude::*;
 pub use crate::sighash::Prevouts;
 use crate::sighash::{self, EcdsaSighashType, SighashCache};
-use crate::Amount;
 
 #[macro_use]
 mod macros;
@@ -823,24 +823,24 @@ pub use self::display_from_str::PsbtParseError;
 mod tests {
     use std::collections::BTreeMap;
 
-    use hashes::{hash160, ripemd160, sha256, Hash};
+    use hashes::{Hash, hash160, ripemd160, sha256};
     use secp256k1::{self, Secp256k1};
     #[cfg(feature = "rand-std")]
     use secp256k1::{All, SecretKey};
 
     use super::*;
+    use crate::Network::Dash;
     use crate::bip32::{ChildNumber, ExtendedPrivKey, ExtendedPubKey, KeySource};
     use crate::blockdata::script::ScriptBuf;
+    use crate::blockdata::transaction::Transaction;
     use crate::blockdata::transaction::outpoint::OutPoint;
     use crate::blockdata::transaction::txin::TxIn;
     use crate::blockdata::transaction::txout::TxOut;
-    use crate::blockdata::transaction::Transaction;
     use crate::blockdata::witness::Witness;
     use crate::internal_macros::hex;
     use crate::psbt::map::{Input, Output};
     use crate::psbt::raw;
     use crate::psbt::serialize::{Deserialize, Serialize};
-    use crate::Network::Dash;
 
     #[test]
     fn trivial_psbt() {
@@ -1111,13 +1111,13 @@ mod tests {
 
         use super::*;
         use crate::blockdata::script::ScriptBuf;
+        use crate::blockdata::transaction::Transaction;
         use crate::blockdata::transaction::outpoint::OutPoint;
         use crate::blockdata::transaction::txin::TxIn;
         use crate::blockdata::transaction::txout::TxOut;
-        use crate::blockdata::transaction::Transaction;
         use crate::blockdata::witness::Witness;
         use crate::psbt::map::{Input, Map, Output};
-        use crate::psbt::{raw, Error, PartiallySignedTransaction};
+        use crate::psbt::{Error, PartiallySignedTransaction, raw};
         use crate::sighash::EcdsaSighashType;
 
         #[test]
@@ -1339,9 +1339,11 @@ mod tests {
             let psbt_non_witness_utxo = psbt.inputs[0].non_witness_utxo.as_ref().unwrap();
 
             assert_eq!(tx_input.previous_output.txid, psbt_non_witness_utxo.txid());
-            assert!(psbt_non_witness_utxo.output[tx_input.previous_output.vout as usize]
-                .script_pubkey
-                .is_p2pkh());
+            assert!(
+                psbt_non_witness_utxo.output[tx_input.previous_output.vout as usize]
+                    .script_pubkey
+                    .is_p2pkh()
+            );
             assert_eq!(
                 psbt.inputs[0].sighash_type.as_ref().unwrap().ecdsa_hash_ty().unwrap(),
                 EcdsaSighashType::All
@@ -1818,9 +1820,9 @@ mod tests {
     #[test]
     #[cfg(feature = "rand-std")]
     fn sign_psbt() {
+        use crate::WPubkeyHash;
         use crate::address::WitnessProgram;
         use crate::bip32::{DerivationPath, Fingerprint};
-        use crate::WPubkeyHash;
 
         let unsigned_tx = Transaction {
             version: 2,
diff --git a/dash/src/psbt/raw.rs b/dash/src/psbt/raw.rs
index 9c1c91509..dc25c0199 100644
--- a/dash/src/psbt/raw.rs
+++ b/dash/src/psbt/raw.rs
@@ -11,7 +11,7 @@ use core::fmt;
 
 use super::serialize::{Deserialize, Serialize};
 use crate::consensus::encode::{
-    self, deserialize, serialize, Decodable, Encodable, ReadExt, VarInt, WriteExt, MAX_VEC_SIZE,
+    self, Decodable, Encodable, MAX_VEC_SIZE, ReadExt, VarInt, WriteExt, deserialize, serialize,
 };
 use crate::io;
 use crate::prelude::*;
diff --git a/dash/src/psbt/serialize.rs b/dash/src/psbt/serialize.rs
index d0b4c16e5..2382040bc 100644
--- a/dash/src/psbt/serialize.rs
+++ b/dash/src/psbt/serialize.rs
@@ -8,17 +8,17 @@
 
 use core::convert::{TryFrom, TryInto};
 
-use hashes::{hash160, ripemd160, sha256, sha256d, Hash};
+use hashes::{Hash, hash160, ripemd160, sha256, sha256d};
 use secp256k1::{self, XOnlyPublicKey};
 
-use super::map::{Input, Map, Output, PsbtSighashType};
 use super::Psbt;
+use super::map::{Input, Map, Output, PsbtSighashType};
 use crate::bip32::{ChildNumber, Fingerprint, KeySource};
 use crate::blockdata::script::ScriptBuf;
-use crate::blockdata::transaction::txout::TxOut;
 use crate::blockdata::transaction::Transaction;
+use crate::blockdata::transaction::txout::TxOut;
 use crate::blockdata::witness::Witness;
-use crate::consensus::encode::{self, deserialize_partial, serialize, Decodable, Encodable};
+use crate::consensus::encode::{self, Decodable, Encodable, deserialize_partial, serialize};
 use crate::crypto::key::PublicKey;
 use crate::crypto::{ecdsa, taproot};
 use crate::prelude::*;
@@ -26,7 +26,7 @@ use crate::psbt::{Error, PartiallySignedTransaction};
 use crate::taproot::{
     ControlBlock, LeafVersion, TapLeafHash, TapNodeHash, TapTree, TaprootBuilder,
 };
-use crate::{io, VarInt};
+use crate::{VarInt, io};
 /// A trait for serializing a value as raw data for insertion into PSBT
 /// key-value maps.
 pub trait Serialize {
diff --git a/dash/src/sign_message.rs b/dash/src/sign_message.rs
index 72d1dbc75..6da63ded0 100644
--- a/dash/src/sign_message.rs
+++ b/dash/src/sign_message.rs
@@ -21,11 +21,11 @@
 //! library is used with the `secp-recovery` feature.
 //!
 
-use hashes::{sha256d, Hash, HashEngine};
+use hashes::{Hash, HashEngine, sha256d};
 
 #[cfg(feature = "secp-recovery")]
 pub use self::message_signing::{MessageSignature, MessageSignatureError};
-use crate::consensus::{encode, Encodable};
+use crate::consensus::{Encodable, encode};
 
 /// The prefix for signed messages using Dash's message signing protocol.
 pub const DASH_SIGNED_MSG_PREFIX: &[u8] = b"\x19DarkCoin Signed Message:\n";
diff --git a/dash/src/signer.rs b/dash/src/signer.rs
index 49cb8a678..c656da554 100644
--- a/dash/src/signer.rs
+++ b/dash/src/signer.rs
@@ -3,12 +3,12 @@
 use core::convert::TryInto;
 
 use anyhow::{anyhow, bail};
-use hashes::{ripemd160, sha256, sha256d, Hash};
+use hashes::{Hash, ripemd160, sha256, sha256d};
 
+use crate::PublicKey as ECDSAPublicKey;
 use crate::prelude::Vec;
 use crate::secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
 use crate::secp256k1::{Message, Secp256k1, SecretKey};
-use crate::PublicKey as ECDSAPublicKey;
 
 /// verifies the ECDSA signature
 /// The provided signature must be recoverable. Which means: it must contain the recovery byte as a prefix
@@ -140,7 +140,7 @@ mod test {
     use super::*;
     use crate::internal_macros::hex;
     use crate::psbt::serialize::Serialize;
-    use crate::{assert_error_contains, PublicKey};
+    use crate::{PublicKey, assert_error_contains};
 
     struct Keys {
         private_key: Vec<u8>,
diff --git a/dash/src/sml/address.rs b/dash/src/sml/address.rs
index 3632add30..5eafec8e8 100644
--- a/dash/src/sml/address.rs
+++ b/dash/src/sml/address.rs
@@ -2,7 +2,7 @@ use std::io;
 use std::io::Write;
 use std::net::{IpAddr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 
-use crate::consensus::{encode, Decodable, Encodable};
+use crate::consensus::{Decodable, Encodable, encode};
 
 impl Encodable for SocketAddr {
     fn consensus_encode<W: Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error> {
diff --git a/dash/src/sml/llmq_entry_verification.rs b/dash/src/sml/llmq_entry_verification.rs
index 1edb9a6b8..efaaeb38a 100644
--- a/dash/src/sml/llmq_entry_verification.rs
+++ b/dash/src/sml/llmq_entry_verification.rs
@@ -3,9 +3,9 @@ use core::fmt::{Display, Formatter};
 #[cfg(feature = "bincode")]
 use bincode::{Decode, Encode};
 
+use crate::BlockHash;
 use crate::prelude::CoreBlockHeight;
 use crate::sml::quorum_validation_error::QuorumValidationError;
-use crate::BlockHash;
 
 #[derive(Clone, Ord, PartialOrd, PartialEq, Eq, Hash, Debug)]
 #[cfg_attr(feature = "bincode", derive(Encode, Decode))]
diff --git a/dash/src/sml/llmq_type/mod.rs b/dash/src/sml/llmq_type/mod.rs
index 7967c09c1..942587ef0 100644
--- a/dash/src/sml/llmq_type/mod.rs
+++ b/dash/src/sml/llmq_type/mod.rs
@@ -7,8 +7,8 @@ use std::io;
 #[cfg(feature = "bincode")]
 use bincode::{Decode, Encode};
 
-use crate::consensus::{encode, Decodable, Encodable};
 use crate::Network;
+use crate::consensus::{Decodable, Encodable, encode};
 
 #[repr(C)]
 #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Hash, Ord)]
diff --git a/dash/src/sml/llmq_type/network.rs b/dash/src/sml/llmq_type/network.rs
index c3f374e29..46f476ecb 100644
--- a/dash/src/sml/llmq_type/network.rs
+++ b/dash/src/sml/llmq_type/network.rs
@@ -1,5 +1,5 @@
-use crate::sml::llmq_type::LLMQType;
 use crate::Network;
+use crate::sml::llmq_type::LLMQType;
 
 impl Network {
     pub fn is_llmq_type(&self) -> LLMQType {
diff --git a/dash/src/sml/masternode_list/masternode_helpers.rs b/dash/src/sml/masternode_list/masternode_helpers.rs
index 2968c795b..f5c808e12 100644
--- a/dash/src/sml/masternode_list/masternode_helpers.rs
+++ b/dash/src/sml/masternode_list/masternode_helpers.rs
@@ -1,7 +1,7 @@
 use std::net::IpAddr;
 
-use crate::sml::masternode_list::MasternodeList;
 use crate::ProTxHash;
+use crate::sml::masternode_list::MasternodeList;
 
 impl MasternodeList {
     pub fn has_valid_masternode(&self, pro_reg_tx_hash: &ProTxHash) -> bool {
diff --git a/dash/src/sml/masternode_list/merkle_roots.rs b/dash/src/sml/masternode_list/merkle_roots.rs
index 62a966cd3..f4b322923 100644
--- a/dash/src/sml/masternode_list/merkle_roots.rs
+++ b/dash/src/sml/masternode_list/merkle_roots.rs
@@ -1,9 +1,9 @@
-use hashes::{sha256d, Hash};
+use hashes::{Hash, sha256d};
 
+use crate::Transaction;
 use crate::hash_types::{MerkleRootMasternodeList, MerkleRootQuorums};
 use crate::sml::masternode_list::MasternodeList;
 use crate::transaction::special_transaction::TransactionPayload;
-use crate::Transaction;
 
 /// Computes the Merkle root from a list of hashes.
 ///
diff --git a/dash/src/sml/masternode_list/peer_addresses.rs b/dash/src/sml/masternode_list/peer_addresses.rs
index 3429f0c58..d5d816609 100644
--- a/dash/src/sml/masternode_list/peer_addresses.rs
+++ b/dash/src/sml/masternode_list/peer_addresses.rs
@@ -3,8 +3,8 @@ use std::net::SocketAddr;
 
 use hashes::Hash;
 
-use crate::sml::masternode_list::masternode_helpers::reverse_cmp_sup;
 use crate::sml::masternode_list::MasternodeList;
+use crate::sml::masternode_list::masternode_helpers::reverse_cmp_sup;
 
 impl MasternodeList {
     /// Retrieves a list of peer addresses from the masternode list, sorted using a nonce for deterministic ordering.
diff --git a/dash/src/sml/masternode_list/scores_for_quorum.rs b/dash/src/sml/masternode_list/scores_for_quorum.rs
index fc35d7d62..0b39f79dc 100644
--- a/dash/src/sml/masternode_list/scores_for_quorum.rs
+++ b/dash/src/sml/masternode_list/scores_for_quorum.rs
@@ -1,14 +1,14 @@
 use std::collections::BTreeMap;
 
+use crate::Network;
 use crate::hash_types::{QuorumModifierHash, ScoreHash};
 use crate::network::message_qrinfo::QuorumSnapshot;
 use crate::sml::llmq_type::LLMQType;
 use crate::sml::masternode_list::MasternodeList;
-use crate::sml::masternode_list_entry::qualified_masternode_list_entry::QualifiedMasternodeListEntry;
 use crate::sml::masternode_list_entry::EntryMasternodeType;
+use crate::sml::masternode_list_entry::qualified_masternode_list_entry::QualifiedMasternodeListEntry;
 use crate::sml::quorum_entry::qualified_quorum_entry::QualifiedQuorumEntry;
 use crate::sml::quorum_entry::quorum_modifier_type::LLMQModifierType;
-use crate::Network;
 
 impl MasternodeList {
     pub fn valid_masternodes_for_quorum<'a, T>(
diff --git a/dash/src/sml/masternode_list_engine/message_request_verification.rs b/dash/src/sml/masternode_list_engine/message_request_verification.rs
index e30a3df65..40df4778c 100644
--- a/dash/src/sml/masternode_list_engine/message_request_verification.rs
+++ b/dash/src/sml/masternode_list_engine/message_request_verification.rs
@@ -94,8 +94,8 @@ impl MasternodeListEngine {
         let quorum_count = self.network.isd_llmq_type().active_quorum_count();
         let n = quorum_count.ilog2();
         let quorum_index_mask = (1 << n) - 1; // Extracts the last log2(quorum_count) bits
-                                              // Extract the last `n` bits from the selection hash
-                                              // Only God and maybe Odysseus knows why (64 - n - 1)
+        // Extract the last `n` bits from the selection hash
+        // Only God and maybe Odysseus knows why (64 - n - 1)
         let quorum_index = quorum_index_mask & (selection_hash_64 >> (64 - n - 1)) as usize;
 
         // Retrieve the selected quorum
@@ -349,8 +349,8 @@ impl MasternodeListEngine {
 mod tests {
     use crate::bls_sig_utils::BLSSignature;
     use crate::consensus::deserialize;
-    use crate::hashes::hex::FromHex;
     use crate::hashes::Hash;
+    use crate::hashes::hex::FromHex;
     use crate::sml::llmq_type::LLMQType;
     use crate::sml::masternode_list_engine::MasternodeListEngine;
     use crate::{BlockHash, ChainLock, InstantLock, QuorumHash};
diff --git a/dash/src/sml/masternode_list_engine/mod.rs b/dash/src/sml/masternode_list_engine/mod.rs
index 35bfd3f4b..341f0c47c 100644
--- a/dash/src/sml/masternode_list_engine/mod.rs
+++ b/dash/src/sml/masternode_list_engine/mod.rs
@@ -15,8 +15,8 @@ use crate::prelude::CoreBlockHeight;
 use crate::sml::error::SmlError;
 use crate::sml::llmq_entry_verification::LLMQEntryVerificationStatus;
 use crate::sml::llmq_type::LLMQType;
-use crate::sml::masternode_list::from_diff::TryIntoWithBlockHashLookup;
 use crate::sml::masternode_list::MasternodeList;
+use crate::sml::masternode_list::from_diff::TryIntoWithBlockHashLookup;
 use crate::sml::quorum_entry::qualified_quorum_entry::{
     QualifiedQuorumEntry, VerifyingChainLockSignaturesType,
 };
@@ -959,6 +959,8 @@ impl MasternodeListEngine {
 
 #[cfg(test)]
 mod tests {
+    use crate::BlockHash;
+    use crate::Network;
     use crate::consensus::deserialize;
     use crate::network::message_qrinfo::QRInfo;
     use crate::network::message_sml::MnListDiff;
@@ -966,17 +968,14 @@ mod tests {
     use crate::sml::llmq_entry_verification::LLMQEntryVerificationStatus;
     use crate::sml::llmq_type::LLMQType;
     use crate::sml::llmq_type::LLMQType::{
-        Llmqtype400_60, Llmqtype400_85, Llmqtype50_60, Llmqtype60_75,
+        Llmqtype50_60, Llmqtype60_75, Llmqtype400_60, Llmqtype400_85,
     };
     use crate::sml::masternode_list::MasternodeList;
-    use crate::sml::masternode_list_engine::BLSSignature;
     use crate::sml::masternode_list_engine::{
         MasternodeListEngine, MasternodeListEngineBlockContainer,
     };
     use crate::sml::quorum_entry::qualified_quorum_entry::VerifyingChainLockSignaturesType;
     use crate::sml::quorum_validation_error::ClientDataRetrievalError;
-    use crate::BlockHash;
-    use crate::Network;
     use std::collections::BTreeMap;
 
     fn verify_masternode_list_quorums(
@@ -1179,7 +1178,7 @@ mod tests {
             )
             .expect("expected to verify quorums");
 
-        let last_masternode_list = mn_list_engine.masternode_lists.last_key_value().unwrap().1;
+        let _last_masternode_list = mn_list_engine.masternode_lists.last_key_value().unwrap().1;
 
         verify_masternode_list_quorums(
             &mn_list_engine,
@@ -1215,7 +1214,7 @@ mod tests {
             )
             .expect("expected to verify quorums");
 
-        let last_masternode_list = mn_list_engine.masternode_lists.last_key_value().unwrap().1;
+        let _last_masternode_list = mn_list_engine.masternode_lists.last_key_value().unwrap().1;
 
         verify_masternode_list_quorums(
             &mn_list_engine,
diff --git a/dash/src/sml/masternode_list_engine/non_rotated_quorum_construction.rs b/dash/src/sml/masternode_list_engine/non_rotated_quorum_construction.rs
index 4e4cee884..f87c21e69 100644
--- a/dash/src/sml/masternode_list_engine/non_rotated_quorum_construction.rs
+++ b/dash/src/sml/masternode_list_engine/non_rotated_quorum_construction.rs
@@ -1,3 +1,4 @@
+use crate::BlockHash;
 use crate::prelude::CoreBlockHeight;
 use crate::sml::masternode_list::MasternodeList;
 use crate::sml::masternode_list_engine::MasternodeListEngine;
@@ -7,7 +8,6 @@ use crate::sml::quorum_entry::qualified_quorum_entry::{
 };
 use crate::sml::quorum_entry::quorum_modifier_type::LLMQModifierType;
 use crate::sml::quorum_validation_error::QuorumValidationError;
-use crate::BlockHash;
 
 impl MasternodeListEngine {
     pub(crate) fn masternode_list_and_height_for_block_hash_8_blocks_ago(
diff --git a/dash/src/sml/masternode_list_engine/rotated_quorum_construction.rs b/dash/src/sml/masternode_list_engine/rotated_quorum_construction.rs
index 8eb08774c..8c8b76c36 100644
--- a/dash/src/sml/masternode_list_engine/rotated_quorum_construction.rs
+++ b/dash/src/sml/masternode_list_engine/rotated_quorum_construction.rs
@@ -1,9 +1,10 @@
+use crate::QuorumHash;
 use crate::bls_sig_utils::BLSSignature;
 use crate::hash_types::QuorumModifierHash;
 use crate::network::message_qrinfo::{MNSkipListMode, QRInfo};
 use crate::prelude::CoreBlockHeight;
-use crate::sml::llmq_type::rotation::{LLMQQuarterReconstructionType, LLMQQuarterUsageType};
 use crate::sml::llmq_type::LLMQType;
+use crate::sml::llmq_type::rotation::{LLMQQuarterReconstructionType, LLMQQuarterUsageType};
 use crate::sml::masternode_list::MasternodeList;
 use crate::sml::masternode_list_engine::MasternodeListEngine;
 use crate::sml::masternode_list_entry::qualified_masternode_list_entry::QualifiedMasternodeListEntry;
@@ -12,7 +13,6 @@ use crate::sml::quorum_entry::qualified_quorum_entry::{
 };
 use crate::sml::quorum_entry::quorum_modifier_type::LLMQModifierType;
 use crate::sml::quorum_validation_error::QuorumValidationError;
-use crate::QuorumHash;
 use std::collections::{BTreeMap, BTreeSet};
 
 impl MasternodeListEngine {
diff --git a/dash/src/sml/masternode_list_engine/validation.rs b/dash/src/sml/masternode_list_engine/validation.rs
index 8b28516ed..011989c7b 100644
--- a/dash/src/sml/masternode_list_engine/validation.rs
+++ b/dash/src/sml/masternode_list_engine/validation.rs
@@ -1,11 +1,11 @@
 use std::collections::BTreeMap;
 
+use crate::QuorumHash;
 use crate::sml::llmq_entry_verification::LLMQEntryVerificationStatus;
 use crate::sml::masternode_list_engine::MasternodeListEngine;
 use crate::sml::masternode_list_entry::qualified_masternode_list_entry::QualifiedMasternodeListEntry;
 use crate::sml::quorum_entry::qualified_quorum_entry::QualifiedQuorumEntry;
 use crate::sml::quorum_validation_error::QuorumValidationError;
-use crate::QuorumHash;
 
 impl MasternodeListEngine {
     fn find_valid_masternodes_for_quorum<'a>(
diff --git a/dash/src/sml/masternode_list_entry/hash.rs b/dash/src/sml/masternode_list_entry/hash.rs
index 69ae1b909..51f5932cf 100644
--- a/dash/src/sml/masternode_list_entry/hash.rs
+++ b/dash/src/sml/masternode_list_entry/hash.rs
@@ -1,4 +1,4 @@
-use hashes::{sha256d, Hash};
+use hashes::{Hash, sha256d};
 
 use crate::consensus::Encodable;
 use crate::sml::masternode_list_entry::MasternodeListEntry;
diff --git a/dash/src/sml/masternode_list_entry/qualified_masternode_list_entry.rs b/dash/src/sml/masternode_list_entry/qualified_masternode_list_entry.rs
index 4668abb14..595d4c9ee 100644
--- a/dash/src/sml/masternode_list_entry/qualified_masternode_list_entry.rs
+++ b/dash/src/sml/masternode_list_entry/qualified_masternode_list_entry.rs
@@ -2,7 +2,7 @@ use std::cmp::Ordering;
 
 #[cfg(feature = "bincode")]
 use bincode::{Decode, Encode};
-use hashes::{sha256d, Hash};
+use hashes::{Hash, sha256d};
 
 use crate::hash_types::ConfirmedHashHashedWithProRegTx;
 use crate::sml::masternode_list_entry::MasternodeListEntry;
diff --git a/dash/src/sml/message_verification_error.rs b/dash/src/sml/message_verification_error.rs
index 3dbadc198..55138342e 100644
--- a/dash/src/sml/message_verification_error.rs
+++ b/dash/src/sml/message_verification_error.rs
@@ -3,12 +3,12 @@ use bincode::{Decode, Encode};
 use hashes::sha256d;
 use thiserror::Error;
 
+use crate::QuorumHash;
 use crate::bls_sig_utils::{BLSPublicKey, BLSSignature};
 use crate::hash_types::CycleHash;
 use crate::prelude::CoreBlockHeight;
 use crate::sml::llmq_type::LLMQType;
 use crate::sml::quorum_validation_error::QuorumValidationError;
-use crate::QuorumHash;
 
 #[derive(Debug, Error, Clone, Ord, PartialOrd, PartialEq, Hash, Eq)]
 #[cfg_attr(feature = "bincode", derive(Encode, Decode))]
diff --git a/dash/src/sml/quorum_entry/hash.rs b/dash/src/sml/quorum_entry/hash.rs
index 090ed6484..fd346c96d 100644
--- a/dash/src/sml/quorum_entry/hash.rs
+++ b/dash/src/sml/quorum_entry/hash.rs
@@ -1,7 +1,7 @@
 use hashes::Hash;
 
-use crate::consensus::encode::{write_compact_size, write_fixed_bitset};
 use crate::consensus::Encodable;
+use crate::consensus::encode::{write_compact_size, write_fixed_bitset};
 use crate::hash_types::{QuorumCommitmentHash, QuorumEntryHash};
 use crate::transaction::special_transaction::quorum_commitment::QuorumEntry;
 
diff --git a/dash/src/sml/quorum_entry/quorum_modifier_type.rs b/dash/src/sml/quorum_entry/quorum_modifier_type.rs
index 0e70e607a..03292bfed 100644
--- a/dash/src/sml/quorum_entry/quorum_modifier_type.rs
+++ b/dash/src/sml/quorum_entry/quorum_modifier_type.rs
@@ -1,12 +1,11 @@
-use std::collections::BTreeMap;
 use std::fmt;
 use std::io::Write;
 
 use hashes::Hash;
 
 use crate::bls_sig_utils::BLSSignature;
-use crate::consensus::encode::VarInt;
 use crate::consensus::Encodable;
+use crate::consensus::encode::VarInt;
 use crate::hash_types::QuorumModifierHash;
 use crate::prelude::CoreBlockHeight;
 use crate::sml::llmq_type::LLMQType;
diff --git a/dash/src/sml/quorum_entry/verify_message.rs b/dash/src/sml/quorum_entry/verify_message.rs
index 24a70e426..931492aab 100644
--- a/dash/src/sml/quorum_entry/verify_message.rs
+++ b/dash/src/sml/quorum_entry/verify_message.rs
@@ -1,5 +1,5 @@
 use blsful::Bls12381G2Impl;
-use hashes::{sha256d, Hash};
+use hashes::{Hash, sha256d};
 
 use crate::bls_sig_utils::BLSSignature;
 use crate::sml::message_verification_error::MessageVerificationError;
diff --git a/dash/src/sml/quorum_validation_error.rs b/dash/src/sml/quorum_validation_error.rs
index 42cb62eb1..3ced05614 100644
--- a/dash/src/sml/quorum_validation_error.rs
+++ b/dash/src/sml/quorum_validation_error.rs
@@ -39,7 +39,9 @@ pub enum QuorumValidationError {
     #[error("Required chain lock not present at block height {0}, block hash: {1}")]
     RequiredChainLockNotPresent(CoreBlockHeight, BlockHash),
 
-    #[error("Required rotated chain lock sig at h - {0} not present for masternode diff block hash: {1}")]
+    #[error(
+        "Required rotated chain lock sig at h - {0} not present for masternode diff block hash: {1}"
+    )]
     RequiredRotatedChainLockSigNotPresent(u8, BlockHash),
 
     #[error("Required rotated chain lock sigs not present for masternode diff block hash: {0}")]
diff --git a/dash/src/taproot.rs b/dash/src/taproot.rs
index 8d8df5976..d182f0564 100644
--- a/dash/src/taproot.rs
+++ b/dash/src/taproot.rs
@@ -10,7 +10,7 @@ use core::convert::TryFrom;
 use core::fmt;
 use core::iter::FusedIterator;
 
-use hashes::{sha256t_hash_newtype, Hash, HashEngine};
+use hashes::{Hash, HashEngine, sha256t_hash_newtype};
 use internals::write_err;
 use secp256k1::{self, Scalar, Secp256k1};
 
@@ -19,7 +19,7 @@ use crate::crypto::key::{TapTweak, TweakedPublicKey, UntweakedPublicKey, XOnlyPu
 // Re-export these so downstream only has to use one `taproot` module.
 pub use crate::crypto::taproot::{Error, Signature};
 use crate::prelude::*;
-use crate::{io, Script, ScriptBuf};
+use crate::{Script, ScriptBuf, io};
 
 // Taproot test vectors from BIP-341 state the hashes without any reversing
 sha256t_hash_newtype! {
@@ -1693,7 +1693,7 @@ mod test {
 
     use hashes::hex::FromHex;
     use hashes::sha256t::Tag;
-    use hashes::{sha256, Hash, HashEngine};
+    use hashes::{Hash, HashEngine, sha256};
     use secp256k1::{VerifyOnly, XOnlyPublicKey};
 
     use super::*;
@@ -1705,7 +1705,7 @@ mod test {
     use {
         crate::internal_macros::hex,
         serde_test::Configure,
-        serde_test::{assert_tokens, Token},
+        serde_test::{Token, assert_tokens},
     };
 
     fn tag_engine(tag_name: &str) -> sha256::HashEngine {
diff --git a/dash/tests/serde.rs b/dash/tests/serde.rs
deleted file mode 100644
index 077d043fa..000000000
--- a/dash/tests/serde.rs
+++ /dev/null
@@ -1,408 +0,0 @@
-//! Regression tests for _most_ types that implement `serde::Serialize`.
-//!
-//! For remaining types see: ./serde_opcodes.rs
-//!
-//! If you find a type defined in `rust-dash` that implements `Serialize` and does _not_ have a
-//! regression test please add it.
-//!
-//! Types/tests were found using, and are ordered by, the output of: `git grep -l Serialize`.
-//!
-
-// In tests below `deserialize` is consensus deserialize while `serialize` is serde serialize, that
-// is why we have two different serialized data files for tests that use binary serialized input.
-//
-// To create a file with the expected serialized data do something like:
-//
-//  use std::fs::File;
-//  use std::io::Write;
-//  let script = ScriptBuf::from(vec![0u8, 1u8, 2u8]);
-//  let got = serialize(&script).unwrap();
-//  let mut file = File::create("/tmp/script_bincode").unwrap();
-//  file.write_all(&got).unwrap();
-
-#![cfg(feature = "serde")]
-
-use std::collections::BTreeMap;
-use std::convert::TryFrom;
-use std::str::FromStr;
-
-use bincode_test::serialize;
-use dashcore::bip32::{ChildNumber, ExtendedPrivKey, ExtendedPubKey, KeySource};
-use dashcore::consensus::deserialize;
-use dashcore::psbt::raw::{Key, Pair, ProprietaryKey};
-use dashcore::psbt::{raw, Input, Output, Psbt, PsbtSighashType};
-use dashcore::sighash::{EcdsaSighashType, TapSighashType};
-use dashcore::taproot::{ControlBlock, LeafVersion, TapTree, TaprootBuilder};
-use dashcore::{
-    absolute, ecdsa, relative, taproot, Address, Block, Network, OutPoint, PrivateKey, PublicKey,
-    ScriptBuf, Target, Transaction, TxIn, TxOut, Txid, Witness, Work,
-};
-use dashcore_hashes::{hash160, ripemd160, sha256, sha256d, Hash};
-use hex_lit::hex;
-
-/// Implicitly does regression test for `BlockHeader` also.
-#[ignore]
-#[test]
-fn serde_regression_block() {
-    let segwit = include_bytes!(
-        "data/testnet_block_000000000000045e0b1660b6445b5e5c5ab63c9a4f956be7e1e69be04fa4497b.raw"
-    );
-    let block: Block = deserialize(segwit).unwrap();
-    let got = serialize(&block).unwrap();
-    let want = include_bytes!("data/serde/block_bincode");
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_absolute_lock_time_height() {
-    let t = absolute::LockTime::from_height(741521).expect("valid height");
-    let got = serialize(&t).unwrap();
-    let want = include_bytes!("data/serde/absolute_lock_time_blocks_bincode") as &[_];
-    assert_eq!(got, want);
-}
-
-#[test]
-fn serde_regression_absolute_lock_time_time() {
-    let seconds: u32 = 1653195600; // May 22nd, 5am UTC.
-    let t = absolute::LockTime::from_time(seconds).expect("valid time");
-    let got = serialize(&t).unwrap();
-
-    let want = include_bytes!("data/serde/absolute_lock_time_seconds_bincode") as &[_];
-    assert_eq!(got, want);
-}
-
-#[test]
-fn serde_regression_relative_lock_time_height() {
-    let t = relative::LockTime::from(relative::Height::from(0xCAFE_u16));
-    let got = serialize(&t).unwrap();
-
-    let want = include_bytes!("data/serde/relative_lock_time_blocks_bincode") as &[_];
-    assert_eq!(got, want);
-}
-
-#[test]
-fn serde_regression_relative_lock_time_time() {
-    let t = relative::LockTime::from(relative::Time::from_512_second_intervals(0xFACE_u16));
-    let got = serialize(&t).unwrap();
-
-    let want = include_bytes!("data/serde/relative_lock_time_seconds_bincode") as &[_];
-    assert_eq!(got, want);
-}
-
-#[test]
-fn serde_regression_script() {
-    let script = ScriptBuf::from(vec![0u8, 1u8, 2u8]);
-    let got = serialize(&script).unwrap();
-    let want = include_bytes!("data/serde/script_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_txin() {
-    let ser = include_bytes!("data/serde/txin_ser");
-    let txin: TxIn = deserialize(ser).unwrap();
-
-    let got = serialize(&txin).unwrap();
-    let want = include_bytes!("data/serde/txin_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_txout() {
-    let txout = TxOut {
-        value: 0xDEADBEEFCAFEBABE,
-        script_pubkey: ScriptBuf::from(vec![0u8, 1u8, 2u8]),
-    };
-    let got = serialize(&txout).unwrap();
-    let want = include_bytes!("data/serde/txout_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[ignore]
-#[test]
-fn serde_regression_transaction() {
-    let ser = include_bytes!("data/serde/transaction_ser");
-    let tx: Transaction = deserialize(ser).unwrap();
-    let got = serialize(&tx).unwrap();
-    let want = include_bytes!("data/serde/transaction_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_witness() {
-    let w0 = hex!("03d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f2105");
-    let w1 = hex!("000000");
-    let vec: Vec<&[u8]> = vec![w0.as_slice(), w1.as_slice()];
-    let witness = Witness::from_slice(&vec);
-
-    let got = serialize(&witness).unwrap();
-    let want = include_bytes!("data/serde/witness_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_address() {
-    let s = include_str!("data/serde/public_key_hex");
-    let pk = PublicKey::from_str(s.trim()).unwrap();
-    let addr = Address::p2pkh(&pk, Network::Dash);
-
-    let got = serialize(&addr).unwrap();
-    let want = include_bytes!("data/serde/address_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_extended_priv_key() {
-    let s = include_str!("data/serde/extended_priv_key");
-    let key = ExtendedPrivKey::from_str(s.trim()).unwrap();
-    let got = serialize(&key).unwrap();
-    let want = include_bytes!("data/serde/extended_priv_key_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_extended_pub_key() {
-    let s = include_str!("data/serde/extended_pub_key");
-    let key = ExtendedPubKey::from_str(s.trim()).unwrap();
-    let got = serialize(&key).unwrap();
-    let want = include_bytes!("data/serde/extended_pub_key_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_ecdsa_sig() {
-    let s = include_str!("data/serde/ecdsa_sig_hex");
-    let sig = ecdsa::Signature {
-        sig: secp256k1::ecdsa::Signature::from_str(s.trim()).unwrap(),
-        hash_ty: EcdsaSighashType::All,
-    };
-
-    let got = serialize(&sig).unwrap();
-    let want = include_bytes!("data/serde/ecdsa_sig_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_control_block() {
-    let s = include_str!("data/serde/control_block_hex");
-    let block = ControlBlock::decode(&hex::decode(s.trim()).unwrap()).unwrap();
-    let got = serialize(&block).unwrap();
-
-    let want = include_bytes!("data/serde/control_block_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_child_number() {
-    let num = ChildNumber::Normal {
-        index: 0xDEADBEEF,
-    };
-    let got = serialize(&num).unwrap();
-    let want = include_bytes!("data/serde/child_number_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_private_key() {
-    let sk = PrivateKey::from_wif("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy").unwrap();
-    let got = serialize(&sk).unwrap();
-    let want = include_bytes!("data/serde/private_key_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_public_key() {
-    let s = include_str!("data/serde/public_key_hex");
-    let pk = PublicKey::from_str(s.trim()).unwrap();
-    let got = serialize(&pk).unwrap();
-    let want = include_bytes!("data/serde/public_key_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[ignore]
-#[test]
-fn serde_regression_psbt() {
-    let tx = Transaction {
-        version: 1,
-        lock_time: 0,
-        input: vec![TxIn {
-            previous_output: OutPoint {
-                txid: "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389"
-                    .parse::<Txid>()
-                    .unwrap(),
-                vout: 1,
-            },
-            script_sig: ScriptBuf::from_hex("160014be18d152a9b012039daf3da7de4f53349eecb985")
-                .unwrap(),
-            sequence: 4294967295,
-            witness: Witness::from_slice(&[hex!(
-                "03d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f2105"
-            )]),
-        }],
-        output: vec![TxOut {
-            value: 190303501938,
-            script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587")
-                .unwrap(),
-        }],
-        special_transaction_payload: None,
-    };
-    let unknown: BTreeMap<raw::Key, Vec<u8>> = vec![(
-        raw::Key {
-            type_value: 1,
-            key: vec![0, 1],
-        },
-        vec![3, 4, 5],
-    )]
-    .into_iter()
-    .collect();
-    let key_source = ("deadbeef".parse().unwrap(), "m/0'/1".parse().unwrap());
-    let keypaths: BTreeMap<secp256k1::PublicKey, KeySource> = vec![(
-        "0339880dc92394b7355e3d0439fa283c31de7590812ea011c4245c0674a685e883".parse().unwrap(),
-        key_source.clone(),
-    )]
-    .into_iter()
-    .collect();
-
-    let proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>> = vec![(
-        raw::ProprietaryKey {
-            prefix: "prefx".as_bytes().to_vec(),
-            subtype: 42,
-            key: "test_key".as_bytes().to_vec(),
-        },
-        vec![5, 6, 7],
-    )]
-    .into_iter()
-    .collect();
-
-    let psbt = Psbt {
-        version: 0,
-        xpub: {
-            let s = include_str!("data/serde/extended_pub_key");
-            let xpub = ExtendedPubKey::from_str(s.trim()).unwrap();
-            vec![(xpub, key_source)].into_iter().collect()
-        },
-        unsigned_tx: {
-            let mut unsigned = tx.clone();
-            unsigned.input[0].script_sig = ScriptBuf::new();
-            unsigned.input[0].witness = Witness::default();
-            unsigned
-        },
-        proprietary: proprietary.clone(),
-        unknown: unknown.clone(),
-
-        inputs: vec![Input {
-            non_witness_utxo: Some(tx),
-            witness_utxo: Some(TxOut {
-                value: 190303501938,
-                script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
-            }),
-            sighash_type: Some(PsbtSighashType::from(EcdsaSighashType::from_str("SIGHASH_SINGLE|SIGHASH_ANYONECANPAY").unwrap())),
-            redeem_script: Some(vec![0x51].into()),
-            witness_script: None,
-            partial_sigs: vec![(
-                "0339880dc92394b7355e3d0439fa283c31de7590812ea011c4245c0674a685e883".parse().unwrap(),
-                "304402204f67e2afb76142d44fae58a2495d33a3419daa26cd0db8d04f3452b63289ac0f022010762a9fb67e94cc5cad9026f6dc99ff7f070f4278d30fbc7d0c869dd38c7fe701".parse().unwrap(),
-            )].into_iter().collect(),
-            bip32_derivation: keypaths.clone().into_iter().collect(),
-            final_script_witness: Some(Witness::from_slice(&[vec![1, 3], vec![5]])),
-            ripemd160_preimages: vec![(ripemd160::Hash::hash(&[]), vec![1, 2])].into_iter().collect(),
-            sha256_preimages: vec![(sha256::Hash::hash(&[]), vec![1, 2])].into_iter().collect(),
-            hash160_preimages: vec![(hash160::Hash::hash(&[]), vec![1, 2])].into_iter().collect(),
-            hash256_preimages: vec![(sha256d::Hash::hash(&[]), vec![1, 2])].into_iter().collect(),
-            proprietary: proprietary.clone(),
-            unknown: unknown.clone(),
-            ..Default::default()
-        }],
-        outputs: vec![Output {
-            bip32_derivation: keypaths.into_iter().collect(),
-            proprietary,
-            unknown,
-            ..Default::default()
-        }],
-    };
-
-    let got = serialize(&psbt).unwrap();
-    let want = include_bytes!("data/serde/psbt_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_raw_pair() {
-    let pair = Pair {
-        key: Key {
-            type_value: 1u8,
-            key: vec![0u8, 1u8, 2u8, 3u8],
-        },
-        value: vec![0u8, 1u8, 2u8, 3u8],
-    };
-    let got = serialize(&pair).unwrap();
-    let want = include_bytes!("data/serde/raw_pair_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_proprietary_key() {
-    let key = ProprietaryKey {
-        prefix: vec![0u8, 1u8, 2u8, 3u8],
-        subtype: 1u8,
-        key: vec![0u8, 1u8, 2u8, 3u8],
-    };
-    let got = serialize(&key).unwrap();
-    let want = include_bytes!("data/serde/proprietary_key_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_taproot_sig() {
-    let s = include_str!("data/serde/taproot_sig_hex");
-    let sig = taproot::Signature {
-        sig: secp256k1::schnorr::Signature::from_str(s.trim()).unwrap(),
-        hash_ty: TapSighashType::All,
-    };
-
-    let got = serialize(&sig).unwrap();
-    let want = include_bytes!("data/serde/taproot_sig_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_taptree() {
-    let ver = LeafVersion::from_consensus(0).unwrap();
-    let script = ScriptBuf::from(vec![0u8, 1u8, 2u8]);
-    let mut builder = TaprootBuilder::new().add_leaf_with_ver(1, script.clone(), ver).unwrap();
-    builder = builder.add_leaf(1, script).unwrap();
-    let tree = TapTree::try_from(builder).unwrap();
-
-    let got = serialize(&tree).unwrap();
-    let want = include_bytes!("data/serde/taptree_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-// Used to get a 256 bit integer as a byte array.
-fn le_bytes() -> [u8; 32] {
-    let x: u128 = 0xDEAD_BEEF_CAFE_BABE_DEAD_BEEF_CAFE_BABE;
-    let y: u128 = 0xCAFE_DEAD_BABE_BEEF_CAFE_DEAD_BABE_BEEF;
-
-    let mut bytes = [0_u8; 32];
-
-    bytes[..16].copy_from_slice(&x.to_le_bytes());
-    bytes[16..].copy_from_slice(&y.to_le_bytes());
-
-    bytes
-}
-
-#[test]
-fn serde_regression_work() {
-    let work = Work::from_le_bytes(le_bytes());
-    let got = serialize(&work).unwrap();
-    let want = include_bytes!("data/serde/u256_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_target() {
-    let target = Target::from_le_bytes(le_bytes());
-    let got = serialize(&target).unwrap();
-    let want = include_bytes!("data/serde/u256_bincode") as &[_];
-    assert_eq!(got, want)
-}
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index 0088259ac..0b3798bc4 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "dash-fuzz"
-edition = "2018"
+edition = "2024"
 version = { workspace = true}
 authors = ["Generated by fuzz/generate-files.sh"]
 publish = false
diff --git a/fuzz/fuzz_targets/hashes/cbor.rs b/fuzz/fuzz_targets/hashes/cbor.rs
index 91b107a5a..099e82752 100644
--- a/fuzz/fuzz_targets/hashes/cbor.rs
+++ b/fuzz/fuzz_targets/hashes/cbor.rs
@@ -1,4 +1,4 @@
-use dashcore::hashes::{ripemd160, sha1, sha256d, sha512, Hmac};
+use dashcore::hashes::{Hmac, ripemd160, sha1, sha256d, sha512};
 use honggfuzz::fuzz;
 use serde::{Deserialize, Serialize};
 
diff --git a/fuzz/fuzz_targets/hashes/json.rs b/fuzz/fuzz_targets/hashes/json.rs
index 42cb7c732..c10545deb 100644
--- a/fuzz/fuzz_targets/hashes/json.rs
+++ b/fuzz/fuzz_targets/hashes/json.rs
@@ -1,4 +1,4 @@
-use dashcore::hashes::{ripemd160, sha1, sha256d, sha512, Hmac};
+use dashcore::hashes::{Hmac, ripemd160, sha1, sha256d, sha512};
 use honggfuzz::fuzz;
 use serde::{Deserialize, Serialize};
 
diff --git a/fuzz/fuzz_targets/hashes/ripemd160.rs b/fuzz/fuzz_targets/hashes/ripemd160.rs
index 69d4e4de3..870cc3783 100644
--- a/fuzz/fuzz_targets/hashes/ripemd160.rs
+++ b/fuzz/fuzz_targets/hashes/ripemd160.rs
@@ -1,4 +1,4 @@
-use dashcore::hashes::{ripemd160, Hash, HashEngine};
+use dashcore::hashes::{Hash, HashEngine, ripemd160};
 use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
diff --git a/fuzz/fuzz_targets/hashes/sha1.rs b/fuzz/fuzz_targets/hashes/sha1.rs
index 9074b846c..c2073dab5 100644
--- a/fuzz/fuzz_targets/hashes/sha1.rs
+++ b/fuzz/fuzz_targets/hashes/sha1.rs
@@ -1,4 +1,4 @@
-use dashcore::hashes::{sha1, Hash, HashEngine};
+use dashcore::hashes::{Hash, HashEngine, sha1};
 use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
diff --git a/fuzz/fuzz_targets/hashes/sha256.rs b/fuzz/fuzz_targets/hashes/sha256.rs
index 6b3905f0b..745f74aeb 100644
--- a/fuzz/fuzz_targets/hashes/sha256.rs
+++ b/fuzz/fuzz_targets/hashes/sha256.rs
@@ -1,4 +1,4 @@
-use dashcore::hashes::{sha256, Hash, HashEngine};
+use dashcore::hashes::{Hash, HashEngine, sha256};
 use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
diff --git a/fuzz/fuzz_targets/hashes/sha512.rs b/fuzz/fuzz_targets/hashes/sha512.rs
index e54d82e38..c2d96989a 100644
--- a/fuzz/fuzz_targets/hashes/sha512.rs
+++ b/fuzz/fuzz_targets/hashes/sha512.rs
@@ -1,4 +1,4 @@
-use dashcore::hashes::{sha512, Hash, HashEngine};
+use dashcore::hashes::{Hash, HashEngine, sha512};
 use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
diff --git a/fuzz/fuzz_targets/hashes/sha512_256.rs b/fuzz/fuzz_targets/hashes/sha512_256.rs
index 3a5c326bf..c0b5515e4 100644
--- a/fuzz/fuzz_targets/hashes/sha512_256.rs
+++ b/fuzz/fuzz_targets/hashes/sha512_256.rs
@@ -1,4 +1,4 @@
-use dashcore::hashes::{sha512_256, Hash, HashEngine};
+use dashcore::hashes::{Hash, HashEngine, sha512_256};
 use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
diff --git a/fuzz/generate-files.sh b/fuzz/generate-files.sh
index cfdf515cb..89cc6a889 100755
--- a/fuzz/generate-files.sh
+++ b/fuzz/generate-files.sh
@@ -11,7 +11,7 @@ source "$REPO_DIR/fuzz/fuzz-util.sh"
 cat > "$REPO_DIR/fuzz/Cargo.toml" <<EOF
 [package]
 name = "dash-fuzz"
-edition = "2018"
+edition = "2024"
 version = "0.0.1"
 authors = ["Generated by fuzz/generate-files.sh"]
 publish = false
diff --git a/hashes/Cargo.toml b/hashes/Cargo.toml
index 8b194d992..1ec98f1ff 100644
--- a/hashes/Cargo.toml
+++ b/hashes/Cargo.toml
@@ -9,7 +9,7 @@ description = "Hash functions used by the rust-dash eccosystem"
 categories = ["algorithms"]
 keywords = [ "crypto", "dash", "hash", "digest" ]
 readme = "README.md"
-edition = "2018"
+edition = "2024"
 exclude = ["tests", "contrib"]
 
 [features]
diff --git a/hashes/embedded/Cargo.toml b/hashes/embedded/Cargo.toml
index 12da5e77a..43d0afafb 100644
--- a/hashes/embedded/Cargo.toml
+++ b/hashes/embedded/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 authors = ["Riccardo Casatta <riccardo@casatta.it>"]
-edition = "2018"
+edition = "2024"
 readme = "README.md"
 name = "embedded"
 version = "0.1.0"
diff --git a/hashes/extended_tests/schemars/Cargo.toml b/hashes/extended_tests/schemars/Cargo.toml
index bf28e595a..c8ff4670b 100644
--- a/hashes/extended_tests/schemars/Cargo.toml
+++ b/hashes/extended_tests/schemars/Cargo.toml
@@ -2,7 +2,7 @@
 name = "schemars"
 version = "0.1.0"
 authors = ["Jeremy Rubin <j@rubin.io>"]
-edition = "2018"
+edition = "2024"
 
 # Prevent this from interfering with workspaces
 [workspace]
diff --git a/hashes/src/bincode_macros.rs b/hashes/src/bincode_macros.rs
index a0d7d91da..7301a7122 100644
--- a/hashes/src/bincode_macros.rs
+++ b/hashes/src/bincode_macros.rs
@@ -1,3 +1,28 @@
+/// Implements `bincode::Encode`, `bincode::Decode`, and `bincode::BorrowDecode`
+/// for types that represent fixed-length byte arrays.
+///
+/// This macro is intended to be used with types that:
+/// - Are wrappers around a fixed-size `[u8; N]` array
+/// - Implement `as_byte_array() -> &[u8; N]`
+/// - Implement `from_byte_array([u8; N]) -> Self`
+///
+/// It generates the necessary trait implementations to support binary encoding
+/// and decoding with the [`bincode`](https://docs.rs/bincode) crate.
+///
+/// # Features
+/// This macro is only available when the `bincode` feature is enabled.
+///
+/// # Parameters
+/// - `$t`: The target type to implement the traits for
+/// - `$len`: The fixed length of the internal byte array
+/// - `$gen`: Optional generic parameters (e.g., `T: SomeTrait`)
+///
+/// # Trait Implementations
+/// - [`bincode::Encode`]: Encodes the value by serializing its internal byte array.
+/// - [`bincode::Decode`]: Decodes a `[u8; N]` array and reconstructs the type using `from_byte_array`.
+/// - [`bincode::BorrowDecode`]: Borrow-decodes a byte slice, checks its length, and uses `from_byte_array`.
+///
+/// ```
 #[macro_export]
 #[cfg(feature = "bincode")]
 macro_rules! bincode_impl {
diff --git a/hashes/src/cmp.rs b/hashes/src/cmp.rs
index 05b430d96..a413a5dcd 100644
--- a/hashes/src/cmp.rs
+++ b/hashes/src/cmp.rs
@@ -92,7 +92,7 @@ mod benches {
     use test::Bencher;
 
     use crate::cmp::fixed_time_eq;
-    use crate::{sha256, sha512, Hash};
+    use crate::{Hash, sha256, sha512};
 
     #[bench]
     fn bench_32b_constant_time_cmp_ne(bh: &mut Bencher) {
diff --git a/hashes/src/error.rs b/hashes/src/error.rs
index 749335267..251258cfa 100644
--- a/hashes/src/error.rs
+++ b/hashes/src/error.rs
@@ -29,7 +29,7 @@ impl fmt::Display for Error {
         use self::Error::*;
 
         match self {
-            InvalidLength(ref ell, ref ell2) => {
+            InvalidLength(ell, ell2) => {
                 write!(f, "invalid slice length {} (expected {})", ell2, ell)
             }
         }
diff --git a/hashes/src/hash160.rs b/hashes/src/hash160.rs
index 47559c6b7..853e89e25 100644
--- a/hashes/src/hash160.rs
+++ b/hashes/src/hash160.rs
@@ -24,7 +24,7 @@ use core::ops::Index;
 use core::slice::SliceIndex;
 use core::str;
 
-use crate::{ripemd160, sha256, Error};
+use crate::{Error, ripemd160, sha256};
 
 crate::internal_macros::hash_type! {
     160,
@@ -51,7 +51,7 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
-        use crate::{hash160, Hash, HashEngine};
+        use crate::{Hash, HashEngine, hash160};
 
         #[derive(Clone)]
         #[cfg(feature = "alloc")]
@@ -105,9 +105,9 @@ mod tests {
     #[cfg(feature = "serde")]
     #[test]
     fn ripemd_serde() {
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
 
-        use crate::{hash160, Hash};
+        use crate::{Hash, hash160};
 
         #[rustfmt::skip]
         static HASH_BYTES: [u8; 20] = [
@@ -128,7 +128,7 @@ mod tests {
 mod benches {
     use test::Bencher;
 
-    use crate::{hash160, Hash, HashEngine};
+    use crate::{Hash, HashEngine, hash160};
 
     #[bench]
     pub fn hash160_10(bh: &mut Bencher) {
diff --git a/hashes/src/hash_x11.rs b/hashes/src/hash_x11.rs
index 664daf663..f84282f17 100644
--- a/hashes/src/hash_x11.rs
+++ b/hashes/src/hash_x11.rs
@@ -31,7 +31,7 @@ use core2::io;
 
 #[cfg(all(feature = "alloc", not(feature = "std")))]
 use crate::alloc::vec::Vec;
-use crate::{hex, Error, HashEngine as _};
+use crate::{Error, HashEngine as _, hex};
 
 crate::internal_macros::hash_type! {
     256,
diff --git a/hashes/src/hmac.rs b/hashes/src/hmac.rs
index b623e5fbe..a00dfa234 100644
--- a/hashes/src/hmac.rs
+++ b/hashes/src/hmac.rs
@@ -246,7 +246,7 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
-        use crate::{sha256, Hash, HashEngine, Hmac, HmacEngine};
+        use crate::{Hash, HashEngine, Hmac, HmacEngine, sha256};
 
         #[derive(Clone)]
         struct Test {
@@ -372,9 +372,9 @@ mod tests {
     #[cfg(feature = "serde")]
     #[test]
     fn hmac_sha512_serde() {
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
 
-        use crate::{sha512, Hash, Hmac};
+        use crate::{Hash, Hmac, sha512};
 
         #[rustfmt::skip]
         static HASH_BYTES: [u8; 64] = [
@@ -404,7 +404,7 @@ mod tests {
 mod benches {
     use test::Bencher;
 
-    use crate::{sha256, Hash, HashEngine, Hmac};
+    use crate::{Hash, HashEngine, Hmac, sha256};
 
     #[bench]
     pub fn hmac_sha256_10(bh: &mut Bencher) {
diff --git a/hashes/src/impls.rs b/hashes/src/impls.rs
index c63605e57..bca44ea9b 100644
--- a/hashes/src/impls.rs
+++ b/hashes/src/impls.rs
@@ -23,7 +23,7 @@ use std::io;
 #[cfg(not(feature = "std"))]
 use core2::io;
 
-use crate::{hmac, ripemd160, sha1, sha256, sha512, siphash24, HashEngine};
+use crate::{HashEngine, hmac, ripemd160, sha1, sha256, sha512, siphash24};
 
 impl io::Write for sha1::HashEngine {
     fn flush(&mut self) -> io::Result<()> {
@@ -94,7 +94,7 @@ impl<T: crate::Hash> io::Write for hmac::HmacEngine<T> {
 #[cfg(test)]
 mod tests {
     use super::io::Write;
-    use crate::{hash160, hmac, ripemd160, sha1, sha256, sha256d, sha512, siphash24, Hash};
+    use crate::{Hash, hash160, hmac, ripemd160, sha1, sha256, sha256d, sha512, siphash24};
 
     macro_rules! write_test {
         ($mod:ident, $exp_empty:expr, $exp_256:expr, $exp_64k:expr,) => {
diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
index d9b8634ea..3b5fa2945 100644
--- a/hashes/src/lib.rs
+++ b/hashes/src/lib.rs
@@ -235,7 +235,7 @@ pub trait Hash:
 
 #[cfg(test)]
 mod tests {
-    use crate::{sha256d, Hash};
+    use crate::{Hash, sha256d};
 
     hash_newtype! {
         /// A test newtype
diff --git a/hashes/src/ripemd160.rs b/hashes/src/ripemd160.rs
index ba2cea120..57fe60a4d 100644
--- a/hashes/src/ripemd160.rs
+++ b/hashes/src/ripemd160.rs
@@ -409,7 +409,7 @@ mod tests {
     fn test() {
         use std::convert::TryFrom;
 
-        use crate::{ripemd160, Hash, HashEngine};
+        use crate::{Hash, HashEngine, ripemd160};
 
         #[derive(Clone)]
         struct Test {
@@ -502,9 +502,9 @@ mod tests {
     #[cfg(feature = "serde")]
     #[test]
     fn ripemd_serde() {
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
 
-        use crate::{ripemd160, Hash};
+        use crate::{Hash, ripemd160};
 
         #[rustfmt::skip]
         static HASH_BYTES: [u8; 20] = [
@@ -525,7 +525,7 @@ mod tests {
 mod benches {
     use test::Bencher;
 
-    use crate::{ripemd160, Hash, HashEngine};
+    use crate::{Hash, HashEngine, ripemd160};
 
     #[bench]
     pub fn ripemd160_10(bh: &mut Bencher) {
diff --git a/hashes/src/serde_macros.rs b/hashes/src/serde_macros.rs
index b60dbe4c8..39db0f0ee 100644
--- a/hashes/src/serde_macros.rs
+++ b/hashes/src/serde_macros.rs
@@ -24,7 +24,7 @@ pub mod serde_details {
 
     use crate::Error;
     struct HexVisitor<ValueT>(PhantomData<ValueT>);
-    use serde::{de, Deserializer, Serializer};
+    use serde::{Deserializer, Serializer, de};
 
     impl<'de, ValueT> de::Visitor<'de> for HexVisitor<ValueT>
     where
diff --git a/hashes/src/sha1.rs b/hashes/src/sha1.rs
index 981fd98d9..39ab526a1 100644
--- a/hashes/src/sha1.rs
+++ b/hashes/src/sha1.rs
@@ -117,10 +117,10 @@ impl HashEngine {
 
         for (i, &wi) in w.iter().enumerate() {
             let (f, k) = match i {
-                0...19 => ((b & c) | (!b & d), 0x5a827999),
-                20...39 => (b ^ c ^ d, 0x6ed9eba1),
-                40...59 => ((b & c) | (b & d) | (c & d), 0x8f1bbcdc),
-                60...79 => (b ^ c ^ d, 0xca62c1d6),
+                0..=19 => ((b & c) | (!b & d), 0x5a827999),
+                20..=39 => (b ^ c ^ d, 0x6ed9eba1),
+                40..=59 => ((b & c) | (b & d) | (c & d), 0x8f1bbcdc),
+                60..=79 => (b ^ c ^ d, 0xca62c1d6),
                 _ => unreachable!(),
             };
 
@@ -146,7 +146,7 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
-        use crate::{sha1, Hash, HashEngine};
+        use crate::{Hash, HashEngine, sha1};
 
         #[derive(Clone)]
         struct Test {
@@ -214,9 +214,9 @@ mod tests {
     #[cfg(feature = "serde")]
     #[test]
     fn sha1_serde() {
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
 
-        use crate::{sha1, Hash};
+        use crate::{Hash, sha1};
 
         #[rustfmt::skip]
         static HASH_BYTES: [u8; 20] = [
@@ -237,7 +237,7 @@ mod tests {
 mod benches {
     use test::Bencher;
 
-    use crate::{sha1, Hash, HashEngine};
+    use crate::{Hash, HashEngine, sha1};
 
     #[bench]
     pub fn sha1_10(bh: &mut Bencher) {
diff --git a/hashes/src/sha256.rs b/hashes/src/sha256.rs
index 88ed578d1..308c129be 100644
--- a/hashes/src/sha256.rs
+++ b/hashes/src/sha256.rs
@@ -20,7 +20,7 @@ use core::ops::Index;
 use core::slice::SliceIndex;
 use core::{cmp, str};
 
-use crate::{hex, sha256d, Error, HashEngine as _};
+use crate::{Error, HashEngine as _, hex, sha256d};
 
 crate::internal_macros::hash_type! {
     256,
@@ -523,7 +523,7 @@ impl secp256k1::ThirtyTwoByteHash for Hash {
 
 #[cfg(test)]
 mod tests {
-    use crate::{sha256, Hash, HashEngine};
+    use crate::{Hash, HashEngine, sha256};
 
     #[test]
     #[cfg(feature = "alloc")]
@@ -700,7 +700,7 @@ mod tests {
     #[cfg(feature = "serde")]
     #[test]
     fn sha256_serde() {
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
 
         #[rustfmt::skip]
         static HASH_BYTES: [u8; 32] = [
@@ -736,7 +736,7 @@ mod tests {
 mod benches {
     use test::Bencher;
 
-    use crate::{sha256, Hash, HashEngine};
+    use crate::{Hash, HashEngine, sha256};
 
     #[bench]
     pub fn sha256_10(bh: &mut Bencher) {
diff --git a/hashes/src/sha256d.rs b/hashes/src/sha256d.rs
index 4c2b8c14b..7e4c393ef 100644
--- a/hashes/src/sha256d.rs
+++ b/hashes/src/sha256d.rs
@@ -19,7 +19,7 @@ use core::ops::Index;
 use core::slice::SliceIndex;
 use core::str;
 
-use crate::{sha256, Error};
+use crate::{Error, sha256};
 
 crate::internal_macros::hash_type! {
     256,
@@ -52,7 +52,7 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
-        use crate::{sha256, sha256d, Hash, HashEngine};
+        use crate::{Hash, HashEngine, sha256, sha256d};
 
         #[derive(Clone)]
         struct Test {
@@ -103,9 +103,9 @@ mod tests {
     #[cfg(feature = "serde")]
     #[test]
     fn sha256_serde() {
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
 
-        use crate::{sha256d, Hash};
+        use crate::{Hash, sha256d};
 
         #[rustfmt::skip]
         static HASH_BYTES: [u8; 32] = [
@@ -128,7 +128,7 @@ mod tests {
 mod benches {
     use test::Bencher;
 
-    use crate::{sha256d, Hash, HashEngine};
+    use crate::{Hash, HashEngine, sha256d};
 
     #[bench]
     pub fn sha256d_10(bh: &mut Bencher) {
diff --git a/hashes/src/sha256t.rs b/hashes/src/sha256t.rs
index 61127bb8c..611d37a29 100644
--- a/hashes/src/sha256t.rs
+++ b/hashes/src/sha256t.rs
@@ -20,7 +20,7 @@ use core::ops::Index;
 use core::slice::SliceIndex;
 use core::{cmp, str};
 
-use crate::{sha256, Error};
+use crate::{Error, sha256};
 
 type HashEngine = sha256::HashEngine;
 
diff --git a/hashes/src/sha512.rs b/hashes/src/sha512.rs
index 71383e082..b461535d3 100644
--- a/hashes/src/sha512.rs
+++ b/hashes/src/sha512.rs
@@ -273,7 +273,7 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
-        use crate::{sha512, Hash, HashEngine};
+        use crate::{Hash, HashEngine, sha512};
 
         #[derive(Clone)]
         struct Test {
@@ -350,9 +350,9 @@ mod tests {
     #[cfg(feature = "serde")]
     #[test]
     fn sha512_serde() {
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
 
-        use crate::{sha512, Hash};
+        use crate::{Hash, sha512};
 
         #[rustfmt::skip]
         static HASH_BYTES: [u8; 64] = [
@@ -382,7 +382,7 @@ mod tests {
 mod benches {
     use test::Bencher;
 
-    use crate::{sha512, Hash, HashEngine};
+    use crate::{Hash, HashEngine, sha512};
 
     #[bench]
     pub fn sha512_10(bh: &mut Bencher) {
diff --git a/hashes/src/sha512_256.rs b/hashes/src/sha512_256.rs
index b4a7193c3..cb02c7fc9 100644
--- a/hashes/src/sha512_256.rs
+++ b/hashes/src/sha512_256.rs
@@ -29,7 +29,7 @@ use core::slice::SliceIndex;
 use core::str;
 
 use crate::sha512::BLOCK_SIZE;
-use crate::{sha512, Error};
+use crate::{Error, sha512};
 
 /// Engine to compute SHA512/256 hash function.
 ///
@@ -90,7 +90,7 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
-        use crate::{sha512_256, Hash, HashEngine};
+        use crate::{Hash, HashEngine, sha512_256};
 
         #[derive(Clone)]
         struct Test {
@@ -177,7 +177,7 @@ mod tests {
 mod benches {
     use test::Bencher;
 
-    use crate::{sha512_256, Hash, HashEngine};
+    use crate::{Hash, HashEngine, sha512_256};
 
     #[bench]
     pub fn sha512_256_10(bh: &mut Bencher) {
diff --git a/hashes/src/siphash24.rs b/hashes/src/siphash24.rs
index bf8fef364..5df24f449 100644
--- a/hashes/src/siphash24.rs
+++ b/hashes/src/siphash24.rs
@@ -45,9 +45,7 @@ fn from_engine(e: HashEngine) -> Hash {
 }
 
 macro_rules! compress {
-    ($state:expr) => {{
-        compress!($state.v0, $state.v1, $state.v2, $state.v3)
-    }};
+    ($state:expr) => {{ compress!($state.v0, $state.v1, $state.v2, $state.v3) }};
     ($v0:expr, $v1:expr, $v2:expr, $v3:expr) => {{
         $v0 = $v0.wrapping_add($v1);
         $v1 = $v1.rotate_left(13);
@@ -374,7 +372,7 @@ mod tests {
 mod benches {
     use test::Bencher;
 
-    use crate::{siphash24, Hash, HashEngine};
+    use crate::{Hash, HashEngine, siphash24};
 
     #[bench]
     pub fn siphash24_1ki(bh: &mut Bencher) {
diff --git a/hashes/src/util.rs b/hashes/src/util.rs
index b157335bb..742ecdd64 100644
--- a/hashes/src/util.rs
+++ b/hashes/src/util.rs
@@ -583,9 +583,9 @@ macro_rules! hash_newtype_known_attrs {
 
 #[cfg(feature = "schemars")]
 pub mod json_hex_string {
-    use schemars::gen::SchemaGenerator;
-    use schemars::schema::{Schema, SchemaObject};
     use schemars::JsonSchema;
+    use schemars::r#gen::SchemaGenerator;
+    use schemars::schema::{Schema, SchemaObject};
     macro_rules! define_custom_hex {
         ($name:ident, $len:expr) => {
             pub fn $name(gen: &mut SchemaGenerator) -> Schema {
@@ -607,7 +607,7 @@ pub mod json_hex_string {
 
 #[cfg(test)]
 mod test {
-    use crate::{sha256, Hash};
+    use crate::{Hash, sha256};
 
     #[test]
     fn hash_as_ref_array() {
diff --git a/internals/Cargo.toml b/internals/Cargo.toml
index 8cb401e06..2f7050875 100644
--- a/internals/Cargo.toml
+++ b/internals/Cargo.toml
@@ -9,7 +9,7 @@ description = "Internal types and macros used by rust-dash ecosystem"
 categories = ["cryptography::cryptocurrencies"]
 keywords = ["internal"]
 readme = "README.md"
-edition = "2018"
+edition = "2024"
 exclude = ["tests", "contrib"]
 
 [features]
diff --git a/internals/src/hex/display.rs b/internals/src/hex/display.rs
index b7943b974..dc541812f 100644
--- a/internals/src/hex/display.rs
+++ b/internals/src/hex/display.rs
@@ -6,8 +6,8 @@
 use core::borrow::Borrow;
 use core::fmt;
 
-use super::buf_encoder::{BufEncoder, OutBytes};
 use super::Case;
+use super::buf_encoder::{BufEncoder, OutBytes};
 use crate::hex::buf_encoder::FixedLenBuf;
 #[cfg(feature = "alloc")]
 use crate::prelude::*;
diff --git a/rpc-client/Cargo.toml b/rpc-client/Cargo.toml
index f334611b5..2b926e7fd 100644
--- a/rpc-client/Cargo.toml
+++ b/rpc-client/Cargo.toml
@@ -12,7 +12,7 @@ repository = "https://github.com/dashevo/rust-dashcore/"
 description = "RPC client library for the Dash Core JSON-RPC API."
 keywords = ["crypto", "dash", "dash-core", "rpc"]
 readme = "README.md"
-edition = "2021"
+edition = "2024"
 
 [lib]
 name = "dashcore_rpc"
diff --git a/rpc-client/examples/test_against_node.rs b/rpc-client/examples/test_against_node.rs
index 9730c0ae7..ad14bd70a 100644
--- a/rpc-client/examples/test_against_node.rs
+++ b/rpc-client/examples/test_against_node.rs
@@ -12,7 +12,7 @@
 //! Core node.
 extern crate dashcore_rpc;
 
-use dashcore_rpc::{dashcore, Auth, Client, Error, RpcApi};
+use dashcore_rpc::{Auth, Client, Error, RpcApi, dashcore};
 
 fn main_result() -> Result<(), Error> {
     let mut args = std::env::args();
diff --git a/rpc-client/src/client.rs b/rpc-client/src/client.rs
index 94ea73b5a..3072c9b6d 100644
--- a/rpc-client/src/client.rs
+++ b/rpc-client/src/client.rs
@@ -20,13 +20,13 @@ use jsonrpc;
 use serde;
 use serde_json::{self, Value};
 
+use crate::Error::UnexpectedStructure;
 use crate::dashcore::address::NetworkUnchecked;
 use crate::dashcore::secp256k1::hashes::hex::DisplayHex;
-use crate::dashcore::{block, consensus, ScriptBuf};
+use crate::dashcore::{ScriptBuf, block, consensus};
 use crate::error::*;
 use crate::json;
 use crate::queryable;
-use crate::Error::UnexpectedStructure;
 use dashcore::hashes::hex::FromHex;
 use dashcore::secp256k1::ecdsa::Signature;
 use dashcore::{
@@ -1719,13 +1719,13 @@ impl RpcApi for Client {
 fn log_response(cmd: &str, resp: &Result<jsonrpc::Response>) {
     if log_enabled!(Warn) || log_enabled!(Debug) || log_enabled!(Trace) {
         match resp {
-            Err(ref e) => {
+            Err(e) => {
                 if log_enabled!(Debug) {
                     debug!(target: "dashcore_rpc", "JSON-RPC failed parsing reply of {}: {:?}", cmd, e);
                 }
             }
-            Ok(ref resp) => {
-                if let Some(ref e) = resp.error {
+            Ok(resp) => {
+                if let Some(e) = &resp.error {
                     if log_enabled!(Debug) {
                         debug!(target: "dashcore_rpc", "JSON-RPC error for {}: {:?}", cmd, e);
                     }
diff --git a/rpc-integration-test/Cargo.toml b/rpc-integration-test/Cargo.toml
index 553bf53ff..6c1cd9bc7 100644
--- a/rpc-integration-test/Cargo.toml
+++ b/rpc-integration-test/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "integration_test"
 authors = ["Steven Roose <steven@stevenroose.org>"]
-edition = "2021"
+edition = "2024"
 publish = false
 
 [dependencies]
diff --git a/rpc-integration-test/src/main.rs b/rpc-integration-test/src/main.rs
index 2f41658d4..a7120f660 100644
--- a/rpc-integration-test/src/main.rs
+++ b/rpc-integration-test/src/main.rs
@@ -12,22 +12,23 @@
 extern crate lazy_static;
 extern crate log;
 
-use log::{trace, Log};
+use log::{Log, trace};
 use std::collections::{HashMap, HashSet};
 use std::str::FromStr;
 
 use dashcore_rpc::jsonrpc::error::Error as JsonRpcError;
 use dashcore_rpc::{
+    Auth, Client, Error, RpcApi,
     dashcore::{
+        Address, AddressType, Amount, EcdsaSighashType, Network, OutPoint, PrivateKey, Script,
+        SignedAmount, Transaction, TxIn, TxOut, Txid, Witness,
         consensus::encode::{deserialize, serialize},
-        hashes::hex::FromHex,
         hashes::Hash,
-        secp256k1, Address, AddressType, Amount, EcdsaSighashType, Network, OutPoint, PrivateKey,
-        Script, SignedAmount, Transaction, TxIn, TxOut, Txid, Witness,
+        hashes::hex::FromHex,
+        secp256k1,
     },
-    Auth, Client, Error, RpcApi,
 };
-use dashcore_rpc::{json, RawTx};
+use dashcore_rpc::{RawTx, json};
 
 use dashcore_rpc::dashcore::address::NetworkUnchecked;
 use dashcore_rpc::dashcore::{BlockHash, ProTxHash, QuorumHash, ScriptBuf};
@@ -1227,9 +1228,11 @@ fn test_create_wallet(cl: &Client) {
     wallet_list.sort();
 
     // Main wallet created for tests
-    assert!(wallet_list
-        .iter()
-        .any(|w| w == &TEST_WALLET_NAME.to_string() || w == &FAUCET_WALLET_NAME.to_string()));
+    assert!(
+        wallet_list
+            .iter()
+            .any(|w| w == &TEST_WALLET_NAME.to_string() || w == &FAUCET_WALLET_NAME.to_string())
+    );
     wallet_list.retain(|w| {
         w != &TEST_WALLET_NAME.to_string() && w != "" && w != &FAUCET_WALLET_NAME.to_string()
     });
diff --git a/rpc-json/Cargo.toml b/rpc-json/Cargo.toml
index dec833682..2acd6316a 100644
--- a/rpc-json/Cargo.toml
+++ b/rpc-json/Cargo.toml
@@ -12,7 +12,7 @@ repository = "https://github.com/dashevo/rust-dashcore/"
 description = "JSON-enabled type structs for dashcore-rpc crate."
 keywords = [ "crypto", "dash", "dashcore", "rpc" ]
 readme = "README.md"
-edition = "2021"
+edition = "2024"
 
 [lib]
 name = "dashcore_rpc_json"
diff --git a/rpc-json/src/lib.rs b/rpc-json/src/lib.rs
index ba994c5b5..0d7ec9b19 100644
--- a/rpc-json/src/lib.rs
+++ b/rpc-json/src/lib.rs
@@ -38,14 +38,14 @@ use dashcore::consensus::encode;
 use dashcore::hashes::hex::Error::InvalidChar;
 use dashcore::hashes::sha256;
 use dashcore::{
-    bip158, bip32, Address, Amount, BlockHash, PrivateKey, ProTxHash, PublicKey, QuorumHash,
-    Script, ScriptBuf, SignedAmount, Transaction, TxMerkleNode, Txid,
+    Address, Amount, BlockHash, PrivateKey, ProTxHash, PublicKey, QuorumHash, Script, ScriptBuf,
+    SignedAmount, Transaction, TxMerkleNode, Txid, bip32, bip158,
 };
 use hex::FromHexError;
 use serde::de::Error as SerdeError;
-use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
 use serde_json::Value;
-use serde_with::{serde_as, Bytes, DisplayFromStr};
+use serde_with::{Bytes, DisplayFromStr, serde_as};
 
 //TODO(stevenroose) consider using a Time type
 
@@ -2436,7 +2436,7 @@ where
             return Err(de::Error::custom(format!(
                 "unknown masternode sync asset name: {}",
                 str_sequence
-            )))
+            )));
         }
     })
 }
@@ -3261,7 +3261,7 @@ mod tests {
     use serde_json::json;
 
     use crate::{
-        deserialize_u32_opt, ExtendedQuorumListResult, MasternodeListDiff, MnSyncStatus, QuorumType,
+        ExtendedQuorumListResult, MasternodeListDiff, MnSyncStatus, QuorumType, deserialize_u32_opt,
     };
 
     #[test]
diff --git a/rustfmt.toml b/rustfmt.toml
index ee0f3ffb4..e01ca03d2 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -57,7 +57,7 @@ trailing_comma = "Vertical"
 match_block_trailing_comma = false
 blank_lines_upper_bound = 1
 blank_lines_lower_bound = 0
-edition = "2018"
+edition = "2024"
 style_edition = "2024"
 inline_attribute_width = 0
 format_generated_files = true