feat(rust/signed-doc): Implement new Catalyst Signed Doc

.config/dictionaries/project.dic

@@ -48,7 +48,6 @@ ciphertexts
 Coap
 codegen
 codepoints
-collabs
 coti
 coverallsapp
 cpus

rust/cardano-blockchain-types/Cargo.toml

@@ -20,8 +20,8 @@ workspace = true
 [dependencies]
 pallas = { version = "0.33.0" }
 # pallas-hardano = { version = "0.33.0" }
-cbork-utils = { version = "0.0.1", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "r20250724-01" }
-catalyst-types = { version = "0.0.4", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "r20250724-01" }
+cbork-utils = { version = "0.0.1", path = "../cbork-utils" }
+catalyst-types = { version = "0.0.4", path = "../catalyst-types" }
 
 ouroboros = "0.18.4"
 tracing = "0.1.41"

rust/cardano-chain-follower/Cargo.toml

@@ -19,8 +19,9 @@ mithril-client = { version = "0.12.2", default-features = false, features = [
     "full",
     "num-integer-backend",
 ] }
-cardano-blockchain-types = { version = "0.0.5", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "cardano-blockchain-types-v0.0.5" }
-catalyst-types = { version = "0.0.4", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "r20250724-01" }
+
+cardano-blockchain-types = { version = "0.0.5", path =  "../cardano-blockchain-types" }
+catalyst-types = { version = "0.0.4", path = "../catalyst-types" }
 
 
 thiserror = "1.0.69"
@@ -64,7 +65,7 @@ test-log = { version = "0.2.16", default-features = false, features = [
     "trace",
 ] }
 clap = "4.5.23"
-rbac-registration = { version = "0.0.5", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "r20250724-01" }
+rbac-registration = { version = "0.0.5", path = "../rbac-registration" }
 
 # Note, these features are for support of features exposed by dependencies.
 [features]

rust/catalyst-types/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "catalyst-types"
-version = "0.0.3"
+version = "0.0.4"
 edition.workspace = true
 license.workspace = true
 authors.workspace = true

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

@@ -709,6 +709,12 @@ impl TryFrom<&[u8]> for CatalystId {
     }
 }
 
+impl From<&CatalystId> for Vec<u8> {
+    fn from(value: &CatalystId) -> Self {
+        value.to_string().into_bytes()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use chrono::{DateTime, Utc};

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

@@ -1,10 +1,10 @@
 //! `UUID` types.
 
-pub use uuid::Uuid;
+pub use uuid::{uuid, Uuid};
 #[allow(clippy::module_name_repetitions)]
-pub use uuid_v4::UuidV4;
+pub use uuid_v4::{InvalidUuidV4, ParsingError as UuidV4ParsingError, UuidV4};
 #[allow(clippy::module_name_repetitions)]
-pub use uuid_v7::UuidV7;
+pub use uuid_v7::{InvalidUuidV7, ParsingError as UuidV7ParsingError, UuidV7};
 
 mod uuid_v4;
 mod uuid_v7;
@@ -15,21 +15,7 @@ use minicbor::data::Tag;
 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/>.
-#[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),
-}
+pub const UUID_CBOR_TAG: u64 = 37;
 
 /// Context for `CBOR` encoding and decoding
 pub enum CborContext {

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

@@ -1,15 +1,23 @@
 //! `UUIDv4` Type.
-use std::fmt::{Display, Formatter};
+use std::{
+    fmt::{Display, Formatter},
+    str::FromStr,
+};
 
 use minicbor::{Decode, Decoder, Encode};
 use uuid::Uuid;
 
-use super::{decode_cbor_uuid, encode_cbor_uuid, CborContext, UuidError, INVALID_UUID};
+use super::{decode_cbor_uuid, encode_cbor_uuid, CborContext};
 
 /// Type representing a `UUIDv4`.
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, serde::Serialize)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, serde::Serialize)]
 pub struct UuidV4(Uuid);
 
+/// `UUIDv4` invalid error
+#[derive(Debug, Clone, thiserror::Error)]
+#[error("'{0}' is not a valid UUIDv4")]
+pub struct InvalidUuidV4(uuid::Uuid);
+
 impl UuidV4 {
     /// Version for `UUIDv4`.
     const UUID_VERSION_NUMBER: usize = 4;
@@ -21,28 +29,28 @@ impl UuidV4 {
         Self(Uuid::new_v4())
     }
 
-    /// Generates a zeroed out `UUIDv4` that can never be valid.
-    #[must_use]
-    pub fn invalid() -> Self {
-        Self(INVALID_UUID)
-    }
-
-    /// Check if this is a valid `UUIDv4`.
-    #[must_use]
-    pub fn is_valid(&self) -> bool {
-        is_valid(&self.uuid())
-    }
-
     /// Returns the `uuid::Uuid` type.
     #[must_use]
     pub fn uuid(&self) -> Uuid {
         self.0
     }
+
+    /// A const alternative impl of `TryFrom<Uuid>`
+    ///
+    /// # Errors
+    ///   - `InvalidUuidV4`
+    pub const fn try_from_uuid(uuid: Uuid) -> Result<Self, InvalidUuidV4> {
+        if is_valid(&uuid) {
+            Ok(Self(uuid))
+        } else {
+            Err(InvalidUuidV4(uuid))
+        }
+    }
 }
 
 /// Check if this is a valid `UUIDv4`.
-fn is_valid(uuid: &Uuid) -> bool {
-    uuid != &INVALID_UUID && uuid.get_version_num() == UuidV4::UUID_VERSION_NUMBER
+const fn is_valid(uuid: &Uuid) -> bool {
+    uuid.get_version_num() == UuidV4::UUID_VERSION_NUMBER
 }
 
 impl Display for UuidV4 {
@@ -54,13 +62,7 @@ impl Display for UuidV4 {
 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)?;
-        if is_valid(&uuid) {
-            Ok(Self(uuid))
-        } else {
-            Err(minicbor::decode::Error::message(UuidError::InvalidUuidV4(
-                uuid,
-            )))
-        }
+        Self::try_from_uuid(uuid).map_err(minicbor::decode::Error::message)
     }
 }
 
@@ -74,14 +76,10 @@ impl Encode<CborContext> for UuidV4 {
 
 /// Returns a `UUIDv4` from `uuid::Uuid`.
 impl TryFrom<Uuid> for UuidV4 {
-    type Error = UuidError;
+    type Error = InvalidUuidV4;
 
     fn try_from(uuid: Uuid) -> Result<Self, Self::Error> {
-        if is_valid(&uuid) {
-            Ok(Self(uuid))
-        } else {
-            Err(UuidError::InvalidUuidV4(uuid))
-        }
+        Self::try_from_uuid(uuid)
     }
 }
 
@@ -98,43 +96,47 @@ 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)))
-        }
+        Self::try_from_uuid(uuid).map_err(serde::de::Error::custom)
+    }
+}
+
+/// `FromStr` invalid error
+#[derive(Debug, Clone, thiserror::Error)]
+pub enum ParsingError {
+    /// `UUIDv4` invalid error
+    #[error(transparent)]
+    InvalidUuidV4(#[from] InvalidUuidV4),
+    /// Invalid string conversion
+    #[error("Invalid string conversion: {0}")]
+    StringConversion(String),
+}
+
+impl FromStr for UuidV4 {
+    type Err = ParsingError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let uuid = Uuid::parse_str(s).map_err(|_| ParsingError::StringConversion(s.to_string()))?;
+        Ok(Self::try_from_uuid(uuid)?)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::uuid::INVALID_UUID;
 
     #[test]
     fn test_invalid_uuid() {
-        let invalid_uuid = UuidV4::invalid();
-        assert!(!invalid_uuid.is_valid(), "Invalid UUID should not be valid");
-        assert_eq!(
-            invalid_uuid.uuid(),
-            INVALID_UUID,
-            "Invalid UUID should match INVALID_UUID"
-        );
-    }
+        assert!(UuidV4::try_from(Uuid::now_v7()).is_err());
 
-    #[test]
-    fn test_valid_uuid() {
-        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() {
         assert!(
             UuidV4::try_from(INVALID_UUID).is_err(),
             "Zero UUID should not be valid"
         );
     }
+
+    #[test]
+    fn test_valid_uuid() {
+        assert!(UuidV4::try_from(Uuid::new_v4()).is_ok());
+    }
 }