@real-life/trust-protocol 0.3.2 → 0.4.0

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

@@ -0,0 +1,801 @@
+import type { Json } from './core.js';
+/** NON-NORMATIVE. The stored state of an @real-life/trust-protocol holder at codec 1 (lib/src/codec.ts): the library's storage format, not a protocol artifact. lib/src/holder-state-v1.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), and an envelope's rkid equals its recipient's keyAgreement. */
+export type HolderStateV1 = {
+    codec: 1;
+    commitSeq: DecV1;
+    lastWhen: MillisV1;
+    register: {
+        labels: string[];
+        pairNonces: Record<string, string>;
+        carriers: Record<string, {
+            nonce: string;
+            generation: DecV1;
+        }[]>;
+        devices: {
+            names: string[];
+            revoked: string[];
+        };
+        community: ({
+            genesis: string;
+            head: DecV1;
+        }) | (null);
+        lineage: {
+            [k: string]: Json;
+        }[];
+    };
+    addresses: {
+        keys: Record<string, {
+            label: string;
+            lastShown: MillisV1;
+            retiredAt?: MillisV1;
+        }>;
+        tombstones: string[];
+    };
+    contacts: Record<string, ContactV1>;
+    relationships: Record<string, RelationshipV1>;
+    entryOrder: {
+        nextPos: DecV1;
+        heads: string[];
+    };
+    groups: Record<string, GroupV1>;
+    profile: {
+        body: Json;
+        revision: DecV1;
+    };
+    effects: Record<string, {
+        ack: (StoredAckV1) | (null);
+        expiresAt: MillisV1;
+    }>;
+    outbox: Record<string, OutboxItemV1>;
+    duties: Record<string, DutyV1>;
+    rotations: Record<string, RotationV1>;
+    prompts: Record<string, PromptV1>;
+    acts: Record<string, ActRecordV1>;
+    encounter: {
+        challenges: Record<string, {
+            value: string;
+            tCh: MillisV1;
+            label: string;
+            card: {
+                [k: string]: Json;
+            };
+        }>;
+        records: Record<string, EnactmentRecordV1>;
+        introductions: Record<string, IntroActV1>;
+        offers: Record<string, {
+            id: string;
+            mediatorContactId: string;
+            pin: string;
+            target: string;
+            at: MillisV1;
+            label?: string;
+        }>;
+        designators: Record<string, string>;
+        declarations: Record<string, {
+            issuer: string;
+            role: string;
+            revision: DecV1;
+            constants: Record<string, string>;
+            at: MillisV1;
+        }>;
+    };
+    joining: {
+        preludes: Record<string, {
+            group: string;
+            inviter: string;
+            contactId: string;
+            rkid: string;
+            memberLabel: string;
+            at: MillisV1;
+        }>;
+        invites: Record<string, {
+            credDigest: string;
+            group: string;
+            name: string;
+            contactId: string;
+            rkid: string;
+            memberLabel: string;
+            invite: {
+                [k: string]: Json;
+            };
+            promptId: string;
+            validUntil: MillisV1;
+            status: "open" | "accepted" | "declined" | "joined";
+            at: MillisV1;
+            acceptDigest?: string;
+        }>;
+    };
+};
+/** a counter as a canonical decimal string */
+export type DecV1 = string;
+/** milliseconds since the epoch, a safe non-negative integer */
+export type MillisV1 = number;
+export type SettingV1 = "default" | "on" | "off";
+export type TrustClassV1 = "star" | "groupStar" | "anchorMapping" | "sealedGroupStar" | "profile";
+export type RecipientV1 = {
+    contactId: string;
+    rkid: string;
+    keyAgreement: string;
+    anchor?: string;
+    via?: string;
+};
+export type EnvelopeV1 = {
+    rkid: string;
+    epk: string;
+    nonce: string;
+    ciphertext: string;
+};
+export type AssemblyV1 = {
+    salt: DecV1;
+    chunks: {
+        [k: string]: Json;
+    };
+};
+export type StarPairV1 = {
+    member: string;
+    head: string;
+};
+export type GroupStarItemV1 = ({
+    group: string;
+    mode: "digest";
+}) | ({
+    group: string;
+    mode: "sealed";
+    member: string;
+    memberOp: string;
+});
+export type StarOutInflightV1 = {
+    view: StarPairV1[];
+    viewDigest: string;
+    digests: string[];
+    acked: string[];
+};
+/** the sender side of one reconciled sequence (5.4); snapshot and snapshotDigest are null together */
+export type StarOutV1 = {
+    lastSalt: DecV1;
+    exhausted: boolean;
+    hwm: DecV1;
+    snapshot: (StarPairV1[]) | (null);
+    snapshotDigest: (string) | (null);
+    inflight: Record<string, StarOutInflightV1>;
+};
+export type StarInV1 = {
+    hwm: DecV1;
+    lowerBound: DecV1;
+    assembly: (AssemblyV1) | (null);
+    accepted: ({
+        salt: DecV1;
+        blinded: string[];
+        matches: string[];
+    }) | (null);
+};
+export type GroupStarOutInflightV1 = {
+    view: GroupStarItemV1[];
+    viewDigest: string;
+    digests: string[];
+    acked: string[];
+};
+/** the sender side of one reconciled sequence (5.4); snapshot and snapshotDigest are null together */
+export type GroupStarOutV1 = {
+    lastSalt: DecV1;
+    exhausted: boolean;
+    hwm: DecV1;
+    snapshot: (GroupStarItemV1[]) | (null);
+    snapshotDigest: (string) | (null);
+    inflight: Record<string, GroupStarOutInflightV1>;
+};
+export type GroupStarInV1 = {
+    hwm: DecV1;
+    lowerBound: DecV1;
+    assembly: (AssemblyV1) | (null);
+    accepted: ({
+        salt: DecV1;
+        entries: {
+            d: string;
+            c: string;
+        }[];
+        groups: string[];
+    }) | (null);
+};
+export type ContinuityDueV1 = ({
+    kind: "choice";
+    prior: string;
+    alts: string[];
+}) | ({
+    kind: "report" | "align";
+    prior: string;
+});
+export type LogHeadV1 = ({
+    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 TupleV1 = {
+    ownPairLabel: string;
+    counterpartAnchor: string;
+    counterpartKeyAgreement: string;
+    rkid: string;
+    entryId: string;
+    priorCandidates: {
+        ownPairLabel: string;
+        counterpartAnchor: string;
+        replaces?: string[];
+    }[];
+    starOut: StarOutV1;
+    starIn: StarInV1;
+    groupStarOut: GroupStarOutV1;
+    groupStarIn: GroupStarInV1;
+    probeOut: {
+        seq: DecV1;
+        inflight: Record<string, {
+            digests: string[];
+            acked: string[];
+        }>;
+        done: boolean;
+    };
+    probeIn: {
+        hwm: DecV1;
+        lowerBound: DecV1;
+        assembly: (AssemblyV1) | (null);
+    };
+    continuityOut: {
+        rev: DecV1;
+        body: Json;
+        proof: Json;
+        sent: string[];
+        align: boolean;
+        chosen: (string) | (null);
+        reported: (string) | (null);
+        aligned: boolean;
+        due: (ContinuityDueV1) | (null);
+    };
+    continuityIn: {
+        rev: DecV1;
+        body: Json;
+        recordPrior: (string) | (null);
+    };
+    mappingOut: {
+        rev: DecV1;
+        body: Json;
+        underAnchor: (string) | (null);
+    };
+    mappingIn: {
+        rev: DecV1;
+        body: Json;
+        self: (string) | (null);
+        card: Json;
+    };
+    profileOut: {
+        rev: DecV1;
+    };
+    profileIn: {
+        rev: DecV1;
+        body: Json;
+        verifiedSeq: DecV1;
+    };
+    deactivated: boolean;
+};
+export type RelationshipV1 = {
+    id: string;
+    contactId: string;
+    tuples: TupleV1[];
+    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: MillisV1;
+        via?: string;
+        viaPin?: string;
+    };
+    chainedInto: (string) | (null);
+    firstVerified: (DecV1) | (null);
+};
+/** one entry of the deliverable set (Trust 2120, 2140); its id equals its key */
+export type ContactV1 = {
+    id: string;
+    pos: (DecV1) | (null);
+    status: "none" | "admitted" | "pending";
+    aliases: string[];
+    relIds: string[];
+    anchorHead: (string) | (null);
+    settings: {
+        star: SettingV1;
+        groupStar: SettingV1;
+        anchorMapping: SettingV1;
+        sealedGroupStar: SettingV1;
+        profile: SettingV1;
+    };
+    groupSettings: Record<string, SettingV1>;
+};
+export type OutboxStepV1 = ({
+    status: "submitted";
+    at: MillisV1;
+    attempt: number;
+}) | ({
+    status: "awaiting-transport";
+    at: MillisV1;
+    reason: "offline" | "transport-unreachable" | "carrier-refused-retriable";
+}) | ({
+    status: "accepted";
+    at: MillisV1;
+}) | ({
+    status: "delivered";
+    at: MillisV1;
+    late: boolean;
+}) | ({
+    status: "failed";
+    at: MillisV1;
+    reason: "unroutable" | "oversize" | "expired-by-adapter-policy";
+}) | ({
+    status: "failed";
+    at: MillisV1;
+    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 OutboxItemV1 = {
+    type: string;
+    threadId: string;
+    recipient: RecipientV1;
+    envelope: EnvelopeV1;
+    attempt: number;
+    history: OutboxStepV1[];
+    nextAttemptAt?: MillisV1;
+};
+export type StoredAckV1 = {
+    digest: string;
+    envelope: EnvelopeV1;
+    threadId: string;
+    recipient: RecipientV1;
+    at: MillisV1;
+    attempt: number;
+    sent: boolean;
+    nextAttemptAt?: MillisV1;
+    sentBy?: "report" | "horizon";
+};
+export type ReissueMappingDutyV1 = {
+    kind: "reissue-mapping";
+    v: 1;
+    id: string;
+    contactId: string;
+    relId: string;
+    awaitHead: (string) | (null);
+    dueAt?: MillisV1;
+};
+export type ClassOnDutyV1 = {
+    kind: "class-on";
+    v: 1;
+    id: string;
+    contactId: string;
+    relId: string;
+    cls: TrustClassV1;
+    dueAt?: MillisV1;
+};
+export type ProfileDutyV1 = {
+    kind: "profile";
+    v: 1;
+    id: string;
+    contactId: string;
+    relId: string;
+    rev: DecV1;
+    dueAt?: MillisV1;
+};
+export type ContinuityDutyV1 = {
+    kind: "continuity";
+    v: 1;
+    id: string;
+    relId: string;
+    tuple: string;
+    step: "probe" | "mapping";
+    dueAt?: MillisV1;
+    attempt?: number;
+    lastAt?: MillisV1;
+};
+export type MergeDutyV1 = {
+    kind: "merge";
+    v: 1;
+    id: string;
+    entryIds: string[];
+    relId: string;
+    witness: {
+        heads: Record<string, string>;
+        superseded: Record<string, string[]>;
+    };
+    dueAt?: MillisV1;
+};
+export type RotationDutyV1 = {
+    kind: "rotation";
+    v: 1;
+    id: string;
+    rotationId: string;
+    dueAt?: MillisV1;
+    attempt?: number;
+    lastAt?: MillisV1;
+};
+export type IntroAckDutyV1 = {
+    kind: "intro-ack";
+    v: 1;
+    id: string;
+    act: string;
+    dueAt?: MillisV1;
+};
+/** a duty of a kind or version this library does not handle: kept as it is */
+export type UnknownDutyV1 = {
+    kind: string;
+    v: number;
+    id: string;
+    [k: string]: Json;
+};
+export type DutyV1 = (ReissueMappingDutyV1) | (ClassOnDutyV1) | (ProfileDutyV1) | (ContinuityDutyV1) | (MergeDutyV1) | (RotationDutyV1) | (IntroAckDutyV1) | (UnknownDutyV1);
+/** a journaled event (events.ts) */
+export type EventV1 = ({
+    type: "contact.added";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    actId?: string;
+}) | ({
+    type: "contact.verified";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    relationshipId: string;
+    actId?: string;
+}) | ({
+    type: "contact.chained";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    from: string;
+    into: string;
+    actId?: string;
+}) | ({
+    type: "contact.merged";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    merged: string[];
+    actId?: string;
+}) | ({
+    type: "contact.split";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    leaver: string;
+    relationshipId: string;
+    actId?: string;
+}) | ({
+    type: "contact.departed";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    relationshipIds: string[];
+    removed: boolean;
+    actId?: string;
+}) | ({
+    type: "trust.given";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    actId?: string;
+}) | ({
+    type: "trust.received";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    actId?: string;
+}) | ({
+    type: "trust.paused";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    paused: boolean;
+    actId?: string;
+}) | ({
+    type: "group.joined";
+    eventId: string;
+    commitSeq: DecV1;
+    groupId: string;
+    actId?: string;
+}) | ({
+    type: "prompt.opened";
+    eventId: string;
+    commitSeq: DecV1;
+    promptId: string;
+    kind: "encounter-confirm" | "group-invite" | "introduction";
+    actId?: string;
+}) | ({
+    type: "prompt.decided";
+    eventId: string;
+    commitSeq: DecV1;
+    promptId: string;
+    kind: "encounter-confirm" | "group-invite" | "introduction";
+    choice: "accept" | "decline";
+    actId?: string;
+}) | ({
+    type: "delivery.status";
+    eventId: string;
+    commitSeq: DecV1;
+    digest: string;
+    threadId: string;
+    status: "submitted" | "accepted" | "delivered" | "failed";
+    actId?: string;
+    late?: boolean;
+}) | ({
+    type: "profile.updated";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: (string) | (null);
+    actId?: string;
+}) | ({
+    type: "anchor.rotated";
+    eventId: string;
+    commitSeq: DecV1;
+    generation: DecV1;
+    actId?: string;
+}) | ({
+    type: "device.added";
+    eventId: string;
+    commitSeq: DecV1;
+    name: string;
+    actId?: string;
+}) | ({
+    type: "device.revoked";
+    eventId: string;
+    commitSeq: DecV1;
+    name: string;
+    actId?: string;
+}) | ({
+    type: "duty.unsupported";
+    eventId: string;
+    commitSeq: DecV1;
+    dutyId: string;
+    kind: string;
+    v: number;
+    actId?: string;
+}) | ({
+    type: "star.accepted";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    relationshipId: string;
+    salt: DecV1;
+    actId?: string;
+}) | ({
+    type: "groupStar.accepted";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    relationshipId: string;
+    salt: DecV1;
+    actId?: string;
+}) | ({
+    type: "encounter.shown";
+    eventId: string;
+    commitSeq: DecV1;
+    challenge: string;
+    card: {
+        [k: string]: Json;
+    };
+    actId?: string;
+}) | ({
+    type: "encounter.scanned";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    card: {
+        [k: string]: Json;
+    };
+    actId?: string;
+}) | ({
+    type: "encounter.recorded";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    relationshipId: string;
+    role: "scanner" | "displayer";
+    actId?: string;
+}) | ({
+    type: "encounter.accepted";
+    eventId: string;
+    commitSeq: DecV1;
+    contactId: string;
+    relationshipId: string;
+    mutual: boolean;
+    actId?: string;
+}) | ({
+    type: "group.founded";
+    eventId: string;
+    commitSeq: DecV1;
+    groupId: string;
+    actId?: string;
+}) | ({
+    type: "group.admitted";
+    eventId: string;
+    commitSeq: DecV1;
+    groupId: string;
+    member: string;
+    actId?: string;
+}) | ({
+    type: "group.vouched";
+    eventId: string;
+    commitSeq: DecV1;
+    groupId: string;
+    member: string;
+    actId?: string;
+});
+export type RosterEntryV1 = {
+    anchor: string;
+    op: string;
+    keyAgreement: string;
+    addedAt: MillisV1;
+    name?: string;
+    contactId?: string;
+    rkid?: string;
+};
+export type OpenInvitationV1 = {
+    invitee: string;
+    keyAgreement: string;
+    contactId: string;
+    rkid: string;
+    threadId: string;
+    credDigest: string;
+    invite: {
+        [k: string]: Json;
+    };
+    validUntil: MillisV1;
+};
+export type EvidenceV1 = {
+    invite: {
+        [k: string]: Json;
+    };
+    accept: {
+        [k: string]: Json;
+    };
+    vouches: {
+        [k: string]: Json;
+    }[];
+    at: MillisV1;
+};
+/** a group the holder is in; a listed group carries memberAnchor and memberOp (Trust 5400) */
+export type GroupV1 = {
+    id: string;
+    name: string;
+    memberLabel: string;
+    rules: {
+        vouchThreshold: DecV1;
+    };
+    listed: boolean;
+    roster: Record<string, RosterEntryV1>;
+    invitations: Record<string, OpenInvitationV1>;
+    evidence: Record<string, EvidenceV1>;
+    preludes: Record<string, {
+        contactId: string;
+        rkid: string;
+        at: MillisV1;
+    }>;
+    did?: string;
+    genesis?: {
+        [k: string]: Json;
+    };
+    memberAnchor?: string;
+    memberOp?: string;
+    acceptDigest?: string;
+};
+export type HeldCredentialV1 = {
+    digest: string;
+    credential: {
+        [k: string]: Json;
+    };
+};
+export type EnactmentRecordV1 = {
+    ceremony: string;
+    own: string;
+    tCh: MillisV1;
+    peer: string;
+    counterpart: string;
+    card: {
+        [k: string]: Json;
+    };
+    bind: string;
+    at: MillisV1;
+    label: string;
+    relId: string;
+    role: "scanner" | "displayer";
+    out: (HeldCredentialV1) | (null);
+    in: (HeldCredentialV1) | (null);
+    thread: (string) | (null);
+    bundleDigest: (string) | (null);
+    threads: Record<string, string>;
+    sentCard: ({
+        [k: string]: Json;
+    }) | (null);
+    counterPending: boolean;
+};
+export type IntroActV1 = {
+    key: string;
+    act: string;
+    role: "requester" | "mediator" | "target";
+    status: "sent" | "acked" | "completed" | "failed" | "received" | "forwarded" | "consented" | "refused";
+    issuedAt: MillisV1;
+    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: MillisV1;
+    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 RotationV1 = {
+    id: string;
+    from: DecV1;
+    to: DecV1;
+    step: "register" | "log" | "duties";
+    startedAt: MillisV1;
+    entry: Json;
+    overHead: LogHeadV1;
+    awaitHead: Record<string, (string) | (null)>;
+};
+export type PromptV1 = {
+    id: string;
+    kind: "encounter-confirm" | "group-invite" | "introduction";
+    openedAt: MillisV1;
+    contactId?: string;
+    groupId?: string;
+    expiresAt?: MillisV1;
+};
+export type ActRecordV1 = {
+    actId: string;
+    inputHash: string;
+    commitSeq: DecV1;
+    outboundDigests: string[];
+    events: EventV1[];
+    at: MillisV1;
+};
+//# sourceMappingURL=holder-state-v1.d.ts.map