What Is a Verifiable Credential Wallet? (Issuer, Holder, Verifier, Explained)

The unlinkability implementation described here is unaudited.

A Verifiable Credential wallet doesn't do everything. "Wallet" suggests something that both holds and validates whatever it holds, but a Verifiable Credential system splits that into three structurally separate roles: an issuer signs a claim once, a holder keeps it and shows it again, a verifier checks the signature when it's presented. No single party does all three.

Solidus Wallet is the holder. Only the holder. It never issues, verify.solidus.network does that, as a separate product, and it never verifies. That separation isn't a policy choice we could reverse later; it's the definition of what a holder is.

① The issuer verifies once and signs a credential. Solidus Wallet is never this role. ② The holder keeps the credential and presents it when asked: this is the role Solidus Wallet plays, and only this role. ③ The verifier checks the signature. Solidus Wallet is never this role either. ④ The verifier never phones the issuer back: that severed line is what makes the credential portable.

Issuer: who signs the claim

An issuer is whoever is positioned to attest something is true, and puts a signature behind it. A government issuing a passport is an issuer: it checks your documents once, then signs a claim ("this person, this name, this birthdate") into a credential you carry away. It doesn't re-check you every time you show the passport at a border: the signature is what travels, not the government's ongoing involvement.

On Solidus, verify.solidus.network is the issuer. It runs the identity checks and signs the resulting Verifiable Credential. Once issued, that credential is no longer verify's to hold or manage: it belongs to whoever it was issued to, and it's their choice where it lives next.

Holder: what Solidus Wallet actually does

The holder is where the credential lives between being issued and being shown again. Solidus Wallet is a holder: it stores the credentials you've been issued and re-presents them when a verifier asks, client-side, under keys that never leave the wallet.

A holder can present a full credential, or, where the credential supports it, present only part of it. The mechanism is a Selective Disclosure property of the credential itself, not something the wallet invents; see the Lexicon entry for how it works. What holding actually buys you across services and over time, carrying one credential instead of re-proving from scratch at every new relying party, is the subject of a separate page: Credential Portability, Explained.

None of this is a verification service. A holder doesn't check anyone else's identity, including its own user's: it only keeps and shows what an issuer already signed.

Verifier: who checks the signature

The verifier is whoever receives a presentation and checks the issuer's signature against the claim being made, confirming the credential is genuine and unaltered, without needing to ask the issuer anything. That's the whole job: check the signature, decide whether to trust the issuer behind it, and act.

Solidus Wallet is never a verifier. It can't be: a wallet checking its own user's credential would defeat the point of having an independent third role at all. Verification happens wherever the credential is presented, using the public key the issuer already published.

The line between holder and verifier never gets crossed, and it's the reason the system is portable at all: the verifier checks the signature and moves on, it never calls the issuer back to confirm anything. Sever that callback and the credential works the same way in front of any verifier, not just the one the issuer originally had in mind.

The full loop, and where it runs

This page describes the roles; it doesn't run the full issue-hold-verify loop end to end, that lives in the canonical Issuer-Holder-Verifier triangle Lexicon entry, which traces a real credential across verify, identity, and the SDK. If selective disclosure is what brought you here, the one public, runnable artifact is the unlinkability demo:

npm i @solidus-network/auth @solidus-network/bbs
node node_modules/@solidus-network/auth/demo/unlinkability-demo.mjs

For the vocabulary itself, Verifiable Credential, Verifiable Presentation. The Lexicon is the source; this page only fixes where Solidus Wallet sits inside it: holder, and holder alone. Back to Now for what's actually live on the wallet today.