@interop/wallet-core 0.41.0 → 0.42.0

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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"}

package/dist/unlock/unlockRecord.d.ts

@@ -0,0 +1,207 @@
+import type { IKeyAgreementKey, IKeyResolver, IZcap } from '@interop/data-integrity-core';
+import type { CollectionEncryption } from '@interop/was-client';
+import type { AccountPointer, RecordSigner, SignedRecord } from '../keyring/record.js';
+/**
+ * An unlock record's account binding is absent, malformed, or does not verify
+ * under the credential's binding MAC key. Its own class, distinct from a
+ * proof or decrypt failure: this is the refusal that says the record's
+ * account core (and ladder seed, where one rides) was not written by a holder
+ * of this credential -- a forged record redirecting login at another account,
+ * or a record from before the account moved hosts (either way the credential
+ * must be rebound).
+ */
+export declare class UnlockBindingError extends Error {
+    constructor(message: string);
+}
+/**
+ * A self-contained sealed record member: its own one-epoch descriptor plus
+ * the envelope sealed under it. Self-containment is what lets a member travel
+ * VERBATIM through a re-mint that re-seals its siblings -- each member
+ * decrypts against its own descriptor, not the frame's.
+ */
+export interface SealedRecordMember {
+    encryption: CollectionEncryption;
+    wrapped: unknown;
+}
+/**
+ * The unwrapped contents of an unlock record: the credential-authenticated
+ * account core (controller + pointer, plus the ladder seed where the
+ * credential is a standing method), the bridge delegation, the optional bind
+ * email, and the bind timestamp. `pointer` is required -- the record exists
+ * only on WAS deployments.
+ */
+export interface UnlockRecordContents {
+    controller: string;
+    email?: string;
+    pointer: AccountPointer;
+    delegation: IZcap;
+    ladderSeed?: Uint8Array;
+    createdAt: string;
+}
+/**
+ * A stored unlock record: the shared signed frame plus the record-kind
+ * members the frame proof also covers.
+ */
+export interface SignedUnlockRecord extends SignedRecord {
+    binding: string;
+    bridge: SealedRecordMember;
+    ladder?: SealedRecordMember;
+}
+/**
+ * Where an unlock record's proof stands after the unwrap: `'verified'` when
+ * the credential-derived unlock key signed it (checked before decryption), or
+ * a pending marker naming the signer the caller must still check against the
+ * account's verified did:webvh document -- the re-mint case, where an
+ * enrolled client signed on the credential's behalf. The pending case defers
+ * the shell's authenticity only, never the account identity: the binding is
+ * verified either way.
+ */
+export type UnlockRecordProofState = 'verified' | {
+    pending: {
+        verificationMethod: string;
+        keyMultibase: string;
+    };
+};
+/**
+ * Computes the account-binding tag: HMAC-SHA-256 over the core values under
+ * the credential-derived binding MAC key, base64url (no pad). Bind time calls
+ * it to stamp the record; login recomputes it to verify.
+ *
+ * @param options {object}
+ * @param options.bindingMacKey {Uint8Array}   the credential-derived MAC key
+ * @param options.controller {string}   the account controller
+ * @param options.pointer {AccountPointer}   the account pointer
+ * @param [options.ladderSeed] {Uint8Array}   the ladder seed, for a standing
+ *   credential
+ * @returns {string}
+ */
+export declare function computeUnlockBinding({ bindingMacKey, controller, pointer, ladderSeed }: {
+    bindingMacKey: Uint8Array;
+    controller: string;
+    pointer: AccountPointer;
+    ladderSeed?: Uint8Array;
+}): string;
+/**
+ * Reads the `binding` frame member off a stored unlock record without
+ * decrypting anything. The re-mint path uses it to confirm the record is
+ * re-mintable before touching it. Refuses a record with no binding: such a
+ * record predates the credential-authenticated core and cannot be re-minted
+ * -- its credential must be rebound.
+ *
+ * @param options {object}
+ * @param options.record {unknown}   the stored record envelope
+ * @returns {string}
+ */
+export declare function unlockRecordBinding({ record }: {
+    record: unknown;
+}): string;
+/**
+ * Wraps an unlock record at bind time: the shell (controller, optional
+ * email, pointer, timestamp) sealed to the credential's unlock KAK, the
+ * bridge delegation and the optional ladder seed sealed as their own
+ * members, the credential-authenticated binding computed over the core, and
+ * the whole frame signed -- by the credential-derived unlock key at bind
+ * time, or by an acting client's account key where a ceremony rebuilds a
+ * record whole (the reader settles the mixed-signer policy either way).
+ *
+ * @param options {object}
+ * @param options.controller {string}   the account controller
+ * @param [options.email] {string}   the account email, when known
+ * @param options.pointer {AccountPointer}   the account pointer
+ * @param options.delegation {IZcap}   the PUT-on-`did.jsonl` delegation to
+ *   the credential-derived signing DID
+ * @param [options.ladderSeed] {Uint8Array}   the update-key ladder seed, for
+ *   a standing credential (a recovery code carries none)
+ * @param options.keyAgreementKey {IKeyAgreementKey}   the credential's unlock
+ *   KAK -- its public half is all the wrap uses
+ * @param options.signer {RecordSigner}   the signing key
+ * @param options.bindingMacKey {Uint8Array}   the credential-derived binding
+ *   MAC key
+ * @param [options.createdAt] {string}   the bind timestamp to stamp, as an
+ *   ISO string; defaults to now. Supplied by a caller that pins record
+ *   freshness.
+ * @returns {Promise<SignedUnlockRecord>}
+ */
+export declare function wrapUnlockRecord({ controller, email, pointer, delegation, ladderSeed, keyAgreementKey, signer, bindingMacKey, createdAt }: {
+    controller: string;
+    email?: string;
+    pointer: AccountPointer;
+    delegation: IZcap;
+    ladderSeed?: Uint8Array;
+    keyAgreementKey: IKeyAgreementKey;
+    signer: RecordSigner;
+    bindingMacKey: Uint8Array;
+    createdAt?: string;
+}): Promise<SignedUnlockRecord>;
+/**
+ * Unwraps and validates an unlock record: the ordinary keyring-record frame
+ * checks plus the required pointer, bridge delegation, and
+ * credential-authenticated binding. A record without a bridge member is not
+ * an unlock record in the standing layout (an ordinary keyring record found
+ * under a credential's unlock Space would mean a torn bind) and is refused.
+ *
+ * The binding is verified before the contents are returned: the decrypted
+ * core must carry the tag the credential-derived MAC key computes over it, or
+ * the record is refused as forged ({@link UnlockBindingError}) -- the check
+ * that closes the host-forgery redirect, since the host never holds the MAC
+ * key. Nothing downstream may trust the pointer (or the ladder seed) before
+ * this returns.
+ *
+ * Proof verification is mixed-signer and ordered deliberately, exactly as the
+ * recovery record's was: a proof by the credential's own unlock key is
+ * verified BEFORE decryption; a proof by any other key comes back as a
+ * pending state naming the signer, for the caller to settle with
+ * `verifyRecordProof` against the verified document of the account the
+ * credential-authenticated pointer names.
+ *
+ * @param options {object}
+ * @param options.record {unknown}   the stored record envelope
+ * @param options.keyAgreementKey {IKeyAgreementKey}   the credential's unlock
+ *   KAK
+ * @param options.keyResolver {IKeyResolver}
+ * @param options.expectedKeyMultibase {string}   the credential-derived
+ *   unlock signing key's multibase
+ * @param options.bindingMacKey {Uint8Array}   the credential-derived binding
+ *   MAC key the record's account binding must verify under
+ * @returns {Promise<{ contents: UnlockRecordContents,
+ *   proofState: UnlockRecordProofState }>}
+ */
+export declare function unwrapUnlockRecord({ record, keyAgreementKey, keyResolver, expectedKeyMultibase, bindingMacKey }: {
+    record: unknown;
+    keyAgreementKey: IKeyAgreementKey;
+    keyResolver: IKeyResolver;
+    expectedKeyMultibase: string;
+    bindingMacKey: Uint8Array;
+}): Promise<{
+    contents: UnlockRecordContents;
+    proofState: UnlockRecordProofState;
+}>;
+/**
+ * Re-mints an unlock record's bridge: the revocation-cascade path that
+ * replaces a rotted or expiring delegation while touching nothing else. The
+ * shell, the ladder member, and the binding are carried VERBATIM (the re-mint
+ * cannot decrypt any of them and does not need to -- each is self-contained
+ * and the binding covers the core), a fresh bridge is sealed to the
+ * credential's unlock KAK public half, and the frame is re-signed by the
+ * acting client's account key -- the mixed-signer case the reader settles
+ * against the verified document.
+ *
+ * A record with no binding cannot be re-minted ({@link UnlockBindingError});
+ * its credential must be rebound.
+ *
+ * @param options {object}
+ * @param options.record {unknown}   the standing stored record
+ * @param options.delegation {IZcap}   the freshly minted `did.jsonl`
+ *   delegation
+ * @param options.keyAgreementKey {IKeyAgreementKey}   the credential's unlock
+ *   KAK, public half only
+ * @param options.signer {RecordSigner}   the acting client's account key
+ * @returns {Promise<SignedUnlockRecord>}
+ */
+export declare function remintUnlockRecordBridge({ record, delegation, keyAgreementKey, signer }: {
+    record: unknown;
+    delegation: IZcap;
+    keyAgreementKey: IKeyAgreementKey;
+    signer: RecordSigner;
+}): Promise<SignedUnlockRecord>;
+//# sourceMappingURL=unlockRecord.d.ts.map

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

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