@joe-broadhead/messaging 0.7.0 → 0.8.0

package/dist/lib/modules/core/conversation/ratchet.js

@@ -0,0 +1,243 @@
+/**
+ * Sender keys (spec §16.5). Each sender device keeps one chain per (conversation, epoch):
+ *
+ *   mk_i     = HKDF-SHA256(ikm = ck_i, salt = empty, info = DOMAIN.convMsg,   32 bytes)
+ *   ck_{i+1} = HKDF-SHA256(ikm = ck_i, salt = empty, info = DOMAIN.convChain, 32 bytes)
+ *
+ * A rotation starts a fresh random chain key at the next index of the same epoch, so `(epoch, device, idx)` names a
+ * message's key whatever the rotations: the share with the greatest `idx` at or below a message's `idx` derives it.
+ * Pure: no clock, no I/O; times are passed in.
+ */
+import { hkdfSync, randomBytes } from "node:crypto";
+import { z } from "../../vendor/zod/index.js";
+import { b64u } from "../b64u.js";
+import { parseWith } from "../check.js";
+import { DOMAIN, Key32, LIMITS, MachineId as MachineIdSchema, Millis } from "../schema/common.js";
+import { KeyShare as KeyShareSchema } from "../schema/conversation.js";
+import { MessagingError } from "../schema/errors.js";
+const EMPTY = new Uint8Array(0);
+function hkdf(ck, info) {
+    return new Uint8Array(hkdfSync("sha256", ck, EMPTY, info, 32));
+}
+/** One ratchet step: the message key for this index and the chain key for the next. */
+export function chainStep(ck) {
+    if (ck.length !== 32)
+        throw new MessagingError("invalid_request", "a chain key is 32 bytes");
+    return { mk: hkdf(ck, DOMAIN.convMsg), next: hkdf(ck, DOMAIN.convChain) };
+}
+const Index = z.number().int().min(0);
+/** A sender chain as a device stores it. */
+export const SenderChainState = z.strictObject({
+    epoch: Index,
+    device: MachineIdSchema,
+    start: Index,
+    origin: Key32,
+    idx: Index,
+    ck: Key32,
+    startedAt: Millis,
+});
+/** The sending side of one chain. `next()` hands out each message key once. */
+export class SenderChain {
+    epoch;
+    device;
+    /** The index this chain starts at. */
+    start;
+    startedAt;
+    #origin;
+    #ck;
+    #idx;
+    constructor(state) {
+        this.epoch = state.epoch;
+        this.device = state.device;
+        this.start = state.start;
+        this.startedAt = state.startedAt;
+        this.#origin = state.origin;
+        this.#ck = state.ck;
+        this.#idx = state.idx;
+    }
+    /** A new chain at `idx` (default 0) of `epoch`, from a fresh random chain key. */
+    static start(args) {
+        return SenderChain.#from(args, randomBytes(32));
+    }
+    /** `start` with a caller-chosen chain key: for test vectors, and for a device restoring its own state. */
+    static startWith(args, ck) {
+        return SenderChain.#from(args, ck);
+    }
+    static #from(args, ck) {
+        const epoch = parseWith(Index, args.epoch, "epoch");
+        const device = parseWith(MachineIdSchema, args.device, "device");
+        const start = parseWith(Index, args.idx ?? 0, "chain index");
+        const startedAt = parseWith(Millis, args.now, "now");
+        if (ck.length !== 32)
+            throw new MessagingError("invalid_request", "a chain key is 32 bytes");
+        const key = new Uint8Array(ck);
+        return new SenderChain({ epoch, device, start, origin: key, idx: start, ck: key, startedAt });
+    }
+    static restore(raw) {
+        const s = parseWith(SenderChainState, raw, "sender chain");
+        if (s.idx < s.start)
+            throw new MessagingError("invalid_request", "a sender chain cannot be behind its start");
+        return new SenderChain({ ...s, origin: b64u.decode(s.origin), ck: b64u.decode(s.ck) });
+    }
+    export() {
+        return { epoch: this.epoch, device: this.device, start: this.start, origin: b64u.encode(this.#origin), idx: this.#idx, ck: b64u.encode(this.#ck), startedAt: this.startedAt };
+    }
+    /** The index the next message gets. */
+    get idx() {
+        return this.#idx;
+    }
+    /** The share that lets a receiver open every message of this chain: its chain key at its start. */
+    share() {
+        return { epoch: this.epoch, device: this.device, idx: this.start, ck: b64u.encode(this.#origin) };
+    }
+    /** The key for the next message, and its index. The chain moves past it. */
+    next() {
+        const { mk, next } = chainStep(this.#ck);
+        const idx = this.#idx;
+        this.#ck = next;
+        this.#idx = idx + 1;
+        return { idx, mk };
+    }
+    /** True once the chain has sent `LIMITS.chainMessages` messages or is `LIMITS.chainMaxMs` old: rotate before the next. */
+    due(now) {
+        return this.#idx - this.start >= LIMITS.chainMessages || now - this.startedAt >= LIMITS.chainMaxMs;
+    }
+    /** A fresh chain in the same epoch, starting at this chain's next index. Share it before sending on it. */
+    rotate(now) {
+        return SenderChain.start({ epoch: this.epoch, device: this.device, idx: this.#idx, now });
+    }
+    /** `rotate` with a caller-chosen chain key, for test vectors. */
+    rotateWith(now, ck) {
+        return SenderChain.startWith({ epoch: this.epoch, device: this.device, idx: this.#idx, now }, ck);
+    }
+}
+const Segment = z.strictObject({
+    epoch: Index,
+    device: MachineIdSchema,
+    start: Index,
+    origin: Key32,
+    pos: Index,
+    ck: Key32,
+    skipped: z.array(z.tuple([Index, Key32])).max(LIMITS.skippedKeys),
+});
+export const ReceiverChainsState = z.strictObject({ chains: z.array(Segment).max(100_000) });
+/**
+ * The receiving side: every chain this device holds for one conversation, by (epoch, sender device). It derives
+ * forward only and hands out each message key once; a message that arrives out of order uses a key kept from an
+ * earlier derivation, at most `LIMITS.skippedKeys` per sender and epoch. The chain keys at each share's index are
+ * kept, so the device can share them with a late joiner (history `shared`).
+ */
+export class ReceiverChains {
+    #chains = new Map();
+    static restore(raw) {
+        const state = parseWith(ReceiverChainsState, raw, "receiver chains");
+        const chains = new ReceiverChains();
+        for (const s of state.chains) {
+            if (s.pos < s.start)
+                throw new MessagingError("invalid_request", "a receiver chain cannot be behind its start");
+            const list = chains.#list(s.epoch, s.device);
+            if (list.some((seg) => seg.start === s.start))
+                throw new MessagingError("invalid_request", "duplicate receiver chain");
+            list.push({ start: s.start, origin: b64u.decode(s.origin), pos: s.pos, ck: b64u.decode(s.ck), skipped: new Map(s.skipped.map(([i, k]) => [i, b64u.decode(k)])) });
+            list.sort((a, b) => a.start - b.start);
+        }
+        return chains;
+    }
+    export() {
+        const chains = [];
+        for (const [key, list] of [...this.#chains].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) {
+            const [epoch, device] = key.split(" ");
+            for (const s of list) {
+                chains.push({
+                    epoch: Number(epoch),
+                    device,
+                    start: s.start,
+                    origin: b64u.encode(s.origin),
+                    pos: s.pos,
+                    ck: b64u.encode(s.ck),
+                    skipped: [...s.skipped].sort(([a], [b]) => a - b).map(([i, k]) => [i, b64u.encode(k)]),
+                });
+            }
+        }
+        return { chains };
+    }
+    #list(epoch, device) {
+        const key = `${epoch} ${device}`;
+        let list = this.#chains.get(key);
+        if (!list) {
+            list = [];
+            this.#chains.set(key, list);
+        }
+        return list;
+    }
+    /**
+     * Adds a share. The first share at a given (epoch, device, idx) wins: a later one with another key changes
+     * nothing, and `add` returns false. Returns true when the share was new.
+     */
+    add(raw) {
+        const share = parseWith(KeyShareSchema, raw, "key share");
+        const list = this.#list(share.epoch, share.device);
+        if (list.some((s) => s.start === share.idx))
+            return false;
+        const ck = b64u.decode(share.ck);
+        list.push({ start: share.idx, origin: ck, pos: share.idx, ck, skipped: new Map() });
+        list.sort((a, b) => a.start - b.start);
+        return true;
+    }
+    /** Every share this device holds, from each chain's start: what it shares with a late joiner. */
+    shares() {
+        const out = [];
+        for (const s of this.export().chains)
+            out.push({ epoch: s.epoch, device: s.device, idx: s.start, ck: s.origin });
+        return out;
+    }
+    /**
+     * The message key for (`epoch`, `device`, `idx`), used once. `not_found` when no share covers it, or its key was
+     * already used or dropped; `too_large` when it is more than `LIMITS.skippedKeys` past the chain's position.
+     */
+    messageKey(epoch, device, idx) {
+        const list = this.#chains.get(`${epoch} ${device}`) ?? [];
+        let at = -1;
+        for (let i = 0; i < list.length; i++)
+            if (list[i].start <= idx)
+                at = i;
+        if (at < 0)
+            throw new MessagingError("not_found", "no key share covers this message");
+        // `at` is the last chain starting at or below `idx`, so the next one (a rotation) starts past it.
+        const seg = list[at];
+        if (idx < seg.pos) {
+            const mk = seg.skipped.get(idx);
+            if (!mk)
+                throw new MessagingError("not_found", "this message key was already used or dropped");
+            seg.skipped.delete(idx);
+            return mk;
+        }
+        if (idx - seg.pos > LIMITS.skippedKeys)
+            throw new MessagingError("too_large", "message index is too far past the chain");
+        let ck = seg.ck;
+        for (let i = seg.pos; i < idx; i++) {
+            const step = chainStep(ck);
+            seg.skipped.set(i, step.mk);
+            ck = step.next;
+        }
+        const { mk, next } = chainStep(ck);
+        seg.ck = next;
+        seg.pos = idx + 1;
+        this.#bound(list);
+        return mk;
+    }
+    /** Keeps at most `LIMITS.skippedKeys` skipped keys per (epoch, device), dropping the lowest indexes first. */
+    #bound(list) {
+        let total = list.reduce((n, s) => n + s.skipped.size, 0);
+        for (const seg of list) {
+            if (total <= LIMITS.skippedKeys)
+                return;
+            for (const i of [...seg.skipped.keys()].sort((a, b) => a - b)) {
+                if (total <= LIMITS.skippedKeys)
+                    return;
+                seg.skipped.delete(i);
+                total--;
+            }
+        }
+    }
+}

package/dist/lib/modules/core/conversation/request-log.js

@@ -0,0 +1,158 @@
+/** Permanent request activation and import reservations, replayed alongside ConvLog (spec §16.11). */
+import { b64u } from "../b64u.js";
+import { canonicalize } from "../jcs.js";
+import { parseWith } from "../check.js";
+import { RequestImport } from "../schema/contact-request.js";
+import { MessagingError } from "../schema/errors.js";
+import { convEventDigest, verifyConvEvent } from "./event.js";
+import { verifyContactAuthorization, verifyPortableRequest, verifyRequestActivation } from "./requests.js";
+const refuse = (message) => { throw new MessagingError("request_required", message); };
+const conflict = (message) => { throw new MessagingError("conv_conflict", message); };
+const digest = (event) => b64u.encode(convEventDigest(event));
+function proofFor(log, proof, binding) {
+    const state = log.state();
+    if (state?.kind !== "dm" || state.participants.length !== 2 || state.participants.some((p) => p.agent !== undefined))
+        refuse("activation is for a two-person DM");
+    const persons = state.participants.map((p) => p.person).sort();
+    const check = (p) => {
+        if (p.realm !== log.realm || p.cid !== log.cid || canonicalize([p.from, p.to].sort()) !== canonicalize(persons))
+            conflict("activation names another DM");
+    };
+    if ("contacts" in proof) {
+        const a = verifyContactAuthorization(proof.contacts[0], binding), b = verifyContactAuthorization(proof.contacts[1], binding);
+        check(a);
+        check(b);
+        if (a.from !== b.to || a.to !== b.from)
+            refuse("both contacts must authorize the DM");
+        return undefined;
+    }
+    const request = verifyRequestActivation(proof, binding);
+    check(request.descriptor);
+    return request;
+}
+/** Rebuilds permanent activation state even when imported messages have expired. */
+export function requestLogState(log, binding) {
+    const entries = log.entries();
+    const first = entries[0];
+    const required = !!first && "event" in first && first.event.class === "op" && first.event.body.op === "create" && first.event.body.admission === "request";
+    const state = { required, active: !required, reservations: new Map() };
+    for (const entry of entries) {
+        if (!("event" in entry) || entry.event.class !== "op" || log.at(entry.seq)?.changed !== entry.seq)
+            continue;
+        const op = entry.event.body;
+        if (op.op === "activate") {
+            if (!required)
+                refuse("this conversation has no request admission");
+            const p = proofFor(log, op.proof, binding);
+            state.active = true;
+            if (p) {
+                const old = state.reservations.get(p.descriptor.id);
+                if (old && canonicalize(old.proof) !== canonicalize(p))
+                    conflict("request activation conflicts with its reservation");
+                if (!old)
+                    state.reservations.set(p.descriptor.id, { proof: p });
+            }
+        }
+        else if (op.op === "request.complete") {
+            const reservation = state.reservations.get(op.request);
+            if (!reservation || reservation.completed)
+                conflict("request completion has no pending reservation");
+            if (entry.event.by.person !== reservation.proof.descriptor.to || entry.event.by.agent !== undefined)
+                refuse("only the accepting person completes an import");
+            const imported = entries[op.seq - 1];
+            if (!imported || op.seq >= entry.seq)
+                conflict("completion must name an earlier import");
+            if ("event" in imported) {
+                const e = imported.event;
+                if (e.class !== "msg" || e.id !== op.request || e.request !== op.request || e.by.person !== reservation.proof.descriptor.to || e.by.agent !== undefined)
+                    conflict("completion names another event");
+            }
+            if (("event" in imported ? digest(imported.event) : imported.digest) !== op.digest)
+                conflict("completion digest does not match the log");
+            reservation.completed = { seq: op.seq, digest: op.digest };
+        }
+    }
+    return state;
+}
+/** Checks before appending. The relay also checks live org admission on create. No mutation on failure. */
+export function checkRequestEvent(log, raw, binding, body) {
+    const event = verifyConvEvent(raw);
+    if (event.realm !== log.realm || event.cid !== log.cid)
+        throw new MessagingError("invalid_request", "request event names another conversation");
+    if (event.class === "op" && event.body.op === "create") {
+        if (event.body.admission && (event.body.kind !== "dm" || event.body.participants.some((p) => p.p.includes("/"))))
+            refuse("request admission is for human DMs only");
+        return;
+    }
+    const s = requestLogState(log, binding);
+    if (event.class === "op" && event.body.op === "activate") {
+        if (!s.required || event.by.agent !== undefined)
+            refuse("activation requires a person's request DM");
+        const p = proofFor(log, event.body.proof, binding);
+        if (p) {
+            if (event.by.person !== p.descriptor.to)
+                refuse("the accepting person activates the request");
+            const old = s.reservations.get(p.descriptor.id);
+            if (old)
+                conflict("this request already has a permanent activation");
+            if (log.entries().some((e) => "event" in e && e.event.id === p.descriptor.id))
+                conflict("request id collides with an existing event");
+        }
+        return;
+    }
+    const deviceControl = event.class === "op" && event.body.op === "rekey" && event.body.cause === "device";
+    if (!s.active && !deviceControl)
+        refuse("accept the contact request before content or key sharing");
+    const pending = [...s.reservations].filter(([, r]) => !r.completed);
+    if (event.class === "keys")
+        return;
+    if (event.class === "op" && event.body.op === "request.complete") {
+        const op = event.body, r = s.reservations.get(op.request);
+        if (!r || r.completed || event.by.person !== r.proof.descriptor.to || event.by.agent !== undefined)
+            conflict("no pending import for this recipient");
+        const e = log.entries()[op.seq - 1];
+        if (!e || ("event" in e ? e.event.class !== "msg" || e.event.request !== op.request || e.event.id !== op.request || digest(e.event) !== op.digest : e.digest !== op.digest))
+            conflict("completion does not bind the imported event");
+        return;
+    }
+    if (event.class === "msg" && event.request !== undefined) {
+        const r = s.reservations.get(event.request);
+        if (!r || r.completed || event.id !== event.request || event.by.person !== r.proof.descriptor.to || event.by.agent !== undefined || event.wake !== undefined)
+            refuse("no accepted import reservation for this author");
+        if (body !== undefined) {
+            const p = parseWith(RequestImport, body, "request import");
+            verifyPortableRequest({ descriptor: p.descriptor, opening: p.opening }, binding);
+            verifyRequestActivation({ descriptor: p.descriptor, decision: p.decision }, binding);
+            if (canonicalize({ descriptor: p.descriptor, decision: p.decision }) !== canonicalize(r.proof))
+                conflict("import differs from the permanent activation");
+        }
+        return;
+    }
+    if (s.reservations.has(event.id))
+        conflict("the request id is reserved for its import");
+    if (pending.length && !deviceControl)
+        refuse("accepted first messages must finish importing before ordinary sends");
+    if (body && typeof body === "object" && "t" in body) {
+        const b = body;
+        if (b.t === "request.import")
+            refuse("request imports require a reserved header");
+        if ((b.t === "edit" || b.t === "delete") && s.reservations.has(b.target)) {
+            if (b.t === "edit")
+                throw new MessagingError("forbidden", "an imported request is immutable");
+            if (event.by.agent !== undefined || event.by.person !== s.reservations.get(b.target).proof.descriptor.from)
+                throw new MessagingError("forbidden", "only the original author deletes a request import");
+        }
+    }
+}
+/** Member admission seam for the cut-over engine; preserves wrapper authorship and verifies source separately. */
+export function applyRequestEntry(log, entry, binding, options = {}) {
+    checkRequestEvent(log, entry.event, binding, options.body);
+    const body = options.body;
+    // ConvLog's line author is the wrapper author. Source attribution/deletion comes only from verified proofs.
+    const imported = body?.t === "request.import" || (body?.t === "delete" && requestLogState(log, binding).reservations.has(body.target));
+    return log.apply(entry, imported ? { ...options, body: undefined } : options);
+}
+/** Public author for a verified import, never the importing device. The renderer uses this only after admission. */
+export function importedRequestAuthor(log, id, binding) {
+    return requestLogState(log, binding).reservations.get(id)?.proof.descriptor.from;
+}

package/dist/lib/modules/core/conversation/request-seal.js

@@ -0,0 +1,41 @@
+/** The request.import profile uses the conversation sender-key seal, with its own strict plaintext schema. */
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { b64u } from "../b64u.js";
+import { asMessagingError, parseWith } from "../check.js";
+import { canonicalize } from "../jcs.js";
+import { RequestImport } from "../schema/contact-request.js";
+import { MessagingError } from "../schema/errors.js";
+import { parseWire } from "../wire.js";
+import { convEventHeader, signConvEvent, verifyConvEvent } from "./event.js";
+export function sealRequestImport(identity, header, body, mk) {
+    try {
+        const value = parseWith(RequestImport, body, "request import");
+        if (header.request !== value.descriptor.id || header.id !== header.request || header.by.person !== value.descriptor.to || header.by.agent !== undefined || header.wake !== undefined)
+            throw new MessagingError("invalid_request", "import header does not bind its recipient and reservation");
+        const nonce = randomBytes(12), cipher = createCipheriv("aes-256-gcm", mk, nonce);
+        cipher.setAAD(Buffer.from(canonicalize(header)));
+        const sealed = Buffer.concat([nonce, cipher.update(canonicalize(value), "utf8"), cipher.final(), cipher.getAuthTag()]);
+        return signConvEvent(identity, { ...header, body: b64u.encode(sealed) });
+    }
+    catch (error) {
+        throw asMessagingError(error, "request import seal");
+    }
+}
+export function openRequestImport(raw, mk) {
+    try {
+        const event = verifyConvEvent(raw);
+        if (event.class !== "msg" || !event.request)
+            throw new MessagingError("invalid_request", "not a reserved request import");
+        const data = b64u.decode(event.body);
+        if (data.length > 8192)
+            throw new MessagingError("too_large", "request import too large");
+        const decipher = createDecipheriv("aes-256-gcm", mk, data.subarray(0, 12));
+        decipher.setAAD(Buffer.from(canonicalize(convEventHeader(event))));
+        decipher.setAuthTag(data.subarray(-16));
+        const bytes = Buffer.concat([decipher.update(data.subarray(12, -16)), decipher.final()]);
+        return parseWith(RequestImport, parseWire(new TextDecoder("utf-8", { fatal: true }).decode(bytes)), "request import");
+    }
+    catch (error) {
+        throw asMessagingError(error, "request import open");
+    }
+}

package/dist/lib/modules/core/conversation/requests.js

@@ -0,0 +1,87 @@
+/** Portable request proofs. Verify raw signatures before using parsed values. No key material is transported. */
+import { createHash, randomBytes } from "node:crypto";
+import { parseWith } from "../check.js";
+import { canonicalize } from "../jcs.js";
+import { assertEd25519PublicKey } from "../keys.js";
+import { DOMAIN, LIMITS } from "../schema/common.js";
+import { ContactAuthorization, PortableRequest, RequestActivation, RequestDecision, RequestDescriptor, RequestOpening } from "../schema/contact-request.js";
+import { MessagingError } from "../schema/errors.js";
+import { sign, verify } from "../sign.js";
+import { dmConvId } from "./ids.js";
+const fail = (message) => { throw new MessagingError("invalid_request", message); };
+const digest = (domain, value) => createHash("sha256").update(domain).update(canonicalize(value)).digest("base64url");
+export const requestCommitment = (opening) => digest(DOMAIN.requestContent, parseWith(RequestOpening, opening, "request opening"));
+export const requestDigest = (descriptor) => digest(DOMAIN.requestDigest, descriptor);
+function signed(schema, raw, domain) {
+    parseWith(schema, raw, "request proof");
+    const value = raw;
+    assertEd25519PublicKey(value.by, "request device");
+    const { sig, ...unsigned } = value;
+    if (!verify(value.by, domain, unsigned, sig))
+        throw new MessagingError("bad_signature", "invalid request proof signature");
+    return parseWith(schema, raw, "request proof");
+}
+function bound(person, device, binding) {
+    if (!binding(person, device))
+        throw new MessagingError("unknown_device", "request signer has no verified person binding");
+}
+function route(p) {
+    if (p.from === p.to || p.cid !== dmConvId(p.from, p.to))
+        fail("request must name its two persons' exact DM");
+}
+export function verifyRequestDescriptor(raw, binding) {
+    const d = signed(RequestDescriptor, raw, DOMAIN.request);
+    route(d);
+    bound(d.from, d.by, binding);
+    if (d.expiresAt <= d.issuedAt || d.expiresAt - d.issuedAt > LIMITS.ttlMs)
+        fail("invalid request consent window");
+    return d;
+}
+export function verifyPortableRequest(raw, binding) {
+    parseWith(PortableRequest, raw, "portable request");
+    const value = raw;
+    const descriptor = verifyRequestDescriptor(value.descriptor, binding);
+    const opening = parseWith(RequestOpening, value.opening, "request opening");
+    if (requestCommitment(opening) !== descriptor.commitment)
+        throw new MessagingError("bad_signature", "request opening does not match signed content");
+    return { descriptor, opening };
+}
+export function createPortableRequest(identity, args, text) {
+    const opening = parseWith(RequestOpening, { salt: randomBytes(32).toString("base64url"), text }, "request opening");
+    const unsigned = { ...args, commitment: requestCommitment(opening), by: identity.machine };
+    return verifyPortableRequest({ descriptor: { ...unsigned, sig: sign(identity, DOMAIN.request, unsigned) }, opening }, (person, by) => person === args.from && by === identity.machine);
+}
+export function verifyRequestDecision(raw, descriptor, binding) {
+    const d = verifyRequestDescriptor(descriptor, binding);
+    const a = signed(RequestDecision, raw, DOMAIN.requestDecision);
+    bound(d.to, a.by, binding);
+    if (a.realm !== d.realm || a.cid !== d.cid || a.id !== d.id || a.from !== d.from || a.to !== d.to || a.descriptor !== requestDigest(d))
+        fail("decision does not bind this request");
+    if (a.at < d.issuedAt || a.at >= d.expiresAt)
+        throw new MessagingError("expired", "decision is outside the original consent window");
+    return a;
+}
+export function signRequestDecision(identity, d, answer, at) {
+    const unsigned = { v: d.v, realm: d.realm, cid: d.cid, id: d.id, from: d.from, to: d.to, descriptor: requestDigest(d), answer, at, by: identity.machine };
+    return parseWith(RequestDecision, { ...unsigned, sig: sign(identity, DOMAIN.requestDecision, unsigned) }, "request decision");
+}
+export function verifyRequestActivation(raw, binding) {
+    parseWith(RequestActivation, raw, "activation");
+    const p = raw;
+    const descriptor = verifyRequestDescriptor(p.descriptor, binding);
+    const decision = verifyRequestDecision(p.decision, descriptor, binding);
+    if (decision.answer !== "accept")
+        throw new MessagingError("forbidden", "a declined request cannot activate a conversation");
+    return { descriptor, decision };
+}
+export function signContactAuthorization(identity, args) {
+    route(args);
+    const unsigned = { ...args, by: identity.machine };
+    return parseWith(ContactAuthorization, { ...unsigned, sig: sign(identity, DOMAIN.contactAuthorization, unsigned) }, "contact authorization");
+}
+export function verifyContactAuthorization(raw, binding) {
+    const c = signed(ContactAuthorization, raw, DOMAIN.contactAuthorization);
+    route(c);
+    bound(c.from, c.by, binding);
+    return c;
+}