feat: move serde serializers to stacks_common

hstove · hstove · commit 21fe7da0eed1 · 2025-05-21T15:49:53.000-07:00
diff --git a/stacks-common/src/util/macros.rs b/stacks-common/src/util/macros.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
+// Copyright (C) 2020-2025 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -613,6 +613,12 @@ macro_rules! impl_byte_array_newtype {
                 Self(o)
             }
         }
+
+        impl crate::util::HexDeser for $thing {
+            fn try_from_hex(hex_str: &str) -> Result<Self, $crate::util::HexError> {
+                $thing::from_hex(hex_str)
+            }
+        }
     };
 }
 
diff --git a/stacks-common/src/util/mod.rs b/stacks-common/src/util/mod.rs
@@ -27,6 +27,7 @@ pub mod pair;
 pub mod pipe;
 pub mod retry;
 pub mod secp256k1;
+pub mod serde_serializers;
 pub mod uint;
 pub mod vrf;
 
@@ -111,6 +112,10 @@ impl error::Error for HexError {
     }
 }
 
+pub trait HexDeser: Sized {
+    fn try_from_hex(hex: &str) -> Result<Self, HexError>;
+}
+
 /// Write any `serde_json` object directly to a file
 pub fn serialize_json_to_file<J, P>(json: &J, path: P) -> Result<(), std::io::Error>
 where
diff --git a/stacks-common/src/util/serde_serializers.rs b/stacks-common/src/util/serde_serializers.rs
@@ -0,0 +1,133 @@
+/// This module serde encodes and decodes optional byte fields in RPC
+/// responses as Some(String) where the String is a `0x` prefixed
+/// hex string.
+pub mod prefix_opt_hex {
+    pub fn serialize<S: serde::Serializer, T: std::fmt::LowerHex>(
+        val: &Option<T>,
+        s: S,
+    ) -> Result<S::Ok, S::Error> {
+        match val {
+            Some(ref some_val) => {
+                let val_str = format!("0x{some_val:x}");
+                s.serialize_some(&val_str)
+            }
+            None => s.serialize_none(),
+        }
+    }
+
+    pub fn deserialize<'de, D: serde::Deserializer<'de>, T: crate::util::HexDeser>(
+        d: D,
+    ) -> Result<Option<T>, D::Error> {
+        let opt_inst_str: Option<String> = serde::Deserialize::deserialize(d)?;
+        let Some(inst_str) = opt_inst_str else {
+            return Ok(None);
+        };
+        let Some(hex_str) = inst_str.get(2..) else {
+            return Err(serde::de::Error::invalid_length(
+                inst_str.len(),
+                &"at least length 2 string",
+            ));
+        };
+        let val = T::try_from_hex(hex_str).map_err(serde::de::Error::custom)?;
+        Ok(Some(val))
+    }
+}
+
+/// This module serde encodes and decodes byte fields in RPC
+/// responses as a String where the String is a `0x` prefixed
+/// hex string.
+pub mod prefix_hex {
+    pub fn serialize<S: serde::Serializer, T: std::fmt::LowerHex>(
+        val: &T,
+        s: S,
+    ) -> Result<S::Ok, S::Error> {
+        s.serialize_str(&format!("0x{val:x}"))
+    }
+
+    pub fn deserialize<'de, D: serde::Deserializer<'de>, T: crate::util::HexDeser>(
+        d: D,
+    ) -> Result<T, D::Error> {
+        let inst_str: String = serde::Deserialize::deserialize(d)?;
+        let Some(hex_str) = inst_str.get(2..) else {
+            return Err(serde::de::Error::invalid_length(
+                inst_str.len(),
+                &"at least length 2 string",
+            ));
+        };
+        T::try_from_hex(hex_str).map_err(serde::de::Error::custom)
+    }
+}
+
+/// This module serde encode and decodes structs that
+/// implement StacksMessageCodec as a 0x-prefixed hex string.
+pub mod prefix_hex_codec {
+    use crate::codec::StacksMessageCodec;
+    use crate::util::hash::{hex_bytes, to_hex};
+
+    pub fn serialize<S: serde::Serializer, T: StacksMessageCodec>(
+        val: &T,
+        s: S,
+    ) -> Result<S::Ok, S::Error> {
+        let mut bytes = vec![];
+        val.consensus_serialize(&mut bytes)
+            .map_err(serde::ser::Error::custom)?;
+        s.serialize_str(&format!("0x{}", to_hex(&bytes)))
+    }
+
+    pub fn deserialize<'de, D: serde::Deserializer<'de>, T: StacksMessageCodec>(
+        d: D,
+    ) -> Result<T, D::Error> {
+        let inst_str: String = serde::Deserialize::deserialize(d)?;
+        let Some(hex_str) = inst_str.get(2..) else {
+            return Err(serde::de::Error::invalid_length(
+                inst_str.len(),
+                &"at least length 2 string",
+            ));
+        };
+        let bytes = hex_bytes(hex_str).map_err(serde::de::Error::custom)?;
+        T::consensus_deserialize(&mut &bytes[..]).map_err(serde::de::Error::custom)
+    }
+}
+
+/// This module serde encode and decodes structs that
+/// implement StacksMessageCodec as a 0x-prefixed hex string.
+/// This is the same as prefix_hex_codec, but for Option<T>.
+pub mod prefix_opt_hex_codec {
+    use crate::codec::StacksMessageCodec;
+    use crate::util::hash::{hex_bytes, to_hex};
+
+    pub fn serialize<S: serde::Serializer, T: StacksMessageCodec>(
+        val: &Option<T>,
+        s: S,
+    ) -> Result<S::Ok, S::Error> {
+        match val {
+            Some(ref some_val) => {
+                let mut bytes = vec![];
+                some_val
+                    .consensus_serialize(&mut bytes)
+                    .map_err(serde::ser::Error::custom)?;
+                let hex_string = format!("0x{}", to_hex(&bytes));
+                s.serialize_some(&hex_string)
+            }
+            None => s.serialize_none(),
+        }
+    }
+
+    pub fn deserialize<'de, D: serde::Deserializer<'de>, T: StacksMessageCodec>(
+        d: D,
+    ) -> Result<Option<T>, D::Error> {
+        let opt_inst_str: Option<String> = serde::Deserialize::deserialize(d)?;
+        let Some(inst_string) = opt_inst_str else {
+            return Ok(None);
+        };
+        let Some(hex_str) = inst_string.get(2..) else {
+            return Err(serde::de::Error::invalid_length(
+                inst_string.len(),
+                &"at least length 2 string",
+            ));
+        };
+        let bytes = hex_bytes(hex_str).map_err(serde::de::Error::custom)?;
+        let val = T::consensus_deserialize(&mut &bytes[..]).map_err(serde::de::Error::custom)?;
+        Ok(Some(val))
+    }
+}
diff --git a/stackslib/src/net/api/get_tenures_fork_info.rs b/stackslib/src/net/api/get_tenures_fork_info.rs
@@ -25,6 +25,7 @@ use stacks_common::types::chainstate::{
 use stacks_common::types::net::PeerHost;
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::{to_hex, Hash160};
+use stacks_common::util::serde_serializers::{prefix_hex, prefix_opt_hex, prefix_opt_hex_codec};
 use stacks_common::util::HexError;
 use {serde, serde_json};
 
@@ -34,7 +35,6 @@ use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState, NakamotoSta
 use crate::chainstate::stacks::db::StacksChainState;
 use crate::chainstate::stacks::Error as ChainError;
 use crate::net::api::getblock_v3::NakamotoBlockStream;
-use crate::net::api::{prefix_hex, prefix_opt_hex, prefix_opt_hex_codec};
 use crate::net::http::{
     parse_bytes, parse_json, Error, HttpBadRequest, HttpChunkGenerator, HttpContentType,
     HttpNotFound, HttpRequest, HttpRequestContents, HttpRequestPreamble, HttpResponse,
diff --git a/stackslib/src/net/api/getsortition.rs b/stackslib/src/net/api/getsortition.rs
@@ -26,6 +26,7 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::types::net::PeerHost;
 use stacks_common::util::hash::{to_hex, Hash160};
+use stacks_common::util::serde_serializers::{prefix_hex, prefix_opt_hex};
 use stacks_common::util::HexError;
 use {serde, serde_json};
 
@@ -37,7 +38,6 @@ use crate::chainstate::nakamoto::{
 use crate::chainstate::stacks::db::StacksChainState;
 use crate::chainstate::stacks::Error as ChainError;
 use crate::net::api::getblock_v3::NakamotoBlockStream;
-use crate::net::api::{prefix_hex, prefix_opt_hex};
 use crate::net::http::{
     parse_bytes, parse_json, Error, HttpBadRequest, HttpChunkGenerator, HttpContentType,
     HttpNotFound, HttpRequest, HttpRequestContents, HttpRequestPreamble, HttpResponse,
diff --git a/stackslib/src/net/api/mod.rs b/stackslib/src/net/api/mod.rs
@@ -165,163 +165,3 @@ impl From<NetError> for Error {
         }
     }
 }
-
-/// This module serde encodes and decodes optional byte fields in RPC
-/// responses as Some(String) where the String is a `0x` prefixed
-/// hex string.
-pub mod prefix_opt_hex {
-    pub fn serialize<S: serde::Serializer, T: std::fmt::LowerHex>(
-        val: &Option<T>,
-        s: S,
-    ) -> Result<S::Ok, S::Error> {
-        match val {
-            Some(ref some_val) => {
-                let val_str = format!("0x{some_val:x}");
-                s.serialize_some(&val_str)
-            }
-            None => s.serialize_none(),
-        }
-    }
-
-    pub fn deserialize<'de, D: serde::Deserializer<'de>, T: super::HexDeser>(
-        d: D,
-    ) -> Result<Option<T>, D::Error> {
-        let opt_inst_str: Option<String> = serde::Deserialize::deserialize(d)?;
-        let Some(inst_str) = opt_inst_str else {
-            return Ok(None);
-        };
-        let Some(hex_str) = inst_str.get(2..) else {
-            return Err(serde::de::Error::invalid_length(
-                inst_str.len(),
-                &"at least length 2 string",
-            ));
-        };
-        let val = T::try_from(hex_str).map_err(serde::de::Error::custom)?;
-        Ok(Some(val))
-    }
-}
-
-/// This module serde encodes and decodes byte fields in RPC
-/// responses as a String where the String is a `0x` prefixed
-/// hex string.
-pub mod prefix_hex {
-    pub fn serialize<S: serde::Serializer, T: std::fmt::LowerHex>(
-        val: &T,
-        s: S,
-    ) -> Result<S::Ok, S::Error> {
-        s.serialize_str(&format!("0x{val:x}"))
-    }
-
-    pub fn deserialize<'de, D: serde::Deserializer<'de>, T: super::HexDeser>(
-        d: D,
-    ) -> Result<T, D::Error> {
-        let inst_str: String = serde::Deserialize::deserialize(d)?;
-        let Some(hex_str) = inst_str.get(2..) else {
-            return Err(serde::de::Error::invalid_length(
-                inst_str.len(),
-                &"at least length 2 string",
-            ));
-        };
-        T::try_from(hex_str).map_err(serde::de::Error::custom)
-    }
-}
-
-/// This module serde encode and decodes structs that
-/// implement StacksMessageCodec as a 0x-prefixed hex string.
-pub mod prefix_hex_codec {
-    use clarity::codec::StacksMessageCodec;
-    use clarity::util::hash::{hex_bytes, to_hex};
-
-    pub fn serialize<S: serde::Serializer, T: StacksMessageCodec>(
-        val: &T,
-        s: S,
-    ) -> Result<S::Ok, S::Error> {
-        let mut bytes = vec![];
-        val.consensus_serialize(&mut bytes)
-            .map_err(serde::ser::Error::custom)?;
-        s.serialize_str(&format!("0x{}", to_hex(&bytes)))
-    }
-
-    pub fn deserialize<'de, D: serde::Deserializer<'de>, T: StacksMessageCodec>(
-        d: D,
-    ) -> Result<T, D::Error> {
-        let inst_str: String = serde::Deserialize::deserialize(d)?;
-        let Some(hex_str) = inst_str.get(2..) else {
-            return Err(serde::de::Error::invalid_length(
-                inst_str.len(),
-                &"at least length 2 string",
-            ));
-        };
-        let bytes = hex_bytes(hex_str).map_err(serde::de::Error::custom)?;
-        T::consensus_deserialize(&mut &bytes[..]).map_err(serde::de::Error::custom)
-    }
-}
-
-/// This module serde encode and decodes structs that
-/// implement StacksMessageCodec as a 0x-prefixed hex string.
-/// This is the same as prefix_hex_codec, but for Option<T>.
-pub mod prefix_opt_hex_codec {
-    use clarity::codec::StacksMessageCodec;
-    use clarity::util::hash::{hex_bytes, to_hex};
-
-    use super::prefix_hex_codec;
-
-    pub fn serialize<S: serde::Serializer, T: StacksMessageCodec>(
-        val: &Option<T>,
-        s: S,
-    ) -> Result<S::Ok, S::Error> {
-        match val {
-            Some(ref some_val) => {
-                let mut bytes = vec![];
-                some_val
-                    .consensus_serialize(&mut bytes)
-                    .map_err(serde::ser::Error::custom)?;
-                let hex_string = format!("0x{}", to_hex(&bytes));
-                s.serialize_some(&hex_string)
-            }
-            None => s.serialize_none(),
-        }
-    }
-
-    pub fn deserialize<'de, D: serde::Deserializer<'de>, T: StacksMessageCodec>(
-        d: D,
-    ) -> Result<Option<T>, D::Error> {
-        let opt_inst_str: Option<String> = serde::Deserialize::deserialize(d)?;
-        let Some(inst_string) = opt_inst_str else {
-            return Ok(None);
-        };
-        let Some(hex_str) = inst_string.get(2..) else {
-            return Err(serde::de::Error::invalid_length(
-                inst_string.len(),
-                &"at least length 2 string",
-            ));
-        };
-        let bytes = hex_bytes(hex_str).map_err(serde::de::Error::custom)?;
-        let val = T::consensus_deserialize(&mut &bytes[..]).map_err(serde::de::Error::custom)?;
-        Ok(Some(val))
-    }
-}
-
-pub trait HexDeser: Sized {
-    fn try_from(hex: &str) -> Result<Self, HexError>;
-}
-
-macro_rules! impl_hex_deser {
-    ($thing:ident) => {
-        impl HexDeser for $thing {
-            fn try_from(hex: &str) -> Result<Self, HexError> {
-                $thing::from_hex(hex)
-            }
-        }
-    };
-}
-
-impl_hex_deser!(BurnchainHeaderHash);
-impl_hex_deser!(StacksBlockId);
-impl_hex_deser!(SortitionId);
-impl_hex_deser!(VRFSeed);
-impl_hex_deser!(ConsensusHash);
-impl_hex_deser!(BlockHeaderHash);
-impl_hex_deser!(Hash160);
-impl_hex_deser!(Sha512Trunc256Sum);
-impl_hex_deser!(Txid);
diff --git a/stackslib/src/net/api/tests/mod.rs b/stackslib/src/net/api/tests/mod.rs
@@ -31,6 +31,7 @@ use stacks_common::types::chainstate::{
 use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::{to_hex, Hash160, Sha512Trunc256Sum};
 use stacks_common::util::pipe::Pipe;
+use stacks_common::util::serde_serializers::{prefix_hex, prefix_opt_hex};
 
 use crate::burnchains::bitcoin::indexer::BitcoinIndexer;
 use crate::burnchains::Txid;
@@ -44,7 +45,6 @@ use crate::chainstate::stacks::{
     TransactionAuth, TransactionPayload, TransactionPostConditionMode, TransactionVersion,
 };
 use crate::core::MemPoolDB;
-use crate::net::api::{prefix_hex, prefix_opt_hex};
 use crate::net::db::PeerDB;
 use crate::net::httpcore::{StacksHttpRequest, StacksHttpResponse};
 use crate::net::relay::Relayer;
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation`
`2`		`-// Copyright (C) 2020 Stacks Open Internet Foundation`
	`2`	`+// Copyright (C) 2020-2025 Stacks Open Internet Foundation`
`3`	`3`	`//`
`4`	`4`	`// This program is free software: you can redistribute it and/or modify`
`5`	`5`	`// it under the terms of the GNU General Public License as published by`
`@@ -613,6 +613,12 @@ macro_rules! impl_byte_array_newtype {`
`613`	`613`	`Self(o)`
`614`	`614`	`}`
`615`	`615`	`}`
	`616`	`+`
	`617`	`+ impl crate::util::HexDeser for $thing {`
	`618`	`+ fn try_from_hex(hex_str: &str) -> Result<Self, $crate::util::HexError> {`
	`619`	`+ $thing::from_hex(hex_str)`
	`620`	`+ }`
	`621`	`+ }`
`616`	`622`	`};`
`617`	`623`	`}`
`618`	`624`