Merge branch 'main' into rbac-registration-improvements

Author: stanislav-tkach

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

@@ -1,11 +1,14 @@
 //! `UUID` types.
 
+#[allow(clippy::module_name_repetitions)]
+pub use uuid_v4::UuidV4;
+#[allow(clippy::module_name_repetitions)]
+pub use uuid_v7::UuidV7;
+
 mod uuid_v4;
 mod uuid_v7;
 
 use minicbor::data::Tag;
-pub use uuid_v4::UuidV4 as V4;
-pub use uuid_v7::UuidV7 as V7;
 
 /// Invalid Doc Type UUID
 pub const INVALID_UUID: uuid::Uuid = uuid::Uuid::from_bytes([0x00; 16]);
@@ -14,6 +17,19 @@ pub const INVALID_UUID: uuid::Uuid = uuid::Uuid::from_bytes([0x00; 16]);
 #[allow(dead_code)]
 const UUID_CBOR_TAG: u64 = 37;
 
+/// Uuid validation errors, which could occur during decoding or converting to
+/// `UuidV4` or `UuidV7` types.
+#[derive(Debug, Clone, thiserror::Error)]
+#[allow(clippy::module_name_repetitions)]
+pub enum UuidError {
+    /// `UUIDv4` invalid error
+    #[error("'{0}' is not a valid UUIDv4")]
+    InvalidUuidV4(uuid::Uuid),
+    /// `UUIDv7` invalid error
+    #[error("'{0}' is not a valid UUIDv7")]
+    InvalidUuidV7(uuid::Uuid),
+}
+
 /// Context for `CBOR` encoding and decoding
 pub enum CborContext {
     /// Untagged bytes
@@ -77,30 +93,52 @@ fn encode_cbor_uuid<W: minicbor::encode::Write>(
 #[cfg(test)]
 mod tests {
 
-    use super::{V4, V7};
+    use super::*;
     use crate::uuid::CborContext;
 
     #[test]
     fn test_cbor_uuid_v4_roundtrip() {
-        let uuid: V4 = uuid::Uuid::new_v4().into();
+        let uuid = UuidV4::new();
         let mut bytes = Vec::new();
         minicbor::encode_with(uuid, &mut bytes, &mut CborContext::Untagged).unwrap();
         let decoded = minicbor::decode_with(bytes.as_slice(), &mut CborContext::Untagged).unwrap();
         assert_eq!(uuid, decoded);
     }
 
+    #[test]
+    fn test_cbor_uuid_v4_invalid_decoding() {
+        let uuid_v7 = UuidV7::new();
+        let mut bytes = Vec::new();
+        minicbor::encode_with(uuid_v7, &mut bytes, &mut CborContext::Untagged).unwrap();
+        assert!(
+            minicbor::decode_with::<_, UuidV4>(bytes.as_slice(), &mut CborContext::Untagged)
+                .is_err()
+        );
+    }
+
     #[test]
     fn test_cbor_uuid_v7_roundtrip() {
-        let uuid: V7 = uuid::Uuid::now_v7().into();
+        let uuid = UuidV7::new();
         let mut bytes = Vec::new();
         minicbor::encode_with(uuid, &mut bytes, &mut CborContext::Untagged).unwrap();
         let decoded = minicbor::decode_with(bytes.as_slice(), &mut CborContext::Untagged).unwrap();
         assert_eq!(uuid, decoded);
     }
 
+    #[test]
+    fn test_cbor_uuid_v7_invalid_decoding() {
+        let uuid_v4 = UuidV4::new();
+        let mut bytes = Vec::new();
+        minicbor::encode_with(uuid_v4, &mut bytes, &mut CborContext::Untagged).unwrap();
+        assert!(
+            minicbor::decode_with::<_, UuidV7>(bytes.as_slice(), &mut CborContext::Untagged)
+                .is_err()
+        );
+    }
+
     #[test]
     fn test_tagged_cbor_uuid_v4_roundtrip() {
-        let uuid: V4 = uuid::Uuid::new_v4().into();
+        let uuid = UuidV4::new();
         let mut bytes = Vec::new();
         minicbor::encode_with(uuid, &mut bytes, &mut CborContext::Tagged).unwrap();
         let decoded = minicbor::decode_with(bytes.as_slice(), &mut CborContext::Tagged).unwrap();
@@ -109,7 +147,7 @@ mod tests {
 
     #[test]
     fn test_tagged_cbor_uuid_v7_roundtrip() {
-        let uuid: V7 = uuid::Uuid::now_v7().into();
+        let uuid = UuidV7::new();
         let mut bytes = Vec::new();
         minicbor::encode_with(uuid, &mut bytes, &mut CborContext::Tagged).unwrap();
         let decoded = minicbor::decode_with(bytes.as_slice(), &mut CborContext::Tagged).unwrap();
@@ -118,7 +156,7 @@ mod tests {
 
     #[test]
     fn test_optional_cbor_uuid_v4_roundtrip() {
-        let uuid: V4 = uuid::Uuid::new_v4().into();
+        let uuid = UuidV4::new();
 
         let mut bytes = Vec::new();
         minicbor::encode_with(uuid, &mut bytes, &mut CborContext::Untagged).unwrap();
@@ -133,7 +171,7 @@ mod tests {
 
     #[test]
     fn test_optional_cbor_uuid_v7_roundtrip() {
-        let uuid: V7 = uuid::Uuid::now_v7().into();
+        let uuid = UuidV7::new();
 
         let mut bytes = Vec::new();
         minicbor::encode_with(uuid, &mut bytes, &mut CborContext::Untagged).unwrap();

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

@@ -2,51 +2,65 @@
 use std::fmt::{Display, Formatter};
 
 use minicbor::{Decode, Decoder, Encode};
+use uuid::Uuid;
 
-use super::{decode_cbor_uuid, encode_cbor_uuid, CborContext, INVALID_UUID};
+use super::{decode_cbor_uuid, encode_cbor_uuid, CborContext, UuidError, INVALID_UUID};
 
 /// Type representing a `UUIDv4`.
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, serde::Serialize, serde::Deserialize)]
-#[serde(from = "uuid::Uuid")]
-#[serde(into = "uuid::Uuid")]
-pub struct UuidV4 {
-    /// UUID
-    uuid: uuid::Uuid,
-}
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, serde::Serialize)]
+pub struct UuidV4(Uuid);
 
 impl UuidV4 {
     /// Version for `UUIDv4`.
     const UUID_VERSION_NUMBER: usize = 4;
 
+    /// Generates a random `UUIDv4`.
+    #[must_use]
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        Self(Uuid::new_v4())
+    }
+
     /// Generates a zeroed out `UUIDv4` that can never be valid.
     #[must_use]
     pub fn invalid() -> Self {
-        Self { uuid: INVALID_UUID }
+        Self(INVALID_UUID)
     }
 
     /// Check if this is a valid `UUIDv4`.
     #[must_use]
     pub fn is_valid(&self) -> bool {
-        self.uuid != INVALID_UUID && self.uuid.get_version_num() == Self::UUID_VERSION_NUMBER
+        is_valid(&self.uuid())
     }
 
     /// Returns the `uuid::Uuid` type.
     #[must_use]
-    pub fn uuid(&self) -> uuid::Uuid {
-        self.uuid
+    pub fn uuid(&self) -> Uuid {
+        self.0
     }
 }
 
+/// Check if this is a valid `UUIDv4`.
+fn is_valid(uuid: &Uuid) -> bool {
+    uuid != &INVALID_UUID && uuid.get_version_num() == UuidV4::UUID_VERSION_NUMBER
+}
+
 impl Display for UuidV4 {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
-        write!(f, "{}", self.uuid)
+        write!(f, "{}", self.0)
     }
 }
 
 impl Decode<'_, CborContext> for UuidV4 {
     fn decode(d: &mut Decoder<'_>, ctx: &mut CborContext) -> Result<Self, minicbor::decode::Error> {
         let uuid = decode_cbor_uuid(d, ctx)?;
-        Ok(Self { uuid })
+        if is_valid(&uuid) {
+            Ok(Self(uuid))
+        } else {
+            Err(minicbor::decode::Error::message(UuidError::InvalidUuidV4(
+                uuid,
+            )))
+        }
     }
 }
 
@@ -59,27 +73,41 @@ impl Encode<CborContext> for UuidV4 {
 }
 
 /// Returns a `UUIDv4` from `uuid::Uuid`.
-///
-/// NOTE: This does not guarantee that the `UUID` is valid.
-impl From<uuid::Uuid> for UuidV4 {
-    fn from(uuid: uuid::Uuid) -> Self {
-        Self { uuid }
+impl TryFrom<Uuid> for UuidV4 {
+    type Error = UuidError;
+
+    fn try_from(uuid: Uuid) -> Result<Self, Self::Error> {
+        if is_valid(&uuid) {
+            Ok(Self(uuid))
+        } else {
+            Err(UuidError::InvalidUuidV4(uuid))
+        }
     }
 }
 
 /// Returns a `uuid::Uuid` from `UUIDv4`.
 ///
 /// NOTE: This does not guarantee that the `UUID` is valid.
-impl From<UuidV4> for uuid::Uuid {
+impl From<UuidV4> for Uuid {
     fn from(value: UuidV4) -> Self {
-        value.uuid
+        value.0
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for UuidV4 {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where D: serde::Deserializer<'de> {
+        let uuid = Uuid::deserialize(deserializer)?;
+        if is_valid(&uuid) {
+            Ok(Self(uuid))
+        } else {
+            Err(serde::de::Error::custom(UuidError::InvalidUuidV4(uuid)))
+        }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use uuid::Uuid;
-
     use super::*;
 
     #[test]
@@ -95,15 +123,17 @@ mod tests {
 
     #[test]
     fn test_valid_uuid() {
-        let valid_uuid = UuidV4::from(Uuid::new_v4());
+        let valid_uuid = UuidV4::try_from(Uuid::new_v4()).unwrap();
+        assert!(valid_uuid.is_valid(), "Valid UUID should be valid");
+
+        let valid_uuid = UuidV4::new();
         assert!(valid_uuid.is_valid(), "Valid UUID should be valid");
     }
 
     #[test]
     fn test_invalid_version_uuid() {
-        let invalid_version_uuid = UuidV4::from(Uuid::from_u128(0));
         assert!(
-            !invalid_version_uuid.is_valid(),
+            UuidV4::try_from(INVALID_UUID).is_err(),
             "Zero UUID should not be valid"
         );
     }