claim metadata

identity_credential/src/sd_jwt_vc/metadata/claim.rs

@@ -0,0 +1,104 @@
+use std::ops::Deref;
+
+use serde::Deserialize;
+use serde::Serialize;
+use serde::Serializer;
+use serde_json::Value;
+
+/// Information about a particular claim for displaying and validation purposes.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ClaimMetadata {
+  /// [`ClaimPath`] of the claim or claims that are being addressed.
+  pub path: ClaimPath,
+  /// Object containing display information for the claim.
+  #[serde(skip_serializing_if = "Vec::is_empty", default)]
+  pub display: Vec<ClaimDisplay>,
+  /// A string indicating whether the claim is selectively disclosable.
+  pub sd: Option<ClaimDisclosability>,
+  /// A string defining the ID of the claim for reference in the SVG template.
+  pub svg_id: Option<String>,
+}
+
+/// A non-empty list of string, `null` values, or non-negative integers.
+/// It is used to selected a particular claim in the credential or a
+/// set of claims. See [Claim Path](https://www.ietf.org/archive/id/draft-ietf-oauth-sd-jwt-vc-05.html#name-claim-path) for more information.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(try_from = "Vec<ClaimPathSegment>")]
+pub struct ClaimPath(Vec<ClaimPathSegment>);
+
+impl TryFrom<Vec<ClaimPathSegment>> for ClaimPath {
+  type Error = anyhow::Error;
+  fn try_from(value: Vec<ClaimPathSegment>) -> Result<Self, Self::Error> {
+    if value.is_empty() {
+      Err(anyhow::anyhow!("`ClaimPath` cannot be empty"))
+    } else {
+      Ok(Self(value))
+    }
+  }
+}
+
+impl Deref for ClaimPath {
+  type Target = [ClaimPathSegment];
+  fn deref(&self) -> &Self::Target {
+    &self.0
+  }
+}
+
+/// A single segment of a [`ClaimPath`].
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(untagged, try_from = "Value")]
+pub enum ClaimPathSegment {
+  /// JSON object property.
+  Name(String),
+  /// JSON array entry.
+  Position(usize),
+  /// All properties or entries.
+  #[serde(serialize_with = "serialize_all_variant")]
+  All,
+}
+
+impl TryFrom<Value> for ClaimPathSegment {
+  type Error = anyhow::Error;
+  fn try_from(value: Value) -> Result<Self, Self::Error> {
+    match value {
+      Value::Null => Ok(ClaimPathSegment::All),
+      Value::String(s) => Ok(ClaimPathSegment::Name(s)),
+      Value::Number(n) => n
+        .as_u64()
+        .ok_or_else(|| anyhow::anyhow!("expected number greater or equal to 0"))
+        .map(|n| ClaimPathSegment::Position(n as usize)),
+      _ => Err(anyhow::anyhow!("expected either a string, number, or null")),
+    }
+  }
+}
+
+fn serialize_all_variant<S>(serializer: S) -> Result<S::Ok, S::Error>
+where
+  S: Serializer,
+{
+  serializer.serialize_none()
+}
+
+/// Information about whether a given claim is selectively disclosable.
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ClaimDisclosability {
+  /// The issuer **must** make the claim selectively disclosable.
+  Always,
+  /// The issuer **may** make the claim selectively disclosable.
+  #[default]
+  Allowed,
+  /// The issuer **must not** make the claim selectively disclosable.
+  Never,
+}
+
+/// Display information for a given claim.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ClaimDisplay {
+  /// A language tag as defined in [RFC5646](https://www.rfc-editor.org/rfc/rfc5646.txt).
+  pub lang: String,
+  /// A human-readable label for the claim.
+  pub label: String,
+  /// A human-readable description for the claim.
+  pub description: Option<String>,
+}

identity_credential/src/sd_jwt_vc/metadata/mod.rs

@@ -1,11 +1,13 @@
 // Copyright 2020-2024 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
+mod claim;
 mod display;
 mod integrity;
 mod issuer;
 mod vc_type;
 
+pub use claim::*;
 pub use display::*;
 pub use integrity::*;
 pub use issuer::*;

identity_credential/src/sd_jwt_vc/metadata/vc_type.rs

@@ -10,6 +10,7 @@ use crate::sd_jwt_vc::Error;
 use crate::sd_jwt_vc::Resolver;
 use crate::sd_jwt_vc::Result;
 
+use super::ClaimMetadata;
 use super::DisplayMetadata;
 use super::IntegrityMetadata;
 
@@ -31,8 +32,12 @@ pub struct TypeMetadata {
   /// Either an embedded schema or a reference to one.
   #[serde(flatten)]
   pub schema: Option<TypeSchema>,
-  /// An object containing display information for the type.
-  pub display: Option<DisplayMetadata>,
+  /// A list containing display information for the type.
+  #[serde(skip_serializing_if = "Vec::is_empty", default)]
+  pub display: Vec<DisplayMetadata>,
+  /// A list of [`ClaimMetadata`] containing information about particular claims.
+  #[serde(skip_serializing_if = "Vec::is_empty", default)]
+  pub claims: Vec<ClaimMetadata>,
 }
 
 impl TypeMetadata {
@@ -186,7 +191,8 @@ mod tests {
     description: None,
     extends: None,
     extends_integrity: None,
-    display: None,
+    display: vec![],
+    claims: vec![],
     schema: Some(TypeSchema::Object {
       schema: json!({
         "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -209,7 +215,8 @@ mod tests {
     description: None,
     extends: None,
     extends_integrity: None,
-    display: None,
+    display: vec![],
+    claims: vec![],
     schema: Some(TypeSchema::Uri {
       schema_uri: Url::parse("https://example.com/vc_types/1").unwrap(),
       schema_uri_integrity: None,