Merge branch 'main' into feat/serialize-signed-docs

Author: Mr-Leshiy

rust/catalyst-types/Cargo.toml

@@ -25,7 +25,7 @@ minicbor = { version = "0.25.1", features = ["std"] }
 num-traits = "0.2.19"
 orx-concurrent-vec = "3.1.0"
 pallas-crypto = { version = "0.30.1", git = "https://github.com/input-output-hk/catalyst-pallas.git", rev = "9b5183c8b90b90fe2cc319d986e933e9518957b3" }
-serde = { version = "1.0.217", features = ["derive"] }
+serde = { version = "1.0.217", features = ["derive", "rc"] }
 thiserror = "2.0.9"
 base64-url = "3.0.0"
 uuid = { version = "1.11.0", features = ["v4", "v7", "serde"] }
@@ -36,3 +36,4 @@ tracing = "0.1.41"
 [dev-dependencies]
 ed25519-dalek = { version = "2.1.1", features = ["rand_core"] }
 rand = "0.8.5"
+serde_json = "1"

rust/catalyst-types/src/problem_report.rs

@@ -469,4 +469,14 @@ mod tests {
         // The original report must have the same (problematic) state.
         assert!(original.is_problematic());
     }
+
+    #[test]
+    fn serialize() {
+        let report = ProblemReport::new("top level context");
+        report.invalid_value("field name", "found", "constraint", "context");
+
+        let serialized = serde_json::to_string(&report).unwrap();
+        let expected = r#"{"context":"top level context","report":[{"kind":{"type":"InvalidValue","field":"field name","value":"found","constraint":"constraint"},"context":"context"}]}"#;
+        assert_eq!(serialized, expected);
+    }
 }

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

@@ -14,6 +14,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
@@ -82,25 +95,45 @@ mod tests {
 
     #[test]
     fn test_cbor_uuid_v4_roundtrip() {
-        let uuid: V4 = uuid::Uuid::new_v4().into();
+        let uuid = V4::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 = V7::new();
+        let mut bytes = Vec::new();
+        minicbor::encode_with(uuid_v7, &mut bytes, &mut CborContext::Untagged).unwrap();
+        assert!(
+            minicbor::decode_with::<_, V4>(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 = V7::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 = V4::new();
+        let mut bytes = Vec::new();
+        minicbor::encode_with(uuid_v4, &mut bytes, &mut CborContext::Untagged).unwrap();
+        assert!(
+            minicbor::decode_with::<_, V7>(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 = V4::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 +142,7 @@ mod tests {
 
     #[test]
     fn test_tagged_cbor_uuid_v7_roundtrip() {
-        let uuid: V7 = uuid::Uuid::now_v7().into();
+        let uuid = V7::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 +151,7 @@ mod tests {
 
     #[test]
     fn test_optional_cbor_uuid_v4_roundtrip() {
-        let uuid: V4 = uuid::Uuid::new_v4().into();
+        let uuid = V4::new();
 
         let mut bytes = Vec::new();
         minicbor::encode_with(uuid, &mut bytes, &mut CborContext::Untagged).unwrap();
@@ -133,7 +166,7 @@ mod tests {
 
     #[test]
     fn test_optional_cbor_uuid_v7_roundtrip() {
-        let uuid: V7 = uuid::Uuid::now_v7().into();
+        let uuid = V7::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"
         );
     }