fix(rust/catalyst-types): fix uuid cbor and add tests

rust/catalyst-types/src/uuid/mod.rs

@@ -1,7 +1,7 @@
 //! `UUID` types.
 
 use displaydoc::Display;
-use minicbor::{data::Tag, Decoder};
+use minicbor::Decoder;
 use thiserror::Error;
 use uuid::Uuid;
 
@@ -14,8 +14,8 @@ pub use uuid_v7::UuidV7 as V7;
 /// Invalid Doc Type UUID
 pub const INVALID_UUID: uuid::Uuid = uuid::Uuid::from_bytes([0x00; 16]);
 
-/// UUID CBOR tag <https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml/>.
-pub(crate) const UUID_CBOR_TAG: u64 = 37;
+// UUID CBOR tag <https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml/>.
+// pub(crate) const UUID_CBOR_TAG: u64 = 37;
 
 /// Errors that can occur when decoding CBOR-encoded UUIDs.
 #[derive(Display, Debug, Error)]
@@ -34,29 +34,67 @@ pub enum CborUuidError {
 }
 
 /// Decode from `CBOR` into `UUID`
-pub(crate) fn decode_cbor_uuid(
-    d: &mut Decoder<'_>, (): &mut (),
+pub(crate) fn decode_cbor_uuid<C>(
+    d: &mut Decoder<'_>, ctx: &mut C,
 ) -> Result<uuid::Uuid, minicbor::decode::Error> {
-    let tag = d.tag()?;
-    if UUID_CBOR_TAG != tag.as_u64() {
-        return Err(minicbor::decode::Error::message(format!(
-            "tag value must be: {UUID_CBOR_TAG}, provided: {}",
-            tag.as_u64(),
-        )));
-    }
     let decoded = d
-        .bytes()?
-        .try_into()
+        .decode_with(ctx)
         .map_err(|_| minicbor::decode::Error::message("Expected UUID to have 16 bytes"))?;
     let uuid = uuid::Uuid::from_bytes(decoded);
     Ok(uuid)
 }
 
 /// Encode `UUID` into `CBOR`
-pub(crate) fn encode_cbor_uuid<W: minicbor::encode::Write>(
-    uuid: uuid::Uuid, e: &mut minicbor::Encoder<W>, (): &mut (),
+pub(crate) fn encode_cbor_uuid<C, W: minicbor::encode::Write>(
+    uuid: uuid::Uuid, e: &mut minicbor::Encoder<W>, ctx: &mut C,
 ) -> Result<(), minicbor::encode::Error<W::Error>> {
-    e.tag(Tag::new(UUID_CBOR_TAG))?;
-    e.bytes(uuid.as_bytes())?;
+    e.encode_with(uuid.as_bytes(), ctx)?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use minicbor::data::Tagged;
+
+    use super::{V4, V7};
+
+    const UUID_CBOR_TAG: u64 = 37;
+
+    #[test]
+    fn test_cbor_uuid_v4_roundtrip() {
+        let uuid: V4 = uuid::Uuid::new_v4().into();
+        let mut bytes = Vec::new();
+        minicbor::encode(uuid, &mut bytes).unwrap();
+        let decoded = minicbor::decode(bytes.as_slice()).unwrap();
+        assert_eq!(uuid, decoded);
+    }
+
+    #[test]
+    fn test_cbor_uuid_v7_roundtrip() {
+        let uuid: V7 = uuid::Uuid::now_v7().into();
+        let mut bytes = Vec::new();
+        minicbor::encode(uuid, &mut bytes).unwrap();
+        let decoded = minicbor::decode(bytes.as_slice()).unwrap();
+        assert_eq!(uuid, decoded);
+    }
+
+    #[test]
+    fn test_cbor_tagged_uuid_v4_roundtrip() {
+        let uuid: V4 = uuid::Uuid::new_v4().into();
+        let tagged: Tagged<UUID_CBOR_TAG, V4> = uuid.into();
+        let mut bytes = Vec::new();
+        minicbor::encode(tagged, &mut bytes).unwrap();
+        let decoded = minicbor::decode(bytes.as_slice()).unwrap();
+        assert_eq!(tagged, decoded);
+    }
+
+    #[test]
+    fn test_cbor_tagged_uuid_v7_roundtrip() {
+        let uuid: V7 = uuid::Uuid::now_v7().into();
+        let tagged: Tagged<UUID_CBOR_TAG, V7> = uuid.into();
+        let mut bytes = Vec::new();
+        minicbor::encode(tagged, &mut bytes).unwrap();
+        let decoded = minicbor::decode(bytes.as_slice()).unwrap();
+        assert_eq!(tagged, decoded);
+    }
+}

rust/catalyst-types/src/uuid/uuid_v7.rs

@@ -43,16 +43,16 @@ impl Display for UuidV7 {
     }
 }
 
-impl Decode<'_, ()> for UuidV7 {
-    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+impl<C> Decode<'_, C> for UuidV7 {
+    fn decode(d: &mut Decoder<'_>, ctx: &mut C) -> Result<Self, minicbor::decode::Error> {
         let uuid = decode_cbor_uuid(d, ctx)?;
         Ok(Self { uuid })
     }
 }
 
-impl Encode<()> for UuidV7 {
+impl<C> Encode<C> for UuidV7 {
     fn encode<W: minicbor::encode::Write>(
-        &self, e: &mut minicbor::Encoder<W>, ctx: &mut (),
+        &self, e: &mut minicbor::Encoder<W>, ctx: &mut C,
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         encode_cbor_uuid(self.uuid(), e, ctx)
     }