@interop/wallet-core 0.41.0 → 0.43.0

package/dist/unlock/standingWebvh.d.ts

@@ -0,0 +1,153 @@
+import type { VerificationMethod } from '@interop/did-method-webvh';
+import type { ClientWebvhUpdateKeys, WebvhEnrollmentKeys, WebvhIdStore } from '../webvh/didWebvh.js';
+/**
+ * The narrow store seam the self-enrollment continuation writes through: a
+ * public read of the log and the delegated `did.jsonl` PUT. A subset of
+ * {@link WebvhIdStore}, so an app's remote-store class satisfies it too.
+ */
+export type UnlockLogStore = Pick<WebvhIdStore, 'getIdResourceRaw' | 'putIdResource'>;
+/**
+ * How a credential's key-agreement key is published in the document: the key
+ * verbatim (a high-entropy credential -- passkey PRF, recovery code), or its
+ * hash commitment (`keyAgreementCommitment`) for a low-entropy-derived key.
+ * A commitment withholds the key material and gives the roster's recipient
+ * resolver a document-anchored check to verify a roster-carried key against.
+ */
+export type UnlockKeyAgreementPublication = {
+    publicKeyMultibase: string;
+} | {
+    commitment: string;
+};
+/**
+ * A standing credential's public posture as the document and log carry it:
+ * its key-agreement publication and the update key whose hash stands in
+ * `nextKeyHashes` (ladder rung 0 at bind time; a code's single derived key).
+ */
+export interface StandingUnlockKeys {
+    keyAgreement: UnlockKeyAgreementPublication;
+    updateKeyMultibase: string;
+}
+/**
+ * The verification-method id a credential's key-agreement entry publishes
+ * under: `<did>#<multibase>` for a verbatim key (indistinguishable by id from
+ * any other keyAgreement entry), `<did>#<commitment>` for a commitment entry
+ * (the commitment string is deterministic, so the id is too).
+ *
+ * @param options {object}
+ * @param options.did {string}   the account's did:webvh
+ * @param options.keyAgreement {UnlockKeyAgreementPublication}
+ * @returns {string}
+ */
+export declare function unlockKeyVmId({ did, keyAgreement }: {
+    did: string;
+    keyAgreement: UnlockKeyAgreementPublication;
+}): string;
+/**
+ * The credential's `keyAgreement` verification method: an ordinary unmarked
+ * entry carrying either the key verbatim (a `Multikey` with
+ * `publicKeyMultibase`) or its hash commitment (a `MultikeyCommitment` with
+ * `publicKeyCommitment` -- the document convention for a low-entropy-derived
+ * key, which withholds the key material and gives the roster resolver a
+ * document-anchored check). Controlled by the account and deliberately
+ * unmarked: a credential is not a listed client, so its entry must never
+ * carry the controller marker a client listing or a revocation removal
+ * matches on.
+ *
+ * @param options {object}
+ * @param options.did {string}   the account's did:webvh
+ * @param options.keyAgreement {UnlockKeyAgreementPublication}
+ * @returns {VerificationMethod}
+ */
+export declare function unlockKeyVerificationMethod({ did, keyAgreement }: {
+    did: string;
+    keyAgreement: UnlockKeyAgreementPublication;
+}): VerificationMethod;
+/**
+ * BIND (run by an enrolled client, root authority): publishes a standing
+ * credential's split posture into the document -- one entry adding the
+ * credential's `keyAgreement` entry (verbatim or commitment) and committing
+ * its current update key's hash in `nextKeyHashes`. The update key joins
+ * `updateKeys` nowhere. Idempotent: a posture already published is a no-op,
+ * so re-running a torn bind converges. The entry publishes conditionally on
+ * the log this call read; a race lost to a concurrent ceremony re-runs and
+ * rebases on the new head.
+ *
+ * @param options {object}
+ * @param options.idStore {WebvhIdStore}
+ * @param options.updateKeys {ClientWebvhUpdateKeys}   the BINDING client's own
+ *   did:webvh update-key seeds
+ * @param options.unlockKeys {StandingUnlockKeys}   the credential's public
+ *   posture
+ * @param [options.expectedDid] {string}   the account DID the log must resolve
+ *   to, from the caller's stored account pointer
+ * @param [options.verb] {string}   what the caller is doing, for the
+ *   pending-rotation refusal message (e.g. `'issuing a recovery code'`)
+ * @returns {Promise<{ did: string }>}
+ */
+export declare function publishUnlockKey(options: {
+    idStore: WebvhIdStore;
+    updateKeys: ClientWebvhUpdateKeys;
+    unlockKeys: StandingUnlockKeys;
+    expectedDid?: string;
+    verb?: string;
+}): Promise<{
+    did: string;
+}>;
+/**
+ * REMOVAL (run by an enrolled client, root authority): removes a standing
+ * credential's posture from the document -- its `keyAgreement` entry and its
+ * committed update-key hash -- in one entry. Idempotent. The roster-side half
+ * (rotating the user key epoch off the credential's wrap) is the caller's,
+ * and runs after this so the resolver's document no longer backs the removed
+ * entry.
+ *
+ * @param options {object}   see {@link publishUnlockKey}
+ * @returns {Promise<{ did: string }>}
+ */
+export declare function removeUnlockKey(options: {
+    idStore: WebvhIdStore;
+    updateKeys: ClientWebvhUpdateKeys;
+    unlockKeys: StandingUnlockKeys;
+    expectedDid?: string;
+    verb?: string;
+}): Promise<{
+    did: string;
+}>;
+/**
+ * SELF-ENROLLMENT (run by the credential-derived client through the delegated
+ * `did.jsonl` PUT): writes the standing continuation described in the module
+ * doc -- the reveal-and-commit entry signed by the attributed ladder rung,
+ * then the add entry signed by the new ordinary client's update key, which
+ * also retires the spent rung. Resumable from durable state alone: a
+ * completed continuation is detected by the new client's update key already
+ * being authorized (no-op), a torn one by the attribution finding the rung
+ * already revealed. Both entries publish conditionally on the read they were
+ * built on, and a race lost to a concurrent ceremony re-runs from the top --
+ * re-attributing, which is exactly the retry-up-the-ladder resolution.
+ *
+ * @param options {object}
+ * @param options.store {UnlockLogStore}   public log read + delegated PUT
+ * @param options.ladderSeed {Uint8Array}   the credential's ladder seed, from
+ *   its unlock record
+ * @param options.newClientKeys {WebvhEnrollmentKeys}   the new ordinary
+ *   client's public halves
+ * @param options.newClientUpdateSeeds {ClientWebvhUpdateKeys}   the new
+ *   client's update-key seeds (minted by the self-enrolling flow, which
+ *   therefore holds them and can sign the add entry)
+ * @param [options.expectedDid] {string}   the account DID the log must resolve
+ *   to, from the credential-authenticated pointer
+ * @returns {Promise<{ did: string, webDoc?: object }>}   the account DID and,
+ *   when the add entry ran here, the final `did.json` projection for the
+ *   enrolled session to republish
+ */
+export declare function selfEnrollWebvhClient(options: {
+    store: UnlockLogStore;
+    ladderSeed: Uint8Array;
+    newClientKeys: WebvhEnrollmentKeys;
+    newClientUpdateSeeds: ClientWebvhUpdateKeys;
+    expectedDid?: string;
+}): Promise<{
+    did: string;
+    webDoc?: object;
+}>;
+//# sourceMappingURL=standingWebvh.d.ts.map

package/dist/unlock/standingWebvh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standingWebvh.d.ts","sourceRoot":"","sources":["../../src/unlock/standingWebvh.ts"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EAAU,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAe3E,OAAO,KAAK,EACV,qBAAqB,EAErB,mBAAmB,EACnB,YAAY,EACb,MAAM,sBAAsB,CAAA;AAG7B;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,IAAI,CAC/B,YAAY,EACZ,kBAAkB,GAAG,eAAe,CACrC,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,6BAA6B,GACvC;IAAE,kBAAkB,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAA;AAEzD;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,6BAA6B,CAAA;IAC3C,kBAAkB,EAAE,MAAM,CAAA;CAC3B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,EAC5B,GAAG,EACH,YAAY,EACb,EAAE;IACD,GAAG,EAAE,MAAM,CAAA;IACX,YAAY,EAAE,6BAA6B,CAAA;CAC5C,GAAG,MAAM,CAMT;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,2BAA2B,CAAC,EAC1C,GAAG,EACH,YAAY,EACb,EAAE;IACD,GAAG,EAAE,MAAM,CAAA;IACX,YAAY,EAAE,6BAA6B,CAAA;CAC5C,GAAG,kBAAkB,CAgBrB;AAsDD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE;IAC9C,OAAO,EAAE,YAAY,CAAA;IACrB,UAAU,EAAE,qBAAqB,CAAA;IACjC,UAAU,EAAE,kBAAkB,CAAA;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,GAAG,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAI3B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE;IAC7C,OAAO,EAAE,YAAY,CAAA;IACrB,UAAU,EAAE,qBAAqB,CAAA;IACjC,UAAU,EAAE,kBAAkB,CAAA;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,GAAG,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAI3B;AAkGD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE;IACnD,KAAK,EAAE,cAAc,CAAA;IACrB,UAAU,EAAE,UAAU,CAAA;IACtB,aAAa,EAAE,mBAAmB,CAAA;IAClC,oBAAoB,EAAE,qBAAqB,CAAA;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,GAAG,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAE5C"}

package/dist/unlock/standingWebvh.js

@@ -0,0 +1,370 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The did:webvh half of the standing unlock-credential lifecycle: the split
+ * posture every unlock method holds under the standing model, and the
+ * self-enrolling continuation a fresh browser runs with nothing but the
+ * credential in hand.
+ *
+ * At bind time the document gains the credential's `keyAgreement` entry --
+ * the key verbatim for a high-entropy credential (a passkey PRF output, a
+ * recovery code), or a `MultikeyCommitment` entry for a low-entropy-derived
+ * key (a passphrase), so the world-readable document carries a check on the
+ * key without carrying the key -- and `nextKeyHashes` gains the hash of the
+ * credential's current update key (a ladder rung, or a code's single derived
+ * key).
+ * Decryption standing, authority latent: the credential's update key joins
+ * `updateKeys` nowhere, and both entries are deliberately unmarked, so client
+ * listings (keyed on `capabilityInvocation`) and revocation removals never
+ * see them. {@link publishUnlockKey} / {@link removeUnlockKey} are one merged
+ * add/remove pair, shared verbatim by the recovery-code wrappers.
+ *
+ * Self-enrollment ({@link selfEnrollWebvhClient}) is the recovery
+ * continuation generalized to a non-spending credential: two entries through
+ * the record's delegated `did.jsonl` bridge --
+ *
+ * 1. **Reveal + commit**: ladder rung `i` joins `updateKeys` (its hash stands
+ *    committed, which is what makes the entry verify) and `nextKeyHashes`
+ *    extends with the new ordinary client's update- and staged-key hashes
+ *    plus `hash(rung i + 1)` -- the credential's next standing commitment.
+ * 2. **Add + retire the rung**: signed by the new client's update key
+ *    (revealed from the commit), this entry publishes the new client's
+ *    verification methods and update key and drops the spent rung and its
+ *    hash. The credential's own posture -- its `keyAgreement` entry and the
+ *    freshly committed `hash(rung i + 1)` -- stands untouched, ready for the
+ *    next self-enrollment. Nothing is spent, and no replacement exists.
+ *
+ * Which rung is current is recovered from the log itself
+ * (`attributeLadderRung`, fail-closed); a lost compare-and-swap race re-runs,
+ * re-attributes, and climbs to the winner's committed rung -- the
+ * retry-up-the-ladder resolution. Every stage is idempotent and resumable
+ * from durable state alone, on the recovery continuation's pattern.
+ */
+import { deriveNextKeyHash, updateDID } from '@interop/did-method-webvh';
+import { assertCarryOverCommitments, BYOE_CONTEXT_URL, markedVerificationMethodPair, MULTIKEY_COMMITMENT_VM_TYPE, MULTIKEY_VM_TYPE, publishUpdatedLog, putLogResource, readPublishedLog, relationIds, updateKeyMultibase, updateKeySigner, withLogConflictRetry } from '../webvh/didWebvh.js';
+import { attributeLadderRung, ladderRung } from './ladder.js';
+/**
+ * The verification-method id a credential's key-agreement entry publishes
+ * under: `<did>#<multibase>` for a verbatim key (indistinguishable by id from
+ * any other keyAgreement entry), `<did>#<commitment>` for a commitment entry
+ * (the commitment string is deterministic, so the id is too).
+ *
+ * @param options {object}
+ * @param options.did {string}   the account's did:webvh
+ * @param options.keyAgreement {UnlockKeyAgreementPublication}
+ * @returns {string}
+ */
+export function unlockKeyVmId({ did, keyAgreement }) {
+    const fragment = 'publicKeyMultibase' in keyAgreement
+        ? keyAgreement.publicKeyMultibase
+        : keyAgreement.commitment;
+    return `${did}#${fragment}`;
+}
+/**
+ * The credential's `keyAgreement` verification method: an ordinary unmarked
+ * entry carrying either the key verbatim (a `Multikey` with
+ * `publicKeyMultibase`) or its hash commitment (a `MultikeyCommitment` with
+ * `publicKeyCommitment` -- the document convention for a low-entropy-derived
+ * key, which withholds the key material and gives the roster resolver a
+ * document-anchored check). Controlled by the account and deliberately
+ * unmarked: a credential is not a listed client, so its entry must never
+ * carry the controller marker a client listing or a revocation removal
+ * matches on.
+ *
+ * @param options {object}
+ * @param options.did {string}   the account's did:webvh
+ * @param options.keyAgreement {UnlockKeyAgreementPublication}
+ * @returns {VerificationMethod}
+ */
+export function unlockKeyVerificationMethod({ did, keyAgreement }) {
+    const id = unlockKeyVmId({ did, keyAgreement });
+    if ('publicKeyMultibase' in keyAgreement) {
+        return {
+            id,
+            type: MULTIKEY_VM_TYPE,
+            controller: did,
+            publicKeyMultibase: keyAgreement.publicKeyMultibase
+        };
+    }
+    return {
+        id,
+        type: MULTIKEY_COMMITMENT_VM_TYPE,
+        controller: did,
+        publicKeyCommitment: keyAgreement.commitment
+    };
+}
+/**
+ * Reads and resolves the published log through the narrow store seam.
+ *
+ * @param options {object}
+ * @param options.store {UnlockLogStore}
+ * @param [options.expectedDid] {string}   the account DID the log must resolve
+ *   to, where the caller holds one
+ * @returns {Promise<PublishedWebvhLog>}
+ */
+async function readLogOrThrow({ store, expectedDid }) {
+    // readPublishedLog only calls getIdResourceRaw, so the narrow seam is safe.
+    const published = await readPublishedLog({
+        idStore: store,
+        ...(expectedDid !== undefined ? { expectedDid } : {})
+    });
+    if (!published) {
+        throw new Error('did:webvh: did.jsonl is missing; nothing to enroll into.');
+    }
+    return published;
+}
+/**
+ * Publishes `did.jsonl` through the narrow seam -- the log only, never
+ * `did.json` (the bridge delegation covers nothing else; the enrolled session
+ * republishes the projection once it is the controller). Conditional on the
+ * read the entry was built on; a lost race surfaces as a
+ * `WebvhLogConflictError` (the mapping lives in `putLogResource`).
+ *
+ * @param options {object}
+ * @param options.store {UnlockLogStore}
+ * @param options.log {DIDLog}
+ * @param [options.ifMatch] {string}   publish only if `did.jsonl` is unchanged
+ * @returns {Promise<void>}
+ */
+async function publishLogOnly({ store, log, ifMatch }) {
+    await putLogResource({ store, log, ifMatch });
+}
+/**
+ * BIND (run by an enrolled client, root authority): publishes a standing
+ * credential's split posture into the document -- one entry adding the
+ * credential's `keyAgreement` entry (verbatim or commitment) and committing
+ * its current update key's hash in `nextKeyHashes`. The update key joins
+ * `updateKeys` nowhere. Idempotent: a posture already published is a no-op,
+ * so re-running a torn bind converges. The entry publishes conditionally on
+ * the log this call read; a race lost to a concurrent ceremony re-runs and
+ * rebases on the new head.
+ *
+ * @param options {object}
+ * @param options.idStore {WebvhIdStore}
+ * @param options.updateKeys {ClientWebvhUpdateKeys}   the BINDING client's own
+ *   did:webvh update-key seeds
+ * @param options.unlockKeys {StandingUnlockKeys}   the credential's public
+ *   posture
+ * @param [options.expectedDid] {string}   the account DID the log must resolve
+ *   to, from the caller's stored account pointer
+ * @param [options.verb] {string}   what the caller is doing, for the
+ *   pending-rotation refusal message (e.g. `'issuing a recovery code'`)
+ * @returns {Promise<{ did: string }>}
+ */
+export async function publishUnlockKey(options) {
+    return withLogConflictRetry(() => setUnlockKeyPostureOnce({ ...options, polarity: 'publish' }));
+}
+/**
+ * REMOVAL (run by an enrolled client, root authority): removes a standing
+ * credential's posture from the document -- its `keyAgreement` entry and its
+ * committed update-key hash -- in one entry. Idempotent. The roster-side half
+ * (rotating the user key epoch off the credential's wrap) is the caller's,
+ * and runs after this so the resolver's document no longer backs the removed
+ * entry.
+ *
+ * @param options {object}   see {@link publishUnlockKey}
+ * @returns {Promise<{ did: string }>}
+ */
+export async function removeUnlockKey(options) {
+    return withLogConflictRetry(() => setUnlockKeyPostureOnce({ ...options, polarity: 'remove' }));
+}
+/**
+ * One attempt of the merged posture edit, re-invoked by the conflict retry.
+ * The publish and remove polarities are one function because the entry they
+ * build is the same edit with the set operations inverted -- a divergence
+ * between two copies would be published into an append-only log.
+ *
+ * @param options {object}   see {@link publishUnlockKey}, plus `polarity`
+ * @returns {Promise<{ did: string }>}
+ */
+async function setUnlockKeyPostureOnce({ idStore, updateKeys, unlockKeys, expectedDid, verb, polarity }) {
+    const published = await readLogOrThrow({
+        store: idStore,
+        ...(expectedDid !== undefined ? { expectedDid } : {})
+    });
+    const { did, doc } = published;
+    const keyHash = await deriveNextKeyHash(unlockKeys.updateKeyMultibase);
+    const vmId = unlockKeyVmId({ did, keyAgreement: unlockKeys.keyAgreement });
+    const vmPresent = (doc.verificationMethod ?? []).some(method => method.id === vmId);
+    const hashCommitted = published.nextKeyHashes.includes(keyHash);
+    const settled = polarity === 'publish'
+        ? vmPresent && hashCommitted
+        : !vmPresent && !hashCommitted;
+    if (settled) {
+        return { did };
+    }
+    const activeKey = await updateKeyMultibase({ seed: updateKeys.updateSeed });
+    if (!published.updateKeys.includes(activeKey)) {
+        throw new Error("did:webvh: the published log does not authorize this client's active " +
+            'update key; finalize the pending rotation before ' +
+            `${verb ?? 'changing an unlock credential'}.`);
+    }
+    await assertCarryOverCommitments({ published });
+    const existingMethods = (doc.verificationMethod ?? []);
+    const signer = await updateKeySigner({ seed: updateKeys.updateSeed });
+    const nextKeyHashes = polarity === 'publish'
+        ? [...new Set([...published.nextKeyHashes, keyHash])]
+        : published.nextKeyHashes.filter(hash => hash !== keyHash);
+    const verificationMethods = polarity === 'publish'
+        ? [
+            ...existingMethods.filter(method => method.id !== vmId),
+            unlockKeyVerificationMethod({
+                did,
+                keyAgreement: unlockKeys.keyAgreement
+            })
+        ]
+        : existingMethods.filter(method => method.id !== vmId);
+    const keyAgreement = polarity === 'publish'
+        ? [...new Set([...relationIds(doc.keyAgreement), vmId])]
+        : relationIds(doc.keyAgreement).filter(id => id !== vmId);
+    const updated = await updateDID({
+        log: published.log,
+        signer,
+        alsoKnownAsWeb: true,
+        // A commitment entry's terms are defined by the byoe context, so the
+        // posture publish appends it to the carried-forward context. The append
+        // is deduplicated, so a document already carrying it is unchanged.
+        additionalContext: [BYOE_CONTEXT_URL],
+        updateKeys: published.updateKeys,
+        nextKeyHashes,
+        verificationMethods,
+        authentication: relationIds(doc.authentication),
+        assertionMethod: relationIds(doc.assertionMethod),
+        keyAgreement,
+        capabilityInvocation: relationIds(doc.capabilityInvocation),
+        capabilityDelegation: relationIds(doc.capabilityDelegation)
+    });
+    await publishUpdatedLog({ idStore, updated, ifMatch: published.etag });
+    return { did: updated.did };
+}
+/**
+ * SELF-ENROLLMENT (run by the credential-derived client through the delegated
+ * `did.jsonl` PUT): writes the standing continuation described in the module
+ * doc -- the reveal-and-commit entry signed by the attributed ladder rung,
+ * then the add entry signed by the new ordinary client's update key, which
+ * also retires the spent rung. Resumable from durable state alone: a
+ * completed continuation is detected by the new client's update key already
+ * being authorized (no-op), a torn one by the attribution finding the rung
+ * already revealed. Both entries publish conditionally on the read they were
+ * built on, and a race lost to a concurrent ceremony re-runs from the top --
+ * re-attributing, which is exactly the retry-up-the-ladder resolution.
+ *
+ * @param options {object}
+ * @param options.store {UnlockLogStore}   public log read + delegated PUT
+ * @param options.ladderSeed {Uint8Array}   the credential's ladder seed, from
+ *   its unlock record
+ * @param options.newClientKeys {WebvhEnrollmentKeys}   the new ordinary
+ *   client's public halves
+ * @param options.newClientUpdateSeeds {ClientWebvhUpdateKeys}   the new
+ *   client's update-key seeds (minted by the self-enrolling flow, which
+ *   therefore holds them and can sign the add entry)
+ * @param [options.expectedDid] {string}   the account DID the log must resolve
+ *   to, from the credential-authenticated pointer
+ * @returns {Promise<{ did: string, webDoc?: object }>}   the account DID and,
+ *   when the add entry ran here, the final `did.json` projection for the
+ *   enrolled session to republish
+ */
+export async function selfEnrollWebvhClient(options) {
+    return withLogConflictRetry(() => selfEnrollWebvhClientOnce(options));
+}
+/**
+ * One attempt of {@link selfEnrollWebvhClient}, re-invoked by the conflict
+ * retry.
+ *
+ * @param options {object}   see {@link selfEnrollWebvhClient}
+ * @returns {Promise<{ did: string, webDoc?: object }>}
+ */
+async function selfEnrollWebvhClientOnce({ store, ladderSeed, newClientKeys, newClientUpdateSeeds, expectedDid }) {
+    let published = await readLogOrThrow({
+        store,
+        ...(expectedDid !== undefined ? { expectedDid } : {})
+    });
+    // Already complete (a torn earlier run finished the add entry): the new
+    // client's update key is authorized, which only the add entry writes.
+    if (published.updateKeys.includes(newClientKeys.updateKeyMultibase)) {
+        return { did: published.did };
+    }
+    // Which rung is current, recovered from the log itself. Fails closed with
+    // `LadderAttributionError` for a revoked (or never-bound) credential and
+    // for any ambiguous history.
+    const { rung, state } = await attributeLadderRung({ ladderSeed, published });
+    const nextRung = await ladderRung({ ladderSeed, index: rung.index + 1 });
+    const rungHash = await deriveNextKeyHash(rung.keyMultibase);
+    const newUpdateHash = await deriveNextKeyHash(newClientKeys.updateKeyMultibase);
+    const newStagedHash = await deriveNextKeyHash(newClientKeys.stagedUpdateKeyMultibase);
+    const nextRungHash = await deriveNextKeyHash(nextRung.keyMultibase);
+    // The reveal-and-commit entry, skipped when a torn earlier run already
+    // published it (the rung revealed AND every needed hash committed).
+    const revealed = state === 'revealed';
+    const committed = [newUpdateHash, newStagedHash, nextRungHash].every(hash => published.nextKeyHashes.includes(hash));
+    if (!revealed || !committed) {
+        await assertCarryOverCommitments({ published });
+        const signer = await updateKeySigner({ seed: rung.seed });
+        const updated = await updateDID({
+            log: published.log,
+            signer,
+            alsoKnownAsWeb: true,
+            updateKeys: [...new Set([...published.updateKeys, rung.keyMultibase])],
+            // The spent rung's own hash is kept through this entry (so a resumed
+            // commit can re-state the revealed key); the add entry drops it, while
+            // the next rung's hash stays as the credential's standing commitment.
+            nextKeyHashes: [
+                ...new Set([
+                    ...published.nextKeyHashes,
+                    rungHash,
+                    newUpdateHash,
+                    newStagedHash,
+                    nextRungHash
+                ])
+            ]
+        });
+        await publishLogOnly({ store, log: updated.log, ifMatch: published.etag });
+        // The same account the reveal entry just extended.
+        published = await readLogOrThrow({ store, expectedDid: published.did });
+    }
+    // The add entry: the new client's verification methods and update key in;
+    // the spent rung's key and hash out. The credential's keyAgreement entry
+    // and the next rung's committed hash stand untouched. Signed by the new
+    // client's update key, whose hash the commit entry just committed.
+    const { did, doc } = published;
+    const vmId = (publicKeyMultibase) => `${did}#${publicKeyMultibase}`;
+    const addedMethods = markedVerificationMethodPair({
+        controller: did,
+        signingKeyMultibase: newClientKeys.signingKeyMultibase,
+        keyAgreementKeyMultibase: newClientKeys.keyAgreementKeyMultibase
+    });
+    const existingMethods = (doc.verificationMethod ?? []);
+    const verificationMethods = [
+        ...existingMethods.filter(method => !addedMethods.some(added => added.id === method.id)),
+        ...addedMethods
+    ];
+    const withReference = (relation, id) => [...new Set([...relationIds(relation), id])];
+    const signingVmId = vmId(newClientKeys.signingKeyMultibase);
+    const signer = await updateKeySigner({
+        seed: newClientUpdateSeeds.updateSeed
+    });
+    const updated = await updateDID({
+        log: published.log,
+        signer,
+        alsoKnownAsWeb: true,
+        updateKeys: [
+            ...new Set([
+                ...published.updateKeys.filter(key => key !== rung.keyMultibase),
+                newClientKeys.updateKeyMultibase
+            ])
+        ],
+        nextKeyHashes: published.nextKeyHashes.filter(hash => hash !== rungHash),
+        verificationMethods,
+        authentication: withReference(doc.authentication, signingVmId),
+        assertionMethod: withReference(doc.assertionMethod, signingVmId),
+        keyAgreement: withReference(doc.keyAgreement, vmId(newClientKeys.keyAgreementKeyMultibase)),
+        capabilityInvocation: withReference(doc.capabilityInvocation, signingVmId),
+        capabilityDelegation: withReference(doc.capabilityDelegation, signingVmId)
+    });
+    // Conditional on the read this entry was built on: the re-read above when
+    // the commit entry ran here, the first read when it was skipped.
+    await publishLogOnly({ store, log: updated.log, ifMatch: published.etag });
+    return { did: updated.did, webDoc: updated.webDoc };
+}
+//# sourceMappingURL=standingWebvh.js.map

package/dist/unlock/standingWebvh.js.map

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