@forgesworn/fold-kit 0.9.0 → 0.12.0

package/dist/mls-admission.js

@@ -0,0 +1,400 @@
+import { hkdf } from '@noble/hashes/hkdf';
+import { sha256 } from '@noble/hashes/sha2';
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
+import { base64, base64urlnopad } from '@scure/base';
+import { nip44 } from 'nostr-tools';
+import { finalizeEvent, getPublicKey } from 'nostr-tools/pure';
+import { isSealPubkey } from './seal.js';
+import { verifyEventUncached } from './verify.js';
+const ID = 'kithmoot/v4/mls-invitation-id';
+const REQUEST_KEY = 'kithmoot/v4/mls-request-key';
+const ANSWER_KEY = 'kithmoot/v4/mls-answer-key';
+const REQUEST = 'kithmoot/v4/mls-request';
+const ANSWER = 'kithmoot/v4/mls-answer';
+const ACCOUNT = 'kithmoot/v4/mls-joiner-account-proof';
+const BROWSER = 'kithmoot/v4/mls-browser-device-proof';
+const ENGINE = 'kithmoot/v4/mls-engine-device-proof';
+const KEEPER_ACCOUNT = 'kithmoot/v4/mls-keeper-account-proof';
+const KEEPER_DEVICE = 'kithmoot/v4/mls-keeper-device-proof';
+export const MLS_ADMISSION_LABELS = Object.freeze([
+    ID, REQUEST_KEY, ANSWER_KEY, REQUEST, ANSWER, ACCOUNT, BROWSER, ENGINE,
+    KEEPER_ACCOUNT, KEEPER_DEVICE,
+]);
+export const MLS_ADMISSION_PLAINTEXT_BYTES = 16_384;
+export const MLS_ADMISSION_CIPHERTEXT_CHARACTERS = 21_936;
+const HEX = /^[0-9a-f]{64}$/;
+const SIG = /^[0-9a-f]{128}$/;
+const DECIMAL = /^(0|[1-9][0-9]*)$/;
+const utf8 = new TextEncoder();
+const text = new TextDecoder('utf-8', { fatal: true });
+const FAILURE = 'invalid MLS admission v4';
+const requests = new WeakMap();
+const answers = new WeakMap();
+function check(ok) {
+    if (!ok)
+        throw new Error(FAILURE);
+}
+function integer(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && !Object.is(value, -0);
+}
+function hex(value) { return typeof value === 'string' && HEX.test(value); }
+function pubkey(value) { return hex(value) && isSealPubkey(value); }
+function time(value) { check(integer(value)); }
+function digest(value) { return bytesToHex(sha256(utf8.encode(JSON.stringify(value)))); }
+function same(a, b) { return JSON.stringify(a) === JSON.stringify(b); }
+function array(value, length) {
+    check(Array.isArray(value) && value.length === length);
+}
+// Every wire-facing decoder accepts bounded strings, never caller event objects
+// or proxies with verification markers/accessors. Scan depth before JSON.parse.
+function parse(raw, max, canonical = true) {
+    check(typeof raw === 'string' && raw.length <= max && utf8.encode(raw).length <= max);
+    let depth = 0, quoted = false, escaped = false;
+    for (const c of raw) {
+        if (quoted) {
+            if (escaped)
+                escaped = false;
+            else if (c === '\\')
+                escaped = true;
+            else if (c === '"')
+                quoted = false;
+        }
+        else if (c === '"')
+            quoted = true;
+        else if (c === '[' || c === '{')
+            check(++depth <= 8);
+        else if (c === ']' || c === '}')
+            check(--depth >= 0);
+    }
+    check(depth === 0 && !quoted);
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(FAILURE);
+    }
+    if (canonical)
+        check(JSON.stringify(value) === raw);
+    return value;
+}
+function secret(foreign, action) {
+    check(foreign instanceof Uint8Array && foreign.length === 32);
+    const owned = new Uint8Array(foreign);
+    try {
+        getPublicKey(owned);
+        return action(owned);
+    }
+    finally {
+        owned.fill(0);
+    }
+}
+function invitation(fragment) {
+    check(typeof fragment === 'string' && fragment.length <= 1024 && /^[A-Za-z0-9_-]+$/.test(fragment));
+    const decoded = base64urlnopad.decode(fragment);
+    let bearer, transferred = false;
+    try {
+        check(base64urlnopad.encode(decoded) === fragment);
+        const value = parse(text.decode(decoded), 1024);
+        array(value, 3);
+        check(value[0] === 4 && typeof value[1] === 'string' && pubkey(value[2]));
+        bearer = base64urlnopad.decode(value[1]);
+        check(bearer.length === 32 && bearer.some(b => b !== 0) && base64urlnopad.encode(bearer) === value[1]);
+        const root = value[2];
+        const result = { root, bearer, id: bytesToHex(hkdf(sha256, bearer, hexToBytes(root), ID, 32)) };
+        transferred = true;
+        return result;
+    }
+    finally {
+        decoded.fill(0);
+        if (!transferred)
+            bearer?.fill(0);
+    }
+}
+/** Link fragment only; caller owns CSPRNG generation and secret lifetime. */
+export function encodeMlsInvitationV4(root, bearer) {
+    check(pubkey(root) && bearer instanceof Uint8Array && bearer.length === 32 && bearer.some(b => b !== 0));
+    return base64urlnopad.encode(utf8.encode(JSON.stringify([4, base64urlnopad.encode(bearer), root])));
+}
+export function readMlsInvitationV4(fragment) {
+    const i = invitation(fragment);
+    return { root: i.root, bearer: i.bearer, invitationId: i.id };
+}
+function withKey(i, sk, peer, direction, action) {
+    const base = nip44.v2.utils.getConversationKey(sk, peer);
+    let key;
+    try {
+        key = hkdf(sha256, base, i.bearer, direction, 32);
+        return action(key);
+    }
+    finally {
+        base.fill(0);
+        key?.fill(0);
+        i.bearer.fill(0);
+    }
+}
+function eventFromArray(raw) {
+    array(raw, 7);
+    const [id, key, created_at, kind, tags, content, sig] = raw;
+    check(hex(id) && pubkey(key) && integer(created_at) && integer(kind) && typeof sig === 'string' && SIG.test(sig));
+    check(typeof content === 'string' && Array.isArray(tags) && tags.length <= 8);
+    for (const tag of tags)
+        check(Array.isArray(tag) && tag.length <= 4 && tag.every(s => typeof s === 'string' && s.length <= 256));
+    const event = { id, pubkey: key, created_at, kind, tags, content, sig };
+    check(verifyEventUncached(event));
+    return event;
+}
+function nested(raw) {
+    check(JSON.stringify(raw).length <= 4096 && utf8.encode(JSON.stringify(raw)).length <= 4096);
+    return eventFromArray(raw);
+}
+function eventArray(e) { return [e.id, e.pubkey, e.created_at, e.kind, e.tags, e.content, e.sig]; }
+function outer(raw) {
+    const value = parse(raw, 32768);
+    check(typeof value === 'object' && value !== null && !Array.isArray(value));
+    const e = value;
+    const keys = ['id', 'pubkey', 'created_at', 'kind', 'tags', 'content', 'sig'];
+    check(Object.keys(e).length === keys.length && keys.every(k => Object.hasOwn(e, k)));
+    check(typeof e.content === 'string' && e.content.length === MLS_ADMISSION_CIPHERTEXT_CHARACTERS && /^[A-Za-z0-9+/]+={0,2}$/.test(e.content));
+    check(base64.encode(base64.decode(e.content)) === e.content);
+    return eventFromArray(keys.map(k => e[k]));
+}
+function credential(raw, account, device, expiry, now) {
+    const e = nested(raw);
+    check(e.kind === 20460 && e.pubkey === account && e.content === '' && e.created_at <= now + 30);
+    const tags = new Map();
+    for (const tag of e.tags) {
+        check(tag.length === 2 && ['d', 'scope', 'device', 'expiration', 'label', 'seal'].includes(tag[0]) && !tags.has(tag[0]));
+        tags.set(tag[0], tag[1]);
+    }
+    check(tags.get('d') === account && tags.get('scope') === 'person' && tags.get('device') === device && pubkey(device));
+    const expiration = tags.get('expiration');
+    check(expiration !== undefined && DECIMAL.test(expiration) && integer(Number(expiration)));
+    const end = Number(expiration);
+    check(end > now && end >= expiry && end - e.created_at <= 30 * 86400 && end - now <= 30 * 86400);
+    check(!tags.has('label') || tags.get('label').length <= 64);
+    check(!tags.has('seal') || pubkey(tags.get('seal')));
+    return e;
+}
+function checkNow(now) { check(integer(now) && now <= Number.MAX_SAFE_INTEGER - 7 * 86400 - 30); }
+function requestCore(raw, i, now) {
+    checkNow(now);
+    array(raw, 17);
+    check(raw[0] === 4 && raw[1] === REQUEST && raw[2] === i.id && raw[3] === i.root && pubkey(raw[4]));
+    for (const index of [5, 6, 12])
+        check(hex(raw[index]));
+    for (const index of [7, 8, 9, 10])
+        check(pubkey(raw[index]));
+    check(typeof raw[13] === 'string' && DECIMAL.test(raw[13]) && raw[13].length <= 20 && BigInt(raw[13]) <= 0xffffffffffffffffn);
+    time(raw[14]);
+    time(raw[15]);
+    time(raw[16]);
+    check(raw[16] === raw[15] + 90 && now < raw[16] && raw[15] <= now + 30);
+    check(raw[14] > raw[16] && raw[14] - raw[15] <= 7 * 86400);
+    credential(raw[11], raw[7], raw[9], raw[14], now);
+    return raw;
+}
+function proofSpecs(core) {
+    const request = core[1] === REQUEST;
+    const keys = request ? [core[7], core[8], core[9]] : [core[15], core[16]];
+    const labels = request ? [ACCOUNT, BROWSER, ENGINE] : [KEEPER_ACCOUNT, KEEPER_DEVICE];
+    return keys.map((key, n) => ({ pubkey: key,
+        event: { kind: request ? 20466 : 20467, created_at: core[request ? 15 : 25],
+            tags: [['t', labels[n]]], content: JSON.stringify([4, digest(core)]) } }));
+}
+function checkProofs(raw, core) {
+    const specs = proofSpecs(core);
+    array(raw, specs.length);
+    for (let n = 0; n < specs.length; n++) {
+        const e = nested(raw[n]), s = specs[n];
+        check(e.pubkey === s.pubkey && e.kind === s.event.kind && e.created_at === s.event.created_at && same(e.tags, s.event.tags) && e.content === s.event.content);
+    }
+    return raw;
+}
+function wrapper(core, proofs) {
+    const empty = JSON.stringify([4, core, proofs, '']);
+    const length = utf8.encode(empty).length;
+    check(length <= MLS_ADMISSION_PLAINTEXT_BYTES);
+    const padded = JSON.stringify([4, core, proofs, '0'.repeat(MLS_ADMISSION_PLAINTEXT_BYTES - length)]);
+    check(utf8.encode(padded).length === MLS_ADMISSION_PLAINTEXT_BYTES);
+    return padded;
+}
+function unwrap(raw) {
+    check(utf8.encode(raw).length === MLS_ADMISSION_PLAINTEXT_BYTES);
+    const value = parse(raw, MLS_ADMISSION_PLAINTEXT_BYTES);
+    array(value, 4);
+    check(value[0] === 4 && Array.isArray(value[1]) && Array.isArray(value[2]) && typeof value[3] === 'string' && /^0*$/.test(value[3]));
+    check(wrapper(value[1], value[2]) === raw);
+    return { core: value[1], proofs: value[2] };
+}
+function requestTags(i, deadline) {
+    return [['d', i.id], ['p', i.root], ['expiration', String(deadline)]];
+}
+function requestOuter(e, core, i) {
+    check(e.kind === 20466 && e.pubkey === core[4] && e.created_at === core[15] && same(e.tags, requestTags(i, core[16])));
+}
+function retainRequest(handle, now) {
+    check(typeof handle === 'object' && handle !== null);
+    const value = requests.get(handle);
+    check(value);
+    const i = { root: value.root, id: value.invitationId };
+    requestCore(value.core, i, now);
+    requestOuter(value.event, value.core, i);
+    return value;
+}
+function answerCore(raw, request, now) {
+    checkNow(now);
+    check(Array.isArray(raw));
+    const q = request.core;
+    check(raw[0] === 4 && raw[1] === ANSWER && (raw[2] === 'allow' || raw[2] === 'deny'));
+    check(raw[3] === q[2] && raw[4] === q[3] && raw[5] === request.event.id && raw[6] === request.digest && raw[7] === q[5] && raw[8] === q[6]);
+    const allow = raw[2] === 'allow', created = allow ? 25 : 9, deadline = allow ? 26 : 10;
+    array(raw, allow ? 27 : 11);
+    time(raw[created]);
+    time(raw[deadline]);
+    check(raw[deadline] === q[16] && q[15] <= raw[created] && raw[created] < raw[deadline] && now < raw[deadline] && raw[created] <= now + 30);
+    if (allow) {
+        for (const [a, b] of [[9, 7], [10, 8], [11, 9], [12, 10], [13, 12], [14, 13]])
+            check(raw[a] === q[b]);
+        for (const index of [15, 16, 18])
+            check(pubkey(raw[index]));
+        for (const index of [19, 20, 21, 22])
+            check(hex(raw[index]));
+        check(raw[19] === q[12] && raw[20] === q[12]);
+        time(raw[23]);
+        time(raw[24]);
+        check(raw[23] > raw[26] && raw[23] <= q[14] && raw[23] <= raw[24] && raw[24] > now);
+        credential(raw[17], raw[15], raw[16], raw[23], now);
+    }
+    return raw;
+}
+function answerTags(request) {
+    return [['p', request.event.pubkey], ['e', request.event.id], ['expiration', String(request.core[16])]];
+}
+function answerOuter(e, core, request) {
+    check(e.kind === 20467 && e.pubkey === request.core[3] && e.created_at === core[core[2] === 'allow' ? 25 : 9] && same(e.tags, answerTags(request)));
+}
+/** Templates only. Account/device signers remain caller-owned and settle under
+ * the application's actual custody. Returned templates never confer authority.
+ * core is the exact canonical request array or, with request, Allow array. */
+export function mlsAdmissionProofTemplatesV4(opts) {
+    const i = invitation(opts.fragment);
+    try {
+        const value = parse(opts.core, MLS_ADMISSION_PLAINTEXT_BYTES);
+        const core = opts.request ? answerCore(value, retainRequest(opts.request, opts.now), opts.now) : requestCore(value, i, opts.now);
+        if (opts.request) {
+            const request = retainRequest(opts.request, opts.now);
+            check(core[2] === 'allow' && i.root === request.root && i.id === request.invitationId);
+        }
+        return proofSpecs(core);
+    }
+    finally {
+        i.bearer.fill(0);
+    }
+}
+/** proofs is canonical JSON of the three seven-field signed proof arrays. */
+export function encodeMlsAdmissionRequestV4(opts) {
+    const i = invitation(opts.fragment);
+    try {
+        const core = requestCore(parse(opts.core, MLS_ADMISSION_PLAINTEXT_BYTES), i, opts.now);
+        const proofs = checkProofs(parse(opts.proofs, MLS_ADMISSION_PLAINTEXT_BYTES), core);
+        const body = wrapper(core, proofs);
+        return secret(opts.requestSecretKey, sk => {
+            check(getPublicKey(sk) === core[4]);
+            const content = withKey(i, sk, i.root, REQUEST_KEY, key => nip44.v2.encrypt(body, key));
+            const e = finalizeEvent({ kind: 20466, created_at: core[15], tags: requestTags(i, core[16]), content }, sk);
+            check(content.length === MLS_ADMISSION_CIPHERTEXT_CHARACTERS);
+            return JSON.stringify({ id: e.id, pubkey: e.pubkey, created_at: e.created_at, kind: e.kind, tags: e.tags, content: e.content, sig: e.sig });
+        });
+    }
+    finally {
+        i.bearer.fill(0);
+    }
+}
+/** Either endpoint may decode its exact request; only this decoder issues the
+ * nominal result, after fresh outer/inner checks. Caller secrets are not kept. */
+export function decodeMlsAdmissionRequestV4(opts) {
+    const i = invitation(opts.fragment);
+    try {
+        checkNow(opts.now);
+        const e = outer(opts.event);
+        check(e.kind === 20466 && (opts.side === 'root' || opts.side === 'joiner'));
+        check(integer(e.created_at + 90) && e.created_at <= opts.now + 30 && opts.now < e.created_at + 90 && same(e.tags, requestTags(i, e.created_at + 90)));
+        return secret(opts.localSecretKey, sk => {
+            check(getPublicKey(sk) === (opts.side === 'root' ? i.root : e.pubkey));
+            const body = withKey(i, sk, opts.side === 'root' ? e.pubkey : i.root, REQUEST_KEY, key => nip44.v2.decrypt(e.content, key));
+            const { core: raw, proofs } = unwrap(body);
+            const core = requestCore(raw, i, opts.now);
+            requestOuter(e, core, i);
+            checkProofs(proofs, core);
+            const handle = Object.freeze(Object.create(null));
+            requests.set(handle, { root: i.root, invitationId: i.id, core, digest: digest(core), event: e });
+            return handle;
+        });
+    }
+    finally {
+        i.bearer.fill(0);
+    }
+}
+/** Returned strings are copies of evidence, not a rehydration format. */
+export function readMlsAdmissionRequestV4(handle) {
+    const value = requests.get(handle);
+    check(value);
+    return Object.freeze({ core: JSON.stringify(value.core), digest: value.digest, eventId: value.event.id });
+}
+/** Root correlation and signed keeper consent only. This encoder cannot attest
+ * current keeper role; actual vault/box custody and fresh checks stay external. */
+export function encodeMlsAdmissionAnswerV4(opts) {
+    const request = retainRequest(opts.request, opts.now), i = invitation(opts.fragment);
+    try {
+        check(i.root === request.root && i.id === request.invitationId);
+        const core = answerCore(parse(opts.core, MLS_ADMISSION_PLAINTEXT_BYTES), request, opts.now);
+        const raw = parse(opts.proofs, MLS_ADMISSION_PLAINTEXT_BYTES);
+        const proofs = core[2] === 'allow' ? checkProofs(raw, core) : (array(raw, 0), raw);
+        const body = wrapper(core, proofs);
+        return secret(opts.rootSecretKey, sk => {
+            check(getPublicKey(sk) === i.root);
+            const content = withKey(i, sk, request.event.pubkey, ANSWER_KEY, key => nip44.v2.encrypt(body, key));
+            const e = finalizeEvent({ kind: 20467, created_at: core[core[2] === 'allow' ? 25 : 9], tags: answerTags(request), content }, sk);
+            check(content.length === MLS_ADMISSION_CIPHERTEXT_CHARACTERS);
+            return JSON.stringify({ id: e.id, pubkey: e.pubkey, created_at: e.created_at, kind: e.kind, tags: e.tags, content: e.content, sig: e.sig });
+        });
+    }
+    finally {
+        i.bearer.fill(0);
+    }
+}
+export function decodeMlsAdmissionAnswerV4(opts) {
+    const request = retainRequest(opts.request, opts.now), i = invitation(opts.fragment);
+    try {
+        check(i.root === request.root && i.id === request.invitationId);
+        const e = outer(opts.event);
+        check(e.kind === 20467 && e.pubkey === i.root && same(e.tags, answerTags(request)));
+        check(request.core[15] <= e.created_at && e.created_at < request.core[16] && e.created_at <= opts.now + 30);
+        return secret(opts.requestSecretKey, sk => {
+            check(getPublicKey(sk) === request.event.pubkey);
+            const body = withKey(i, sk, i.root, ANSWER_KEY, key => nip44.v2.decrypt(e.content, key));
+            const { core: raw, proofs } = unwrap(body);
+            const core = answerCore(raw, request, opts.now);
+            answerOuter(e, core, request);
+            if (core[2] === 'allow')
+                checkProofs(proofs, core);
+            else
+                array(proofs, 0);
+            const handle = Object.freeze(Object.create(null));
+            answers.set(handle, { core, digest: digest(core), event: e, requestEventId: request.event.id });
+            return handle;
+        });
+    }
+    finally {
+        i.bearer.fill(0);
+    }
+}
+/** Cryptographic evidence only: no usable capability, child or admission. The
+ * application must obtain current role witness and consume the operation once. */
+export function readMlsAdmissionAnswerV4(handle) {
+    const value = answers.get(handle);
+    check(value);
+    return Object.freeze({ decision: value.core[2], core: JSON.stringify(value.core), digest: value.digest,
+        eventId: value.event.id, requestEventId: value.requestEventId });
+}

package/dist/persistent-invitation-evidence.d.ts

@@ -0,0 +1,83 @@
+import { type RoomInvitation } from './invitation.js';
+import { type PersistentRoomAdmission } from './persistent-invitation.js';
+import type { RelayTransport } from './transport.js';
+export declare const MAX_PERSISTENT_INVITATION_EVIDENCE_EVENTS = 64;
+export declare const MAX_PERSISTENT_INVITATION_EVENT_BYTES = 16384;
+export declare const MAX_PERSISTENT_INVITATION_EVIDENCE_BYTES = 262144;
+/** Protected, local observation metadata. EOSE is NOT evidence of relay
+ * completeness, current membership or global absence of retirement.
+ * `events` are canonical allowlisted Event carriers, not original wire JSON. */
+export interface PersistentInvitationEvidence {
+    readonly version: 1;
+    readonly invitationId: string;
+    readonly inviter: string;
+    readonly completion: 'eose';
+    readonly eventIds: readonly string[];
+    readonly events: readonly string[];
+}
+export interface PersistentInvitationContributors {
+    readonly room: readonly string[];
+    readonly ends: readonly string[];
+    readonly destruct: readonly string[];
+    readonly relays: readonly string[];
+}
+export type PersistentInvitationEvidenceOutcome = {
+    readonly status: 'admitted';
+    /** A fresh owned secret buffer; caller must erase it when finished. */
+    readonly admission: PersistentRoomAdmission;
+    readonly contributors: PersistentInvitationContributors;
+} | {
+    readonly status: 'held';
+    readonly reason: 'unavailable' | 'retired' | 'conflicting-rooms' | 'conflicting-relays' | 'wrong-room';
+    readonly retirementEventIds: readonly string[];
+};
+export interface PersistentInvitationEvidenceResult {
+    readonly evidence: PersistentInvitationEvidence;
+    readonly outcome: PersistentInvitationEvidenceOutcome;
+}
+/** One authenticated group event, without an observation/completion claim.
+ * This proves its signed fields only, not publication, current membership,
+ * latest selection or absence of retirement. */
+export interface PersistentInvitationSource {
+    readonly version: 1;
+    readonly invitationId: string;
+    readonly inviter: string;
+    readonly eventId: string;
+    readonly createdAt: number;
+    /** Exact canonical carrier bytes to retain and reuse for publication. */
+    readonly event: string;
+    /** Fresh owned decoded fields; caller must erase the secret after use. */
+    readonly admission: PersistentRoomAdmission;
+}
+/** Incomplete observations are bounded diagnostic custody only. They are
+ * never accepted by revalidatePersistentInvitationEvidence. */
+export declare class PersistentInvitationEvidenceQueryError extends Error {
+    readonly observation: Omit<PersistentInvitationEvidence, 'completion'> & {
+        readonly completion: 'incomplete';
+    };
+    constructor(message: string, observation: PersistentInvitationEvidenceQueryError['observation']);
+}
+/** Validate an actual encoder Event or its exact retained canonical carrier.
+ * A room-root pin is mandatory. No signing, query, storage or publication is
+ * performed. In particular, this cannot manufacture one-event EOSE evidence. */
+export declare function revalidatePersistentInvitationSource(opts: {
+    event: unknown;
+    invitation: RoomInvitation;
+    expectedRoomSecret: Uint8Array;
+}): PersistentInvitationSource;
+/** Reverify all carriers and reproduce selection from protected evidence.
+ * Optional expectedRoomSecret binds an existing physical room to its exact
+ * root, not merely the invitation's current or historical room label. */
+export declare function revalidatePersistentInvitationEvidence(opts: {
+    evidence: unknown;
+    invitation: RoomInvitation;
+    expectedRoomSecret?: Uint8Array;
+}): PersistentInvitationEvidenceResult;
+/** Additive evidence query. No publication, storage, relay defaults or
+ * membership authority. Only a complete bounded query can yield a result. */
+export declare function requestPersistentRoomAdmissionEvidence(opts: {
+    transport: RelayTransport;
+    invitation: RoomInvitation;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<PersistentInvitationEvidenceResult>;