Struct Credential 

#[non_exhaustive]
pub struct Credential {

    pub context: Context,
    pub id: Option<Uri>,
    pub types: OneOrMany<String>,
    pub issuer: Party,
    pub issuance_date: DateTime<Utc>,
    pub expiration_date: Option<DateTime<Utc>>,
    pub credential_subject: OneOrMany<Subject>,
    pub credential_status: Option<TypedObject>,
    pub credential_schema: Option<OneOrMany<TypedObject>>,
    pub refresh_service: Option<OneOrMany<TypedObject>>,
    pub terms_of_use: Option<OneOrMany<TypedObject>>,
    pub evidence: Option<OneOrMany<TypedObject>>,
    pub properties: IndexMap<String, Value>,
}

Available on crate feature vc only.

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

The properties the data model defines are fields; everything else, proof included, lives in properties in insertion order. Deserialization checks the structural requirements of the data model: the first @context is the base context, type includes VerifiableCredential, there is at least one subject. Nothing is verified: a credential is secured by signing its JWT form, see to_jwt_claims.

Examples

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

// VCDM 1.1 Example 1, as data.
let credential = Credential::new(
    Uri::parse("https://example.edu/issuers/565049")?,
    Utc.with_ymd_and_hms(2010, 1, 1, 0, 0, 0).unwrap(),
    Subject::new(Uri::parse("did:example:ebfeb1f712ebc6f1c276e12ec21")?)
        .with_property("alumniOf", json!({ "id": "did:example:c276e12ec21ebfeb1f712ebc6f1" })),
)
.with_context("https://www.w3.org/2018/credentials/examples/v1")
.with_id(Uri::parse("http://example.edu/credentials/1872")?)
.with_type("AlumniCredential");

let json = serde_json::to_value(&credential)?;
assert_eq!(json["type"], json!(["VerifiableCredential", "AlumniCredential"]));
assert_eq!(json["issuanceDate"], "2010-01-01T00:00:00Z");
assert_eq!(serde_json::from_value::<Credential>(json)?, 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 Credential::CONTEXT.

id: Option<Uri>

The identifier of the credential.

types: OneOrMany<String>

type, including Credential::TYPE.

issuer: Party

The issuer.

issuance_date: DateTime<Utc>

When the credential becomes valid.

expiration_date: Option<DateTime<Utc>>

When the credential ceases to be valid.

credential_subject: OneOrMany<Subject>

The subjects and the claims about them; one, in a credential that has a JWT form.

credential_status: Option<TypedObject>

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

credential_schema: Option<OneOrMany<TypedObject>>

credentialSchema.

refresh_service: Option<OneOrMany<TypedObject>>

refreshService.

terms_of_use: Option<OneOrMany<TypedObject>>

termsOfUse.

evidence: Option<OneOrMany<TypedObject>>

evidence.

properties: IndexMap<String, Value>

Every other property, in insertion order.

Implementations

impl Credential

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

where __S: Serializer,

impl<'de> Credential

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

where __D: Deserializer<'de>,

impl Credential

pub const CONTEXT: &'static str = CONTEXT_V1

The base context, https://www.w3.org/2018/credentials/v1.

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

The type every credential has, VerifiableCredential.

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

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

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_expiration_date(self, expiration_date: DateTime<Utc>) -> Self

This credential with its expirationDate 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 its credentialStatus set.

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

This credential with a credentialSchema added.

pub fn with_terms_of_use(self, terms: TypedObject) -> Self

This credential with a termsOfUse added.

pub fn with_evidence(self, evidence: TypedObject) -> Self

This credential with an evidence 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 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 expirationDate is not before issuanceDate.

Errors

The first CredentialError found.

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

The JWT claims set of the credential (VCDM 1.1 §6.3.1 “JWT Encoding”): iss is the issuer, jti the id, nbf the issuance date, exp the expiration date, sub the id of the subject, and the credential without those properties is the vc claim. An issuer object stays in vc, as iss carries only its id. A NumericDate counts whole seconds, so a fraction of a second or a leap second in a date is dropped from nbf and exp.

Errors

What check reports, and CredentialError::MultipleSubjects for a credential with several subjects, which a JWT cannot express.

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

The credential of a JWT claims set (VCDM 1.1 §6.3.1 “JWT Decoding”): the vc claim with iss, jti, nbf, exp and sub mapped back to its properties. A property present in both places must agree with the claim.

Errors

CredentialError::MissingClaim without a vc claim, CredentialError::InvalidClaim when a claim or the credential it yields is malformed, CredentialError::ClaimMismatch when a claim and its property disagree, and what check reports.

Trait Implementations

impl Clone for Credential

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 Credential

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Credential

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

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

impl Eq for Credential

impl PartialEq for Credential

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

Equality operator ==.

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

Inequality operator !=.

impl PartialSchema for Credential

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 Credential

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Credential

impl ToSchema for Credential

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.