sdk%refac: switch from hex to hex-conservative

pkgs/p2p_core/Cargo.toml

@@ -36,7 +36,7 @@ serde = { version = "1", default-features = false, features = [
 ], optional = true }
 
 [dev-dependencies]
-hex = "0.4"
+hex-conservative = "0.3"
 hex-literal = "0.4"
 rstest = "0.25"
 

pkgs/p2p_core/tests/addrv2.rs

@@ -14,6 +14,7 @@ use dash_p2p_core::primitives::service_flags::ServiceFlags;
 
 use bitcoin_consensus_encoding::{decode_from_slice, encode_to_vec};
 use dash_primitives::NetworkType;
+use hex_conservative::FromHex;
 use rstest::rstest;
 
 fn ipv4_entry(ip: [u8; 4], port: u16, time: u32) -> AddrV2Entry {
@@ -95,7 +96,7 @@ fn addrv2_bip155_wire_vector() {
     "f1f2",                             // port 0xf1f2
   );
 
-  let bytes = hex::decode(hex).unwrap_or_else(|e| panic!("bad hex: {e}"));
+  let bytes = Vec::<u8>::from_hex(hex).unwrap_or_else(|e| panic!("bad hex: {e}"));
   let decoded: AddrV2Msg = decode_from_slice(&bytes).unwrap_or_else(|e| panic!("decode failed: {e}"));
 
   assert_eq!(decoded.addrs.len(), 3);
@@ -145,7 +146,7 @@ fn addr_v1_wire_vector() {
     "f1f2",                             // port
   );
 
-  let bytes = hex::decode(hex).unwrap_or_else(|e| panic!("bad hex: {e}"));
+  let bytes = Vec::<u8>::from_hex(hex).unwrap_or_else(|e| panic!("bad hex: {e}"));
   let decoded: Addr = decode_from_slice(&bytes).unwrap_or_else(|e| panic!("decode failed: {e}"));
 
   assert_eq!(decoded.addrs.len(), 3);
@@ -169,10 +170,10 @@ fn addr_v1_wire_vector() {
 /// round-trip correctly.
 #[rstest]
 fn addrv2_all_bip155_network_types() {
-  let torv3: Vec<u8> = hex::decode("79bcc625184b05194975c28b66b66b0469f7f6556fb1ac3189a79b40dda32f1f")
+  let torv3: Vec<u8> = Vec::<u8>::from_hex("79bcc625184b05194975c28b66b66b0469f7f6556fb1ac3189a79b40dda32f1f")
     .unwrap_or_else(|e| panic!("bad hex: {e}"));
 
-  let i2p: Vec<u8> = hex::decode("a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87")
+  let i2p: Vec<u8> = Vec::<u8>::from_hex("a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87")
     .unwrap_or_else(|e| panic!("bad hex: {e}"));
 
   let original = AddrV2Msg {

pkgs/pkc/Cargo.toml

@@ -30,7 +30,7 @@ zeroize = { version = "1", default-features = false, features = ["derive"] }
 
 [dev-dependencies]
 divan = "0.1"
-hex = "0.4"
+hex-conservative = "0.3"
 rand_core = { version = "0.6", features = ["getrandom"] }
 rstest = "0.25"
 serde = { version = "1", features = ["derive"] }

pkgs/pkc/tests/bls_chia_aggregate.rs

@@ -96,6 +96,8 @@ fn secure_aggregate_order_independent() {
 
 mod kat {
   use super::common::{self, decode_hex, VectorFile};
+
+  use hex_conservative::DisplayHex;
   use serde::Deserialize;
 
   #[derive(Deserialize)]
@@ -135,7 +137,7 @@ mod kat {
         .collect();
       let pk_refs: Vec<_> = pks.iter().collect();
       let agg = dash_pkc::bls_chia::aggregate_pk(&pk_refs).unwrap();
-      assert_eq!(hex::encode(agg.to_bytes()), v.agg_pk);
+      assert_eq!(agg.to_bytes().to_lower_hex_string(), v.agg_pk);
     }
   }
 
@@ -155,7 +157,7 @@ mod kat {
         .collect();
       let sig_refs: Vec<_> = sigs.iter().collect();
       let agg = dash_pkc::bls_chia::aggregate_sig(&sig_refs).unwrap();
-      assert_eq!(hex::encode(agg.to_bytes()), v.agg_sig);
+      assert_eq!(agg.to_bytes().to_lower_hex_string(), v.agg_sig);
     }
   }
 

pkgs/pkc/tests/bls_chia_dh.rs

@@ -39,6 +39,8 @@ fn dh_exchange_roundtrip(sk_seed0: SecretKey, sk_seed1: SecretKey) {
 
 mod kat {
   use super::common::{self, decode_hex, VectorFile};
+
+  use hex_conservative::DisplayHex;
   use serde::Deserialize;
 
   #[derive(Deserialize)]
@@ -59,7 +61,7 @@ mod kat {
       let sk = dash_pkc::bls_chia::SecretKey::from_bytes(&sk_bytes).unwrap();
       let peer_pk = dash_pkc::bls_chia::PublicKey::from_bytes(&pk_bytes).unwrap();
       let shared = dash_pkc::bls_chia::PublicKey::dh_exchange(&sk, &peer_pk).unwrap();
-      assert_eq!(hex::encode(shared.to_bytes()), v.shared);
+      assert_eq!(shared.to_bytes().to_lower_hex_string(), v.shared);
     }
   }
 }

pkgs/pkc/tests/bls_chia_keygen.rs

@@ -67,6 +67,8 @@ fn cross_format_pk_differs(sk_seed0: SecretKey) {
 
 mod kat {
   use super::common::{self, decode_hex, VectorFile};
+
+  use hex_conservative::DisplayHex;
   use serde::Deserialize;
 
   #[derive(Deserialize)]
@@ -84,7 +86,7 @@ mod kat {
       let sk_bytes: [u8; 32] = decode_hex(&v.sk).try_into().unwrap();
       let sk = dash_pkc::bls_chia::SecretKey::from_bytes(&sk_bytes).unwrap();
       assert_eq!(
-        hex::encode(sk.public_key().to_bytes()),
+        sk.public_key().to_bytes().to_lower_hex_string(),
         v.pk,
         "pk mismatch for sk {}",
         v.sk

pkgs/pkc/tests/bls_chia_llmq.rs

@@ -14,6 +14,8 @@ mod common;
 use dash_pkc::bls_chia::{aggregate_pk, aggregate_sig, threshold, PublicKey, SecretKey, Signature};
 use dash_pkc::Hash256;
 
+use hex_conservative::DisplayHex;
+
 #[test]
 fn llmq_contribute_vvec() {
   let f = common::load("bls_chia_llmq_100");
@@ -115,7 +117,7 @@ fn llmq_commit_quorum_key() {
     .collect();
   let pk_refs: Vec<&PublicKey> = member_pks.iter().collect();
   let agg_pk = aggregate_pk(&pk_refs).unwrap();
-  assert_eq!(hex::encode(agg_pk.to_bytes()), expected_qpk);
+  assert_eq!(agg_pk.to_bytes().to_lower_hex_string(), expected_qpk);
 }
 
 #[test]
@@ -133,7 +135,7 @@ fn llmq_commit_sk_share() {
 
     let refs: Vec<&SecretKey> = received.iter().collect();
     let agg = dash_pkc::bls_chia::aggregate_sk(&refs).unwrap();
-    assert_eq!(hex::encode(agg.to_bytes()), expected_share);
+    assert_eq!(agg.to_bytes().to_lower_hex_string(), expected_share);
   }
 }
 
@@ -203,7 +205,12 @@ fn llmq_finalize_recover_quorum_sig() {
     .iter()
     .map(|sid| {
       let sid_bytes = common::hex_to_32(sid);
-      let sid_display = hex::encode(sid_bytes.iter().copied().rev().collect::<Vec<u8>>());
+      let sid_display = sid_bytes
+        .iter()
+        .copied()
+        .rev()
+        .collect::<Vec<u8>>()
+        .to_lower_hex_string();
       let idx = member_ids.iter().position(|m| *m == sid_display).unwrap();
       let sk = SecretKey::from_bytes(&common::hex_to_32(commits[idx]["sk_share"].as_str().unwrap())).unwrap();
       let member_id = common::hash_from_hex(&sid_display);

pkgs/pkc/tests/bls_chia_ser.rs

@@ -13,6 +13,8 @@ mod common;
 
 mod kat {
   use super::common::{self, decode_hex, VectorFile};
+
+  use hex_conservative::DisplayHex;
   use serde::Deserialize;
 
   #[derive(Deserialize)]
@@ -39,7 +41,11 @@ mod kat {
       // identically.
       let legacy_bytes: [u8; 48] = decode_hex(&v.pk_legacy).try_into().unwrap();
       let pk = dash_pkc::bls_chia::PublicKey::from_bytes(&legacy_bytes).unwrap();
-      assert_eq!(hex::encode(pk.to_bytes()), v.pk_legacy, "legacy pk roundtrip mismatch");
+      assert_eq!(
+        pk.to_bytes().to_lower_hex_string(),
+        v.pk_legacy,
+        "legacy pk roundtrip mismatch"
+      );
 
       // The two formats must differ for the same point.
       assert_ne!(v.pk_legacy, v.pk_ietf, "legacy and ietf should differ");
@@ -56,7 +62,7 @@ mod kat {
       let legacy_bytes: [u8; 96] = decode_hex(&v.sig_legacy).try_into().unwrap();
       let sig = dash_pkc::bls_chia::Signature::from_bytes(&legacy_bytes).unwrap();
       assert_eq!(
-        hex::encode(sig.to_bytes()),
+        sig.to_bytes().to_lower_hex_string(),
         v.sig_legacy,
         "legacy sig roundtrip mismatch"
       );

pkgs/pkc/tests/bls_chia_sign.rs

@@ -120,6 +120,8 @@ fn legacy_pk_serialization_differs_from_ietf() {
 
 mod kat {
   use super::common::{self, decode_hex, VectorFile};
+
+  use hex_conservative::DisplayHex;
   use serde::Deserialize;
   use sha2::{Digest, Sha256};
 
@@ -156,7 +158,7 @@ mod kat {
       let sk = dash_pkc::bls_chia::SecretKey::from_bytes(&sk_bytes).unwrap();
       let sig = sk.sign(&msg);
       assert_eq!(
-        hex::encode(sig.to_bytes()),
+        sig.to_bytes().to_lower_hex_string(),
         v.sig,
         "sig mismatch for sk={} msg={}",
         v.sk,
@@ -193,7 +195,7 @@ mod kat {
         concat[..32].copy_from_slice(&h0);
         concat[32..].copy_from_slice(&h1);
         assert_eq!(
-          hex::encode(concat),
+          concat.to_lower_hex_string(),
           **exp,
           "SHA-256 mismatch for tag {:?}",
           std::str::from_utf8(*tag).unwrap()

pkgs/pkc/tests/bls_ietf_aggregate.rs

@@ -118,6 +118,8 @@ fn secure_verify_rejects_naive_aggregate(sk_seed0: SecretKey, sk_seed1: SecretKe
 
 mod kat {
   use super::common::{self, decode_hex, VectorFile};
+
+  use hex_conservative::DisplayHex;
   use serde::Deserialize;
 
   #[derive(Deserialize)]
@@ -163,7 +165,7 @@ mod kat {
         .collect();
       let pk_refs: Vec<_> = pks.iter().collect();
       let agg = dash_pkc::bls_ietf::aggregate_pk(&pk_refs).unwrap();
-      assert_eq!(hex::encode(agg.to_bytes()), v.agg_pk);
+      assert_eq!(agg.to_bytes().to_lower_hex_string(), v.agg_pk);
     }
   }
 
@@ -183,7 +185,7 @@ mod kat {
         .collect();
       let sig_refs: Vec<_> = sigs.iter().collect();
       let agg = dash_pkc::bls_ietf::aggregate_sig(&sig_refs).unwrap();
-      assert_eq!(hex::encode(agg.to_bytes()), v.agg_sig);
+      assert_eq!(agg.to_bytes().to_lower_hex_string(), v.agg_sig);
     }
   }
 
@@ -203,7 +205,7 @@ mod kat {
         .collect();
       let sk_refs: Vec<_> = sks.iter().collect();
       let agg = dash_pkc::bls_ietf::aggregate_sk(&sk_refs).unwrap();
-      assert_eq!(hex::encode(agg.to_bytes()), v.agg_sk);
+      assert_eq!(agg.to_bytes().to_lower_hex_string(), v.agg_sk);
     }
   }
 

pkgs/pkc/tests/bls_ietf_dh.rs

@@ -39,6 +39,8 @@ fn dh_exchange_roundtrip(sk_seed0: SecretKey, sk_seed1: SecretKey) {
 
 mod kat {
   use super::common::{self, decode_hex, VectorFile};
+
+  use hex_conservative::DisplayHex;
   use serde::Deserialize;
 
   #[derive(Deserialize)]
@@ -59,7 +61,7 @@ mod kat {
       let sk = dash_pkc::bls_ietf::SecretKey::from_bytes(&sk_bytes).unwrap();
       let peer_pk = dash_pkc::bls_ietf::PublicKey::from_bytes(&pk_bytes).unwrap();
       let shared = dash_pkc::bls_ietf::PublicKey::dh_exchange(&sk, &peer_pk).unwrap();
-      assert_eq!(hex::encode(shared.to_bytes()), v.shared);
+      assert_eq!(shared.to_bytes().to_lower_hex_string(), v.shared);
     }
   }
 }

pkgs/pkc/tests/bls_ietf_keygen.rs

@@ -65,6 +65,8 @@ fn cross_format_pk_differs(sk_seed0: SecretKey) {
 
 mod kat {
   use super::common::{self, decode_hex, VectorFile};
+
+  use hex_conservative::DisplayHex;
   use serde::Deserialize;
 
   #[derive(Deserialize)]
@@ -82,7 +84,7 @@ mod kat {
       let sk_bytes: [u8; 32] = decode_hex(&v.sk).try_into().unwrap();
       let sk = dash_pkc::bls_ietf::SecretKey::from_bytes(&sk_bytes).unwrap();
       assert_eq!(
-        hex::encode(sk.public_key().to_bytes()),
+        sk.public_key().to_bytes().to_lower_hex_string(),
         v.pk,
         "pk mismatch for sk {}",
         v.sk

pkgs/pkc/tests/bls_ietf_llmq.rs

@@ -18,6 +18,8 @@ mod common;
 use dash_pkc::bls_ietf::{aggregate_pk, aggregate_sig, threshold, PublicKey, SecretKey, Signature};
 use dash_pkc::Hash256;
 
+use hex_conservative::DisplayHex;
+
 #[test]
 fn llmq_contribute_vvec() {
   let f = common::load("bls_ietf_llmq_100");
@@ -149,7 +151,7 @@ fn llmq_commit_quorum_key() {
     .collect();
   let pk_refs: Vec<&PublicKey> = member_pks.iter().collect();
   let agg_pk = aggregate_pk(&pk_refs).unwrap();
-  assert_eq!(hex::encode(agg_pk.to_bytes()), expected_qpk,);
+  assert_eq!(agg_pk.to_bytes().to_lower_hex_string(), expected_qpk,);
 }
 
 #[test]
@@ -172,7 +174,7 @@ fn llmq_commit_sk_share() {
     let refs: Vec<&SecretKey> = received.iter().collect();
     let agg = dash_pkc::bls_ietf::aggregate_sk(&refs).unwrap();
     assert_eq!(
-      hex::encode(agg.to_bytes()),
+      agg.to_bytes().to_lower_hex_string(),
       expected_share,
       "sk_share mismatch for member {}",
       member_idx,
@@ -250,7 +252,12 @@ fn llmq_finalize_recover_quorum_sig() {
       // sid is internal byte order; byte-reverse to get
       // the display hex that matches member_ids.
       let sid_bytes = common::hex_to_32(sid);
-      let sid_display = hex::encode(sid_bytes.iter().copied().rev().collect::<Vec<u8>>());
+      let sid_display = sid_bytes
+        .iter()
+        .copied()
+        .rev()
+        .collect::<Vec<u8>>()
+        .to_lower_hex_string();
       let idx = member_ids.iter().position(|m| *m == sid_display).unwrap();
       let sk = SecretKey::from_bytes(&common::hex_to_32(commits[idx]["sk_share"].as_str().unwrap())).unwrap();
       let member_id = common::hash_from_hex(&sid_display);

pkgs/pkc/tests/bls_ietf_sign.rs

@@ -129,6 +129,8 @@ fn cross_format_sig_differs(sk_seed0: SecretKey) {
 
 mod kat {
   use super::common::{self, decode_hex, VectorFile};
+
+  use hex_conservative::DisplayHex;
   use serde::Deserialize;
 
   #[derive(Deserialize)]
@@ -149,7 +151,7 @@ mod kat {
       let sk = dash_pkc::bls_ietf::SecretKey::from_bytes(&sk_bytes).unwrap();
       let sig = sk.sign(&msg);
       assert_eq!(
-        hex::encode(sig.to_bytes()),
+        sig.to_bytes().to_lower_hex_string(),
         v.sig,
         "sig mismatch for sk={} msg={}",
         v.sk,