This is the frozen v1.1 publication. The current version is at latest.

did:avtr Method Specification

Version: 1.1

Editor: Amod Dange, Avatar Inc

Contact: did@avatar.me

Latest version: https://docs.avatar.me/specs/did-method-avtr/latest/

Date: September 2026


Abstract

The did:avtr method is a Decentralized Identifier method for biometric-rooted, self-sovereign human identity. It does not rely on a blockchain. It combines on-device cryptographic key material rooted in a live biometric with a server-side resolution registry that stores only public DID Documents, never biometric data or personal information.

The method provides one accountable human per identity, biometric-rooted recovery, and per-relying-party unlinkability, and conforms to W3C DID Core.

1. Introduction

1.1 Overview

did:avtr consists of a root key derived on the holder's device, a persistent, resolvable did:avtr DID that belongs to exactly one enrolled human, a Resolution Registry that holds its public DID Document, and Sybil resistance from a cryptographic key derived on the holder's device from an identity-anchor record. Together these make the identity a specific accountable human and make recovery possible.

1.2 Why a custom method

Ledger-based methods (did:ethr, did:ion) anchor to a ledger; key-only methods (did:key) are neither updatable nor persistent; did:web identifies a domain, not a person. did:avtr occupies a distinct spot: a biometric-rooted, persistent DID for a deduplicated human. It identifies the human holder and is not intended for issuers or services.

1.3 Conformance

Conforms to W3C DID Core v1.0. RFC 2119 and RFC 8174 keywords apply.

did:avtr is designed to implement the proposed human:// URI scheme. A main identifier's bytes may be carried in a human:// URI in the scheme's base32 form; the scheme defines the two forms as equivalent on their decoded bytes (scheme §8.1). This document does not yet claim conformance to that scheme. References of the form "scheme §n" in this document point to that specification.

1.4 Terminology

2. DID Method Name

The method name is avtr, from Avatar. A conforming DID MUST begin with did:avtr: (lowercase).

3. The verifiable data registry

did:avtr does not use a blockchain. Its verifiable data registry is the Resolution Registry: a server-side registry of public DID Documents, exposing a DIF Universal-Resolver-compatible driver (§7.2). The Registry stores only what the controller publishes — public keys, service endpoints and document metadata — and holds no biometric data, no identity-anchor record contents and no personal information. Every document carries its controller's proof (§6.3), which the Registry verifies on write and returns on read. The proof establishes that a document is consistent with the key it names; what a reader can verify without relying on the Registry, and what it cannot, is stated in §3.1.

Deduplication (§8) is not a function of the Registry. It is performed by a separate deduplication service that receives no DID Document and no identifier, while the Registry receives no deduplication value. The Registry verifies registration tokens (§8.1) against the deduplication service's published verification keys and holds nothing else about that service.

The Registry answers only about an identifier the querier already holds. It offers no operation that lists, searches or counts identifiers, and none that reports on an identifier other than resolution of that identifier (§7.2).

3.1 What a reader relies on the Registry for

3.2 Registry discovery

Each network (§4) has one Registry and one deduplication service. Their HTTPS origins are published in the method's discovery document, served from the same origin as this specification:

https://docs.avatar.me/specs/did-method-avtr/registries.json
{
  "main": { "registry": "https://…", "deduplication": "https://…", "keys": "https://…" },
  "test": { "registry": "https://…", "deduplication": "https://…", "keys": "https://…" }
}

A resolver MUST obtain a network's Registry origin from the discovery document and MUST NOT accept a document for an identifier of that network from any other origin. keys is the URL at which the network's deduplication service publishes the verification keys for its registration tokens as a JSON Web Key Set (RFC 7517), each key identified by kid; the Registry verifies tokens against that set (§8.1). The discovery document changes only with a new version of this specification.

4. DID Syntax — the identifier

The did:avtr method-specific identifier is self-certifying: 66 bytes, being 32 random bytes followed by the controlling public key as the DID Document publishes it (the Multikey value of §6.1, multicodec prefix included), encoded together as one base58btc string. The random part is created on-device at registration from a CSPRNG and is decoupled from all key material (NOT derived from any key or any biometric input, and MUST NOT be computable from them); the key part is the DID's controlling key (§5), which never changes. A reader therefore holds, in the identifier itself, the key that every document of the DID must carry (§4.3).

The identifier space is the set of all values of the form in §4.1, and every identifier in it is at all times in one of two states: inactive or active. Registration (§7.1) moves an identifier from inactive to active; deactivation (§7.4) moves it back, permanently. Resolution reports the state (§7.2): an active identifier resolves to its document, and an inactive one resolves with deactivated: true and no document. The method has no notion of an identifier that does not exist, and an identifier that was withdrawn is in the same state, and answers in the same way, as one that was never activated.

did:avtr:<network>:<multibase-encoded-identifier>

4.1 ABNF

did-avtr        = "did:avtr:" network ":" identifier
network         = "main" / "test"
identifier      = "z" 89*91base58-char   ; base58btc of exactly 66 bytes:
                                         ; 32 random bytes ‖ 34-byte Multikey controlling key
base58-char     = %x31-39 / %x41-48 / %x4A-4E / %x50-5A / %x61-6B / %x6D-7A

4.2 Examples

did:avtr:main:z2SgtXTJjRd2tUix14qjK3ySYFMUbFwCXf1FbUE1EXsZcFck6mZyegKHCuC6E9Zoq4PCvHnvbrbr5MU6ZdWNQJZtLYpy
did:avtr:test:z2Q2Jn9LjZFx7xrByF1tasnyRNXiJzWwDsTbTLjgUph4hNSSZZaJ5WRVqZ1nj2GNF7LcNAG6sYH4A3oBZo3hsbtErtMn

The same main identifier in the human:// URI form (scheme §4.7, §8.1): the DID form encodes the 66 bytes in base58btc, the URI form in base32; the two are equivalent on the decoded bytes, and the URI form carries the controlling key exactly as the DID form does.

did:avtr:main:z2SgtXTJjRd2tUix14qjK3ySYFMUbFwCXf1FbUE1EXsZcFck6mZyegKHCuC6E9Zoq4PCvHnvbrbr5MU6ZdWNQJZtLYpy
human://b23oclo3bfgisi4mrlrjg2vqkalakqwewm7wafepuq555m4rnfk362aijl6nbuwk53z2v3ammyboxjpkyf7czqpdzbaos3vsedloqyl4eei

4.3 The identifier certifies its own key

The key part of the identifier (§4) is the controlling key, so a DID Document is bound to its identifier by content, not by anyone's word. A Registry MUST refuse to register a document whose controlling verification method does not carry, in publicKeyMultibase, exactly the key part of the document's id. A resolver MUST make the same check on every document it obtains and MUST report a document that fails it as a failure of the binding, never as the DID's document. A reader who holds a did:avtr DID therefore verifies the first document it ever sees for that DID without relying on the Registry (§3.1), and there is no form of the identifier that lacks the key: the human:// form carries the same bytes (§4.2). This is the self-certifying form the scheme requires of every identifier (scheme §3.2).

The identifier discloses nothing that resolution does not already publish: the controlling public key is public (§10), and the random part is unguessable, so a DID cannot be discovered; a party holds one only because the holder disclosed it (§3, §5, §10).

5. The key model

The root key is a key pair the holder derives on their own device from their verified identity and never stores; the holder can derive it on any of their devices.

The DID Document is controlled by a controlling key that is unique to the DID, is never replaced for that DID, and that the holder can re-derive on any device. It signs registration, updates and deactivation; the document lists its public half as the controlling verification method, and the identifier carries the same public half (§4).

How an implementation derives the root key and the controlling key is outside this method, as key generation is outside every DID method. This method depends on two properties only: the controlling key is unique to its DID, and the holder can re-derive it on any device from the same verified identity.

Relying parties never see the DID unless the holder chooses to reveal it: each relying party is presented a distinct key of its own, as a did:key. Which keys an implementation uses for which operations is an implementation choice; the DID Document records only what the controller publishes.

6. DID Document

The did:avtr DID Document describes one thing: the key that controls it. Relying-party keys are not enumerated here; they are off-document did:keys (§5).

{
  "@context": [
    "https://www.w3.org/ns/did/v1",
    "https://w3id.org/security/multikey/v1",
    "https://w3id.org/security/data-integrity/v2"
  ],
  "id": "did:avtr:main:z2SgtXTJjRd2tUix14qjK3ySYFMUbFwCXf1FbUE1EXsZcFck6mZyegKHCuC6E9Zoq4PCvHnvbrbr5MU6ZdWNQJZtLYpy",
  "verificationMethod": [
    {
      "id": "did:avtr:main:z2SgtXTJjRd2tUix14qjK3ySYFMUbFwCXf1FbUE1EXsZcFck6mZyegKHCuC6E9Zoq4PCvHnvbrbr5MU6ZdWNQJZtLYpy#control-1",
      "type": "Multikey",
      "controller": "did:avtr:main:z2SgtXTJjRd2tUix14qjK3ySYFMUbFwCXf1FbUE1EXsZcFck6mZyegKHCuC6E9Zoq4PCvHnvbrbr5MU6ZdWNQJZtLYpy",
      "publicKeyMultibase": "z6Mkf5rGMoatrSj1f372GNPBvqi8m6xTA1JkCwEfcZ4ySmd3"
    }
  ],
  "capabilityInvocation":  ["did:avtr:main:z2SgtXTJjRd2tUix14qjK3ySYFMUbFwCXf1FbUE1EXsZcFck6mZyegKHCuC6E9Zoq4PCvHnvbrbr5MU6ZdWNQJZtLYpy#control-1"],
  "proof": {
    "type": "DataIntegrityProof",
    "cryptosuite": "eddsa-jcs-2022",
    "verificationMethod": "did:avtr:main:z2SgtXTJjRd2tUix14qjK3ySYFMUbFwCXf1FbUE1EXsZcFck6mZyegKHCuC6E9Zoq4PCvHnvbrbr5MU6ZdWNQJZtLYpy#control-1",
    "proofPurpose": "capabilityInvocation",
    "proofValue": "z3FXQjecWufY46yg5abdVZsXqLhxhueuSoZgNSARiKBk9czhSePTFehP8c3PGfb6a22gkfUKodSHKZFp9tmnkbSs4"
  }
}

6.1 Verification methods

Verification methods are of type Multikey (W3C Controlled Identifiers), and proofs use the Data Integrity context (§6). The controlling key is an Ed25519 key, encoded in publicKeyMultibase with the Ed25519 multicodec prefix; the root key's public half is never published. The document lists it under capabilityInvocation only: it controls the document (§5); it is not an authentication or assertion key, and the document therefore lists none.

6.2 Service endpoints

This method defines no service types. Service entries, where an implementation publishes them, are governed by DID Core. Where an implementation publishes a service, its serviceEndpoint MUST be identical for every holder; anything that selects a holder travels in the signed request body, never in the URL.

6.3 Proof

Every DID Document carries a Data Integrity proof: a signature by the controlling key over the document, under proofPurpose: capabilityInvocation, using the eddsa-jcs-2022 cryptosuite or a successor. The proof carries no created time (§10). The Registry MUST verify the proof before storing a document and MUST return it, unaltered, with the document on every resolution. A resolver MUST pass the proof through, and a client MUST verify it against the #control-1 key in the document it accompanies and MUST reject a document whose proof does not verify. A document therefore proves its own integrity to any reader, whatever path delivered it; the Registry is a store, not a party whose word is taken. The controlling key is never replaced for a DID (§5, §7.3), so every version of a document is signed by the same key, and a reader who holds that key from the identifier itself (§4.3) or from any previous version verifies every later one against it.

7. DID Method Operations

7.1 Create (Register)

  1. Identity verification and root derivation — the holder's identity is verified on-device (liveness REQUIRED for the biometric) and the root key is derived on-device.
  2. Controlling key — generate the 32 random bytes of the identifier (§4), independent of all keys, and derive the DID's controlling key (§5).
  3. DID construction and DID Document — form the identifier from the random bytes and the controlling public key (§4); assemble the document from the id, the controlling key as the sole verification method, and its control relationship (§6).
  4. Enrollment and registration token (§8) — the device proves to the deduplication service that the holder is enrolled exactly once, enrolling the holder if they are not, and obtains a registration token (§8.1) bound to the DID and the controlling key of step 3; the service does not see which DID or key it authorizes, and the device discloses no identifier to it. The deduplication service never sees the Registry's data, and the Registry never sees the deduplication service's.
  5. Registration — the device submits the DID Document, carrying its proof (§6.3), together with the registration token, to the network's Registry (§3.2). The Registry verifies the proof against the document's own verification method, verifies that the controlling key matches the identifier (§4.3), verifies the token against the deduplication service's published keys and against the submitted DID and controlling key (§8.1), checks that the identifier has never been activated (§7.2), and stores the document. It receives no deduplication value of any kind and no identifier of the holder beyond the DID itself: no party to registration is able to correlate the resulting identifier with another record of the person (scheme §3.2), and no value that identifies the person reaches or rests at any server.

7.2 Read (Resolve)

A Registry exposes a DIF Universal-Resolver-compatible driver: GET /1.0/identifiers/{did} returns { didResolutionMetadata, didDocument, didDocumentMetadata } on success, the document carrying its proof (§6.3). A Registry serves one network; a resolver routes on the network segment (§3.2) and returns notFound for an identifier of a network it does not serve. Resolution is open: any party may resolve any did:avtr. What a holder discloses, and to whom, is decided in the holder's application (§5, §10), never by the Registry.

Metadata. For an active identifier, didDocumentMetadata contains versionId only, a string the Registry increments on every update (§7.3). It never contains created or updated, because they would date a holder's registration and activity. For an inactive identifier (§4) it contains deactivated: true and nothing else, didDocument is empty and didResolutionMetadata carries no error: the resolution succeeded and reported the identifier's state, as DID Core requires of a deactivated DID.

didResolutionMetadata carries the standard fields, contentType and, on failure, error: invalidDid for a string that is not a did:avtr DID (§4), and notFound only for an identifier of a network the Registry does not serve. An identifier of the Registry's own network never fails to resolve: it is active or inactive (§4). The metadata also carries two fields this method defines:

Resolution reports state, never history. Every inactive identifier, withdrawn or never activated, returns the same response, byte-identical and on the same code path, because the Registry holds no document for either and consults nothing else to answer (scheme §6.5). A querier learns whether the identifier it presented is active now, which is what resolution is for, and nothing about whether it was ever active. The Registry retains no document, no key and no time for a withdrawn identifier. For the sole purpose of never activating an identifier twice (§7.4), it keeps a keyed digest of every identifier it has ever activated, consulted at registration and never at resolution.

7.3 Update

The controller re-derives the controlling key, modifies the document, attaches a proof by the controlling key (§6.3), and submits it to the Registry; the Registry verifies the proof against the current document's key and increments versionId. The controlling key itself is never replaced: it is unique to the DID (§5), and a compromised root is addressed by deactivation and a new DID (§9). Relying-party keys rotate freely off-document and require no Registry operation.

7.4 Deactivate and recovery

8. Sybil resistance

One accountable human per identity is this method's premise. Uniqueness is established once, at enrollment (§7.1), by a proprietary deduplication method whose input is a cryptographic key derived on the holder's device from the identity-anchor record (§1.4). The record never leaves the device. What the deduplication service receives is derived from the key and, by construction, cannot be traced to a specific person or to the record; it suffices to establish that the holder is enrolled exactly once, and for nothing else. No server other than the deduplication service receives any deduplication value, and no server receives biometric data, record contents or personal information. The Registry does not deduplicate (§3). Deduplication is global within a network: one enrollment per human across every relying party, never per relying party (scheme §3.3, Condition 1); the two networks are separate (§4).

This specification relies on the deduplication method's properties, not on its construction; the properties are the subject of independent evaluation under the evidence rules of the human:// scheme (scheme §3.4), against which this document does not yet claim conformance (§1.3). The registration token below is what carries uniqueness from the deduplication service to the Registry without carrying anything else.

8.1 Registration token

9. Security Considerations

10. Privacy Considerations

11. References

W3C DID Core v1.0 · DID Resolution v0.3 · DIF Universal Resolver · Controlled Identifiers v1.0 (Multikey) · Verifiable Credential Data Integrity 1.0 · Data Integrity EdDSA Cryptosuites · Multibase · Multicodec table (Ed25519 public key prefix) · RFC 2119 · RFC 8174 · RFC 4648 (base32) · RFC 9474 (registration tokens) · RFC 8017 (RSA-PSS) · RFC 7517 (JSON Web Key) · The human:// URI scheme (cited as "scheme §n").


© Avatar Inc. This specification may be reproduced and distributed, without modification, for the purpose of building resolvers for, or reviewing, the method it describes.