@real-life/trust-protocol 0.4.0 → 0.5.0

package/dist/holder-state-v2.d.ts

@@ -0,0 +1,858 @@
+import type { Json } from './core.js';
+/** NON-NORMATIVE. The stored state of an @real-life/trust-protocol holder at codec 2 (lib/src/codec.ts): the library's storage format, not a protocol artifact. lib/src/holder-state-v2.ts is generated from it (scripts/build-holder-state-types.mjs). Not expressible here and checked by the codec alone: a record's id equals its key (contacts, relationships, groups, duties, rotations, prompts, acts, roster, invitations, records, introductions, offers, challenges, the inbox), an envelope's rkid equals its recipient's keyAgreement, and a set of strings (joining.surfaced, joining.declined, messages.blocked, messages.ready) is sorted. */
+export type HolderStateV2 = {
+    codec: 2;
+    commitSeq: DecV2;
+    lastWhen: MillisV2;
+    register: {
+        labels: string[];
+        pairNonces: Record<string, string>;
+        carriers: Record<string, {
+            nonce: string;
+            generation: DecV2;
+        }[]>;
+        devices: {
+            names: string[];
+            revoked: string[];
+        };
+        community: ({
+            genesis: string;
+            head: DecV2;
+        }) | (null);
+        lineage: {
+            [k: string]: Json;
+        }[];
+    };
+    addresses: {
+        keys: Record<string, {
+            label: string;
+            lastShown: MillisV2;
+            retiredAt?: MillisV2;
+        }>;
+        tombstones: string[];
+    };
+    contacts: Record<string, ContactV2>;
+    relationships: Record<string, RelationshipV2>;
+    entryOrder: {
+        nextPos: DecV2;
+        heads: string[];
+    };
+    groups: Record<string, GroupV2>;
+    profile: {
+        body: Json;
+        revision: DecV2;
+    };
+    effects: Record<string, {
+        ack: (StoredAckV2) | (null);
+        expiresAt: MillisV2;
+    }>;
+    outbox: Record<string, OutboxItemV2>;
+    duties: Record<string, DutyV2>;
+    rotations: Record<string, RotationV2>;
+    prompts: Record<string, PromptV2>;
+    acts: Record<string, ActRecordV2>;
+    encounter: {
+        challenges: Record<string, {
+            value: string;
+            tCh: MillisV2;
+            label: string;
+            card: {
+                [k: string]: Json;
+            };
+        }>;
+        records: Record<string, EnactmentRecordV2>;
+        introductions: Record<string, IntroActV2>;
+        offers: Record<string, {
+            id: string;
+            mediatorContactId: string;
+            pin: string;
+            target: string;
+            at: MillisV2;
+            label?: string;
+        }>;
+        designators: Record<string, string>;
+        declarations: Record<string, {
+            issuer: string;
+            role: string;
+            revision: DecV2;
+            constants: Record<string, string>;
+            at: MillisV2;
+        }>;
+    };
+    joining: {
+        preludes: Record<string, {
+            group: string;
+            inviter: string;
+            contactId: string;
+            rkid: string;
+            memberLabel: string;
+            at: MillisV2;
+        }>;
+        invites: Record<string, {
+            credDigest: string;
+            group: string;
+            name: string;
+            /** the contact of the relationship its prelude binding attributed it to (RLTP-MT-3100); absent for an invitation attributed to none */
+            contactId?: string;
+            rkid?: string;
+            memberLabel: string;
+            invite: {
+                [k: string]: Json;
+            };
+            promptId: string;
+            validUntil: MillisV2;
+            status: "open" | "accepted" | "declined" | "joined";
+            at: MillisV2;
+            acceptDigest?: string;
+        }>;
+        /** the credential digest of every invitation surfaced, for the life of the holder (RLTP-MT-3130); sorted */
+        surfaced: string[];
+        /** the register of declined invitations (Message Tasks 6.4): credential digests, holder-wide, for the life of the holder; sorted */
+        declined: string[];
+    };
+    /** Message Tasks 0.1 on the holder (message/holder.ts); the time mark of RLTP-MSG-4060 is lastWhen */
+    messages: {
+        /** the relationships under a block (Message Tasks 6.1), by relationship id; sorted */
+        blocked: string[];
+        /** per relationship id: acceptance times inside the last 24 hours (Message Tasks 4.2) */
+        rates: Record<string, {
+            invites: MillisV2[];
+            messages: MillisV2[];
+        }>;
+        /** the own pair labels of the ready tuples (Message Tasks 5.1); sorted */
+        ready: string[];
+        /** the completion record (Message Tasks 4.4), per own pair label: mid → bodyDigest and sentAt */
+        records: Record<string, Record<string, {
+            bodyDigest: string;
+            sentAt: MillisV2;
+        }>>;
+        /** the inbox (Message Tasks 4.5), by the accepted document digest */
+        inbox: Record<string, {
+            id: string;
+            tuple: string;
+            mid: string;
+            body: {
+                [k: string]: Json;
+            };
+            receivedAt: MillisV2;
+            displayAt: MillisV2;
+        }>;
+    };
+};
+/** a counter as a canonical decimal string */
+export type DecV2 = string;
+/** milliseconds since the epoch, a safe non-negative integer */
+export type MillisV2 = number;
+export type SettingV2 = "default" | "on" | "off";
+export type TrustClassV2 = "star" | "groupStar" | "anchorMapping" | "sealedGroupStar" | "profile";
+export type RecipientV2 = {
+    contactId: string;
+    rkid: string;
+    keyAgreement: string;
+    anchor?: string;
+    via?: string;
+};
+export type EnvelopeV2 = {
+    rkid: string;
+    epk: string;
+    nonce: string;
+    ciphertext: string;
+};
+export type AssemblyV2 = {
+    salt: DecV2;
+    chunks: {
+        [k: string]: Json;
+    };
+};
+export type StarPairV2 = {
+    member: string;
+    head: string;
+};
+export type GroupStarItemV2 = ({
+    group: string;
+    mode: "digest";
+}) | ({
+    group: string;
+    mode: "sealed";
+    member: string;
+    memberOp: string;
+});
+export type StarOutInflightV2 = {
+    view: StarPairV2[];
+    viewDigest: string;
+    digests: string[];
+    acked: string[];
+};
+/** the sender side of one reconciled sequence (5.4); snapshot and snapshotDigest are null together */
+export type StarOutV2 = {
+    lastSalt: DecV2;
+    exhausted: boolean;
+    hwm: DecV2;
+    snapshot: (StarPairV2[]) | (null);
+    snapshotDigest: (string) | (null);
+    inflight: Record<string, StarOutInflightV2>;
+};
+export type StarInV2 = {
+    hwm: DecV2;
+    lowerBound: DecV2;
+    assembly: (AssemblyV2) | (null);
+    accepted: ({
+        salt: DecV2;
+        blinded: string[];
+        matches: string[];
+    }) | (null);
+};
+export type GroupStarOutInflightV2 = {
+    view: GroupStarItemV2[];
+    viewDigest: string;
+    digests: string[];
+    acked: string[];
+};
+/** the sender side of one reconciled sequence (5.4); snapshot and snapshotDigest are null together */
+export type GroupStarOutV2 = {
+    lastSalt: DecV2;
+    exhausted: boolean;
+    hwm: DecV2;
+    snapshot: (GroupStarItemV2[]) | (null);
+    snapshotDigest: (string) | (null);
+    inflight: Record<string, GroupStarOutInflightV2>;
+};
+export type GroupStarInV2 = {
+    hwm: DecV2;
+    lowerBound: DecV2;
+    assembly: (AssemblyV2) | (null);
+    accepted: ({
+        salt: DecV2;
+        entries: {
+            d: string;
+            c: string;
+        }[];
+        groups: string[];
+    }) | (null);
+};
+export type ContinuityDueV2 = ({
+    kind: "choice";
+    prior: string;
+    alts: string[];
+}) | ({
+    kind: "report" | "align";
+    prior: string;
+});
+export type LogHeadV2 = ({
+    genesis: string;
+    empty: true;
+}) | ({
+    genesis: string;
+    entryId: string;
+    gen: number;
+    next: string;
+    commit: string;
+});
+/** one enactment's tuple of a relationship (Trust 6.4) */
+export type TupleV2 = {
+    ownPairLabel: string;
+    counterpartAnchor: string;
+    counterpartKeyAgreement: string;
+    rkid: string;
+    entryId: string;
+    priorCandidates: {
+        ownPairLabel: string;
+        counterpartAnchor: string;
+        replaces?: string[];
+    }[];
+    starOut: StarOutV2;
+    starIn: StarInV2;
+    groupStarOut: GroupStarOutV2;
+    groupStarIn: GroupStarInV2;
+    probeOut: {
+        seq: DecV2;
+        inflight: Record<string, {
+            digests: string[];
+            acked: string[];
+        }>;
+        done: boolean;
+    };
+    probeIn: {
+        hwm: DecV2;
+        lowerBound: DecV2;
+        assembly: (AssemblyV2) | (null);
+    };
+    continuityOut: {
+        rev: DecV2;
+        body: Json;
+        proof: Json;
+        sent: string[];
+        align: boolean;
+        chosen: (string) | (null);
+        reported: (string) | (null);
+        aligned: boolean;
+        due: (ContinuityDueV2) | (null);
+    };
+    continuityIn: {
+        rev: DecV2;
+        body: Json;
+        recordPrior: (string) | (null);
+    };
+    mappingOut: {
+        rev: DecV2;
+        body: Json;
+        underAnchor: (string) | (null);
+    };
+    mappingIn: {
+        rev: DecV2;
+        body: Json;
+        self: (string) | (null);
+        card: Json;
+    };
+    profileOut: {
+        rev: DecV2;
+    };
+    profileIn: {
+        rev: DecV2;
+        body: Json;
+        verifiedSeq: DecV2;
+    };
+    deactivated: boolean;
+};
+export type RelationshipV2 = {
+    id: string;
+    contactId: string;
+    tuples: TupleV2[];
+    activeHead: string;
+    earliestAnchor: (string) | (null);
+    links: {
+        prev: string;
+        next: string;
+    }[];
+    bindings: Record<string, string[]>;
+    heldCounterpartHead: (string) | (null);
+    memory: {
+        [k: string]: Json;
+    };
+    provenance: {
+        kind: "ceremony" | "introduced";
+        at: MillisV2;
+        via?: string;
+        viaPin?: string;
+    };
+    chainedInto: (string) | (null);
+    firstVerified: (DecV2) | (null);
+};
+/** one entry of the deliverable set (Trust 2120, 2140); its id equals its key */
+export type ContactV2 = {
+    id: string;
+    pos: (DecV2) | (null);
+    status: "none" | "admitted" | "pending";
+    aliases: string[];
+    relIds: string[];
+    anchorHead: (string) | (null);
+    settings: {
+        star: SettingV2;
+        groupStar: SettingV2;
+        anchorMapping: SettingV2;
+        sealedGroupStar: SettingV2;
+        profile: SettingV2;
+    };
+    groupSettings: Record<string, SettingV2>;
+};
+export type OutboxStepV2 = ({
+    status: "submitted";
+    at: MillisV2;
+    attempt: number;
+}) | ({
+    status: "awaiting-transport";
+    at: MillisV2;
+    reason: "offline" | "transport-unreachable" | "carrier-refused-retriable";
+}) | ({
+    status: "accepted";
+    at: MillisV2;
+}) | ({
+    status: "delivered";
+    at: MillisV2;
+    late: boolean;
+}) | ({
+    status: "failed";
+    at: MillisV2;
+    reason: "unroutable" | "oversize" | "expired-by-adapter-policy" | "task-expired";
+}) | ({
+    status: "failed";
+    at: MillisV2;
+    reason: "rejected-by-receiver";
+    code: "malformedRequest" | "unsupportedType" | "proofRequired" | "proofInvalid" | "wrongRecipient" | "identityMismatch";
+});
+/** an issued document; its envelope's rkid equals recipient.keyAgreement (not expressible here, checked by the codec) */
+export type OutboxItemV2 = {
+    type: string;
+    threadId: string;
+    recipient: RecipientV2;
+    envelope: EnvelopeV2;
+    attempt: number;
+    history: OutboxStepV2[];
+    nextAttemptAt?: MillisV2;
+    /** the sender lifetime its type declares (Delivery RLTP-DEL-7020) */
+    expiresAt?: MillisV2;
+};
+export type StoredAckV2 = {
+    digest: string;
+    envelope: EnvelopeV2;
+    threadId: string;
+    recipient: RecipientV2;
+    at: MillisV2;
+    attempt: number;
+    sent: boolean;
+    nextAttemptAt?: MillisV2;
+    sentBy?: "report" | "horizon";
+};
+export type ReissueMappingDutyV2 = {
+    kind: "reissue-mapping";
+    v: 1;
+    id: string;
+    contactId: string;
+    relId: string;
+    awaitHead: (string) | (null);
+    dueAt?: MillisV2;
+};
+export type ClassOnDutyV2 = {
+    kind: "class-on";
+    v: 1;
+    id: string;
+    contactId: string;
+    relId: string;
+    cls: TrustClassV2;
+    dueAt?: MillisV2;
+};
+export type ProfileDutyV2 = {
+    kind: "profile";
+    v: 1;
+    id: string;
+    contactId: string;
+    relId: string;
+    rev: DecV2;
+    dueAt?: MillisV2;
+};
+export type ContinuityDutyV2 = {
+    kind: "continuity";
+    v: 1;
+    id: string;
+    relId: string;
+    tuple: string;
+    step: "probe" | "mapping";
+    dueAt?: MillisV2;
+    attempt?: number;
+    lastAt?: MillisV2;
+};
+export type MergeDutyV2 = {
+    kind: "merge";
+    v: 1;
+    id: string;
+    entryIds: string[];
+    relId: string;
+    witness: {
+        heads: Record<string, string>;
+        superseded: Record<string, string[]>;
+    };
+    dueAt?: MillisV2;
+};
+export type RotationDutyV2 = {
+    kind: "rotation";
+    v: 1;
+    id: string;
+    rotationId: string;
+    dueAt?: MillisV2;
+    attempt?: number;
+    lastAt?: MillisV2;
+};
+export type IntroAckDutyV2 = {
+    kind: "intro-ack";
+    v: 1;
+    id: string;
+    act: string;
+    dueAt?: MillisV2;
+};
+/** a duty of a kind or version this library does not handle: kept as it is */
+export type UnknownDutyV2 = {
+    kind: string;
+    v: number;
+    id: string;
+    [k: string]: Json;
+};
+export type DutyV2 = (ReissueMappingDutyV2) | (ClassOnDutyV2) | (ProfileDutyV2) | (ContinuityDutyV2) | (MergeDutyV2) | (RotationDutyV2) | (IntroAckDutyV2) | (UnknownDutyV2);
+/** a journaled event (events.ts) */
+export type EventV2 = ({
+    type: "contact.added";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    actId?: string;
+}) | ({
+    type: "contact.verified";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    relationshipId: string;
+    actId?: string;
+}) | ({
+    type: "contact.chained";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    from: string;
+    into: string;
+    actId?: string;
+}) | ({
+    type: "contact.merged";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    merged: string[];
+    actId?: string;
+}) | ({
+    type: "contact.split";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    leaver: string;
+    relationshipId: string;
+    actId?: string;
+}) | ({
+    type: "contact.departed";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    relationshipIds: string[];
+    removed: boolean;
+    actId?: string;
+}) | ({
+    type: "trust.given";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    actId?: string;
+}) | ({
+    type: "trust.received";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    actId?: string;
+}) | ({
+    type: "trust.paused";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    paused: boolean;
+    actId?: string;
+}) | ({
+    type: "group.joined";
+    eventId: string;
+    commitSeq: DecV2;
+    groupId: string;
+    actId?: string;
+}) | ({
+    type: "prompt.opened";
+    eventId: string;
+    commitSeq: DecV2;
+    promptId: string;
+    kind: "encounter-confirm" | "group-invite" | "introduction";
+    actId?: string;
+}) | ({
+    type: "prompt.decided";
+    eventId: string;
+    commitSeq: DecV2;
+    promptId: string;
+    kind: "encounter-confirm" | "group-invite" | "introduction";
+    choice: "accept" | "decline";
+    actId?: string;
+}) | ({
+    type: "delivery.status";
+    eventId: string;
+    commitSeq: DecV2;
+    digest: string;
+    threadId: string;
+    status: "submitted" | "accepted" | "delivered" | "failed";
+    actId?: string;
+    late?: boolean;
+}) | ({
+    type: "profile.updated";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: (string) | (null);
+    actId?: string;
+}) | ({
+    type: "anchor.rotated";
+    eventId: string;
+    commitSeq: DecV2;
+    generation: DecV2;
+    actId?: string;
+}) | ({
+    type: "device.added";
+    eventId: string;
+    commitSeq: DecV2;
+    name: string;
+    actId?: string;
+}) | ({
+    type: "device.revoked";
+    eventId: string;
+    commitSeq: DecV2;
+    name: string;
+    actId?: string;
+}) | ({
+    type: "duty.unsupported";
+    eventId: string;
+    commitSeq: DecV2;
+    dutyId: string;
+    kind: string;
+    v: number;
+    actId?: string;
+}) | ({
+    type: "star.accepted";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    relationshipId: string;
+    salt: DecV2;
+    actId?: string;
+}) | ({
+    type: "groupStar.accepted";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    relationshipId: string;
+    salt: DecV2;
+    actId?: string;
+}) | ({
+    type: "encounter.shown";
+    eventId: string;
+    commitSeq: DecV2;
+    challenge: string;
+    card: {
+        [k: string]: Json;
+    };
+    actId?: string;
+}) | ({
+    type: "encounter.scanned";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    card: {
+        [k: string]: Json;
+    };
+    actId?: string;
+}) | ({
+    type: "encounter.recorded";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    relationshipId: string;
+    role: "scanner" | "displayer";
+    actId?: string;
+}) | ({
+    type: "encounter.accepted";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    relationshipId: string;
+    mutual: boolean;
+    actId?: string;
+}) | ({
+    type: "group.founded";
+    eventId: string;
+    commitSeq: DecV2;
+    groupId: string;
+    actId?: string;
+}) | ({
+    type: "group.admitted";
+    eventId: string;
+    commitSeq: DecV2;
+    groupId: string;
+    member: string;
+    actId?: string;
+}) | ({
+    type: "group.vouched";
+    eventId: string;
+    commitSeq: DecV2;
+    groupId: string;
+    member: string;
+    actId?: string;
+}) | ({
+    type: "contact.blocked";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    blocked: boolean;
+    actId?: string;
+}) | ({
+    type: "message.sent";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    mid: string;
+    digest: string;
+    actId?: string;
+}) | ({
+    type: "message.received";
+    eventId: string;
+    commitSeq: DecV2;
+    contactId: string;
+    inboxId: string;
+    actId?: string;
+});
+export type RosterEntryV2 = {
+    anchor: string;
+    op: string;
+    keyAgreement: string;
+    addedAt: MillisV2;
+    name?: string;
+    contactId?: string;
+    rkid?: string;
+};
+export type OpenInvitationV2 = {
+    invitee: string;
+    keyAgreement: string;
+    contactId: string;
+    rkid: string;
+    threadId: string;
+    credDigest: string;
+    invite: {
+        [k: string]: Json;
+    };
+    validUntil: MillisV2;
+};
+export type EvidenceV2 = {
+    invite: {
+        [k: string]: Json;
+    };
+    accept: {
+        [k: string]: Json;
+    };
+    vouches: {
+        [k: string]: Json;
+    }[];
+    at: MillisV2;
+};
+/** a group the holder is in; a listed group carries memberAnchor and memberOp (Trust 5400) */
+export type GroupV2 = {
+    id: string;
+    name: string;
+    memberLabel: string;
+    rules: {
+        vouchThreshold: DecV2;
+    };
+    listed: boolean;
+    roster: Record<string, RosterEntryV2>;
+    invitations: Record<string, OpenInvitationV2>;
+    evidence: Record<string, EvidenceV2>;
+    preludes: Record<string, {
+        contactId: string;
+        rkid: string;
+        at: MillisV2;
+    }>;
+    did?: string;
+    genesis?: {
+        [k: string]: Json;
+    };
+    memberAnchor?: string;
+    memberOp?: string;
+    acceptDigest?: string;
+};
+export type HeldCredentialV2 = {
+    digest: string;
+    credential: {
+        [k: string]: Json;
+    };
+};
+export type EnactmentRecordV2 = {
+    ceremony: string;
+    own: string;
+    tCh: MillisV2;
+    peer: string;
+    counterpart: string;
+    card: {
+        [k: string]: Json;
+    };
+    bind: string;
+    at: MillisV2;
+    label: string;
+    relId: string;
+    role: "scanner" | "displayer";
+    out: (HeldCredentialV2) | (null);
+    in: (HeldCredentialV2) | (null);
+    thread: (string) | (null);
+    bundleDigest: (string) | (null);
+    threads: Record<string, string>;
+    sentCard: ({
+        [k: string]: Json;
+    }) | (null);
+    counterPending: boolean;
+};
+export type IntroActV2 = {
+    key: string;
+    act: string;
+    role: "requester" | "mediator" | "target";
+    status: "sent" | "acked" | "completed" | "failed" | "received" | "forwarded" | "consented" | "refused";
+    issuedAt: MillisV2;
+    request: {
+        [k: string]: Json;
+    };
+    requestCard: {
+        [k: string]: Json;
+    };
+    reply: ({
+        [k: string]: Json;
+    }) | (null);
+    replyCard: ({
+        [k: string]: Json;
+    }) | (null);
+    pins: {
+        requester?: string;
+        target?: string;
+        mediator?: string;
+    };
+    threads: {
+        request: string;
+        forward?: string;
+    };
+    at: MillisV2;
+    ackDelayMs: number;
+    ownLabel: (string) | (null);
+    ack: ({
+        [k: string]: Json;
+    }) | (null);
+    replyForwarded: boolean;
+    vouchersSent: boolean;
+    pendingVoucher: ({
+        [k: string]: Json;
+    }) | (null);
+    voucher: ({
+        [k: string]: Json;
+    }) | (null);
+    vouched: boolean;
+    promptId: (string) | (null);
+    peerName?: string;
+};
+export type RotationV2 = {
+    id: string;
+    from: DecV2;
+    to: DecV2;
+    step: "register" | "log" | "duties";
+    startedAt: MillisV2;
+    entry: Json;
+    overHead: LogHeadV2;
+    awaitHead: Record<string, (string) | (null)>;
+};
+export type PromptV2 = {
+    id: string;
+    kind: "encounter-confirm" | "group-invite" | "introduction";
+    openedAt: MillisV2;
+    contactId?: string;
+    groupId?: string;
+    expiresAt?: MillisV2;
+};
+export type ActRecordV2 = {
+    actId: string;
+    inputHash: string;
+    commitSeq: DecV2;
+    outboundDigests: string[];
+    events: EventV2[];
+    at: MillisV2;
+};
+//# sourceMappingURL=holder-state-v2.d.ts.map