Merge branch 'rbac-registration-improvements' into test/rbac

Signed-off-by: bkioshn <[email protected]>

Author: bkioshn

rust/cardano-blockchain-types/src/cip134_uri.rs

@@ -8,7 +8,7 @@ use std::fmt::{Display, Formatter};
 use anyhow::{anyhow, Context, Error, Result};
 use pallas::ledger::addresses::Address;
 
-/// An URI in the CIP-0134 format.
+/// A URI in the CIP-0134 format.
 ///
 /// See the [proposal] for more details.
 ///

rust/cardano-blockchain-types/src/lib.rs

@@ -1,6 +1,7 @@
 //! Catalyst Enhanced `MultiEraBlock` Structures
 
 mod auxdata;
+mod cip134_uri;
 mod fork;
 mod metadata;
 mod multi_era_block_data;
@@ -27,5 +28,3 @@ pub use point::Point;
 pub use slot::Slot;
 pub use txn_index::TxnIndex;
 pub use txn_witness::{TxnWitness, VKeyHash};
-
-mod cip134_uri;

rust/cardano-blockchain-types/src/slot.rs

@@ -11,7 +11,7 @@ use serde::Serialize;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Default, Serialize)]
 
-/// Slot on the blockchain, typically one slot equals one second.  However chain
+/// Slot on the blockchain, typically one slot equals one second. However chain
 /// parameters can alter how long a slot is.
 pub struct Slot(u64);
 

rust/catalyst-types/Cargo.toml

@@ -23,9 +23,9 @@ fluent-uri = "0.3.2"
 hex = "0.4.3"
 minicbor = { version = "0.25.1", features = ["std"] }
 num-traits = "0.2.19"
-orx-concurrent-vec = "3.1.0"
+orx-concurrent-vec = { version = "3.2.0", features = ["serde"] }
 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

@@ -7,7 +7,7 @@
 use std::sync::Arc;
 
 use orx_concurrent_vec::ConcurrentVec;
-use serde::{ser::SerializeSeq, Serialize};
+use serde::Serialize;
 
 /// The kind of problem being reported
 #[derive(Debug, Serialize, Clone)]
@@ -82,20 +82,9 @@ struct Entry {
 }
 
 /// The Problem Report list
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
 struct Report(ConcurrentVec<Entry>);
 
-impl Serialize for Report {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where S: serde::Serializer {
-        let mut seq = serializer.serialize_seq(Some(self.0.len()))?;
-        for e in self.0.iter_cloned() {
-            seq.serialize_element(&e)?;
-        }
-        seq.end()
-    }
-}
-
 /// An inner state of the report.
 #[derive(Debug, Serialize)]
 struct State {
@@ -469,4 +458,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

@@ -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"
         );
     }