@interop/did-method-peer 0.0.0-stage → 0.1.0

package/LICENSE.md

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Interop Alliance
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,351 @@
-# Temporary Holding Version
+# did:peer:4 (numalgo 4) driver _(@interop/did-method-peer)_
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![Node.js CI](https://github.com/interop-alliance/did-method-peer/workflows/CI/badge.svg)](https://github.com/interop-alliance/did-method-peer/actions?query=workflow%3A%22CI%22)
+[![NPM Version](https://img.shields.io/npm/v/@interop/did-method-peer.svg)](https://npm.im/@interop/did-method-peer)
+
+> A [`did:peer`](https://identity.foundation/peer-did-method-spec/) numalgo 4
+> codec and driver for `@interop/did-io`, for use in the browser, Node.js, and
+> React Native.
+
+## Table of Contents
+
+- [Background](#background)
+- [Security](#security)
+- [Install](#install)
+- [Usage](#usage)
+- [Contribute](#contribute)
+- [License](#license)
+
+## Background
+
+The [peer DID method](https://identity.foundation/peer-did-method-spec/) defines
+several algorithms, called numalgos.
+[Numalgo 4](https://identity.foundation/peer-did-method-spec/#method-4-short-form-and-long-form)
+is the current one. It is statically resolvable. The DID carries everything
+needed to resolve it, and no registry or network is involved.
+
+A numalgo 4 DID starts from an input document. The input document looks like the
+eventual DID document with four differences:
+
+- it has no root `id`;
+- every identifier defined in it is relative (`#key-0`);
+- every reference to a resource in it is relative;
+- a verification method omits `controller` when the controller is the document
+  owner.
+
+To encode it, the input document is serialized as JSON without whitespace,
+prefixed with the multicodec `json` code, and encoded as base58btc multibase.
+That string is the encoded document. The SHA2-256 hash of the encoded document
+string, as a multihash in base58btc, is the hash. Then:
+
+- The long form is `did:peer:4{hash}:{encoded document}`. It carries the whole
+  document and resolves with no other input.
+- The short form is `did:peer:4{hash}`. It is shorter, but it can only be
+  resolved by a party that has already seen the long form.
+
+DIDComm v2 agents send the long form at first contact and the short form in
+every message after that.
+
+This package provides:
+
+- A pure codec: `encodeLongForm`, `encodeShortForm`, `decode`, `longToShort`,
+  `resolveLongForm` and `resolveShortForm`, plus the form checks and regexes.
+- A `@interop/did-io` driver with `generate()`, `get()`, `fromKeyPair()`,
+  `publicKeyToDidDoc()` and `publicMethodFor()`.
+- Input document validation.
+- A `LongFormStore` contract for resolving short forms.
+
+Out of scope:
+
+- Numalgos 0, 1, 2 and 3. `get()` rejects those DIDs with `DIDResolutionError`
+  `methodNotSupported`.
+- A DID Resolution `resolveDID()` method on the driver. `CachedResolver` adapts
+  `get()` into a resolution result.
+- A persistent long form store. The driver defines the contract and ships no
+  store of its own.
+
+## Security
+
+- The hash protects against corruption. It does not protect against a hostile
+  sender, because the sender computes the hash over a document of their choice.
+  A valid hash proves the document is the one the DID names. It does not prove
+  the document is trustworthy.
+- `decode` rejects any long form longer than `MAX_LONG_FORM_LENGTH` (4096
+  characters) before hashing or decoding it. This stops a multi-megabyte DID
+  string from blocking the event loop. The limit is not configurable.
+- Resolution does not validate the input document beyond a structural guard. A
+  hash-valid document with an unusable shape fails with `DIDResolutionError`
+  `invalidDid`.
+- `alsoKnownAs` entries other than the one the library appends, and any
+  `controller` value naming a different DID, are claims made by the
+  counterparty. The library passes them through and does not verify them.
+- A document's `@context` is supplied by the counterparty. Remote context
+  fetching is the consumer's documentLoader policy.
+
+## Install
+
+- Node.js 24+ is recommended.
+
+### PNPM
+
+To install via PNPM:
+
+```
+pnpm install @interop/did-method-peer
+```
+
+### Development
+
+To install locally (for development):
+
+```
+git clone https://github.com/interop-alliance/did-method-peer.git
+cd did-method-peer
+pnpm install
+```
+
+## Usage
+
+### With did-io
+
+```js
+import { CachedResolver } from '@interop/did-io'
+import { Ed25519VerificationKey } from '@interop/ed25519-verification-key'
+import * as didPeer from '@interop/did-method-peer'
+
+const didPeerDriver = didPeer.driver({ longFormStore: new Map() })
+didPeerDriver.use({
+  keyPairClass: Ed25519VerificationKey,
+  enableEncryptionKeyDerivation: true
+})
+
+const resolver = new CachedResolver()
+resolver.use(didPeerDriver)
+
+const { didDocument, keyPairs, methodFor } = await didPeerDriver.generate()
+
+// Long form, resolved offline
+await resolver.get({ did: didDocument.id })
+
+// Key node, id is `${longForm}#z6Mk...`
+const signingKey = methodFor({ purpose: 'authentication' })
+await resolver.get({ url: signingKey.id })
+
+// Short form, resolved through the long form store
+await resolver.get({ did: didDocument.alsoKnownAs[0] })
+```
+
+`resolver.generate({ method: 'peer' })` also works, because the driver exposes
+`generate`.
+
+### Codec only
+
+An application that only needs to encode and decode DIDs imports the `./codec`
+subpath. It does not load the driver or any key suite.
+
+```js
+import {
+  encodeLongForm,
+  decode,
+  resolveLongForm,
+  longToShort
+} from '@interop/did-method-peer/codec'
+
+const inputDocument = {
+  '@context': ['https://www.w3.org/ns/did/v1'],
+  verificationMethod: [
+    {
+      id: '#key-0',
+      type: 'Multikey',
+      publicKeyMultibase: 'z6MkqRYqQiSgvZQdnBytw86Qbs2ZWUkGv22od935YF4s8M7V'
+    }
+  ],
+  authentication: ['#key-0']
+}
+
+const longForm = encodeLongForm({ inputDocument })
+const shortForm = longToShort({ did: longForm })
+
+// The input document as it was encoded, relative ids intact
+const decoded = decode({ did: longForm })
+
+// The contextualized DID document, relative references left relative
+const didDocument = resolveLongForm({ did: longForm })
+```
+
+`encodeLongForm` and `encodeShortForm` do not validate. The codec functions are
+synchronous. They throw `DIDResolutionError` with `code: 'invalidDid'` for
+malformed input.
+
+### Creating a DID with `generate()`
+
+`generate()` takes one of three mutually exclusive entry paths. It returns
+`{ didDocument, keyPairs, methodFor }`. `didDocument.id` is the long form.
+
+- `inputDocument`. The library validates, encodes and resolves a document you
+  built. An optional `keyPairs` map, keyed by bare fragment, binds live key
+  pairs to methods in that document. A pair whose public key differs from the
+  document's method is a `TypeError`. A method serialized without
+  `publicKeyMultibase` (a 2018 suite's `publicKeyBase58`, a JSON Web Key) is
+  read through the pair's registered suite for the comparison.
+- `seed`. A `Uint8Array` of exactly 32 bytes, or a string in `z1A...` form. The
+  library generates one key pair from it and proceeds as in the third path. The
+  same seed always yields the same DID.
+- Nothing, or explicit key pairs. With no options, the library generates one
+  random key pair with the registered suite. Otherwise you pass
+  `verificationKeyPair`, `keyAgreementKeyPair`, `verificationMethods` and
+  `service`.
+
+Details of the third path:
+
+- The verification key gets the purposes `authentication`, `assertionMethod`,
+  `capabilityDelegation` and `capabilityInvocation`.
+- The default fragment is the key's `fingerprint()`, so a method id looks like
+  `#z6Mk...`. A `verificationMethods` entry of the form
+  `{ keyPair, fragment, purposes }` overrides the fragment and the purposes.
+- A `verificationMethods` entry can also be a third-party method. Pass a string
+  DID URL, or a full verification method object whose `controller` names the
+  other DID. It is placed as given and gets the four default purposes. To give
+  it other purposes, wrap it as `{ method, purposes }`.
+- With `enableEncryptionKeyDerivation`, an Ed25519 key also yields a derived
+  `X25519KeyAgreementKey2020` key under `keyAgreement`. Derivation is opt-in,
+  because it uses one key's material for both signing and encryption.
+- `service` is copied as given.
+
+Mixing paths is a `TypeError`. For example, `inputDocument` together with
+`seed`, or `seed` together with `verificationKeyPair`.
+
+`methodFor({ purpose })` returns the live key pair for that purpose. It throws
+when no method serves the purpose, and when the method has no live pair.
+
+### The long form store
+
+A short form is only a hash. To resolve one, the driver must have seen the long
+form it belongs to. The spec says a short form cannot be resolved without first
+seeing and storing its long form.
+
+`LongFormStore` is that memory. It maps a short form to its long form:
+
+```ts
+interface LongFormStore {
+  get(shortForm: string): string | undefined | Promise<string | undefined>
+  set(shortForm: string, longForm: string): unknown
+}
+```
+
+A plain `Map<string, string>` satisfies it. A persistent store (IndexedDB, a
+wallet's encrypted storage) implements the same two methods and returns
+promises. The driver awaits both methods. There is no default store. Without
+one, every short form fails with `DIDResolutionError` `notFound`.
+
+The driver uses the store like this:
+
+- `generate()` always writes the new DID's pair, so the creator can resolve its
+  own short form.
+- `get({ did })` with a long form writes the pair after a successful resolution,
+  when `rememberOnResolve` is on.
+- `get({ did })` with a short form reads the store. It never writes.
+- `publicKeyToDidDoc()` does not write.
+
+`rememberOnResolve` is a constructor option and defaults to `true`. DIDComm
+clients keep the default, since the counterparty sends its long form once. A
+verifier that only fetches key nodes for signature checks should set it to
+`false`. Otherwise every key fetch is a durable write, and a store failure would
+fail the verification.
+
+```js
+const verifierDriver = didPeer.driver({
+  longFormStore: store,
+  rememberOnResolve: false
+})
+```
+
+An application that wants to gate contact acceptance resolves with
+`rememberOnResolve: false`. It writes `store.set(longToShort({ did }), did)`
+itself when it accepts the contact.
+
+A stored long form is checked on the way out. `decode` checks it against its own
+hash. The driver then checks that the long form's short form equals the one
+requested. A corrupt or mis-keyed entry fails with `invalidDid`. A store that
+throws or rejects fails with `internalError`, with the store error as `cause`. A
+failed store write in a long form `get()` also fails with `internalError`.
+
+Store growth. A store that writes on sight gains one entry per distinct long
+form resolved. Any counterparty can mint unlimited distinct long forms. A
+persistent store is therefore unbounded by construction. The store implementer
+owns bounds and eviction.
+
+The long form store is separate from the `CachedResolver` cache. That cache
+memoizes successful results by exact DID string for a few seconds. It knows
+nothing about short and long forms.
+
+### Errors
+
+| condition                                                                                     | thrown                                                       |
+| --------------------------------------------------------------------------------------------- | ------------------------------------------------------------ |
+| bad argument shape (`did` missing, both `inputDocument` and `seed`, ...)                      | `TypeError`                                                  |
+| not `did:peer:`                                                                               | `DIDResolutionError` `methodNotSupported`                    |
+| `did:peer:` with numalgo other than 4                                                         | `DIDResolutionError` `methodNotSupported`                    |
+| fails the long form regex, hash mismatch, bad multibase or multicodec prefix, non-object JSON | `DIDResolutionError` `invalidDid`                            |
+| short form with no stored long form                                                           | `DIDResolutionError` `notFound`                              |
+| stored long form's short form differs from the one requested                                  | `DIDResolutionError` `invalidDid`                            |
+| store `get` throws or rejects                                                                 | `DIDResolutionError` `internalError`, store error as `cause` |
+| store `set` rejects in `generate()`                                                           | `generate()` rejects with the store error as `cause`         |
+| store `set` rejects in `get()` (long form)                                                    | `DIDResolutionError` `internalError`, store error as `cause` |
+| hash-valid document whose shape contextualization cannot handle                               | `DIDResolutionError` `invalidDid`                            |
+| long form over `MAX_LONG_FORM_LENGTH`                                                         | `DIDResolutionError` `invalidDid`                            |
+| more than one `#` in a DID URL                                                                | `DIDResolutionError` `invalidDidUrl`                         |
+| `?query` or `/path` in a DID URL                                                              | stripped, and the authority resolves (no error)              |
+| fragment not in document                                                                      | `VerificationMethodError` `notFound`                         |
+| input document fails `validateInputDocument`                                                  | `TypeError` with the failing path in the message             |
+| unsupported multibase header, no or multiple suites                                           | plain `Error`                                                |
+
+No `TypeError` leaves resolution. A counterparty's document can only produce
+`DIDResolutionError`s. Match on `name` and `code`.
+
+`DIDResolutionError` comes from `@interop/data-integrity-core`. `CachedResolver`
+(did-io 4.3.0 and later) recognizes it by `name` and `code`, so a duplicated
+copy of that package in your dependency tree does not change the envelope.
+
+### Notes for implementers
+
+- Absolute and relative references. The driver returns absolute DID URLs. The
+  document from `get({ did })` and `generate()`, and the node from
+  `get({ url })`, use ids like `${did}#z6Mk...`. This is what the ecosystem's
+  verifiers compare against. The codec functions `resolveLongForm` and
+  `resolveShortForm` keep relative references, as the spec does.
+- Use the long form in proofs. A node fetched by long form URL carries the long
+  form in `id` and `controller`. The same node fetched by short form URL carries
+  the short form. No verifier in the ecosystem treats `alsoKnownAs` as an
+  equivalence. A proof naming one form and a capability controller naming the
+  other fails authorization. Put the long form in `proof.verificationMethod` and
+  in zcap `controller` fields. It resolves with no store, and it survives a lost
+  store.
+- `MAX_LONG_FORM_LENGTH` is 4096 characters, the longest base58 string the
+  `@scure/base` codec decodes. It is exported so callers can see it. The encoder
+  has its own limit of 2048 bytes of input; a larger input document fails
+  `encodeLongForm` and `generate()` with an `Error` naming the size.
+- Non-ASCII interop. The library serializes the input document with
+  `JSON.stringify`, which emits non-ASCII characters raw. Python's `json.dumps`
+  escapes them by default. An identical input document containing non-ASCII text
+  therefore yields a different long form from the Python library. Resolution is
+  unaffected, because the hash covers the bytes the creator produced. Only
+  independent re-derivation of the same DID from the same document differs.
+  `JSON.stringify` also emits integer-like keys first and serializes floats
+  differently from Python. Published test vectors are all ASCII.
+- DID URL queries. A `?query` or `/path` is stripped and ignored. A `?service=`
+  URL resolves to the document, or to the node named by its fragment.
+- The library does not canonicalize the input document. Key order and formatting
+  are preserved as given.
+
+## Contribute
+
+PRs accepted. See [CONTRIBUTING.md](CONTRIBUTING.md) for editor setup (Prettier,
+ESLint, and EditorConfig) and how it maps to CI.
+
+If editing the Readme, please conform to the
+[standard-readme](https://github.com/RichardLitt/standard-readme) specification.
+
+## License
+
+[MIT License](LICENSE.md) © 2026 Interop Alliance.

package/dist/DidPeerDriver.d.ts

@@ -0,0 +1,223 @@
+import type { DidGenerationResult, DidMethodDriver } from '@interop/did-io';
+import { type AbstractKeyPair, type IDIDDocument, type IKeyPair, type IPublicKey, type IVerificationMethodEntry } from '@interop/data-integrity-core';
+import type { DidPeerDriverOptions, FromMultibase, InputDocument, KeyPairClass, LongFormStore, RegisteredKeyType } from './types.js';
+type LiveEntry = {
+    keyPair: AbstractKeyPair | IKeyPair;
+    fragment?: string;
+    purposes?: string[];
+};
+/**
+ * A third-party method with explicit purposes. A bare
+ * `IVerificationMethodEntry` gets the four default purposes instead.
+ */
+type ThirdPartyEntry = {
+    method: IVerificationMethodEntry;
+    purposes: string[];
+};
+/**
+ * `generate()` options. The three entry paths are mutually exclusive:
+ * `inputDocument` (with optional `keyPairs`), `seed`, or explicit key pairs.
+ */
+export interface GenerateOptions {
+    inputDocument?: InputDocument;
+    keyPairs?: Map<string, AbstractKeyPair>;
+    seed?: string | Uint8Array;
+    keyType?: KeyPairClass | string;
+    verificationKeyPair?: AbstractKeyPair | IKeyPair;
+    keyAgreementKeyPair?: AbstractKeyPair | IKeyPair;
+    verificationMethods?: Array<LiveEntry | ThirdPartyEntry | IVerificationMethodEntry>;
+    service?: object[];
+}
+export declare class DidPeerDriver implements DidMethodDriver {
+    method: string;
+    longFormStore?: LongFormStore;
+    rememberOnResolve: boolean;
+    _allowedKeyTypes: Map<string, RegisteredKeyType>;
+    /**
+     * @param options {object}
+     * @param [options.longFormStore] {LongFormStore} - Where long forms are
+     *   remembered so short forms resolve. A `Map` works for in-memory use.
+     *   Without one, every short form is `notFound`.
+     * @param [options.rememberOnResolve=true] {boolean} - Whether a successful
+     *   long form `get()` writes the store. `generate()` always writes.
+     */
+    constructor({ longFormStore, rememberOnResolve }?: DidPeerDriverOptions);
+    /**
+     * Registers a key suite for generation and key rebuilding.
+     *
+     * Preferred form: pass a `keyPairClass` exposing static `multibaseHeader`,
+     * `from` and (optionally) `generate`. Lower-level form: pass
+     * `multibaseMultikeyHeader` plus a `fromMultibase` deserializer; suites
+     * registered this way cannot `generate()`.
+     *
+     * @param options {object}
+     * @param [options.keyPairClass] {KeyPairClass}
+     * @param [options.multibaseMultikeyHeader] {string}
+     * @param [options.fromMultibase] {FromMultibase}
+     * @param [options.enableEncryptionKeyDerivation=false] {boolean} - When
+     *   `true`, generating with this (Ed25519) suite also derives an X25519
+     *   `keyAgreement` key from the verification key. Off by default, since
+     *   reusing one key for signing and key agreement is a posture choice.
+     */
+    use({ keyPairClass, multibaseMultikeyHeader, fromMultibase, enableEncryptionKeyDerivation }?: {
+        keyPairClass?: KeyPairClass;
+        multibaseMultikeyHeader?: string;
+        fromMultibase?: FromMultibase;
+        enableEncryptionKeyDerivation?: boolean;
+    }): void;
+    /**
+     * Generates a did:peer numalgo 4 DID. Three mutually exclusive entry paths:
+     *
+     * 1. `inputDocument`: validated, encoded and resolved as given. `keyPairs`
+     *    (keyed by bare fragment) binds live pairs to the document's methods;
+     *    a fragment with no method, or a public key that differs, is a
+     *    `TypeError`.
+     * 2. `seed`: one key pair is derived with the selected or sole registered
+     *    suite, then as path 3.
+     * 3. Explicit or random key pairs: `verificationKeyPair` (or a fresh random
+     *    pair) gets the four default purposes; `keyAgreementKeyPair` gets
+     *    `keyAgreement`, or an X25519 key is derived when the suite was
+     *    registered with `enableEncryptionKeyDerivation`; `verificationMethods`
+     *    entries (`{ keyPair, fragment?, purposes? }`, `{ method, purposes }`
+     *    for a third-party method with explicit purposes, or a bare third-party
+     *    reference / method object with the default four) are added in order;
+     *    `service` is copied.
+     *
+     * Every path binds the live pairs (`controller` and `id` set to the long
+     * form), writes the long form store when one is configured, and returns the
+     * did-io generation result. `didDocument.id` is the long form.
+     *
+     * @param [options] {GenerateOptions}
+     *
+     * @returns {Promise<DidGenerationResult>}
+     */
+    generate(options?: GenerateOptions): Promise<DidGenerationResult>;
+    _generate({ inputDocument, keyPairs, seed, keyType, verificationKeyPair, keyAgreementKeyPair, verificationMethods, service }: GenerateOptions, { remember }: {
+        remember: boolean;
+    }): Promise<DidGenerationResult>;
+    /**
+     * Generates a did:peer DID from existing key pairs (live instances or plain
+     * public key descriptions, rebuilt through the registered suites). With only
+     * `keyAgreementKeyPair`, no signing key is generated.
+     *
+     * @param options {object}
+     * @param [options.verificationKeyPair] {AbstractKeyPair | IKeyPair}
+     * @param [options.keyAgreementKeyPair] {AbstractKeyPair | IKeyPair}
+     *
+     * @returns {Promise<DidGenerationResult>}
+     */
+    fromKeyPair({ verificationKeyPair, keyAgreementKeyPair }?: {
+        verificationKeyPair?: AbstractKeyPair | IKeyPair;
+        keyAgreementKeyPair?: AbstractKeyPair | IKeyPair;
+    }): Promise<DidGenerationResult>;
+    /**
+     * Converts a public key description to a did:peer DID document. An X25519
+     * description becomes the `keyAgreement` key, anything else the
+     * verification key. Unlike `generate()`, no `keyPairs` map is returned and
+     * the long form store is not written.
+     *
+     * @param options {object}
+     * @param options.publicKeyDescription {AbstractKeyPair | IKeyPair | IPublicKey}
+     *
+     * @returns {Promise<{didDocument: IDIDDocument}>}
+     */
+    publicKeyToDidDoc({ publicKeyDescription }?: {
+        publicKeyDescription?: AbstractKeyPair | IKeyPair | IPublicKey;
+    }): Promise<{
+        didDocument: IDIDDocument;
+    }>;
+    /**
+     * Resolves a did:peer numalgo 4 DID or DID URL. A long form resolves
+     * offline; a short form resolves through the long form store. A `#fragment`
+     * returns the verification method or service node with that id, cloned,
+     * with an `@context`. A `?query` or `/path` is stripped and the authority
+     * resolved.
+     *
+     * @param options {object}
+     * @param [options.did] {string}
+     * @param [options.url] {string} - Alias for `did`.
+     *
+     * @throws {DIDResolutionError} `methodNotSupported` for a non-did:peer DID
+     *   or another numalgo; `invalidDid` for a malformed or tampered DID;
+     *   `invalidDidUrl` for more than one `#`; `notFound` for a short form whose
+     *   long form has not been seen; `internalError` for a store failure.
+     * @throws {VerificationMethodError} `notFound` for an unknown fragment.
+     *
+     * @returns {Promise<IDIDDocument | IPublicKey>}
+     */
+    get({ did, url }?: {
+        did?: string;
+        url?: string;
+        [key: string]: unknown;
+    }): Promise<IDIDDocument | IPublicKey>;
+    /**
+     * Returns the public verification method for a purpose from a DID document
+     * returned by this driver (whose references are absolute), without
+     * `@context`.
+     *
+     * @param options {object}
+     * @param options.didDocument {IDIDDocument}
+     * @param options.purpose {string}
+     *
+     * @returns {IPublicKey}
+     */
+    publicMethodFor({ didDocument, purpose }?: {
+        didDocument?: IDIDDocument;
+        purpose?: string;
+    }): IPublicKey;
+    /**
+     * Resolves a short form through the long form store: a missing store or a
+     * value that is not a non-empty string is `notFound`; a store that throws,
+     * or returns a string that is not a long form, is `internalError`; a stored
+     * long form whose own short form differs from the requested one is
+     * `invalidDid`. Does not write.
+     */
+    _resolveShortForm(shortForm: string): Promise<IDIDDocument>;
+    /**
+     * Checks that a live pair's public key equals the input document's method
+     * `#${fragment}` before the pair is bound to it. A method carrying
+     * `publicKeyMultibase` is compared directly. Any other serialization (a 2018
+     * suite's `publicKeyBase58`, a JSON Web Key's `publicKeyJwk`) is rebuilt
+     * through the pair's own registered suite and compared by fingerprint, so
+     * the suite decides which serializations it can read.
+     */
+    _assertPairMatchesMethod({ inputDocument, fragment, pair }: {
+        inputDocument: InputDocument;
+        fragment: string;
+        pair: AbstractKeyPair;
+    }): Promise<void>;
+    /**
+     * Returns a live pair's public key as a multibase Multikey string: its
+     * `publicKeyMultibase`, or its `fingerprint()` for a suite that serializes
+     * the public key another way.
+     */
+    _publicKeyMultibaseOf(pair: AbstractKeyPair): string;
+    /**
+     * Derives an X25519 key agreement pair from a live Ed25519 pair when its
+     * suite was registered with `enableEncryptionKeyDerivation`; otherwise
+     * returns `undefined`.
+     */
+    _deriveKeyAgreementKey(verificationPair: AbstractKeyPair): AbstractKeyPair | undefined;
+    /**
+     * Generates a key pair from the selected or sole registered suite.
+     */
+    _generateKeyPair({ seed, keyType }?: {
+        seed?: string | Uint8Array;
+        keyType?: KeyPairClass | string;
+    }): Promise<AbstractKeyPair>;
+    /**
+     * Returns a live key pair for a live instance or a plain public key
+     * description (rebuilt through the registered suite for its header).
+     */
+    _toKeyPair(description: AbstractKeyPair | IKeyPair | IPublicKey): Promise<AbstractKeyPair>;
+}
+/**
+ * Factory matching the `.driver()` API of the other did-io drivers.
+ *
+ * @param [options] {DidPeerDriverOptions}
+ *
+ * @returns {DidPeerDriver}
+ */
+export declare function driver(options?: DidPeerDriverOptions): DidPeerDriver;
+export {};
+//# sourceMappingURL=DidPeerDriver.d.ts.map

package/dist/DidPeerDriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DidPeerDriver.d.ts","sourceRoot":"","sources":["../src/DidPeerDriver.ts"],"names":[],"mappings":"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"}