fix(sign-doc): impl tryfrom instead of new and move err to own file

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

Author: bkioshn

rust/signed_doc/examples/mk_signed_doc.rs

@@ -108,7 +108,7 @@ fn decode_signed_doc(cose_bytes: &[u8]) {
         hex::encode(cose_bytes)
     );
 
-    match CatalystSignedDocument::new(cose_bytes) {
+    match CatalystSignedDocument::try_from(cose_bytes) {
         Ok(cat_signed_doc) => {
             println!("This is a valid Catalyst Document.");
             println!("{cat_signed_doc}");

rust/signed_doc/src/error.rs

@@ -0,0 +1,48 @@
+//! Catalyst Signed Document Error
+
+use std::fmt;
+
+use catalyst_types::problem_report::ProblemReport;
+
+/// Catalyst Signed Document Error
+#[allow(clippy::module_name_repetitions)]
+#[derive(Debug)]
+pub struct CatalystSignedDocError {
+    /// List of errors during processing.
+    report: ProblemReport,
+    /// Actual error.
+    error: anyhow::Error,
+}
+
+impl CatalystSignedDocError {
+    /// Create a new `CatalystSignedDocError`.
+    #[must_use]
+    pub fn new(report: ProblemReport, error: anyhow::Error) -> Self {
+        Self { report, error }
+    }
+
+    /// Get the error report.
+    #[must_use]
+    pub fn report(&self) -> &ProblemReport {
+        &self.report
+    }
+
+    /// Get the actual error.
+    #[must_use]
+    pub fn error(&self) -> &anyhow::Error {
+        &self.error
+    }
+}
+
+impl fmt::Display for CatalystSignedDocError {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let report_json = serde_json::to_string(&self.report)
+            .unwrap_or_else(|_| String::from("Failed to serialize ProblemReport"));
+
+        write!(
+            fmt,
+            "CatalystSignedDocError {{ error: {}, report: {} }}",
+            self.error, report_json
+        )
+    }
+}

rust/signed_doc/src/lib.rs

@@ -2,20 +2,22 @@
 
 mod builder;
 mod content;
+pub mod error;
 mod metadata;
 mod signature;
 mod utils;
 
 use std::{
     convert::TryFrom,
-    fmt::{self, Display, Formatter},
+    fmt::{Display, Formatter},
     sync::Arc,
 };
 
 pub use builder::Builder;
 use catalyst_types::problem_report::ProblemReport;
 pub use content::Content;
 use coset::{CborSerializable, Header};
+use error::CatalystSignedDocError;
 pub use metadata::{DocumentRef, ExtraFields, Metadata, UuidV4, UuidV7};
 pub use minicbor::{decode, encode, Decode, Decoder, Encode};
 pub use signature::{KidUri, Signatures};
@@ -65,55 +67,7 @@ impl From<InnerCatalystSignedDocument> for CatalystSignedDocument {
     }
 }
 
-/// Catalyst Signed Document Error
-#[derive(Debug)]
-pub struct CatalystSignedDocError {
-    /// List of errors during processing.
-    report: ProblemReport,
-    /// Actual error.
-    error: anyhow::Error,
-}
-
-impl fmt::Display for CatalystSignedDocError {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let report_json = serde_json::to_string(&self.report)
-            .unwrap_or_else(|_| String::from("Failed to serialize ProblemReport"));
-
-        write!(
-            fmt,
-            "CatalystSignedDocError {{ error: {}, report: {} }}",
-            self.error, report_json
-        )
-    }
-}
-
 impl CatalystSignedDocument {
-    /// Create a new Catalyst Signed Document from a COSE Sign document bytes.
-    ///
-    /// # Arguments
-    ///
-    /// * `cose_bytes` - COSE Sign document bytes.
-    ///
-    /// # Returns
-    ///
-    /// A new Catalyst Signed Document.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the COSE Sign document bytes are invalid or decode error.
-    pub fn new(cose_bytes: &[u8]) -> anyhow::Result<Self, CatalystSignedDocError> {
-        let error_report = ProblemReport::new("Catalyst Signed Document");
-        let mut ctx = SignDocContext { error_report };
-        let decoded: CatalystSignedDocument =
-            minicbor::decode_with(cose_bytes, &mut ctx).map_err(|e| {
-                CatalystSignedDocError {
-                    report: ctx.error_report,
-                    error: e.into(),
-                }
-            })?;
-        Ok(decoded)
-    }
-
     // A bunch of getters to access the contents, or reason through the document, such as.
 
     /// Return Document Type `UUIDv4`.
@@ -153,6 +107,18 @@ impl CatalystSignedDocument {
     }
 }
 
+impl TryFrom<&[u8]> for CatalystSignedDocument {
+    type Error = CatalystSignedDocError;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        let error_report = ProblemReport::new("Catalyst Signed Document");
+        let mut ctx = SignDocContext { error_report };
+        let decoded: CatalystSignedDocument = minicbor::decode_with(value, &mut ctx)
+            .map_err(|e| CatalystSignedDocError::new(ctx.error_report, e.into()))?;
+        Ok(decoded)
+    }
+}
+
 impl Decode<'_, SignDocContext> for CatalystSignedDocument {
     fn decode(d: &mut Decoder<'_>, ctx: &mut SignDocContext) -> Result<Self, decode::Error> {
         let start = d.position();
@@ -319,7 +285,7 @@ mod tests {
         let mut bytes = Vec::new();
         minicbor::encode_with(doc, &mut bytes, &mut ()).unwrap();
 
-        let decoded = CatalystSignedDocument::new(&bytes).unwrap();
+        let decoded: CatalystSignedDocument = bytes.as_slice().try_into().unwrap();
 
         assert_eq!(decoded.doc_type(), uuid_v4);
         assert_eq!(decoded.doc_id(), uuid_v7);