feat(dmq): add 'DmqMessage' type to wrap a 'DmqMsg'

Author: jpraynaud

Cargo.lock

@@ -10,16 +10,24 @@ license.workspace = true
 repository.workspace = true
 include = ["**/*.rs", "Cargo.toml", "README.md", ".gitignore"]
 
+[package.metadata.cargo-machete]
+# `serde_bytes` is used for DmqMessage serialization
+ignored = ["serde_bytes"]
+
 [lib]
 crate-type = ["lib", "cdylib", "staticlib"]
 
 [dependencies]
 anyhow = { workspace = true }
 async-trait = { workspace = true }
+bincode = { version = "2.0.1" }
 blake2 = "0.10.6"
 mithril-cardano-node-chain = { path = "../cardano-node/mithril-cardano-node-chain" }
 mithril-common = { path = "../../mithril-common" }
 pallas-network = { git = "https://github.com/txpipe/pallas.git", branch = "main" }
+pallas-codec = { git = "https://github.com/txpipe/pallas.git", branch = "main" }
+serde = { workspace = true }
+serde_bytes = "0.11.17"
 slog = { workspace = true }
 tokio = { workspace = true, features = ["sync"] }
 

internal/mithril-dmq/Cargo.toml

@@ -0,0 +1,100 @@
+use std::ops::{Deref, DerefMut};
+
+use pallas_codec::minicbor::{Decode, Decoder, Encode, Encoder};
+use pallas_network::miniprotocols::localmsgsubmission::DmqMsg;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+/// Type alias for a DMQ message.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DmqMessage(DmqMsg);
+
+#[derive(Serialize, Deserialize)]
+struct RawBytes(#[serde(with = "serde_bytes")] Vec<u8>);
+
+impl Deref for DmqMessage {
+    type Target = DmqMsg;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for DmqMessage {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl From<DmqMsg> for DmqMessage {
+    fn from(msg: DmqMsg) -> Self {
+        Self(msg)
+    }
+}
+
+impl From<DmqMessage> for DmqMsg {
+    fn from(msg: DmqMessage) -> Self {
+        msg.0
+    }
+}
+
+impl Serialize for DmqMessage {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let raw_bytes = RawBytes({
+            let mut e = Encoder::new(Vec::new());
+            self.0.encode(&mut e, &mut ()).map_err(|e| {
+                serde::ser::Error::custom(format!("DMQ message serialization error: {e}"))
+            })?;
+            Ok(e.into_writer())
+        }?);
+
+        raw_bytes.serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for DmqMessage {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let raw_bytes = RawBytes::deserialize(deserializer)?;
+        let res = DmqMsg::decode(&mut Decoder::new(&raw_bytes.0), &mut ())
+            .map_err(|e| {
+                serde::de::Error::custom(format!("DMQ message deserialization error: {e}"))
+            })?
+            .into();
+
+        Ok(res)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_dmq_message_serialize_deserialize() {
+        let dmq_msg = DmqMsg {
+            msg_id: vec![1, 2, 3],
+            msg_body: vec![4, 5, 6],
+            block_number: 123,
+            ttl: 10,
+            kes_signature: vec![7, 8, 9],
+            operational_certificate: vec![10, 11, 12],
+            kes_period: 0,
+        };
+
+        let dmq_message = DmqMessage::from(dmq_msg.clone());
+        let serialized = bincode::serde::encode_to_vec(&dmq_message, bincode::config::standard())
+            .expect("Serialization failed");
+
+        let (deserialized, _) =
+            bincode::serde::decode_from_slice(&serialized, bincode::config::standard())
+                .expect("Deserialization failed");
+
+        assert_eq!(dmq_message, deserialized);
+        assert_eq!(dmq_message.0, dmq_msg);
+    }
+}

internal/mithril-dmq/src/model/message.rs

@@ -1,3 +1,5 @@
 mod builder;
+mod message;
 
 pub use builder::*;
+pub use message::*;