Struct CredentialV2 

#[non_exhaustive]
pub struct CredentialV2 {
    pub context: Context,
    pub id: Option<Uri>,
    pub types: OneOrMany<String>,
    pub name: Option<Value>,
    pub description: Option<Value>,
    pub issuer: Party,
    pub valid_from: Option<DateTime<Utc>>,
    pub valid_until: Option<DateTime<Utc>>,
    pub credential_status: Option<OneOrMany<TypedObject>>,
    pub credential_subject: OneOrMany<Subject>,
    pub credential_schema: Option<OneOrMany<TypedObject>>,
    pub properties: IndexMap<String, Value>,
}

Available on crate feature vc only.

A verifiable credential of the Verifiable Credentials Data Model 2.0, as data.

Secured per VC-JOSE-COSE, the credential itself is the JWT payload: @context and the other properties are claims next to the registered ones, with typ: vc+jwt in the header. See to_jwt_claims.

Deserialization checks that the first @context is the base context, type includes VerifiableCredential, there is a subject, and validUntil is not before validFrom.

Examples

use chrono::{TimeZone as _, Utc};
use identity_kit::did::Uri;
use identity_kit::vc::{CredentialV2, Subject};
use serde_json::json;

let credential = CredentialV2::new(
    Uri::parse("https://university.example/issuers/14")?,
    Subject::new(Uri::parse("did:example:ebfeb1f712ebc6f1c276e12ec21")?)
        .with_property("degree", json!({ "type": "ExampleBachelorDegree" })),
)
.with_type("ExampleDegreeCredential")
.with_valid_from(Utc.with_ymd_and_hms(2010, 1, 1, 19, 23, 24).unwrap());

let claims = credential.to_jwt_claims();
assert_eq!(claims.additional["validFrom"], "2010-01-01T19:23:24Z");
assert_eq!(CredentialV2::from_jwt_claims(&claims)?, credential);

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

context: Context

@context, starting with CredentialV2::CONTEXT.

id: Option<Uri>

The identifier of the credential.

types: OneOrMany<String>

type, including CredentialV2::TYPE.

name: Option<Value>

name: a string or language-tagged values, kept as JSON.

description: Option<Value>

description: a string or language-tagged values, kept as JSON.

issuer: Party

The issuer.

valid_from: Option<DateTime<Utc>>

When the credential becomes valid.

valid_until: Option<DateTime<Utc>>

When the credential ceases to be valid.

credential_status: Option<OneOrMany<TypedObject>>

credentialStatus: where to learn whether the credential is revoked or suspended.

credential_subject: OneOrMany<Subject>

The subjects and the claims about them.

credential_schema: Option<OneOrMany<TypedObject>>

credentialSchema.

properties: IndexMap<String, Value>

Every other property (relatedResource, termsOfUse, evidence, refreshService, …), in insertion order.

Implementations

impl CredentialV2

pub fn serialize<__S>( __self: &CredentialV2, __serializer: __S, ) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

impl<'de> CredentialV2

pub fn deserialize<__D>(__deserializer: __D) -> Result<CredentialV2, __D::Error>

where __D: Deserializer<'de>,

impl CredentialV2

pub const CONTEXT: &'static str = CONTEXT_V2

The base context, https://www.w3.org/ns/credentials/v2.

pub const TYPE: &'static str = "VerifiableCredential"

The type every credential has, VerifiableCredential.

pub const JWT_TYP: &'static str = "vc+jwt"

The typ of a JWT securing a credential, vc+jwt.

pub const JWT_MEDIA_TYPE: &'static str = "application/vc+jwt"

The media type of a JWT securing a credential, application/vc+jwt.

pub fn new(issuer: impl Into<Party>, subject: Subject) -> Self

A credential of type VerifiableCredential in the base context, issued by issuer about subject, valid indefinitely.

pub fn with_context(self, context: impl Into<String>) -> Self

This credential with context appended to its @context.

pub fn with_id(self, id: impl Into<Uri>) -> Self

This credential with its id set.

pub fn with_type(self, credential_type: impl Into<String>) -> Self

This credential with credential_type appended to its type.

pub fn with_name(self, name: impl Into<Value>) -> Self

This credential with its name set.

pub fn with_description(self, description: impl Into<Value>) -> Self

This credential with its description set.

pub fn with_valid_from(self, valid_from: DateTime<Utc>) -> Self

This credential with its validFrom set.

pub fn with_valid_until(self, valid_until: DateTime<Utc>) -> Self

This credential with its validUntil set.

pub fn with_subject(self, subject: Subject) -> Self

This credential with another subject.

pub fn with_status(self, status: TypedObject) -> Self

This credential with a credentialStatus added.

pub fn with_schema(self, schema: TypedObject) -> Self

This credential with a credentialSchema added.

pub fn with_property( self, name: impl Into<String>, value: impl Into<Value>, ) -> Self

This credential with the property name set to value.

pub fn subject(&self) -> Option<&Subject>

The one subject, when there is exactly one.

pub fn has_type(&self, credential_type: &str) -> bool

Whether credential_type is among the types.

pub fn statuses(&self) -> impl Iterator<Item = &TypedObject>

The status entries, in order; none when credentialStatus is absent.

pub fn check(&self) -> Result<(), CredentialError>

Checks the structural requirements of the data model: the first @context is the base context, type includes VerifiableCredential, there is a subject, and validUntil is not before validFrom.

Errors

The first CredentialError found.

pub fn to_jwt_claims(&self) -> JwtClaims

The JWT claims set securing the credential (VC-JOSE-COSE §3.1.1): the credential’s own properties, nothing else. iss, jti, sub, iat and exp are the caller’s to add and must agree with the credential when they are.

pub fn from_jwt_claims(jwt_claims: &JwtClaims) -> Result<Self, CredentialError>

The credential a JWT claims set secures: its non-registered claims, with iss, jti and sub, when present, checked against issuer, id and the subject.

Errors

CredentialError::InvalidClaim when the claims hold a vc claim or do not form a credential, CredentialError::ClaimMismatch when a registered claim disagrees with the property it duplicates, and what check reports.

Trait Implementations

impl Clone for CredentialV2

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CredentialV2

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CredentialV2

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Reads the credential and checks it with CredentialV2::check.

impl Eq for CredentialV2

impl PartialEq for CredentialV2

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialSchema for CredentialV2

Available on crate feature utoipa only.

fn schema() -> RefOr<Schema>

Return ref or schema of implementing type that can then be used to construct combined schemas.

impl Serialize for CredentialV2

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CredentialV2

impl ToSchema for CredentialV2

Available on crate feature utoipa only.

fn name() -> Cow<'static, str>

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference utoipa::openapi::schema::Schemas for this type.