keri 0.0.0-dev.0ddd65e

package/dist/cli/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/main.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { parse } from "../parser/parser.js";
+import { FileSystemKeyStore } from "../keystore/keystore-fs.js";
+import { SqliteEventStore } from "../db/sqlite-db.js";
+import { Habitat } from "../keri/habitat.js";
+const db = new SqliteEventStore({ filename: ".keri/db.sqlite" });
+db.init();
+program.command("parse").action(async () => {
+    const stream = process.stdin;
+    for await (const event of parse(ReadableStream.from(stream))) {
+        console.log(event);
+    }
+});
+program
+    .command("keygen")
+    .requiredOption("--passcode <passcode>")
+    .action(async ({ passcode }) => {
+    const keystore = new FileSystemKeyStore({ dir: ".keri/keys", passphrase: passcode });
+    await keystore.incept();
+});
+program.command("resolve <oobi>").action(async (oobi) => {
+    const response = await fetch(oobi);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch oobi: ${response.status} ${response.statusText}`);
+    }
+    if (!response.body) {
+        throw new Error(`No body in response`);
+    }
+    for await (const event of parse(response.body)) {
+        db.saveEvent(event.payload);
+    }
+});
+program
+    .command("incept")
+    .requiredOption("--passcode <passcode>")
+    .option("--wit <wit>")
+    .action(async ({ passcode, wit }) => {
+    if (typeof passcode !== "string") {
+        throw new Error(`Invalid passcode`);
+    }
+    const keystore = new FileSystemKeyStore({ dir: ".keri/keys", passphrase: passcode });
+    const hab = new Habitat({ db, keystore });
+    const wits = [];
+    if (typeof wit === "string") {
+        wits.push(wit);
+    }
+    const result = await hab.create({ wits });
+    console.dir(result);
+});
+program
+    .command("interact")
+    .requiredOption("--passcode <passcode>")
+    .requiredOption("--aid <aid>")
+    .action(async ({ passcode, aid }) => {
+    if (typeof passcode !== "string") {
+        throw new Error(`Invalid passcode`);
+    }
+    if (typeof aid !== "string") {
+        throw new Error(`Invalid aid`);
+    }
+    const keystore = new FileSystemKeyStore({ dir: ".keri/keys", passphrase: passcode });
+    const hab = new Habitat({ db, keystore });
+    const payload = await hab.interact(aid);
+    console.dir(payload);
+});
+program.command("export").action(async () => {
+    for (const event of await db.list()) {
+        console.log(event);
+    }
+});
+program.parse(process.argv);

package/dist/data-type.d.ts

@@ -0,0 +1,9 @@
+export type DataValue = string | number | boolean | DataObject | DataArray;
+export type DataArray = DataValue[];
+/**
+ * Defines a data object that can be serialized to JSON.
+ * E.g. key events and acdc objects
+ */
+export interface DataObject {
+    [x: string]: DataValue;
+}

package/dist/data-type.js

@@ -0,0 +1 @@
+export {};

package/dist/db/event-store.d.ts

@@ -0,0 +1,20 @@
+import type { KeyEvent } from "../events/main.ts";
+export interface KeyEventMessage<T extends KeyEvent = KeyEvent> {
+    event: T;
+    attachments: KeyEventAttachment[];
+}
+export interface ListArgs {
+    i?: string;
+    d?: string;
+    t?: string;
+    r?: string;
+}
+export interface KeyEventAttachment {
+    code: string;
+    value: string;
+}
+export interface EventStore {
+    list(args?: ListArgs): Promise<KeyEventMessage[]>;
+    saveEvent(event: KeyEvent): Promise<void>;
+    saveAttachment(eventId: string, attachment: KeyEventAttachment): Promise<void>;
+}

package/dist/db/event-store.js

@@ -0,0 +1 @@
+export {};

package/dist/db/sqlite-db.d.ts

@@ -0,0 +1,13 @@
+import type { KeyEvent } from "../events/main.ts";
+import type { EventStore, KeyEventAttachment, KeyEventMessage, ListArgs } from "./event-store.ts";
+export interface SqliteEventStoreOptions {
+    filename?: string;
+}
+export declare class SqliteEventStore implements EventStore {
+    #private;
+    constructor(options?: SqliteEventStoreOptions);
+    init(): void;
+    saveEvent(event: KeyEvent): Promise<void>;
+    saveAttachment(id: string, attachment: KeyEventAttachment): Promise<void>;
+    list(args?: ListArgs): Promise<KeyEventMessage[]>;
+}

package/dist/db/sqlite-db.js

@@ -0,0 +1,123 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SqliteEventStore_db;
+import { DatabaseSync } from "node:sqlite";
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+function parseRow(row) {
+    if (!row || typeof row !== "object") {
+        throw new Error(`Row not found`);
+    }
+    const data = "event_data" in row && row["event_data"];
+    if (!data || typeof data !== "string") {
+        throw new Error(`Unexpected row format`);
+    }
+    if ("attachments" in row && typeof row["attachments"] !== "string") {
+        throw new Error(`Unexpected row format`);
+    }
+    const attachments = JSON.parse(row["attachments"] || "[]");
+    if (!Array.isArray(attachments)) {
+        throw new Error(`Unexpected row format`);
+    }
+    return {
+        event: JSON.parse(data),
+        attachments: attachments.filter((att) => att.code && att.value),
+    };
+}
+function ensureDirSync(filename) {
+    const dir = dirname(filename);
+    if (!existsSync(dir)) {
+        mkdirSync(dir);
+    }
+}
+export class SqliteEventStore {
+    constructor(options = {}) {
+        _SqliteEventStore_db.set(this, void 0);
+        if (options.filename) {
+            ensureDirSync(options.filename);
+        }
+        __classPrivateFieldSet(this, _SqliteEventStore_db, new DatabaseSync(options.filename ?? ":memory:"), "f");
+    }
+    init() {
+        __classPrivateFieldGet(this, _SqliteEventStore_db, "f").exec(`
+        CREATE TABLE IF NOT EXISTS events (
+            event_id TEXT PRIMARY KEY,
+            event_data JSON NOT NULL
+        );
+    `);
+        __classPrivateFieldGet(this, _SqliteEventStore_db, "f").exec(`
+        CREATE TABLE IF NOT EXISTS attachments (
+            event_id TEXT NOT NULL,
+            attachment_code TEXT NOT NULL,
+            attachment_value TEXT NOT NULL,
+            FOREIGN KEY(event_id) REFERENCES events(event_id)
+            PRIMARY KEY(event_id, attachment_code, attachment_value)
+        );
+    `);
+    }
+    async saveEvent(event) {
+        const sql = `
+      INSERT INTO events (event_id, event_data)
+      VALUES ($id, $data) ON CONFLICT(event_id) DO NOTHING;
+    `;
+        __classPrivateFieldGet(this, _SqliteEventStore_db, "f").prepare(sql).run({
+            id: event.d,
+            data: JSON.stringify(event),
+        });
+    }
+    async saveAttachment(id, attachment) {
+        const sql = `
+      INSERT INTO attachments (event_id, attachment_code, attachment_value)
+      VALUES ($id, $group, $data)
+      ON CONFLICT(event_id, attachment_code, attachment_value) DO NOTHING;
+    `;
+        __classPrivateFieldGet(this, _SqliteEventStore_db, "f").prepare(sql).run({
+            id: id,
+            group: attachment.code,
+            data: attachment.value,
+        });
+    }
+    async list(args = {}) {
+        const filter = [];
+        const params = {};
+        if (args.i) {
+            filter.push("json_extract(event_data, '$.i') = $i");
+            params["i"] = args.i;
+        }
+        if (args.d) {
+            filter.push("json_extract(event_data, '$.d') = $d");
+            params["d"] = args.d;
+        }
+        if (args.t) {
+            filter.push("json_extract(event_data, '$.t') = $t");
+            params["t"] = args.t;
+        }
+        if (args.r) {
+            filter.push("json_extract(event_data, '$.r') = $r");
+            params["r"] = args.r;
+        }
+        const sql = `
+      SELECT
+        event_data,
+        json_group_array(json_object('code', attachment_code, 'value', attachment_value)) as attachments
+      FROM
+        events
+        LEFT JOIN attachments ON events.event_id = attachments.event_id
+      ${filter.length ? "WHERE " + filter.join(" AND ") : ""}
+      GROUP BY events.event_id
+      ORDER BY json_extract(event_data, '$.sn') DESC;
+    `;
+        const rows = __classPrivateFieldGet(this, _SqliteEventStore_db, "f").prepare(sql).all(params);
+        return rows.map(parseRow);
+    }
+}
+_SqliteEventStore_db = new WeakMap();

package/dist/events/common.d.ts

@@ -0,0 +1,6 @@
+export interface KeyEvent {
+    v: string;
+    t: string;
+    d: string;
+}
+export type Threshold = string | string[];

package/dist/events/common.js

@@ -0,0 +1 @@
+export {};

package/dist/events/incept.d.ts

@@ -0,0 +1,26 @@
+import type { DataArray } from "../data-type.ts";
+import type { Threshold } from "./common.ts";
+export interface InceptArgs {
+    k: string[];
+    kt: Threshold;
+    n: string[];
+    nt: Threshold;
+    b?: string[];
+    bt?: string;
+}
+export interface InceptEvent {
+    v: string;
+    t: "icp";
+    d: string;
+    i: string;
+    s: string;
+    kt: Threshold;
+    k: string[];
+    nt: Threshold;
+    n: string[];
+    bt: string;
+    b: string[];
+    c: string[];
+    a: DataArray;
+}
+export declare function incept(data: InceptArgs): InceptEvent;

package/dist/events/incept.js

@@ -0,0 +1,28 @@
+import { blake3 } from "@noble/hashes/blake3";
+import cesr from "../parser/cesr-encoding.js";
+import { MatterCode } from "../parser/codes.js";
+import { versify } from "../parser/version.js";
+export function incept(data) {
+    const event = versify({
+        t: "icp",
+        d: "#".repeat(44),
+        i: "#".repeat(44),
+        s: "0",
+        kt: data.kt,
+        k: data.k,
+        nt: data.nt,
+        n: data.n,
+        bt: data.bt ?? "0",
+        b: data.b ?? [],
+        c: [],
+        a: [],
+    });
+    const encoder = new TextEncoder();
+    const digest = cesr.encode(MatterCode.Blake3_256, blake3
+        .create({ dkLen: 32 })
+        .update(encoder.encode(JSON.stringify(event)))
+        .digest());
+    event["d"] = digest;
+    event["i"] = digest;
+    return event;
+}

package/dist/events/interact.d.ts

@@ -0,0 +1,17 @@
+import type { DataArray } from "../data-type.ts";
+export interface InteractArgs {
+    i: string;
+    s: string;
+    p: string;
+    a: DataArray;
+}
+export interface InteractEvent {
+    v: string;
+    t: "ixn";
+    d: string;
+    i: string;
+    s: string;
+    p: string;
+    a: DataArray;
+}
+export declare function interact(data: InteractArgs): InteractEvent;

package/dist/events/interact.js

@@ -0,0 +1,21 @@
+import { blake3 } from "@noble/hashes/blake3";
+import cesr from "../parser/cesr-encoding.js";
+import { MatterCode } from "../parser/codes.js";
+import { versify } from "../parser/version.js";
+export function interact(data) {
+    const event = versify({
+        t: "ixn",
+        d: "#".repeat(44),
+        i: data.i,
+        s: data.s,
+        p: data.p,
+        a: data.a,
+    });
+    const encoder = new TextEncoder();
+    const digest = cesr.encode(MatterCode.Blake3_256, blake3
+        .create({ dkLen: 32 })
+        .update(encoder.encode(JSON.stringify(event)))
+        .digest());
+    event["d"] = digest;
+    return Object.freeze(event);
+}

package/dist/events/main.d.ts

@@ -0,0 +1,4 @@
+export * from "./common.ts";
+export * from "./incept.ts";
+export * from "./reply.ts";
+export * from "./interact.ts";

package/dist/events/main.js

@@ -0,0 +1,4 @@
+export * from "./common.js";
+export * from "./incept.js";
+export * from "./reply.js";
+export * from "./interact.js";

package/dist/events/reply.d.ts

@@ -0,0 +1,15 @@
+import type { DataObject } from "../data-type.ts";
+export interface ReplyArgs {
+    dt?: string;
+    r: string;
+    a: DataObject;
+}
+export interface ReplyEvent {
+    v: string;
+    t: "rpy";
+    d: string;
+    dt: string;
+    r: string;
+    a: DataObject;
+}
+export declare function reply(data: ReplyArgs): ReplyEvent;

package/dist/events/reply.js

@@ -0,0 +1,20 @@
+import { blake3 } from "@noble/hashes/blake3";
+import cesr from "../parser/cesr-encoding.js";
+import { MatterCode } from "../parser/codes.js";
+import { versify } from "../parser/version.js";
+export function reply(data) {
+    const event = versify({
+        t: "rpy",
+        d: "#".repeat(44),
+        dt: data.dt ?? new Date().toISOString(),
+        r: data.r,
+        a: data.a,
+    });
+    const encoder = new TextEncoder();
+    const digest = cesr.encode(MatterCode.Blake3_256, blake3
+        .create({ dkLen: 32 })
+        .update(encoder.encode(JSON.stringify(event)))
+        .digest());
+    event["d"] = digest;
+    return event;
+}

package/dist/keri/habitat.d.ts

@@ -0,0 +1,20 @@
+import type { EventStore, KeyEventMessage } from "../db/event-store.ts";
+import type { KeyStore } from "../keystore/keystore.ts";
+import type { InteractEvent, InceptEvent } from "../events/main.ts";
+export interface HabitatDeps {
+    keystore: KeyStore;
+    db: EventStore;
+}
+export interface InceptIdentifierArgs {
+    wits: string[];
+    toad?: number;
+}
+export declare class Habitat {
+    #private;
+    constructor(deps: HabitatDeps);
+    create(args: InceptIdentifierArgs): Promise<InceptEvent>;
+    interact(aid: string): Promise<InteractEvent>;
+    resolve(oobi: string): Promise<void>;
+    submit(eventId: string): Promise<void>;
+    list(id: string): Promise<KeyEventMessage[]>;
+}

package/dist/keri/habitat.js

@@ -0,0 +1,130 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Habitat_db, _Habitat_keystore;
+import { cesr, CounterCode } from "../main-common.js";
+import { parse } from "../parser/parser.js";
+import { resolveKeyState, submit } from "./keri.js";
+import { interact, incept } from "../events/main.js";
+export class Habitat {
+    constructor(deps) {
+        _Habitat_db.set(this, void 0);
+        _Habitat_keystore.set(this, void 0);
+        __classPrivateFieldSet(this, _Habitat_db, deps.db, "f");
+        __classPrivateFieldSet(this, _Habitat_keystore, deps.keystore, "f");
+    }
+    async create(args) {
+        const keys = [await __classPrivateFieldGet(this, _Habitat_keystore, "f").incept(), await __classPrivateFieldGet(this, _Habitat_keystore, "f").incept()];
+        const toad = args.toad ?? (args.wits.length === 0 ? 0 : args.wits.length === 1 ? 1 : args.wits.length - 1);
+        const payload = incept({
+            kt: "1",
+            k: keys.map((key) => key.current),
+            nt: "1",
+            n: keys.map((key) => key.next),
+            bt: toad.toString(),
+            b: args.wits,
+        });
+        await __classPrivateFieldGet(this, _Habitat_db, "f").saveEvent(payload);
+        const raw = new TextEncoder().encode(JSON.stringify(payload));
+        await Promise.all(keys.map(async (key, index) => {
+            const sig = await __classPrivateFieldGet(this, _Habitat_keystore, "f").sign(key.current, raw);
+            await __classPrivateFieldGet(this, _Habitat_db, "f").saveAttachment(payload.d, {
+                code: CounterCode.ControllerIdxSigs,
+                value: cesr.index(sig, index),
+            });
+        }));
+        await this.submit(payload.d);
+        return payload;
+    }
+    async interact(aid) {
+        const events = await __classPrivateFieldGet(this, _Habitat_db, "f").list({ i: aid });
+        if (events.length === 0) {
+            throw new Error(`Could not find aid ${aid}`);
+        }
+        const state = resolveKeyState(events.map((e) => e.event));
+        const payload = interact({
+            i: aid,
+            s: (parseInt(state.s, 16) + 1).toString(),
+            a: [],
+            p: state.event,
+        });
+        await __classPrivateFieldGet(this, _Habitat_db, "f").saveEvent(payload);
+        const raw = new TextEncoder().encode(JSON.stringify(payload));
+        await Promise.all(state.keys.map(async (key, index) => {
+            const sig = await __classPrivateFieldGet(this, _Habitat_keystore, "f").sign(key, raw);
+            await __classPrivateFieldGet(this, _Habitat_db, "f").saveAttachment(payload.d, {
+                code: CounterCode.ControllerIdxSigs,
+                value: cesr.index(sig, index),
+            });
+        }));
+        await this.submit(payload.d);
+        return payload;
+    }
+    async resolve(oobi) {
+        const response = await fetch(oobi);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch oobi: ${response.status} ${response.statusText}`);
+        }
+        if (!response.body) {
+            throw new Error(`No body in response`);
+        }
+        for await (const event of parse(response.body)) {
+            __classPrivateFieldGet(this, _Habitat_db, "f").saveEvent(event.payload);
+        }
+    }
+    async submit(eventId) {
+        const [event] = await __classPrivateFieldGet(this, _Habitat_db, "f").list({ d: eventId });
+        if (!event || !("i" in event.event && typeof event.event.i === "string")) {
+            throw new Error("No such event");
+        }
+        const [inception] = await __classPrivateFieldGet(this, _Habitat_db, "f").list({ i: event.event.i, t: "icp" });
+        if (!inception) {
+            throw new Error("No inception event found");
+        }
+        const state = resolveKeyState([inception.event]);
+        const locations = await __classPrivateFieldGet(this, _Habitat_db, "f").list({ t: "rpy", r: "/loc/scheme" });
+        const witnessEndpoints = await Promise.all(state.wits.map((wit) => {
+            const result = locations.map((loc) => loc.event).find((rpy) => rpy.a.eid === wit);
+            if (!result) {
+                throw new Error(`No location found for wit ${wit}`);
+            }
+            return result.a.url;
+        }));
+        for (const wit of witnessEndpoints) {
+            const response = await submit({
+                event: event.event,
+                signatures: {
+                    controllers: event.attachments
+                        .filter((attachment) => attachment.code === CounterCode.ControllerIdxSigs)
+                        .map((attachment) => attachment.value),
+                    witnesses: [],
+                },
+            }, wit);
+            for await (const receipt of parse(response)) {
+                await __classPrivateFieldGet(this, _Habitat_db, "f").saveEvent(receipt.payload);
+                let code = null;
+                for (const attachment of receipt.attachments) {
+                    if (attachment.startsWith("-")) {
+                        code = attachment;
+                    }
+                    else if (code) {
+                        await __classPrivateFieldGet(this, _Habitat_db, "f").saveAttachment(receipt.payload.d, { code: code, value: attachment });
+                        code = null;
+                    }
+                }
+            }
+        }
+    }
+    async list(id) {
+        return __classPrivateFieldGet(this, _Habitat_db, "f").list({ i: id });
+    }
+}
+_Habitat_db = new WeakMap(), _Habitat_keystore = new WeakMap();

package/dist/keri/keri.d.ts

@@ -0,0 +1,26 @@
+import type { KeyEvent } from "../events/main.ts";
+export interface WitnessSignature {
+    aid: string;
+    signature: string;
+}
+export interface KeyEventSignatures {
+    controllers: string[];
+    witnesses?: WitnessSignature[];
+}
+export interface KeyEventMessage {
+    event: KeyEvent;
+    signatures: KeyEventSignatures;
+}
+export declare function resolveKeyState(events: KeyEvent[]): {
+    s: string;
+    prefix: string;
+    event: string;
+    wits: string[];
+    keys: string[];
+    sith: import("../main-common.ts").Threshold;
+};
+export declare function serializeAttachment(message: KeyEventMessage): string;
+export interface Receipt {
+    event: KeyEvent;
+}
+export declare function submit(message: KeyEventMessage, witnessEndpoint: string): Promise<ReadableStream<Uint8Array>>;

package/dist/keri/keri.js

@@ -0,0 +1,43 @@
+import { CounterCode, encodeBase64Int } from "../main-common.js";
+export function resolveKeyState(events) {
+    const inception = events[0];
+    if (inception.t !== "icp") {
+        throw new Error("First event was not inception");
+    }
+    return {
+        s: "0",
+        prefix: inception.d,
+        event: inception.d,
+        wits: inception.b,
+        keys: inception.k,
+        sith: inception.kt,
+    };
+}
+export function serializeAttachment(message) {
+    const sigs = message.signatures.controllers;
+    const controllerSigs = `${CounterCode.ControllerIdxSigs}${encodeBase64Int(message.signatures.controllers.length, 2)}${sigs.join("")}`;
+    const attachmentSize = new TextEncoder().encode(controllerSigs).length / 4;
+    const attachment = `${CounterCode.AttachmentGroup}${encodeBase64Int(attachmentSize, 2)}${controllerSigs}`;
+    return attachment;
+}
+export async function submit(message, witnessEndpoint) {
+    const url = new URL("/receipts", witnessEndpoint);
+    const response = await fetch(url, {
+        method: "POST",
+        body: JSON.stringify(message.event),
+        headers: {
+            "Content-Type": "application/cesr+json",
+            "CESR-ATTACHMENT": serializeAttachment(message),
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to send event to wit ${witnessEndpoint}: ${response.status} ${response.statusText}`);
+    }
+    if (response.status !== 200) {
+        throw new Error(`Failed to send event to wit ${witnessEndpoint}: ${response.status} ${response.statusText}`);
+    }
+    if (!response.body) {
+        throw new Error(`Failed to send event to wit ${witnessEndpoint}: ${response.status} ${response.statusText}`);
+    }
+    return response.body;
+}

package/dist/keystore/encrypt.d.ts

@@ -0,0 +1,2 @@
+export declare function encrypt(passphrase: string, data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+export declare function decrypt(passphrase: string, ciphertext: Uint8Array): Promise<Uint8Array>;