Skip to main content

Trust Model (VCDM 2.0)

Under development

VCDM 2.0 support in the Authorisation service is still under development. It is currently available on the test network only, and will be supported in the other environments in the future.

The VCDM 2.0 trust model is the issuer trust model for VCDM 2.0 credentials. It keeps the same actors and the same registry (the Issuers Registry) as the VCDM 1.1 trust model, but makes the chain explicit: every credential names its parent accreditation and the root authorisation, and carries a typed policy.

Both models coexist

Each credential is validated with the trust model of its VCDM version. VCDM 1.1 remains the default, and no deprecation date has been announced. A Verifiable Presentation is of one version only, and so are the credentials inside it.

In short: accreditations carry a typed policy in termsOfUse, link directly to the root authorisation, and the role of an entity is checked against the on-chain issuerType. See Differences from VCDM 1.1 for the full comparison.

Credentials and policies​

The roles and the permission credentials are the same as in VCDM 1.1:

RolePermission credentialtermsOfUse.typePolicy fields
Root TAOVerifiableAuthorisationForTrustChainTrustFrameworkPolicytrustFramework, policyId, legalBasis (optional)
TAOVerifiableAccreditationToAccreditAccreditationPolicyparentAccreditation, rootAuthorisation
TIVerifiableAccreditationToAttestAccreditationPolicyparentAccreditation, rootAuthorisation
Domain VC (issued by a TI or the Support Office seed; onboarding VCs also by a TAO)—AttestationPolicyparentAccreditation, rootAuthorisation
note

TrustFrameworkPolicy belongs to the Root TAO's VerifiableAuthorisationForTrustChain, not to domain credentials. Domain credentials carry an AttestationPolicy.

Each trust model credential stored in the Issuers Registry carries the policy of its kind, and nothing else: a VerifiableAuthorisationForTrustChain has a single TrustFrameworkPolicy, and a VerifiableAccreditationToAccredit or VerifiableAccreditationToAttest a single AccreditationPolicy. The Trust Model schema and the role check enforce it. Domain and onboarding credentials should carry AttestationPolicy entries; for the credential being verified, the verifier accepts either an AccreditationPolicy or an AttestationPolicy (or a single TrustFrameworkPolicy) and follows each entry: the credential's own type doesn't have to match the kind of policy.

  • A Trust Framework Policy links to a regulation, directive, national policy or similar document that defines the requirements for the trust chain. trustFramework names the framework, policyId identifies the policy and legalBasis gives its legal basis.
  • parentAccreditation and rootAuthorisation are Issuers Registry attribute URLs. parentAccreditation is the accreditation of the issuer. rootAuthorisation is the Root TAO's VerifiableAuthorisationForTrustChain of the chain.
  • credentialSubject.permissionFor[] lists what the subject may do: { schemaId, types, jurisdiction }. jurisdiction is a string or an array of strings.

All trust model credentials must also contain:

  • validUntil;
  • credentialSubject.reservedAttributeId, the final attribute id the credential is stored at in the Issuers Registry: the id derived by the contract (SHA-256 of the ABI-encoded (DID, salt, 0, "")), never the salt. Verifiers reject a body whose reservedAttributeId is missing or differs from the attribute it was fetched from;
  • credentialStatus of type EbsiAccreditationEntry, whose id is the Issuers Registry attribute URL of the subject (/issuers/{subject.id}/attributes/{reservedAttributeId});
  • a credentialSchema pointing at the vcdm2.0-trust-model-schema.

The Support Office's seed record is the exception: it has no credentialStatus or termsOfUse and uses the generic attestation schema.

A domain VC with an AttestationPolicy also references the AttestationPolicy extension schema in its credentialSchema.

Use EBSI URIs

The examples on this page link to Issuers Registry attributes and to schemas with EBSI URIs (ebsi:<network>:<service>:<resource>), so the credentials aren't tied to one node or domain. The EBSI libraries also accept a regular URL of a trusted node (https://<host>/v1/<service>/…).

How the chain is linked​

parentAccreditation points one level up. rootAuthorisation always points straight at the root, so a verifier knows which Root TAO and which trust framework apply from the first step. A TAO accredited directly by the Root TAO has the same URL in both fields.

Who can accredit whom​

The roles and the hierarchy are those of Introduction to Trust Chains. A Root TAO or a TAO may accredit a TAO or a TI. A Root TAO only accredits: the verifier doesn't accept a Root TAO as the parent of a domain or onboarding credential. Domain VCs are issued by a TI (or by the Support Office through its seed record, see Self-accreditation), with an AttestationPolicy. VerifiableAuthorisationToOnboard credentials are issued by the Support Office (seed), a TAO or a TI. A DID that is a Root TAO can issue domain VCs only through a separate TI attribute, accredited like any other TI.

Who issues a Root TAO's authorisation

Each Root TAO issues its own VerifiableAuthorisationForTrustChain: the issuer and the subject are the Root TAO itself, as in the Root TAO example below. The Issuers Registry contract records a Root TAO as its own tao and rootTao (setAttributeMetadata ignores the accreditor DID for RootTAO), and verifiers require the issuer of every attribute body to equal the recorded tao, with no exception. An authorisation issued by another DID, for example the Support Office, is therefore rejected.

The Root TAO is anchored by the RootTAO metadata, which only a holder of the IssuersRegistry:setAttributeMetadata policy in the Policies Registry can write. The Support Office's own RootTAO record is a different credential: a self-issued VerifiableAccreditationToAttest that grants VerifiableAuthorisationForTrustChain, with no termsOfUse (see Self-accreditation).

Example chain​

The following credentials form one chain: Root TAO → TAO → TI → domain VC. DIDs, URLs and hashes are abbreviated.

VerifiableAuthorisationForTrustChain
{
"@context": ["https://www.w3.org/ns/credentials/v2"],
"id": "urn:uuid:1d7b6f0a-5a64-4c0e-8d2f-6a5d1f1c0001",
"type": [
"VerifiableCredential",
"VerifiableAttestation",
"VerifiableTrustModel",
"VerifiableAuthorisationForTrustChain"
],
"issuer": "did:ebsi:zRootTao...",
"validFrom": "2025-01-01T00:00:00Z",
"validUntil": "2030-01-01T00:00:00Z",
"credentialSubject": {
"id": "did:ebsi:zRootTao...",
"reservedAttributeId": "0x9b21...",
"permissionFor": [
{
"schemaId": "0x23039e63...",
"types": [
"VerifiableCredential",
"VerifiableAttestation",
"CertificateOfTrademarkRegistration"
],
"jurisdiction": "https://publications.europa.eu/resource/authority/atu/EUR"
}
]
},
"credentialStatus": {
"id": "ebsi:pilot:issuers-registry:/issuers/did:ebsi:zRootTao.../attributes/0x9b21...",
"type": "EbsiAccreditationEntry"
},
"credentialSchema": [
{
"id": "ebsi:pilot:schemas-registry:/schemas/0xd36167db...",
"type": "JsonSchema"
}
],
"termsOfUse": {
"type": "TrustFrameworkPolicy",
"trustFramework": "Employment&Life",
"policyId": "https://example.com/policies/125",
"legalBasis": "professional qualifications directive"
}
}

Verification​

A verifier validates a domain VC as follows. The EBSI library implements these steps in validateAccreditations (@europeum-ebsi/verifiable-credential/vcdm20.js).

  1. Read the policies. Every termsOfUse entry of the domain VC must be an AttestationPolicy or an AccreditationPolicy (or a single TrustFrameworkPolicy, see below), with a parentAccreditation and a rootAuthorisation. Each policy is followed.

  2. Dereference each Issuers Registry link (IssuersRegistryData is the attribute returned by GET /issuers-registry/issuers/{did}/attributes/{attributeId}):

    • IssuersRegistryData.attribute.issuerType must not be Revoked (and an empty body is rejected).

    • The attribute body is a VC-JWT. Verify its signature, its dates and the Trust Model schema (the Support Office's seed record is exempt from the schema).

    • credentialSubject must include IssuersRegistryData.did (it can have several subjects), and the credential issuer must equal IssuersRegistryData.attribute.tao, with no exception: the contract records a Root TAO as its own tao, so a Root TAO's authorisation must be issued by the Root TAO itself.

    • For each subject whose id is the attribute's DID, credentialSubject.reservedAttributeId is required and must equal the attribute id of the dereferenced link (the 0x prefix and the hex case are ignored, and a percent-encoded id in the link is decoded first). Otherwise the verifier fails with Accreditation reservedAttributeId "<id>" doesn't match the attribute "<url>", or Accreditation has no reservedAttributeId, expected the attribute "<url>". There is no exception, including for the Support Office's seed record.

    • The role comes from the on-chain issuerType, and the credential must match it:

      issuerTypeCredential type containstermsOfUse.type
      RootTAOVerifiableAuthorisationForTrustChainTrustFrameworkPolicy
      TAOVerifiableAccreditationToAccreditAccreditationPolicy
      TIVerifiableAccreditationToAttestAccreditationPolicy
  3. Check the root. Dereference rootAuthorisation. Its role must be the root (a Root TAO's VerifiableAuthorisationForTrustChain) or the Support Office's seed record. For a root, the verifier then decides whether the credentialSubject.id, trustFramework, policyId and legalBasis are acceptable for its use case. The library exposes them through the optional trustFrameworkPolicyValidator hook, which is called once the whole chain (step 4) has been validated. If trustChainRootDid (a single DID) is set, the root's issuer must be that DID. Because the issuer must also equal the on-chain tao, the only Root TAO accepted is then that DID itself. The seed record is not compared with it in VCDM 2.0. Without trustChainRootDid, the issuer of the root is not compared with a root DID and the chain is anchored on the on-chain RootTAO metadata.

  4. Walk up from parentAccreditation. The first node is the issuer's own accreditation: the DID of its attribute must equal the credential issuer. On each node:

    • its role must be allowed to accredit the kind of credential below it:

      Credential belowParent role allowed
      AccreditationRoot TAO, TAO
      Domain VCSupport Office seed, TI
      Onboarding VCSupport Office seed, TAO, TI

      A Root TAO is never the direct parent of a domain or onboarding credential;

    • one single permissionFor entry must cover what the credential below needs: for the first node, the types and schemas of the credential (or, for an accreditation, its own permissionFor); for each higher node, the permissionFor of the accreditation below it. This applies to the root too, and its schemaId comparison is independent of the encoding (hex or base58btc). The types VerifiableCredential, VerifiableAttestation and VerifiableTrustModel are implicit, as are VerifiableAuthorisationToOnboard for a TAO or TI and VerifiableAccreditationToAttest for a TAO. The Support Office seed skips this check;

    • its own policy's rootAuthorisation must point to the same root;

    • a node already seen is rejected as a loop.

    The walk succeeds when it reaches the rootAuthorisation attribute. It examines at most 32 attributes, the root included (33 for a domain or onboarding credential, because the issuer's own accreditation is then the one being written on chain), and fails beyond that with The trust chain is longer than <limit> attributes (the Root TAO included), where <limit> is the one that applied (32 or 33). A chain that was within the limit when it was written is accepted as long as it is unchanged: the contract checks the depth only when an attribute is written, so if a TAO in the middle of a chain is later re-parented under a deeper TAO, the descendants written earlier can exceed the limit and are rejected.

  5. Revocation. The whole chain is walked at verification time, so revoking any ancestor makes every credential beneath it fail with Revoked.

  6. Jurisdiction. jurisdiction is not compared by the library. It is passed to trustFrameworkPolicyValidator through permissionFor (always a string[], a single URI being an array of one), next to a trustChain field with the permissions of every accreditation of the chain, so acceptance is a use-case decision.

Presented Trust Framework Policy credential​

A VerifiableAuthorisationForTrustChain with a TrustFrameworkPolicy can also be presented directly as the credential being verified. It must be issued by the trust chain root when trustChainRootDid is set, and the verifier follows each subject with a string reservedAttributeId to GET /issuers/{subject}/attributes/{reservedAttributeId}. Subjects without a reservedAttributeId are ignored.

  • The reservedAttributeId must be 32 bytes of hexadecimal, with or without 0x, and the subject id must be a plain DID. This keeps a query from steering the registry instance.
  • A 404 or 400 for a subject only matters if no subject qualifies. Any other registry error (timeout, 5xx) rejects the credential.
  • The did of the record must be the subject, and the record must be a RootTAO whose on-chain tao equals the credential issuer, that is the Root TAO itself: a credential issued by another registered DID, for example the Support Office, is rejected (Credential issuer "<did>" doesn't match the TAO recorded for the Root TAO attribute).
  • The first subject that qualifies supplies the policy. Errors are prefixed with Invalid trust framework policy: .

Self-accreditation​

The self-accreditation rule of VCDM 1.1 applies, with permissionFor in place of accreditedFor. The Support Office's own self-accreditation is the seed of the chain and is exempt from the permission check. Three differences from VCDM 1.1:

  • the seed's issuer is not checked against trustChainRootDid: that check only applies to a Root TAO's authorisation and to a presented Trust Framework Policy credential;
  • the seed can be the parent of a domain or onboarding credential, but never of an accreditation, so a separate Root TAO must accredit TAOs and TIs;
  • its body still needs a reservedAttributeId equal to its attribute id.

Differences from VCDM 1.1​

Trust model​

AspectVCDM 1.1 trust modelVCDM 2.0 trust model
Domain VC termsOfUseIssuanceCertificate { id }AttestationPolicy { parentAccreditation, rootAuthorisation }
Link to the rootNot checked: the contract enforces the path to itExplicit rootAuthorisation in every credential
Root TAO policyNoneTrustFrameworkPolicy { trustFramework, policyId, legalBasis }
TAO and TI policyIssuanceCertificate { id }AccreditationPolicy { parentAccreditation, rootAuthorisation }
Rights of the subjectcredentialSubject.accreditedFor[]credentialSubject.permissionFor[]
JurisdictionlimitJurisdictionjurisdiction (string or array)
Base typeVerifiableAccreditation / VerifiableAttestationVerifiableTrustModel
Role of an entityFrom the type of the credential in the attribute bodyFrom the on-chain issuerType, which must match the credential
Issuer cross-checkIssuer = attribute.tao for every attribute, Root TAO included (no exception)Issuer = attribute.tao for every attribute, Root TAO included (no exception)
Chain validatedOnly the accreditation of the issuerThe whole chain up to the root (at most 32 attributes, root included; 33 for domain or onboarding credentials; loops rejected)
Ancestor revocationNot noticed: only the issuer's own attribute is checkedRevoking any ancestor fails every credential beneath it
Who issues domain and onboarding VCsAny accredited issuer; a Root TAO through its wildcardDomain: TI or Support Office seed. Onboarding: seed, TAO or TI. Never a Root TAO
Support Office seed accrediting TAOs and TIsYes, through its wildcardNo: a seed is only the parent of domain and onboarding credentials
Root trust decisionThe root DID must be trustedThe root DID, and the framework, policy and legal basis, for the use case
Schema and types checkOne accreditedFor entry covers types and schemaIdOne permissionFor entry must cover the types and the schemaId
Permissions read fromOnly the subjects whose id is the issuerAll the subjects of the accreditation
Revoked attributeEmpty body first, then RevokedRevoked first, then the empty body
Accreditation statusBitstringStatusListEntry or EbsiAccreditationEntryEbsiAccreditationEntry required on every trust model credential

Data model and securing​

AspectVCDM 1.1VCDM 2.0
First @contexthttps://www.w3.org/2018/credentials/v1https://www.w3.org/ns/credentials/v2
DatesissuanceDate, expirationDate (plus issued, validFrom)validFrom, validUntil
VC-JWT typJWTvc+jwt (optional on verification)
VP-JWT typJWTvp+jwt (optional on verification)
JWT payloadNested vc / vp claim; iss, sub, jti, iat, nbf, exp mirror the credentialFlat payload; JWT claims optional and only checked if present; iat is not tied to validFrom
VCs in a VPCompact JWT strings{ "type": "EnvelopedVerifiableCredential", "id": "data:application/vc+jwt,<jwt>" }

Using VCDM 2.0​

  • Libraries. Import the version you need: @europeum-ebsi/verifiable-credential/vcdm20.js and @europeum-ebsi/verifiable-presentation/vcdm20.js (or vcdm11.js for VCDM 1.1). The caller picks the version; nothing is detected at runtime. A service that accepts both must detect the version from the presented JWT (@context[0] of a flat payload, or the nested vc / vp claim).
  • SDK and CLI. @europeum-ebsi/sdk and the EBSI CLI produce VCDM 1.1 by default. Set vcdmVersion: "2.0" in the SDK, or --vcdm-version 2.0 (also read from EBSI_VCDM_VERSION) in the CLI. The SDK builds the AttestationPolicy of a VCDM 2.0 credential: parentAccreditation is the issuer's own Issuers Registry attribute, and rootAuthorisation is read from the issuer's accreditation, unless you pass it explicitly.
  • Authorisation API. POST /auth/token detects the version from the presentation JWT. VCDM 1.1 is always accepted. VCDM 2.0 presentations are accepted only where the deployment enables them (currently the test network); elsewhere they are rejected with an invalid_request error (VCDM 2.0 presentations are not supported).
  • Issuers Registry. The registry stores the attribute body as opaque bytes, so VCDM 2.0 accreditations are written with setAttributeData and read back like VCDM 1.1 ones.
  • Validate a credential. Use the VC Validator, which supports both versions.