@interop/wallet-core 0.69.0 → 0.70.0

package/README.md

@@ -38,9 +38,10 @@ The subpaths:
   shared collection ids and descriptive specs (`private-credentials`,
   `public-credentials`, `wallet-activity`, `app-connections`), the
   `wallet-activity` wire shape with its pure `addHistory*` payload builders, the
-  `publicCredentialUrl` derivation, and the `was-link` QR hand-off contract.
-  Contacts collection specs live in
-  [`@interop/social-core`](https://npm.im/@interop/social-core).
+  `publicCredentialUrl` derivation, and the `was-link` QR hand-off contract
+  (`buildWasLinkPayload` / `parseWasLinkPayload` / `encodeWasLinkSecret`) with
+  its structural recognizer, `isWasLinkPayload`. Contacts collection specs live
+  in [`@interop/social-core`](https://npm.im/@interop/social-core).
 
 - **`@interop/wallet-core/identity`** -- the WAS identity derivation both wallet
   apps must perform byte-for-byte identically: `agentsFromSecret` /
@@ -50,22 +51,6 @@ The subpaths:
   (the same assembly from a `CapabilityAgent` an app derived itself), and
   `singleKeyResolver`.
 
-- **`@interop/wallet-core/request`** -- wallet-request / exchange protocol
-  handling: request classification and parsing (CHAPI get/store events,
-  wallet-api messages and URLs), QueryByExample matching, cryptosuite
-  negotiation, `composeVp` (signer and holder injected), the pure
-  `processRequest` (consent runs in the caller; zcap / App Connect processing
-  injected), the App Connect app-key credential module (query validation,
-  matching, minting, store-time refusal, legacy re-issue), the
-  `WalletOnboardingQuery` transport vocabulary (compose and classification), the
-  VC-API exchange client, VCALM `interaction:` URL handling, the requester's
-  half of a server's ephemeral exchange (`createEphemeralExchange` /
-  `pollEphemeralExchange`, the poll bounded by a caller signal or its own
-  deadline), and `composeCapabilityRequest`, the zcap-only VPR a requester
-  stores on such an exchange. The VPR type vocabulary lives in
-  [`@interop/data-integrity-core`](https://npm.im/@interop/data-integrity-core)
-  and is re-exported here.
-
 - **`@interop/wallet-core/webvh`** -- the account's did:webvh identity: the
   hosted DID log, its per-client update-key rotation, the client enrollment
   entries, the one-entry client-revocation edit (verification methods, update
@@ -161,8 +146,9 @@ The subpaths:
   record codec (shell / bridge delegation / ladder members under a
   credential-authenticated binding, with the bridge-only re-mint), the merged
   document-inventory edit (a verbatim `keyAgreement` entry or a
-  `publicKeyCommitment` entry for a low-entropy-derived key), and the
-  self-enrolling continuation with its composed completion.
+  `publicKeyCommitment` entry for a low-entropy-derived key, either naming its
+  ladder's rung-0 hash as `ladderCommitment`), and the self-enrolling
+  continuation with its composed completion.
 
 - **`@interop/wallet-core/recovery`** -- recovery codes on the roster identity
   model, over the `unlock` machinery: a code as a minimal always-enrolled wallet
@@ -183,6 +169,10 @@ The subpaths:
   per-visit readiness ensure, and the transient-recovery continuation. It sits
   on top of the other subpaths and none of them import from it.
 
+The request pipeline (input classification, VPR parsing, cryptosuite
+negotiation, VP composition, the App Connect app-key credential) now lives in
+[`@interop/wallet-request`](https://npm.im/@interop/wallet-request).
+
 ## Install
 
 - Node.js 24+ is recommended.
@@ -213,15 +203,14 @@ import {
 ```
 
 The `sync` and `space` subpaths are re-exported from the package root as well.
-Every other subpath (`identity`, `request`, `webvh`, `resourceLog`, `keys`,
-`clients`, `descriptors`, `keyring`, `enrollment`, `genesis`, `unlock`,
-`recovery`, `clientAnnex`) is import-directly-only, so consumers of the root
-never pull the signing / KMS / document-loader dependency graph.
+Every other subpath (`identity`, `webvh`, `resourceLog`, `keys`, `clients`,
+`descriptors`, `keyring`, `enrollment`, `genesis`, `unlock`, `recovery`,
+`clientAnnex`) is import-directly-only, so consumers of the root never pull the
+signing / KMS / document-loader dependency graph.
 
-Two further exports are leaves of that same isolation, carved out to stay
+One further export is a leaf of that same isolation, carved out to stay
 dependency-light: `keys/clientKeyRecord` is the client-key record codec alone,
-so a wallet's storage tests load without the crypto graph, and
-`request/matching` is the QueryByExample matchers alone.
+so a wallet's storage tests load without the crypto graph.
 
 ## Contribute
 

package/dist/clientAnnex/ladder.d.ts

@@ -216,56 +216,97 @@ export declare function assertNextKeyHashesRemain({ nextKeyHashes, ceremony }: {
 }): string[];
 /**
  * The anchor a credential's ladder walk starts from when the caller holds no
- * recorded update key -- the log-only anchoring a cold browser needs. The
- * credential's own `keyAgreement` member id is the anchor: the entry that
- * FIRST introduced that member is the credential's bind entry, and what that
- * entry did to the standing parameters names rung 0.
- *
- * Two shapes are read, both fail-closed:
- *
- * - the entry authorized exactly one update key and that key signed it (a
- *   prerotation reveal, the ladder-anchored genesis shape), so rung 0 is that
- *   key outright;
- * - the entry authorized no key of its own and newly committed exactly one
- *   hash (the `publishUnlockKey` bind an enrolled client signs, and the
- *   recovery-code issuance sharing it), so rung 0's hash is that hash.
- *
- * A third shape is the recovery add-and-retire entry, which the two above
- * cannot read: the transient continuation's introduces the fresh credential's
- * member and the replacement code's together, and the remembered
- * continuation's introduces the replacement's beside an enrolled client. Both
- * are the HANDOVER of `decisions/0007`, read here as the anchor rule of
- * `decisions/0014`: the entry authorized exactly one key, that key signed it,
- * that key's hash was committed by an earlier reveal-and-commit entry whose
- * signer this entry retires, and that earlier entry appended exactly three
- * hashes with the successor's first. The reveal entry's LAST addition is then
- * the replacement code's rung-0 hash (what an entry hands to a successor
- * credential comes last), and the successor key is the fresh credential's
- * rung 0. Which member is which is read off the `keyAgreement` relation's
- * order, which the emitter fixes: the fresh credential's member precedes the
- * replacement code's. So a two-member bind that publishes no enrolled client
- * anchors its first member on the successor key and its second on the last
- * addition; a one-member bind that publishes an enrolled client anchors that
- * member on the last addition alone, since the successor key there is the
- * client's.
- *
- * Anything else is ambiguous and returns `undefined`, which the callers report
- * as unclaimed rather than acting on.
+ * recorded update key -- the log-only anchoring a cold browser needs. Every
+ * credential-class `keyAgreement` member names its own ladder's rung-0
+ * commitment (`ladderCommitment`, written by every bind site through
+ * `unlockKeyVerificationMethod`), so the anchor is read off the member
+ * itself rather than inferred from the shape of the entry that introduced
+ * it. The value is `hash(rung 0)` in the form `nextKeyHashes` carries, the
+ * same commitment the bind puts there.
+ *
+ * The value is taken from the entry that INTRODUCED the member, and only
+ * from an account-controlled member (an enrolled client's marked twin is
+ * never a credential). A member is introduced each time it appears after
+ * not standing, so a member re-bound after a retirement (the same passphrase
+ * added again) anchors on the fresh ladder's commitment, and a log read
+ * before the retirement entry that struck it still names it. What a later
+ * entry says about a member that already stood is checked, not adopted: the
+ * property is a document member any update-key holder can restate, and a
+ * value that changes while the member stands continuously is a retargeting
+ * no bind performs. Such a member names no anchor for the rest of that
+ * standing run, so the retargeting is reported as unclaimed rather than
+ * quietly walked from the substituted hash. The write side carries the same
+ * rule: `publishUnlockKey`, the one path in this library that rewrites a
+ * standing member, refuses a bind whose rung-0 hash differs from the value
+ * the member already names, so a retargeting in a served log is a foreign
+ * writer's and never a torn re-run's. The guard covers only a
+ * continuous run: the same update-key holder can strike the member in one
+ * entry and re-add it under a fresh commitment in the next, which reads as a
+ * legitimate re-bind and is not distinguishable from one seedlessly. That
+ * shape rests on the log's loudness and on `survivingClientKeyProtection`
+ * instead. A member without the property, or one nowhere in the log, names
+ * no anchor either.
+ *
+ * The named hash must also be one the log COMMITTED FOR THE MEMBER: newly
+ * added to `nextKeyHashes` by the introducing entry (the merged bind, the
+ * ladder-anchored genesis), by a later entry of the same standing run (the
+ * split bind's authority entry, two versions after its key entry), or by an
+ * earlier entry whose signer the introducing entry retires (the recovery
+ * continuations' reveal-and-commit entry, signed by the spent code's rung,
+ * which the add-and-retire entry introducing the replacement's member and
+ * the fresh credential's strikes -- every reveal entry of a torn and resumed
+ * continuation is that shape). A member naming a hash that stood in
+ * `nextKeyHashes` already, committed by some other entry for something else
+ * -- an enrolled client's staged hash, say, which any update-key holder can
+ * read off the log and restate as a commitment -- names no anchor. Without
+ * the check the walk would claim that hash for the credential, and a
+ * retirement that honored the claim would strike a surviving client's
+ * staged commitment. The check is necessary rather than sufficient: an
+ * approver can name a hash BEFORE the enrollment it approves commits it, and
+ * that is the shape `survivingClientKeyProtection`'s positional exemption
+ * closes. Every refusal returns `undefined`, which the callers report as
+ * unclaimed rather than acting on.
  *
  * @param options {object}
  * @param options.log {DIDLog}   a resolved, caller-verified log
  * @param options.credentialVmId {string}   the credential's `keyAgreement`
  *   verification-method id
- * @returns {Promise<{ anchorKeyMultibase?: string, anchorHash?: string } |
- *   undefined>}
+ * @returns {{ anchorHash: string } | undefined}
  */
 export declare function credentialLadderAnchor({ log, credentialVmId }: {
     log: DIDLog;
     credentialVmId: string;
-}): Promise<{
-    anchorKeyMultibase?: string;
-    anchorHash?: string;
-} | undefined>;
+}): {
+    anchorHash: string;
+} | undefined;
+/**
+ * What the log says about a credential member's `ladderCommitment`, before
+ * {@link credentialLadderAnchor} decides whether it is an anchor: the value
+ * the entry introducing the member's latest standing run named (`named`),
+ * whether the member stands in the head document (`stands`), whether a later
+ * entry of that run restated the value (`retargeted`), and whether the log
+ * committed the named hash for the member (`committed`). The anchor reader
+ * is the refusing composition of these; the bind's write-side check reads
+ * them apart, since a split bind's authority entry meets a member that names
+ * its hash while the log has not committed it yet.
+ *
+ * @param options {object}
+ * @param options.log {DIDLog}   a resolved, caller-verified log
+ * @param options.credentialVmId {string}   the credential's `keyAgreement`
+ *   verification-method id
+ * @returns {{ named?: string, stands: boolean, retargeted: boolean,
+ *   committed: boolean } | undefined}   `undefined` for a member the log
+ *   never introduced
+ */
+export declare function credentialLadderCommitment({ log, credentialVmId }: {
+    log: DIDLog;
+    credentialVmId: string;
+}): {
+    named?: string;
+    stands: boolean;
+    retargeted: boolean;
+    committed: boolean;
+} | undefined;
 /**
  * The ladder VMs the log introduced ALONGSIDE something of this credential's
  * -- the question a fail-closed retirement gate asks when its seedless walk
@@ -317,7 +358,7 @@ export declare function ladderVmIdsIntroducedWithCredential({ log, credentialVmI
  * lists, read off the log alone -- the latent commitments a client removal
  * must exclude before it attributes the removed client's staged hash. Each
  * credential-class `keyAgreement` member (an unmarked method, verbatim key or
- * commitment) is anchored from its bind entry and walked
+ * commitment) is anchored from its member's `ladderCommitment` and walked
  * ({@link attributeLadderInventory}); a credential whose anchor or walk
  * refuses claims nothing and is named on `unclaimedCredentialVmIds`, so the
  * caller can tell "no latent hashes stand" from "one credential's could not
@@ -407,9 +448,12 @@ export declare function retiredCredentialRungsBeforeKey({ log, authorizedKeyMult
  *   than a property of the walk, because a mis-anchored walk landing on a
  *   client's key would otherwise end that client's ability to extend the
  *   account log for good. The walks therefore run FIRST, and the hashes they
- *   claimed are passed to the protection as known-latent, so a retiring
+ *   claimed are passed to the protection as walk-derived, so a retiring
  *   credential's own rung cannot make a client's staged attribution ambiguous
- *   and get itself protected as a candidate;
+ *   and get itself protected as a candidate. The protection never lets such
+ *   a claim prune the hash the decision-0007 position names as a client's
+ *   staged hash, so a walk anchored on a member that names that hash claims
+ *   it and is withheld, rather than striking it;
  * - a listed enrolled client whose ACTIVE update key the log cannot attribute
  *   withholds the WHOLE strike: nothing is struck and every credential is
  *   reported, since the structural guard cannot say what that client holds.
@@ -540,29 +584,31 @@ export declare function attributeRetiredCredentialRungs({ log, credentialVmIds,
  * once matches no legitimate history and fails closed ({@link
  * LadderAttributionError}).
  *
- * One shape is out of reach seedlessly, and it is reachable today. The
- * last-client transition strikes the ladder VM and reinstalls it in the same
- * run (`forgetLastEnrolledClient` stage 1): same seed, the credential's
- * member standing, the acting rung's hash still committed, and no hash added.
- * A later self-enrollment then spends that already-revealed rung, so its
+ * One shape is out of the backward walk's reach. The last-client transition
+ * strikes the ladder VM and reinstalls it in the same run
+ * (`forgetLastEnrolledClient` stage 1): same seed, the credential's member
+ * standing, the acting rung's hash still committed, and no hash added. A
+ * later self-enrollment then spends that already-revealed rung, so its
  * reveal-and-commit entry authorizes no key while committing the next rung's
  * hash, and the registry anchor advances to that next rung. The backward walk
  * climbs from the anchor by asking which key the entry that committed its
  * hash authorized; that entry authorized none, so the walk cannot name the
- * rung that signed it, and the earlier rung and the reinstalled VM go
- * unrecovered. A seedless retirement then reports the VM as `unclaimed` and
- * leaves it standing. Tracked as WC-158.
+ * rung that signed it, and a walk anchored on the registry key alone leaves
+ * the earlier rung and the reinstalled VM unrecovered. A walk anchored on the
+ * member's own rung-0 commitment reads that history forward with no climb,
+ * which is why the removal paths walk from both anchors
+ * (`attributeUnlockLadderInventory`) and act on the member's reading.
  *
  * The anchor comes in three forms, and the walk is the same afterwards. A
  * recorded update-key multibase (`anchorKeyMultibase`) is what a caller
  * holding a registry entry passes. A hash (`anchorHash`) is the same anchor
  * with the key withheld: the rung is picked up when the log reveals it, since
  * the reveal test already matches on the commitment. With neither, and a
- * `credentialVmId` in hand, the anchor is read off the credential's bind entry
- * ({@link credentialLadderAnchor}) -- the cold-browser mode, where no registry
- * is readable before the entry is written. An anchor the bind entry cannot
- * name unambiguously refuses with {@link LadderAttributionError} rather than
- * walking from a guess.
+ * `credentialVmId` in hand, the anchor is read off the credential's own
+ * `keyAgreement` member ({@link credentialLadderAnchor}) -- the cold-browser
+ * mode, where no registry is readable before the entry is written. A member
+ * naming no ladder commitment refuses with {@link LadderAttributionError}
+ * rather than walking from a guess.
  *
  * @param options {object}
  * @param options.log {DIDLog}   a resolved, caller-verified log

package/dist/clientAnnex/ladder.d.ts.map

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