The credential and governance layer: Verifiable Trust Communities (VTCs) and Verifiable Relationship Credentials (VRCs), with W3C Verifiable Credentials recording relationship and membership claims. Multi-step trust operations run as trust-task ceremonies. A unified Credential Factory issues credentials, while a Governance Guard and data-driven Policy Engine enforce the applicable community rules.
The Credential Factory, Governance Guard, Policy Engine, and trust-task ceremony engine are implemented and shipped in v0.2.0, and exercised by the reference applications.
Layer 3 is the credential and governance layer — where the authenticated relationships established in Layer 2 are used to perform meaningful trust tasks: issuing credentials, verifying membership, representing another entity within specified bounds, and participating in governance.
The core primitives at this layer are:
These primitives let applications evaluate signed evidence about relationships and community membership. Changing signed content causes verification against the original signature to fail. A successful proof check does not establish that a claim is true, that an issuer is suitable, or that an action is authorized.
Layer 3 runs multi-step operations as ceremonies: an ordered sequence of steps,
each of which is either a policy gate (a decision that must allow) or an effect
(an action dispatched through the transaction coordinator). The ceremony and step definitions live
in the database (ceremony_templates and trust_task_templates), while the
executors live in code. Every step is recorded as a request/response pair in the
trust_tasks log, giving each operation a complete, auditable trail.
VTC establishment — creating a community and minting its founding members'
membership credentials in a single atomic transaction, then fanning out delivery over TSP — is
live in the testbed, alongside membership onboarding, mutual acknowledgment, and policy evaluation ceremonies. The ceremony engine,
templates, and the trust_tasks audit log all ship in v0.2.0.
The Credential Factory provides a shared interface for issuing, verifying, and displaying supported credentials. Higher layers request a credential by kind and scenario. Credential formats and cryptographic proof mechanisms are separate from encodings such as CESR or JCard.
The draft’s seven core types and VSC profiles define specification concepts. Release support must be assessed for the particular workflow and format; this page does not claim that v0.2.0 implements every type or profile in Working Draft 0.6.0.
Within the stack’s governed ceremony paths, the Governance Guard assembles the facts and performs cryptographic checks such as signature verification and M-of-N threshold counting. It supplies that evidence to the Policy Engine. Applications must integrate the relevant checks at their own action boundaries; policy does not enforce itself outside those paths.
The authorization decision itself belongs to the Policy Engine, an in-process
interpreter for structured JSON policy documents. A community's rules live as data in its
governance.policy_rules column and can be edited at runtime — no code change, no
redeploy. The engine supports six comparison operators, nested
any/all/not groupings, and the allow /
deny / requireStepUp / requireConsent decision vocabulary,
with a fail-closed default: deny short-circuits, and a rule whose fact cannot be
determined refuses rather than guesses.
The Trust Tasks framework is
an independent effort to standardize how trust tasks are executed. We have incorporated its
approach: our trust tasks use peer-scoped type identifiers —
task:p2pts:<family>:<slug>:<version>, for example
task:p2pts:policy:evaluate:0.1 — carried in a conformant JSON envelope with request
and response forms, and our policy documents use the framework's document and decision vocabulary.
This adoption is in anticipation of interoperability. Our identifiers stay peer-scoped rather than web-domain-scoped, so any mapping to the trusttasks.org vocabulary would be applied out-of-band at the boundary. That interop is not implemented yet — no bridge ships in v0.2.0, and a formal compatibility assessment against the registry is still pending.
Visit trusttasks.org →The DTG Credentials specification, Working Draft 0.6.0, targeting specification version 1.0, defines seven core credential types. The table summarizes their support in v0.2.0, based on the available code paths. Full conformance to the draft has not been established.
| Credential | Release coverage |
|---|---|
| Verifiable Relationship Credential (VRC) | Used in peer relationship establishment and mutual acknowledgment flows. |
| Verifiable Membership Credential (VMC) | Used in community creation and member onboarding. |
| Verifiable Invitation Credential (VIC) | Used in the member-invitation ceremony. |
| Verifiable Persona Credential (VPC) | A VPC builder is available. Its use in reference application workflows and conformance to Working Draft 0.6.0 have not been verified. |
| Verifiable Statement Credential (VSC) | Partial support through endorsement and witness profile adapters. The Credential Factory's
witness branch still constructs a WitnessCredential directly, so the profile
form is not used consistently. |
| Verifiable Delegation Credential (VDC) | A generic credential builder and delegation records are available. The credential registry marks this type as future work; a complete draft-compliant workflow has not been confirmed. |
| Verifiable Authority Credential (VAC) | The factory has a generic AuthorizationCredential entry marked as future work.
Support for the draft's AuthorityCredential and authority-chain verification
has not been confirmed. |
Verifiable Endorsement Credential (VEC) and Verifiable Witness Credential (VWC) are VSC predicate profiles, not additional core types. R-cards are verifiable data structures, not core credential types.
A VTC is a community entity identified by a VID and represented digitally by a VTA. Members participate under shared rules. In Working Draft 0.6.0, membership is represented by reciprocal Verifiable Membership Credentials (VMCs), rather than by treating the community as a collection of identifiers.
Community governance can describe joining criteria, required credentials, permitted actions, and dispute processes. The Policy Engine evaluates configured rules at integrated decision points; a DID document does not itself enforce those rules.
A VRC attests to one direction of a peer relationship. Two VRCs, one issued by each peer, form the complete relationship edge under Working Draft 0.6.0. This differs from describing one credential as jointly issued or signed by both peers.
The draft distinguishes peer relationships (VRC), community membership (VMC), delegation (VDC), statements (VSC), and authority (VAC). These concepts should not be conflated simply because each can involve signed records.
The W3C Verifiable Credentials Data Model supplies a common model for claims. Compatibility between systems also depends on credential formats, proofs, DID methods, status mechanisms, and exchange protocols.
An r-card is a verifiable data structure containing human- and machine-readable information about its publisher. R-cards are typically exchanged alongside relationship credentials and may be encapsulated in a verifiable credential. This is a specification-level description; it does not establish credential wrapping, verified updates, or zero-knowledge presentation support in v0.2.0.
A Verifiable Delegation Credential establishes that a delegate may act in another entity’s name within specified bounds. It does not itself confer authority.
A Verifiable Authority Credential grants its subject permission to act in its own name within a defined scope. When a delegate acts, the application must separately establish whether the delegator is permitted to perform the requested action.
These definitions describe Working Draft 0.6.0. Version 0.2.0 includes delegation record management and permission grants. Complete VDC/VAC chain verification, invocation binding, and checks of the delegator's permissions across delegated actions have not been confirmed.
Revocation does not erase a credential or make its original signature cease to verify. Verifiers need applicable status checks, validity checks, and application policy before accepting the evidence or permitting an action.
In v0.2.0, the Credential Factory checks cryptographic proofs and issuer/key binding. Its
valid result reports proof verification; it does not include expiry or revocation status
checks. The Utility Server's stored-credential verification endpoint checks expiry and stored
revoked or expired status.
The default receive policy, warn, logs verification outcomes and stores credentials
even when proof verification fails. Applications need separate checks before relying on stored
credentials. Automatic external credentialStatus resolution and status-list
interoperability have not been confirmed.
A trust task is a defined, repeatable action that requires trust — for example, "verify that this person is a member of this community," "confirm that this agent has authority to sign this document," or "check that this organization meets these compliance requirements." Trust tasks are the unit of work at Layer 3, expressed as conformant JSON documents and executed using verifiable credentials as the evidence of trust.
In this stack, a community's governance rules are not hard-coded — they are a policy document stored with the community and evaluated by the Policy Engine at each decision point. That means the answer to questions like "how many admins must approve?", "which credential kinds may be issued?", or "may this child community affiliate?" can change at runtime, per community, with a full history and without touching the code that runs the stack.