@openlfcp/wire 0.2.1 → 0.3.0

package/dist/invite.js

@@ -1,5 +1,5 @@
-import { bytesEqual, controlRecordId, fromBase64url, LfcpError, resourceId, toBase64url, toHex, } from "@openlfcp/core";
-import { exportSecretKeyBytes, InvitationSecret, importAgreementKey, importSigningKey, } from "@openlfcp/crypto";
+import { bytesEqual, controlRecordId, fromBase64url, LfcpError, principalId, resourceId, toBase64url, toHex, } from "@openlfcp/core";
+import { exportSecretKeyBytes, InvitationSecret, importAgreementKey, importSigningKey, sha256, } from "@openlfcp/crypto";
 import { ABILITY } from "./capability.js";
 import { cborMap, decodeDeterministic, encode } from "./cbor/index.js";
 import { strictUtf8Decoder, utf8Encoder } from "./cbor/text.js";
@@ -147,56 +147,35 @@ function id32(text, what) {
  * percent-encoded (G-RS4).
  */
 export function assembleInviteUri(invitation) {
-    if (invitation.endpoints.length === 0)
-        invalid("at least one endpoint is required (§18.2)");
-    for (const url of invitation.endpoints) {
-        try {
-            checkWriterUrl(url);
-        }
-        catch {
-            invalid("an endpoint is not a URL a writer may use (§16)");
-        }
-    }
-    const query = [
-        ...invitation.endpoints.map((url) => `endpoint=${percentEncode(url)}`),
-        `grant=${toBase64url(invitation.grantId)}`,
-    ].join("&");
-    const fragment = invitation.secret === undefined
-        ? ""
-        : `#secret=${toBase64url(encodeInviteSecret(invitation.secret))}`;
-    return `${PREFIX}${toBase64url(invitation.resourceId)}?${query}${fragment}`;
+    return assembleLink(PREFIX, invitation.resourceId, invitation.endpoints, "grant", invitation.grantId, invitation.secret);
 }
 /**
- * Parses a §18.2 invitation URI. The scheme and host compare
- * case-insensitively (RFC 3986 §3.1, §3.2.2); the path is one Resource ID;
- * the query has one or more `endpoint` parameters and exactly one `grant`;
- * other parameters are ignored, for forward compatibility, once their
- * percent-encoding is checked; a fragment, if present, is exactly
- * `secret=<b64url>`.
- * Endpoints are percent-decoded and must use ws or wss (§16). Throws
- * INVALID_INVITATION, never with the URI or the secret in the message.
- * Verify a bearer secret against the grant (verifyInvitationSecret) before
- * using it.
+ * The §18.2 parser shared by invitation and pairing links: `prefix` and
+ * its one required 32-byte ID parameter `param`. The scheme and host
+ * compare case-insensitively (RFC 3986 §3.1, §3.2.2); the path is one
+ * Resource ID; one or more `endpoint` parameters; other parameters are
+ * ignored once their percent-encoding is checked; a fragment, if present,
+ * is exactly `secret=<b64url>`.
  */
-export function parseInviteUri(uri) {
+function parseLink(uri, prefix, param, label) {
     if (typeof uri !== "string")
         invalid("the URI is not a string");
-    if (uri.slice(0, PREFIX.length).toLowerCase() !== PREFIX)
-        invalid("the URI does not start with lfcp://join/");
+    if (uri.slice(0, prefix.length).toLowerCase() !== prefix)
+        invalid(`the URI does not start with ${prefix}`);
     const hash = uri.indexOf("#");
     const beforeFragment = hash === -1 ? uri : uri.slice(0, hash);
     const question = beforeFragment.indexOf("?");
     if (question === -1)
         invalid("the URI has no query");
-    const path = beforeFragment.slice(PREFIX.length, question);
+    const path = beforeFragment.slice(prefix.length, question);
     const resource = resourceId(id32(path, "the Resource ID"));
     const endpoints = [];
-    let grant;
+    let id;
     for (const parameter of beforeFragment.slice(question + 1).split("&")) {
         const eq = parameter.indexOf("=");
         const name = eq === -1 ? parameter : parameter.slice(0, eq);
         const value = eq === -1 ? "" : parameter.slice(eq + 1);
-        if ((name === "endpoint" || name === "grant") && value === "")
+        if ((name === "endpoint" || name === param) && value === "")
             invalid(`the ${name} parameter has no value`);
         if (name === "endpoint") {
             const url = percentDecode(value, "an endpoint");
@@ -208,10 +187,10 @@ export function parseInviteUri(uri) {
             }
             endpoints.push(url);
         }
-        else if (name === "grant") {
-            if (grant !== undefined)
-                invalid("the grant parameter appears twice");
-            grant = controlRecordId(id32(value, "the grant ID"));
+        else if (name === param) {
+            if (id !== undefined)
+                invalid(`the ${param} parameter appears twice`);
+            id = id32(value, label);
         }
         else {
             // Not defined by §18.2: ignored, but still a well-formed query parameter.
@@ -221,8 +200,8 @@ export function parseInviteUri(uri) {
     }
     if (endpoints.length === 0)
         invalid("the URI has no endpoint parameter");
-    if (grant === undefined)
-        invalid("the URI has no grant parameter");
+    if (id === undefined)
+        invalid(`the URI has no ${param} parameter`);
     let secret;
     if (hash !== -1) {
         const fragment = uri.slice(hash + 1);
@@ -237,11 +216,117 @@ export function parseInviteUri(uri) {
         }
         secret = decodeInviteSecret(bytes);
     }
-    return Object.freeze({
-        resourceId: resource,
+    return {
+        resource,
         endpoints: Object.freeze(endpoints),
-        grantId: grant,
+        id: id,
         ...(secret !== undefined ? { secret } : {}),
+    };
+}
+/** The §18.2 query and fragment of a link: endpoints, the ID parameter, the optional secret. */
+function assembleLink(prefix, resource, endpoints, param, id, secret) {
+    if (endpoints.length === 0)
+        invalid("at least one endpoint is required (§18.2)");
+    for (const url of endpoints) {
+        try {
+            checkWriterUrl(url);
+        }
+        catch {
+            invalid("an endpoint is not a URL a writer may use (§16)");
+        }
+    }
+    const query = [
+        ...endpoints.map((url) => `endpoint=${percentEncode(url)}`),
+        `${param}=${toBase64url(id)}`,
+    ].join("&");
+    const fragment = secret === undefined ? "" : `#secret=${toBase64url(encodeInviteSecret(secret))}`;
+    return `${prefix}${toBase64url(resource)}?${query}${fragment}`;
+}
+/**
+ * Parses a §18.2 invitation URI: lfcp://join/<resource>, one or more
+ * `endpoint` parameters and exactly one `grant` (see parseLink).
+ * Endpoints are percent-decoded and must use ws or wss (§16). Throws
+ * INVALID_INVITATION, never with the URI or the secret in the message.
+ * Verify a bearer secret against the grant (verifyInvitationSecret) before
+ * using it. A pairing link (lfcp://pair/) is not an invitation.
+ */
+export function parseInviteUri(uri) {
+    const link = parseLink(uri, PREFIX, "grant", "the grant ID");
+    return Object.freeze({
+        resourceId: link.resource,
+        endpoints: link.endpoints,
+        grantId: controlRecordId(link.id),
+        ...(link.secret !== undefined ? { secret: link.secret } : {}),
     });
 }
+// ---------------------------------------------------------------------------
+// Pairing links (IDENTITY-PROFILE-01 §5.2)
+const PAIR_PREFIX = "lfcp://pair/";
+/**
+ * The canonical pairing link: lfcp://pair/<I>?endpoint=…[&endpoint=…]&device=<J>#secret=<secret>.
+ * `pairingDevice` must be the Principal the secret determines.
+ */
+export function assemblePairingUri(link) {
+    if (!bytesEqual(invitationPrincipal(link.secret).principalId, link.pairingDevice))
+        invalid("the secret is not the pairing device's (IDENTITY-PROFILE-01 §5.2)");
+    return assembleLink(PAIR_PREFIX, link.identityResourceId, link.endpoints, "device", link.pairingDevice, link.secret);
+}
+/**
+ * Parses a pairing link (IDENTITY-PROFILE-01 §5.2) with the §18.2 rules
+ * (percent-encoding, several `endpoint` parameters, unknown parameters
+ * ignored) and exactly one `device`. The `#secret=` fragment is required,
+ * and the Principal recomputed from it must be `device`: a receiver MUST
+ * check that before using the secret. An lfcp://join/ link is rejected.
+ * Throws INVALID_INVITATION, never with the URI or the secret in the
+ * message. Opening `I` as `J` and checking that `J` is a registered,
+ * active kind-2 device of `I`'s owner is the client's next step.
+ */
+export function parsePairingUri(uri) {
+    const link = parseLink(uri, PAIR_PREFIX, "device", "the pairing device ID");
+    const secret = link.secret ?? invalid("a pairing link carries #secret=<b64url>");
+    const device = principalId(link.id);
+    if (!bytesEqual(invitationPrincipal(secret).principalId, device))
+        invalid("the secret is not the device's (IDENTITY-PROFILE-01 §5.2)");
+    return Object.freeze({
+        identityResourceId: link.resource,
+        endpoints: link.endpoints,
+        pairingDevice: device,
+        secret,
+    });
+}
+/** The pairing device as a signer, recomputed from the link's secret (IDENTITY-PROFILE-01 §5.2). */
+export function pairingDeviceSigner(link) {
+    const descriptor = invitationPrincipal(link.secret);
+    if (!bytesEqual(descriptor.principalId, link.pairingDevice))
+        invalid("the secret is not the device's (IDENTITY-PROFILE-01 §5.2)");
+    return Object.freeze({ key: link.secret.signingKey, descriptor });
+}
+const FP_DOMAIN = utf8Encoder.encode("LFCP-DEVICE-FP-v1");
+const BASE32 = "abcdefghijklmnopqrstuvwxyz234567";
+/**
+ * The device fingerprint shown during pairing (IDENTITY-PROFILE-01 §5.2):
+ * base32-lower-nopad(SHA-256("LFCP-DEVICE-FP-v1" || principal_id)[0..10]),
+ * as four groups of four characters joined by "-". A display convention,
+ * not a wire object.
+ */
+export function deviceFingerprint(device) {
+    if (!(device instanceof Uint8Array) || device.length !== ID_LENGTH)
+        throw new LfcpError("INVALID_LENGTH", "a Principal ID is 32 bytes");
+    const input = new Uint8Array(FP_DOMAIN.length + ID_LENGTH);
+    input.set(FP_DOMAIN, 0);
+    input.set(device, FP_DOMAIN.length);
+    const digest = sha256(input).subarray(0, 10);
+    let bits = 0;
+    let value = 0;
+    let out = "";
+    for (const byte of digest) {
+        value = (value << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            out += BASE32[(value >>> (bits - 5)) & 31];
+            bits -= 5;
+        }
+    }
+    return out.match(/.{4}/g).join("-");
+}
 //# sourceMappingURL=invite.js.map

package/dist/objects.d.ts

@@ -23,7 +23,7 @@ import { type ActorHave } from "./have.js";
  *
  * Errors and their wire mapping (ADR 0001):
  * - COSE_MALFORMED, CBOR_* and INVALID_STRUCTURE → MALFORMED_MESSAGE;
- * - UNSUPPORTED_VALUE (reserved core Control Record type) →
+ * - UNSUPPORTED_VALUE (reserved core Control Record type 11–31) →
  *   INVALID_CONTROL_CHAIN (§14);
  * - INVALID_CONTROL_CHAIN (a Genesis not at control_seq 0 with a null
  *   link, §13.1) → INVALID_CONTROL_CHAIN;
@@ -34,7 +34,7 @@ export interface Parsed<P> {
     readonly signed: SignedObject;
     readonly payload: P;
 }
-/** §14 Control Record types defined by LFCP-WIRE-01. 9–31 are reserved; 32 and up are extensions. */
+/** §14 Control Record types defined by LFCP-WIRE-01. 11–31 are reserved; 32 and up are extensions. */
 export declare const CONTROL_TYPE: Readonly<{
     GENESIS: 0n;
     CAPABILITY_GRANT: 1n;
@@ -45,6 +45,8 @@ export declare const CONTROL_TYPE: Readonly<{
     OWNER_TRANSFER_COMMIT: 6n;
     COORDINATOR_RECOVERY: 7n;
     RESOURCE_TOMBSTONE: 8n;
+    DEVICE_GRANT: 9n;
+    DEVICE_REVOKE: 10n;
 }>;
 /**
  * `control-record-payload` (§13). The body is the decoded `any` value. It is
@@ -107,6 +109,14 @@ export interface SnapshotPayload {
  * (LFCP-020).
  */
 export declare function controlRecordPayloadFromCbor(value: CborValue): ControlRecordPayload;
+/**
+ * controlRecordPayloadFromCbor without the Genesis placement rule (§13.1,
+ * class 2 of §62), for a decoder that checks the typed body (class 1)
+ * first. Package-internal.
+ */
+export declare function readControlRecordPayload(value: CborValue): ControlRecordPayload;
+/** §13.1: a Genesis is at control_seq 0 with a null link (INVALID_CONTROL_CHAIN). Package-internal. */
+export declare function checkGenesisPlacement(p: ControlRecordPayload): ControlRecordPayload;
 /**
  * Structural rules: the §26 field set and actor sequence >= 1 (§8, N4).
  * A non-null previous unit at sequence 1 is not rejected here: §26.2 asks

package/dist/objects.js

@@ -3,7 +3,7 @@ import { decodeDeterministic, decodeStrict } from "./cbor/index.js";
 import { parseSignedObject } from "./cose.js";
 import { Fields, invalid } from "./fields.js";
 import { canonicalFrontierFromCbor } from "./have.js";
-/** §14 Control Record types defined by LFCP-WIRE-01. 9–31 are reserved; 32 and up are extensions. */
+/** §14 Control Record types defined by LFCP-WIRE-01. 11–31 are reserved; 32 and up are extensions. */
 export const CONTROL_TYPE = Object.freeze({
     GENESIS: 0n,
     CAPABILITY_GRANT: 1n,
@@ -14,8 +14,10 @@ export const CONTROL_TYPE = Object.freeze({
     OWNER_TRANSFER_COMMIT: 6n,
     COORDINATOR_RECOVERY: 7n,
     RESOURCE_TOMBSTONE: 8n,
+    DEVICE_GRANT: 9n,
+    DEVICE_REVOKE: 10n,
 });
-const FIRST_RESERVED_CONTROL_TYPE = 9n;
+const FIRST_RESERVED_CONTROL_TYPE = 11n;
 const FIRST_EXTENSION_CONTROL_TYPE = 32n;
 const ALL_FIELDS = [0, 1, 2, 3, 4, 5, 6];
 /**
@@ -26,6 +28,14 @@ const ALL_FIELDS = [0, 1, 2, 3, 4, 5, 6];
  * (LFCP-020).
  */
 export function controlRecordPayloadFromCbor(value) {
+    return checkGenesisPlacement(readControlRecordPayload(value));
+}
+/**
+ * controlRecordPayloadFromCbor without the Genesis placement rule (§13.1,
+ * class 2 of §62), for a decoder that checks the typed body (class 1)
+ * first. Package-internal.
+ */
+export function readControlRecordPayload(value) {
     const f = new Fields(value, "control-record-payload", ALL_FIELDS.slice(0, 6));
     const rid = resourceId(f.bytes(0, 32));
     const controlSeq = f.uint(1);
@@ -35,8 +45,6 @@ export function controlRecordPayloadFromCbor(value) {
     if (controlType >= FIRST_RESERVED_CONTROL_TYPE && controlType < FIRST_EXTENSION_CONTROL_TYPE) {
         throw new LfcpError("UNSUPPORTED_VALUE", `Control Record type ${controlType} is reserved for LFCP core (§14)`);
     }
-    if (controlType === CONTROL_TYPE.GENESIS && (controlSeq !== 0n || prev !== null))
-        throw new LfcpError("INVALID_CONTROL_CHAIN", "a Genesis record must have control_seq 0 and a null prev_control_id (§13.1)");
     return Object.freeze({
         kind: "control-record",
         resourceId: rid,
@@ -48,6 +56,12 @@ export function controlRecordPayloadFromCbor(value) {
         body: f.any(5),
     });
 }
+/** §13.1: a Genesis is at control_seq 0 with a null link (INVALID_CONTROL_CHAIN). Package-internal. */
+export function checkGenesisPlacement(p) {
+    if (p.controlType === CONTROL_TYPE.GENESIS && (p.controlSeq !== 0n || p.prevControlId !== null))
+        throw new LfcpError("INVALID_CONTROL_CHAIN", "a Genesis record must have control_seq 0 and a null prev_control_id (§13.1)");
+    return p;
+}
 /**
  * Structural rules: the §26 field set and actor sequence >= 1 (§8, N4).
  * A non-null previous unit at sequence 1 is not rejected here: §26.2 asks

package/dist/persistent-map.d.ts

@@ -0,0 +1,42 @@
+/**
+ * An immutable map from strings with structural sharing: a persistent AVL
+ * tree ordered by the full key. `set` copies only the nodes on the path
+ * to its key (at most about 1.44 log2 n of them) and rebalances there, so
+ * the states a chain keeps for every head share all untouched entries
+ * (review of #8, R8-1).
+ *
+ * Keys are compared whole: no hash, no bucket, so no choice of keys (an
+ * arbitrary device ID in a pre-emptive revocation, for example) can make
+ * an update copy more than one path (review of #8, R8-1b). Iteration is
+ * in ascending key order (UTF-16 code units).
+ */
+export declare class PersistentMap<V> implements ReadonlyMap<string, V> {
+    #private;
+    readonly size: number;
+    private constructor();
+    static empty<V>(): PersistentMap<V>;
+    static from<V>(entries: Iterable<readonly [string, V]>): PersistentMap<V>;
+    get(key: string): V | undefined;
+    has(key: string): boolean;
+    /** A map with `key` set to `value`; this one is unchanged. */
+    set(key: string, value: V): PersistentMap<V>;
+    /** The tree's height (tests: it stays logarithmic whatever the keys). */
+    get height(): number;
+    /**
+     * Adds every tree node of this map to `seen` (tests: the structure the
+     * retained states hold together, shared nodes counted once).
+     */
+    collectNodes(seen: Set<object>): void;
+    entries(): ArrayIterator<[string, V]>;
+    keys(): ArrayIterator<string>;
+    values(): ArrayIterator<V>;
+    [Symbol.iterator](): ArrayIterator<[string, V]>;
+    forEach(fn: (value: V, key: string, map: ReadonlyMap<string, V>) => void, thisArg?: unknown): void;
+}
+/**
+ * `map` with `key` set to `value`, sharing structure when `map` is
+ * persistent; any other ReadonlyMap (a state built by a caller) is copied
+ * once into a persistent one.
+ */
+export declare function put<V>(map: ReadonlyMap<string, V>, key: string, value: V): PersistentMap<V>;
+//# sourceMappingURL=persistent-map.d.ts.map

package/dist/persistent-map.js

@@ -0,0 +1,147 @@
+/**
+ * An immutable map from strings with structural sharing: a persistent AVL
+ * tree ordered by the full key. `set` copies only the nodes on the path
+ * to its key (at most about 1.44 log2 n of them) and rebalances there, so
+ * the states a chain keeps for every head share all untouched entries
+ * (review of #8, R8-1).
+ *
+ * Keys are compared whole: no hash, no bucket, so no choice of keys (an
+ * arbitrary device ID in a pre-emptive revocation, for example) can make
+ * an update copy more than one path (review of #8, R8-1b). Iteration is
+ * in ascending key order (UTF-16 code units).
+ */
+const heightOf = (n) => (n === undefined ? 0 : n.height);
+function node(key, value, left, right) {
+    const height = 1 + Math.max(heightOf(left), heightOf(right));
+    return Object.freeze({ key, value, left, right, height });
+}
+/** A node for (key, value) over `left` and `right`, whose heights differ by at most two. */
+function balanced(key, value, left, right) {
+    const hl = heightOf(left);
+    const hr = heightOf(right);
+    if (hl > hr + 1) {
+        const l = left;
+        if (heightOf(l.left) >= heightOf(l.right))
+            return node(l.key, l.value, l.left, node(key, value, l.right, right));
+        const lr = l.right;
+        return node(lr.key, lr.value, node(l.key, l.value, l.left, lr.left), node(key, value, lr.right, right));
+    }
+    if (hr > hl + 1) {
+        const r = right;
+        if (heightOf(r.right) >= heightOf(r.left))
+            return node(r.key, r.value, node(key, value, left, r.left), r.right);
+        const rl = r.left;
+        return node(rl.key, rl.value, node(key, value, left, rl.left), node(r.key, r.value, rl.right, r.right));
+    }
+    return node(key, value, left, right);
+}
+/** `n` with `key` set; the second element is whether the key is new. */
+function insert(n, key, value) {
+    if (n === undefined)
+        return [node(key, value, undefined, undefined), true];
+    if (key < n.key) {
+        const [left, added] = insert(n.left, key, value);
+        return [balanced(n.key, n.value, left, n.right), added];
+    }
+    if (key > n.key) {
+        const [right, added] = insert(n.right, key, value);
+        return [balanced(n.key, n.value, n.left, right), added];
+    }
+    return [node(key, value, n.left, n.right), false];
+}
+function lookup(root, key) {
+    let n = root;
+    while (n !== undefined) {
+        if (key < n.key)
+            n = n.left;
+        else if (key > n.key)
+            n = n.right;
+        else
+            return n;
+    }
+    return undefined;
+}
+/** `pick` of every node under `n`, in key order, appended to `out`. */
+function collect(n, pick, out) {
+    const stack = [];
+    let at = n;
+    while (at !== undefined || stack.length > 0) {
+        while (at !== undefined) {
+            stack.push(at);
+            at = at.left;
+        }
+        const top = stack.pop();
+        out.push(pick(top));
+        at = top.right;
+    }
+    return out;
+}
+const pickEntry = (n) => [n.key, n.value];
+const pickKey = (n) => n.key;
+const pickValue = (n) => n.value;
+export class PersistentMap {
+    static #EMPTY = new PersistentMap(undefined, 0);
+    #root;
+    size;
+    constructor(root, size) {
+        this.#root = root;
+        this.size = size;
+        Object.freeze(this);
+    }
+    static empty() {
+        return PersistentMap.#EMPTY;
+    }
+    static from(entries) {
+        let map = PersistentMap.empty();
+        for (const [k, v] of entries)
+            map = map.set(k, v);
+        return map;
+    }
+    get(key) {
+        return lookup(this.#root, key)?.value;
+    }
+    has(key) {
+        return lookup(this.#root, key) !== undefined;
+    }
+    /** A map with `key` set to `value`; this one is unchanged. */
+    set(key, value) {
+        const [root, added] = insert(this.#root, key, value);
+        return new PersistentMap(root, added ? this.size + 1 : this.size);
+    }
+    /** The tree's height (tests: it stays logarithmic whatever the keys). */
+    get height() {
+        return heightOf(this.#root);
+    }
+    /**
+     * Adds every tree node of this map to `seen` (tests: the structure the
+     * retained states hold together, shared nodes counted once).
+     */
+    collectNodes(seen) {
+        collect(this.#root, (n) => seen.add(n).size, []);
+    }
+    entries() {
+        return collect(this.#root, pickEntry, []).values();
+    }
+    keys() {
+        return collect(this.#root, pickKey, []).values();
+    }
+    values() {
+        return collect(this.#root, pickValue, []).values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    forEach(fn, thisArg) {
+        for (const [k, v] of this.entries())
+            fn.call(thisArg, v, k, this);
+    }
+}
+/**
+ * `map` with `key` set to `value`, sharing structure when `map` is
+ * persistent; any other ReadonlyMap (a state built by a caller) is copied
+ * once into a persistent one.
+ */
+export function put(map, key, value) {
+    return (map instanceof PersistentMap ? map : PersistentMap.from(map)).set(key, value);
+}
+//# sourceMappingURL=persistent-map.js.map

package/dist/revoked-reader.d.ts

@@ -0,0 +1,29 @@
+import { type ControlRecordId, type PrincipalId } from "@openlfcp/core";
+import type { ChainResult } from "./chain.js";
+type Linear = Extract<ChainResult, {
+    kind: "linear";
+}>;
+/** The end of the Control Chain prefix a revoked reader may still read (W §41). */
+export interface RevokedReaderPrefix {
+    /** Position of the revoking record in the chain (Genesis is 0). */
+    readonly index: number;
+    /** The first record that revoked the Principal: the prefix's only Control Head. */
+    readonly recordId: ControlRecordId;
+    readonly reason: bigint;
+}
+/**
+ * W §41 "Control read for a revoked reader": a Principal `p` that no longer
+ * holds `data/read` at the accepted head may read the Control Chain prefix
+ * through the first `DEVICE_REVOKE {root, p, ...}` with `root =
+ * devices[p].root`, when `p` is registered and held `data/read` at the head
+ * immediately before that record. Undefined otherwise: an unbound,
+ * intermediate-only or out-of-scope device, a device whose mask never
+ * conferred `data/read`, a device whose root lost standing without a
+ * revocation, and a current reader get nothing from this rule. A consumed
+ * pairing device (reason 3) is covered like any revoked reader. This is
+ * what lets a revoked device prove its revocation (IDENTITY-PROFILE-01
+ * §8.6); a server serves it, a client verifies it the same way.
+ */
+export declare function revokedReaderPrefix(chain: Linear, p: PrincipalId): RevokedReaderPrefix | undefined;
+export {};
+//# sourceMappingURL=revoked-reader.d.ts.map

package/dist/revoked-reader.js

@@ -0,0 +1,39 @@
+import { bytesEqual, controlRecordId, toHex, } from "@openlfcp/core";
+import { ABILITY, hasAbility } from "./capability.js";
+/**
+ * W §41 "Control read for a revoked reader": a Principal `p` that no longer
+ * holds `data/read` at the accepted head may read the Control Chain prefix
+ * through the first `DEVICE_REVOKE {root, p, ...}` with `root =
+ * devices[p].root`, when `p` is registered and held `data/read` at the head
+ * immediately before that record. Undefined otherwise: an unbound,
+ * intermediate-only or out-of-scope device, a device whose mask never
+ * conferred `data/read`, a device whose root lost standing without a
+ * revocation, and a current reader get nothing from this rule. A consumed
+ * pairing device (reason 3) is covered like any revoked reader. This is
+ * what lets a revoked device prove its revocation (IDENTITY-PROFILE-01
+ * §8.6); a server serves it, a client verifies it the same way.
+ */
+export function revokedReaderPrefix(chain, p) {
+    if (hasAbility(chain.state, p, ABILITY.DATA_READ))
+        return undefined;
+    const d = chain.state.devices.get(toHex(p));
+    if (d === undefined || !d.registered)
+        return undefined;
+    for (let i = 1; i < chain.records.length; i++) {
+        const r = chain.records[i];
+        if (r?.body.type !== "DEVICE_REVOKE")
+            continue;
+        if (!bytesEqual(r.body.device, p) || !bytesEqual(r.body.root, d.root))
+            continue;
+        const before = chain.stateAt(chain.records[i - 1]?.signed.id);
+        if (before === undefined || !hasAbility(before, p, ABILITY.DATA_READ))
+            return undefined;
+        return Object.freeze({
+            index: i,
+            recordId: controlRecordId(r.signed.id),
+            reason: r.body.reason,
+        });
+    }
+    return undefined;
+}
+//# sourceMappingURL=revoked-reader.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlfcp/wire",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Deterministic CBOR, COSE and LFCP Wire structures and codecs.",
   "keywords": [
     "openlfcp",
@@ -47,7 +47,7 @@
     "tag": "latest"
   },
   "dependencies": {
-    "@openlfcp/core": "^0.2.1",
-    "@openlfcp/crypto": "^0.2.1"
+    "@openlfcp/core": "^0.3.0",
+    "@openlfcp/crypto": "^0.3.0"
   }
 }