Pairwise DID
Ayrıca şöyle anılır pairwise-pseudonymous DID, per-verifier DID, pairwise identifier
A pairwise DID is an identifier a person's wallet generates specifically for one relationship, one service, one verifier, instead of using the same identifier everywhere. Show the same DID to every website and, if two of those websites ever compare notes, they can tell it's the same person visiting both. Derive a different DID for each one instead, and that correlation becomes impossible, while the same verifier still sees the same DID every time that person returns, so it can recognize a returning user without needing to know who anyone else sees them as.
The trick is doing this without creating a management nightmare: rather than storing a separate secret key per relationship, a wallet can derive each pairwise identifier mathematically from one master seed plus the name of the verifier it's talking to. Run the same derivation again with the same inputs and you get the identical identifier back, no state needs to be stored, and the wallet's existing backup/recovery process covers every pairwise identity automatically, because they're all just recomputed from the same seed.
Who actually built this
This is a Hyperledger Indy/Aries and Sovrin Foundation idea from around 2017–2019, later written up formally in DIF's did:peer specification. The core insight, every relationship gets its own identifier, derived, not stored, predates Solidus by years. What Solidus wrote itself is the specific derivation function used in its own wallet, which reuses an HKDF-based key-derivation approach it already uses elsewhere in its SDK, domain-separated by verifier.
Solidus today
This shipped to production on 2026-07-12 and passed seven consecutive internal test sessions. It is not anchored on-chain (a pairwise DID is a presentation-layer string, never submitted as a chain transaction), and it does not yet carry a cryptographic proof binding the pairwise identifier to the underlying credential, a documented, deliberate tradeoff explained above.
See also
SSI is the broader principle this serves. Credential Portability and Trust Registry are the adjacent mechanisms that make a presented credential trustworthy in the first place.
Nereden geliyor
Bunu başkası belirtti. Solidus bir uygulamasını yazdı.
The pattern, deriving a different, unlinkable identifier for every relationship instead of showing one global identifier everywhere, comes from the Hyperledger Indy/Aries and Sovrin community's work on "pairwise-pseudonymous DIDs," later formalized in DIF's did:peer method specification (led by Daniel Hardman), and discussed as a core privacy pattern in the W3C DID Core specification itself. Solidus is a DIF Associate Member, so this is a body it has joined, not just borrowed vocabulary from. Solidus did not invent per-relationship identifiers; it wrote its own derivation scheme (an HKDF-based key derivation over a wallet's existing seed, domain-separated per verifier) rather than adopting did:peer or the newer IRTF CFRG BBS-pseudonym draft wholesale.
Bunu nasıl doğrularsınız
Bugün üretimde çalışıyor.
None a stranger can run without a Solidus Identity wallet, this lives inside the presentation/login flow, not as a standalone public check. For context, a related but distinct privacy property (one-shot unlinkability of a single credential presentation, not the return-visit recognition pairwise DIDs solve) does ship a public, runnable demo via npm i @solidus-network/auth, worth mentioning for orientation, not offered as direct proof of this specific mechanism.