input-output-hk
diff --git a/‎rust/Earthfile‎
Lines changed: 2 additions & 0 deletions b/‎rust/Earthfile‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎rust/signed_doc/Cargo.toml‎
Lines changed: 1 addition & 5 deletions b/‎rust/signed_doc/Cargo.toml‎
Lines changed: 1 addition & 5 deletions
diff --git a/‎rust/signed_doc/examples/mk_signed_doc.rs‎
Lines changed: 14 additions & 9 deletions b/‎rust/signed_doc/examples/mk_signed_doc.rs‎
Lines changed: 14 additions & 9 deletions
diff --git a/‎rust/signed_doc/src/builder.rs‎
Lines changed: 42 additions & 68 deletions b/‎rust/signed_doc/src/builder.rs‎
Lines changed: 42 additions & 68 deletions
diff --git a/‎rust/signed_doc/src/content.rs‎
Lines changed: 14 additions & 28 deletions b/‎rust/signed_doc/src/content.rs‎
Lines changed: 14 additions & 28 deletions
@@ -67,6 +67,8 @@ build:
 
     SAVE ARTIFACT target/doc doc
     SAVE ARTIFACT target/release/cbork cbork
+    # Catalyst Signed Documents cli tool
+    SAVE ARTIFACT target/release/examples/mk_signed_doc mk_signed_doc
 
 # build-src-check: Check for any caching issues with the source we are building against.
 check-builder-src-cache:
 
@@ -30,8 +30,4 @@ futures = "0.3.31"
 base64-url = "3.0.0"
 rand = "0.8.5"
 tokio = { version = "1.42.0", features = [ "macros" ] }
-ed25519-dalek = { version = "2.1.1", features = ["rand_core"] }
-
-[[bin]]
-name = "signed-docs"
-path = "examples/mk_signed_doc.rs"
+ed25519-dalek = { version = "2.1.1", features = ["rand_core", "pem"] }
@@ -9,7 +9,7 @@ use std::{
 };
 
 use anyhow::Context;
-use catalyst_signed_doc::{Builder, CatalystSignedDocument, IdUri, Metadata};
+use catalyst_signed_doc::{Builder, CatalystSignedDocument, IdUri};
 use clap::Parser;
 use ed25519_dalek::pkcs8::DecodePrivateKey;
 
@@ -59,8 +59,8 @@ impl Cli {
         match self {
             Self::Build { doc, output, meta } => {
                 // Load Metadata from JSON file
-                let metadata: Metadata = load_json_from_file(&meta)
-                    .map_err(|e| anyhow::anyhow!("Failed to load metadata from file: {e}"))?;
+                let metadata: serde_json::Value =
+                    load_json_from_file(&meta).context("Failed to load metadata from file")?;
                 println!("{metadata}");
                 // Load Document from JSON file
                 let json_doc: serde_json::Value = load_json_from_file(&doc)?;
@@ -69,17 +69,22 @@ impl Cli {
                 // Start with no signatures.
                 let signed_doc = Builder::new()
                     .with_decoded_content(payload)
-                    .with_metadata(metadata)
-                    .build()?;
+                    .with_json_metadata(metadata)?
+                    .build();
+                println!(
+                    "report {}",
+                    serde_json::to_string(&signed_doc.problem_report())?
+                );
                 save_signed_doc(signed_doc, &output)?;
             },
             Self::Sign { sk, doc, kid } => {
-                let sk = load_secret_key_from_file(&sk)
-                    .map_err(|e| anyhow::anyhow!("Failed to load SK FILE: {e}"))?;
+                let sk = load_secret_key_from_file(&sk).context("Failed to load SK FILE")?;
                 let cose_bytes = read_bytes_from_file(&doc)?;
                 let signed_doc = signed_doc_from_bytes(cose_bytes.as_slice())?;
-                let builder = signed_doc.into_builder()?;
-                let new_signed_doc = builder.add_signature(sk.to_bytes(), kid)?.build()?;
+                let new_signed_doc = signed_doc
+                    .into_builder()
+                    .add_signature(sk.to_bytes(), kid)?
+                    .build();
                 save_signed_doc(new_signed_doc, &doc)?;
             },
             Self::Inspect { path } => {
 
@@ -8,50 +8,43 @@ use crate::{
 };
 
 /// Catalyst Signed Document Builder.
-#[derive(Debug, Default, Clone)]
-pub struct Builder {
-    /// Document Metadata
-    metadata: Option<Metadata>,
-    /// Document Content
-    content: Option<Vec<u8>>,
-    /// Signatures
-    signatures: Signatures,
+#[derive(Debug)]
+pub struct Builder(InnerCatalystSignedDocument);
+
+impl Default for Builder {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 impl Builder {
     /// Start building a signed document
     #[must_use]
     pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Set document metadata
-    #[must_use]
-    pub fn with_metadata(mut self, metadata: Metadata) -> Self {
-        self.metadata = Some(metadata);
-        self
+        let report = ProblemReport::new(PROBLEM_REPORT_CTX);
+        Self(InnerCatalystSignedDocument {
+            report,
+            metadata: Metadata::default(),
+            content: Content::default(),
+            signatures: Signatures::default(),
+        })
     }
 
     /// Set document metadata in JSON format
+    /// Collect problem report if some fields are missing.
     ///
     /// # Errors
-    /// - Fails if it is invalid metadata JSON object.
+    /// - Fails if it is invalid metadata fields JSON object.
     pub fn with_json_metadata(mut self, json: serde_json::Value) -> anyhow::Result<Self> {
-        self.metadata = Some(serde_json::from_value(json)?);
+        let metadata = serde_json::from_value(json)?;
+        self.0.metadata = Metadata::from_metadata_fields(metadata, &self.0.report);
         Ok(self)
     }
 
     /// Set decoded (original) document content bytes
     #[must_use]
     pub fn with_decoded_content(mut self, content: Vec<u8>) -> Self {
-        self.content = Some(content);
-        self
-    }
-
-    /// Set document signatures
-    #[must_use]
-    pub fn with_signatures(mut self, signatures: Signatures) -> Self {
-        self.signatures = signatures;
+        self.0.content = Content::from_decoded(content);
         self
     }
 
@@ -62,59 +55,40 @@ impl Builder {
     /// Fails if a `CatalystSignedDocument` cannot be created due to missing metadata or
     /// content, due to malformed data, or when the signed document cannot be
     /// converted into `coset::CoseSign`.
-    pub fn add_signature(self, sk: SecretKey, kid: IdUri) -> anyhow::Result<Self> {
+    pub fn add_signature(mut self, sk: SecretKey, kid: IdUri) -> anyhow::Result<Self> {
         let cose_sign = self
-            .clone()
-            .build()
-            .map_err(|e| anyhow::anyhow!("Failed to sign: {e}"))?
+            .0
             .as_cose_sign()
             .map_err(|e| anyhow::anyhow!("Failed to sign: {e}"))?;
-        let Self {
-            metadata: Some(metadata),
-            content: Some(content),
-            mut signatures,
-        } = self
-        else {
-            anyhow::bail!("Metadata and Content are needed for signing");
-        };
+
         let sk = ed25519_dalek::SigningKey::from_bytes(&sk);
-        let protected_header = coset::HeaderBuilder::new()
-            .key_id(kid.to_string().into_bytes())
-            .algorithm(metadata.algorithm()?.into());
+        let protected_header = coset::HeaderBuilder::new().key_id(kid.to_string().into_bytes());
+
         let mut signature = coset::CoseSignatureBuilder::new()
             .protected(protected_header.build())
             .build();
         let data_to_sign = cose_sign.tbs_data(&[], &signature);
         signature.signature = sk.sign(&data_to_sign).to_vec();
-        signatures.push(kid, signature);
-        Ok(Self::new()
-            .with_decoded_content(content)
-            .with_metadata(metadata)
-            .with_signatures(signatures))
+        self.0.signatures.push(kid, signature);
+
+        Ok(self)
     }
 
-    /// Build a signed document
-    ///
-    /// ## Errors
-    ///
-    /// Fails if any of the fields are missing.
-    pub fn build(self) -> anyhow::Result<CatalystSignedDocument> {
-        let Some(metadata) = self.metadata else {
-            anyhow::bail!("Failed to build Catalyst Signed Document, missing metadata");
-        };
-        let Some(content) = self.content else {
-            anyhow::bail!("Failed to build Catalyst Signed Document, missing document's content");
-        };
-        let signatures = self.signatures;
-        let content = Content::from_decoded(content, metadata.content_type()?)?;
+    /// Build a signed document with the collected error report.
+    /// Could provide an invalid document.
+    #[must_use]
+    pub fn build(self) -> CatalystSignedDocument {
+        self.0.into()
+    }
+}
 
-        let empty_report = ProblemReport::new(PROBLEM_REPORT_CTX);
-        Ok(InnerCatalystSignedDocument {
-            metadata,
-            content,
-            signatures,
-            report: empty_report,
-        }
-        .into())
+impl From<&CatalystSignedDocument> for Builder {
+    fn from(value: &CatalystSignedDocument) -> Self {
+        Self(InnerCatalystSignedDocument {
+            metadata: value.inner.metadata.clone(),
+            content: value.inner.content.clone(),
+            signatures: value.inner.signatures.clone(),
+            report: value.inner.report.clone(),
+        })
     }
 }
@@ -1,8 +1,9 @@
 //! Catalyst Signed Document Content Payload
 
+use anyhow::Context;
 use catalyst_types::problem_report::ProblemReport;
 
-use crate::metadata::{ContentEncoding, ContentType};
+use crate::metadata::ContentEncoding;
 
 /// Decompressed Document Content type bytes.
 #[derive(Debug, Clone, PartialEq, Default)]
@@ -16,8 +17,7 @@ impl Content {
     /// verifies a Document's content, that it is correctly encoded and it corresponds and
     /// parsed to the specified type
     pub(crate) fn from_encoded(
-        mut data: Vec<u8>, content_type: Option<ContentType>,
-        content_encoding: Option<ContentEncoding>, report: &ProblemReport,
+        mut data: Vec<u8>, content_encoding: Option<ContentEncoding>, report: &ProblemReport,
     ) -> Self {
         if let Some(content_encoding) = content_encoding {
             if let Ok(decoded_data) = content_encoding.decode(&data) {
@@ -32,29 +32,12 @@ impl Content {
                 return Self::default();
             }
         }
-        if let Some(content_type) = content_type {
-            if content_type.validate(&data).is_err() {
-                report.invalid_value(
-                    "payload",
-                    &hex::encode(&data),
-                    &format!("Invalid Document content type, should {content_type} encodable"),
-                    "Invalid Document content type.",
-                );
-                return Self::default();
-            }
-        }
-
-        Self { data: Some(data) }
+        Self::from_decoded(data)
     }
 
     /// Creates a new `Content` value, from the decoded (original) data.
-    /// verifies that it corresponds and parsed to the specified type.
-    ///
-    /// # Errors
-    /// Returns an error if content is not correctly encoded
-    pub(crate) fn from_decoded(data: Vec<u8>, content_type: ContentType) -> anyhow::Result<Self> {
-        content_type.validate(&data)?;
-        Ok(Self { data: Some(data) })
+    pub(crate) fn from_decoded(data: Vec<u8>) -> Self {
+        Self { data: Some(data) }
     }
 
     /// Return an decoded (original) content bytes.
@@ -74,13 +57,16 @@ impl Content {
     ///  - Missing Document content
     ///  - Failed to encode content.
     pub(crate) fn encoded_bytes(
-        &self, content_encoding: ContentEncoding,
+        &self, content_encoding: Option<ContentEncoding>,
     ) -> anyhow::Result<Vec<u8>> {
         let content = self.decoded_bytes()?;
-        let data = content_encoding
-            .encode(content)
-            .map_err(|e| anyhow::anyhow!("Failed to encode {content_encoding} content: {e}"))?;
-        Ok(data)
+        if let Some(content_encoding) = content_encoding {
+            content_encoding
+                .encode(content)
+                .context(format!("Failed to encode {content_encoding} content"))
+        } else {
+            Ok(content.to_vec())
+        }
     }
 
     /// Return content byte size.