chore: updated packages and change to rust edition 2024

.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

.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:

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,38 +48,34 @@ 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 }
 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"] }
 

dash/embedded/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 authors = ["Riccardo Casatta <[email protected]>", "Dev Random <[email protected]>"]
-edition = "2018"
+edition = "2024"
 readme = "README.md"
 name = "embedded"
 version = "0.1.0"

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,

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");

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>> {

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() {

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;
 

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);

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};

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,26 +712,32 @@ 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);
             let mut query = Vec::new();
             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()
+            );
         }
     }
 

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")]

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) {