wip

Author: Mr-Leshiy

rust/catalyst-signed-doc-spec/Cargo.toml

@@ -12,6 +12,7 @@ workspace = true
 
 [dependencies]
 catalyst-types = { version = "0.0.11", git = "https://github.com/input-output-hk/catalyst-libs.git", branch = "feat/json-schema-to-catalyst-types" }
+cbork-cddl-parser = { version = "0.0.3", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "cbork-cddl-parser/v0.0.3" }
 
 serde_json = "1.0.142"
 anyhow = "1.0.99"

rust/catalyst-signed-doc-spec/src/cddl_definitions.rs

@@ -0,0 +1,57 @@
+//! 'cddlDefinitions' field definition
+
+use std::{collections::HashMap, fmt::Display};
+
+use cbork_cddl_parser::validate_cddl;
+
+#[derive(serde::Deserialize)]
+pub struct CddlDefitions(HashMap<CddlType, CddlDef>);
+
+#[derive(serde::Deserialize, PartialEq, Eq, Hash)]
+pub struct CddlType(String);
+
+#[derive(serde::Deserialize)]
+struct CddlDef {
+    def: String,
+    requires: Vec<CddlType>,
+}
+
+impl Display for CddlType {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl CddlDefitions {
+    /// Returns a full CDDL specification schema.
+    /// Performs
+    pub fn get_cddl_spec(
+        &self,
+        cddl_type: &CddlType,
+    ) -> anyhow::Result<String> {
+        let def = self.0.get(cddl_type).ok_or(anyhow::anyhow!(
+            "Cannot find a cddl defition for the {cddl_type}"
+        ))?;
+
+        let mut spec = def
+            .requires
+            .iter()
+            .enumerate()
+            // replace `requires[i]` entries with the proper CDDL type names from the `requires`
+            // list
+            .fold(def.def.clone(), |spec, (i, req)| {
+                spec.replace(&format!("requires[{i}]"), &req.0)
+            });
+
+        for req in &def.requires {
+            let req_spec = self.get_cddl_spec(req)?;
+            spec.push_str(&req_spec);
+        }
+
+        validate_cddl(&mut spec, &cbork_cddl_parser::Extension::CDDL)?;
+        Ok(spec)
+    }
+}

rust/catalyst-signed-doc-spec/src/lib.rs

@@ -2,7 +2,8 @@
 
 #![allow(missing_docs, clippy::missing_docs_in_private_items)]
 
-pub mod copyright;
+pub mod cddl_definitions;
+mod copyright;
 pub mod doc_types;
 pub mod headers;
 pub mod is_required;
@@ -15,16 +16,19 @@ use std::{collections::HashMap, fmt::Display, ops::Deref};
 use build_info as build_info_lib;
 
 use crate::{
-    copyright::Copyright, headers::Headers, metadata::Metadata, payload::Payload, signers::Signers,
+    cddl_definitions::CddlDefitions, copyright::Copyright, headers::Headers, metadata::Metadata,
+    payload::Payload, signers::Signers,
 };
 
 build_info_lib::build_info!(pub(crate) fn build_info);
 
 /// Catalyst Signed Document spec representation struct
 #[derive(serde::Deserialize)]
 pub struct CatalystSignedDocSpec {
-    pub docs: DocSpecs,
+    #[serde(rename = "cddlDefinitions")]
+    pub cddl_definitions: CddlDefitions,
     copyright: Copyright,
+    pub docs: DocSpecs,
 }
 
 #[derive(serde::Deserialize)]

rust/catalyst-signed-doc-spec/src/payload.rs

@@ -3,6 +3,8 @@
 use catalyst_types::json_schema::JsonSchema;
 use serde::Deserialize;
 
+use crate::cddl_definitions::CddlType;
+
 /// `signed_doc.json` "payload" field JSON object
 #[derive(serde::Deserialize)]
 #[allow(clippy::missing_docs_in_private_items)]
@@ -12,7 +14,7 @@ pub struct Payload {
 }
 
 pub enum Schema {
-    Cddl(String),
+    Cddl(CddlType),
     Json(JsonSchema),
 }
 
@@ -22,17 +24,17 @@ impl<'de> Deserialize<'de> for Schema {
         #[derive(serde::Deserialize)]
         #[serde(untagged)]
         pub enum SchemaSerde {
-            Cddl(String),
+            Cddl(CddlType),
             Json(serde_json::Value),
         }
 
         match SchemaSerde::deserialize(deserializer)? {
-            SchemaSerde::Json(schema) => {
-                JsonSchema::try_from(&schema)
+            SchemaSerde::Json(json) => {
+                JsonSchema::try_from(&json)
                     .map(|v| Self::Json(v))
                     .map_err(|e| serde::de::Error::custom(e))
             },
-            SchemaSerde::Cddl(schema) => Ok(Self::Cddl(schema)),
+            SchemaSerde::Cddl(cddl_type) => Ok(Self::Cddl(cddl_type)),
         }
     }
 }

rust/signed_doc/src/validator/rules/content/mod.rs

@@ -5,7 +5,10 @@ mod tests;
 
 use std::fmt::Debug;
 
-use catalyst_signed_doc_spec::payload::{Payload, Schema};
+use catalyst_signed_doc_spec::{
+    cddl_definitions::CddlDefitions,
+    payload::{Payload, Schema},
+};
 use catalyst_types::json_schema::JsonSchema;
 use minicbor::Encode;
 
@@ -45,7 +48,10 @@ pub(crate) enum ContentRule {
 
 impl ContentRule {
     /// Generating `ContentRule` from specs
-    pub(crate) fn new(spec: &Payload) -> anyhow::Result<Self> {
+    pub(crate) fn new(
+        cddl_def: &CddlDefitions,
+        spec: &Payload,
+    ) -> anyhow::Result<Self> {
         if spec.nil {
             anyhow::ensure!(
             spec.schema.is_none(),
@@ -58,7 +64,11 @@ impl ContentRule {
             Some(Schema::Json(schema)) => {
                 Ok(Self::StaticSchema(ContentSchema::Json(schema.clone())))
             },
-            Some(Schema::Cddl(_)) => Ok(Self::StaticSchema(ContentSchema::Cddl)),
+            Some(Schema::Cddl(cddl_type)) => {
+                cddl_def
+                    .get_cddl_spec(cddl_type)
+                    .map(|_| Self::StaticSchema(ContentSchema::Cddl))
+            },
             None => Ok(Self::NotNil),
         }
     }

rust/signed_doc/src/validator/rules/mod.rs

@@ -2,7 +2,7 @@
 //! <https://input-output-hk.github.io/catalyst-libs/architecture/08_concepts/signed_doc/meta/>
 
 use anyhow::Context;
-use catalyst_signed_doc_spec::{DocSpec, DocSpecs};
+use catalyst_signed_doc_spec::{cddl_definitions::CddlDefitions, DocSpec, DocSpecs};
 use futures::FutureExt;
 
 use crate::{
@@ -118,6 +118,7 @@ impl Rules {
 
     /// Creating a `Rules` instance from the provided specs.
     fn new(
+        cddl_defs: &CddlDefitions,
         all_docs_specs: &DocSpecs,
         doc_spec: &DocSpec,
     ) -> anyhow::Result<Self> {
@@ -133,7 +134,7 @@ impl Rules {
             reply: ReplyRule::new(all_docs_specs, &doc_spec.metadata.reply)?,
             section: SectionRule::NotSpecified,
             collaborators: CollaboratorsRule::new(&doc_spec.metadata.collaborators),
-            content: ContentRule::new(&doc_spec.payload)?,
+            content: ContentRule::new(cddl_defs, &doc_spec.payload)?,
             kid: SignatureKidRule::new(&doc_spec.signers.roles)?,
             signature: SignatureRule,
             ownership: DocumentOwnershipRule::new(&doc_spec.signers.update, doc_spec)?,
@@ -157,7 +158,7 @@ impl Rules {
                 continue;
             }
 
-            let rules = Self::new(&spec.docs, doc_spec)
+            let rules = Self::new(&spec.cddl_definitions, &spec.docs, doc_spec)
                 .context(format!("Fail to initializing document '{doc_name}'"))?;
             let doc_type = doc_spec.doc_type.parse()?;