keri 0.0.0-dev.8b0703e

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/sqlite-db.d.ts

@@ -0,0 +1,14 @@
+import type { KeyEvent, ReplyEvent } from "../events/main.ts";
+export interface SqliteEventStoreOptions {
+    filename?: string;
+}
+export declare class SqliteEventStore {
+    #private;
+    constructor(options?: SqliteEventStoreOptions);
+    init(): void;
+    insert(event: KeyEvent): Promise<void>;
+    get(id: string): Promise<any>;
+    aid(id: string): Promise<any[]>;
+    locations(id: string): Promise<ReplyEvent[]>;
+    list(): Promise<KeyEvent[]>;
+}

package/dist/db/sqlite-db.js

@@ -0,0 +1,90 @@
+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 = "data" in row && row["data"];
+    if (!data || typeof data !== "string") {
+        throw new Error(`Unexpected row format`);
+    }
+    return JSON.parse(data);
+}
+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 (
+            id TEXT PRIMARY KEY,
+            data JSON NOT NULL
+        );
+    `);
+    }
+    async insert(event) {
+        const sql = `
+      INSERT INTO events (id, data)
+      VALUES ($id, $data) ON CONFLICT(id) DO NOTHING;
+    `;
+        __classPrivateFieldGet(this, _SqliteEventStore_db, "f").prepare(sql).run({
+            id: event.d,
+            data: JSON.stringify(event),
+        });
+    }
+    async get(id) {
+        const row = __classPrivateFieldGet(this, _SqliteEventStore_db, "f").prepare("SELECT * FROM events WHERE id = ?").get(id);
+        return parseRow(row);
+    }
+    async aid(id) {
+        const sql = `
+      SELECT * FROM events WHERE json_extract(data, '$.i') = $aid
+      ORDER BY json_extract(data, '$.sn') DESC;
+    `;
+        const rows = __classPrivateFieldGet(this, _SqliteEventStore_db, "f").prepare(sql).all({ aid: id });
+        return rows.map(parseRow);
+    }
+    async locations(id) {
+        const sql = `
+      SELECT * FROM
+        events
+      WHERE
+        json_extract(data, '$.t') = 'rpy' AND
+        json_extract(data, '$.r') = '/loc/scheme' AND
+        json_extract(data, '$.a.eid') = $id;
+    `;
+        const rows = __classPrivateFieldGet(this, _SqliteEventStore_db, "f").prepare(sql).all({ id });
+        return rows.map(parseRow);
+    }
+    async list() {
+        const sql = `
+      SELECT * FROM events;
+    `;
+        const rows = __classPrivateFieldGet(this, _SqliteEventStore_db, "f").prepare(sql).all();
+        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,14 @@
+import type { DataArray } from "../data-type.ts";
+export interface InteractArgs {
+    i: string;
+    s: string;
+    a: DataArray;
+}
+export interface InteractEvent {
+    v: string;
+    t: "ixn";
+    d: string;
+    i: string;
+    a: DataArray;
+}
+export declare function interact(data: InteractArgs): InteractEvent;

package/dist/events/interact.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 interact(data) {
+    const event = versify({
+        t: "ixn",
+        d: "#".repeat(44),
+        i: data.i,
+        s: data.s,
+        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/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.d.ts

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

package/dist/keri.js

@@ -0,0 +1,110 @@
+import { program } from "commander";
+import { parseStream } from "./parser/parser.js";
+import { CounterCode } from "./parser/codes.js";
+import { incept } from "./events/incept.js";
+import cesr from "./parser/cesr-encoding.js";
+import { encodeBase64Int } from "./parser/base64.js";
+import { FileSystemKeyStore } from "./keystore/keystore-fs.js";
+import { SqliteEventStore } from "./db/sqlite-db.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 parseStream(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 parseStream(response.body)) {
+        db.insert(event.payload);
+    }
+});
+program
+    .command("incept")
+    .requiredOption("--passcode <passcode>")
+    .requiredOption("--name <name>")
+    .option("--wit <wit>")
+    .action(async ({ passcode, name, wit }) => {
+    if (typeof passcode !== "string") {
+        throw new Error(`Invalid passcode`);
+    }
+    if (typeof name !== "string") {
+        throw new Error(`Invalid name`);
+    }
+    const keystore = new FileSystemKeyStore({ dir: ".keri/keys", passphrase: passcode });
+    const keys = [await keystore.incept()];
+    const wits = [];
+    if (typeof wit === "string") {
+        wits.push(wit);
+    }
+    const payload = incept({
+        kt: "1",
+        k: keys.map((key) => key.current),
+        nt: "1",
+        n: keys.map((key) => key.next),
+        bt: "1",
+        b: wits,
+    });
+    const witnessEndpoints = await Promise.all(wits.map(async (wit) => {
+        const result = await db.locations(wit);
+        if (result.length === 0) {
+            throw new Error(`No location found for wit ${wit}`);
+        }
+        return result[0].a.url;
+    }));
+    const sigs = await Promise.all(keys.map(async (key, index) => {
+        const sig = await keystore.sign(key.current, new TextEncoder().encode(JSON.stringify(payload)));
+        return cesr.index(sig, index);
+    }));
+    const sigGroup = `${CounterCode.ControllerIdxSigs}${encodeBase64Int(sigs.length, 2)}${sigs.join("")}`;
+    const attachmentSize = new TextEncoder().encode(sigGroup).length / 4;
+    const attachment = `${CounterCode.AttachmentGroup}${encodeBase64Int(attachmentSize, 2)}${sigGroup}`;
+    for (const wit of witnessEndpoints) {
+        const url = new URL("/receipts", wit);
+        const response = await fetch(url, {
+            method: "POST",
+            body: JSON.stringify(payload),
+            headers: {
+                "Content-Type": "application/cesr+json",
+                "CESR-ATTACHMENT": attachment,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to send event to wit ${wit}: ${response.status} ${response.statusText}`);
+        }
+        if (response.status !== 200) {
+            throw new Error(`Failed to send event to wit ${wit}: ${response.status} ${response.statusText}`);
+        }
+        if (response.body) {
+            for await (const receipt of parseStream(response.body)) {
+                await db.insert(receipt.payload);
+                console.log(receipt);
+            }
+        }
+    }
+    console.dir({
+        payload: payload,
+        sigs,
+        attachment,
+    });
+});
+program.command("export").action(async () => {
+    for (const event of await db.list()) {
+        console.log(event);
+    }
+});
+program.parse(process.argv);

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>;

package/dist/keystore/encrypt.js

@@ -0,0 +1,38 @@
+export async function encrypt(passphrase, data) {
+    const encoder = new TextEncoder();
+    const encryptionKey = await crypto.subtle.importKey("raw", encoder.encode(passphrase), "PBKDF2", false, [
+        "deriveBits",
+        "deriveKey",
+    ]);
+    const salt = crypto.getRandomValues(new Uint8Array(16));
+    const iv = crypto.getRandomValues(new Uint8Array(16));
+    const key = await crypto.subtle.deriveKey({
+        name: "PBKDF2",
+        salt,
+        iterations: 100000,
+        hash: "SHA-256",
+    }, encryptionKey, { name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"]);
+    const encrypted = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, data);
+    const result = new Uint8Array(salt.byteLength + iv.byteLength + encrypted.byteLength);
+    result.set(salt, 0);
+    result.set(iv, salt.byteLength);
+    result.set(new Uint8Array(encrypted), salt.byteLength + iv.byteLength);
+    return result;
+}
+export async function decrypt(passphrase, ciphertext) {
+    const encoder = new TextEncoder();
+    const keyMaterial = await crypto.subtle.importKey("raw", encoder.encode(passphrase), "PBKDF2", false, [
+        "deriveBits",
+        "deriveKey",
+    ]);
+    const salt = ciphertext.slice(0, 16);
+    const iv = ciphertext.slice(16, 32);
+    const encrypted = ciphertext.slice(32);
+    const key = await crypto.subtle.deriveKey({
+        name: "PBKDF2",
+        salt,
+        iterations: 100000,
+        hash: "SHA-256",
+    }, keyMaterial, { name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"]);
+    return new Uint8Array(await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, encrypted));
+}

package/dist/keystore/keystore-fs.d.ts

@@ -0,0 +1,13 @@
+import type { KeyStore, Key } from "./keystore.ts";
+export interface FileSystemKeyStoreOptions {
+    dir: string;
+    passphrase: string;
+}
+export declare class FileSystemKeyStore implements KeyStore {
+    private readonly options;
+    constructor(options: FileSystemKeyStoreOptions);
+    private load;
+    incept(): Promise<Key>;
+    rotate(currentKey: string): Promise<Key>;
+    sign(publicKey: string, message: Uint8Array): Promise<string>;
+}

package/dist/keystore/keystore-fs.js

@@ -0,0 +1,50 @@
+import { ed25519 } from "@noble/curves/ed25519";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import cesr from "../parser/cesr-encoding.js";
+import { MatterCode } from "../parser/codes.js";
+import { decodeBase64, encodeBase64 } from "../parser/base64.js";
+import { decrypt, encrypt } from "./encrypt.js";
+import { join } from "node:path";
+import { blake3 } from "@noble/hashes/blake3";
+export class FileSystemKeyStore {
+    constructor(options) {
+        this.options = options;
+    }
+    async load(publicKey) {
+        const value = await readFile(join(this.options.dir, publicKey), "utf-8");
+        const [key0, key1] = value.split("\n");
+        return [
+            await decrypt(this.options.passphrase, decodeBase64(key0)),
+            await decrypt(this.options.passphrase, decodeBase64(key1)),
+        ];
+    }
+    async incept() {
+        const key0 = ed25519.utils.randomPrivateKey();
+        const key1 = ed25519.utils.randomPrivateKey();
+        await mkdir(this.options.dir, { recursive: true });
+        const current = cesr.encode(MatterCode.Ed25519, ed25519.getPublicKey(key0));
+        const next = cesr.encode(MatterCode.Blake3_256, blake3.create({ dkLen: 32 }).update(current).digest());
+        await writeFile(join(this.options.dir, current), [
+            encodeBase64(await encrypt(this.options.passphrase, key0)),
+            encodeBase64(await encrypt(this.options.passphrase, key1)),
+            "\n",
+        ].join("\n"));
+        return { current, next };
+    }
+    async rotate(currentKey) {
+        const [, key0] = await this.load(currentKey);
+        const key1 = ed25519.utils.randomPrivateKey();
+        const current = cesr.encode(MatterCode.Ed25519, ed25519.getPublicKey(key0));
+        const next = cesr.encode(MatterCode.Blake3_256, blake3.create({ dkLen: 32 }).update(current).digest());
+        await writeFile(join(this.options.dir, current), [
+            encodeBase64(await encrypt(this.options.passphrase, key0)),
+            encodeBase64(await encrypt(this.options.passphrase, key1)),
+            "\n",
+        ].join("\n"));
+        return { current, next };
+    }
+    async sign(publicKey, message) {
+        const [key] = await this.load(publicKey);
+        return cesr.sign(message, key, "ed25519");
+    }
+}

package/dist/keystore/keystore-web.d.ts

@@ -0,0 +1,12 @@
+import type { Key, KeyStore } from "./keystore.ts";
+export interface WebKeyStoreOptions {
+    passphrase: string;
+}
+export declare class WebKeyStore implements KeyStore {
+    private readonly options;
+    constructor(options: WebKeyStoreOptions);
+    private load;
+    incept(): Promise<Key>;
+    rotate(currentKey: string): Promise<Key>;
+    sign(publicKey: string, message: Uint8Array): Promise<string>;
+}

package/dist/keystore/keystore-web.js

@@ -0,0 +1,48 @@
+import { ed25519 } from "@noble/curves/ed25519";
+import cesr from "../parser/cesr-encoding.js";
+import { MatterCode } from "../parser/codes.js";
+import { decodeBase64, encodeBase64 } from "../parser/base64.js";
+import { decrypt, encrypt } from "./encrypt.js";
+import { blake3 } from "@noble/hashes/blake3";
+export class WebKeyStore {
+    constructor(options) {
+        this.options = options;
+    }
+    async load(publicKey) {
+        const value = localStorage.getItem(publicKey);
+        if (!value) {
+            throw new Error("No such key");
+        }
+        const [key0, key1] = value.split("\n");
+        return [
+            await decrypt(this.options.passphrase, decodeBase64(key0)),
+            await decrypt(this.options.passphrase, decodeBase64(key1)),
+        ];
+    }
+    async incept() {
+        const key0 = ed25519.utils.randomPrivateKey();
+        const key1 = ed25519.utils.randomPrivateKey();
+        const current = cesr.encode(MatterCode.Ed25519, ed25519.getPublicKey(key0));
+        const next = cesr.encode(MatterCode.Blake3_256, blake3.create({ dkLen: 32 }).update(current).digest());
+        localStorage.setItem(current, [
+            encodeBase64(await encrypt(this.options.passphrase, key0)),
+            encodeBase64(await encrypt(this.options.passphrase, key1)),
+        ].join("\n"));
+        return { current, next };
+    }
+    async rotate(currentKey) {
+        const [, key0] = await this.load(currentKey);
+        const key1 = ed25519.utils.randomPrivateKey();
+        const current = cesr.encode(MatterCode.Ed25519, ed25519.getPublicKey(key0));
+        const next = cesr.encode(MatterCode.Blake3_256, blake3.create({ dkLen: 32 }).update(current).digest());
+        localStorage.setItem(current, [
+            encodeBase64(await encrypt(this.options.passphrase, key0)),
+            encodeBase64(await encrypt(this.options.passphrase, key1)),
+        ].join("\n"));
+        return { current, next };
+    }
+    async sign(publicKey, message) {
+        const [key] = await this.load(publicKey);
+        return cesr.sign(message, key, "ed25519");
+    }
+}

package/dist/keystore/keystore.d.ts

@@ -0,0 +1,15 @@
+export interface Key {
+    /**
+     * The public key of the tranferable key.
+     */
+    current: string;
+    /**
+     * Digest of the next public key of the key pair.
+     */
+    next: string;
+}
+export interface KeyStore {
+    incept(): Promise<Key>;
+    rotate(currentKey: string): Promise<Key>;
+    sign(publicKey: string, message: Uint8Array): Promise<string>;
+}

package/dist/keystore/keystore.js

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

package/dist/main-common.d.ts

@@ -0,0 +1,7 @@
+import cesr from "./parser/cesr-encoding.ts";
+import { incept } from "./events/incept.ts";
+export * from "./keystore/keystore.ts";
+export * from "./parser/codes.ts";
+export * from "./parser/base64.ts";
+export * from "./parser/parser.ts";
+export { incept, cesr };

package/dist/main-common.js

@@ -0,0 +1,7 @@
+import cesr from "./parser/cesr-encoding.js";
+import { incept } from "./events/incept.js";
+export * from "./keystore/keystore.js";
+export * from "./parser/codes.js";
+export * from "./parser/base64.js";
+export * from "./parser/parser.js";
+export { incept, cesr };

package/dist/main-web.d.ts

@@ -0,0 +1,2 @@
+export * from "./keystore/keystore-web.ts";
+export * from "./main-common.ts";

package/dist/main-web.js

@@ -0,0 +1,2 @@
+export * from "./keystore/keystore-web.js";
+export * from "./main-common.js";

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+export * from "./keystore/keystore-fs.ts";
+export * from "./main-common.ts";

package/dist/main.js

@@ -0,0 +1,2 @@
+export * from "./keystore/keystore-fs.js";
+export * from "./main-common.js";

package/dist/parser/base64.d.ts

@@ -0,0 +1,6 @@
+export declare function encodeBase64(uint8: Uint8Array): string;
+export declare function decodeBase64(b64: string): Uint8Array;
+export declare function decodeBase64Int(value: string): number;
+export declare function encodeBase64Int(value: number, length?: number): string;
+export declare function encodeBase64Url(buffer: Uint8Array): string;
+export declare function decodeBase64Url(input: string): Uint8Array;