cojson 0.0.1 → 0.0.2

package/src/contentType.test.ts

@@ -0,0 +1,196 @@
+import {
+    agentIDfromSessionID,
+    getAgent,
+    getAgentID,
+    newRandomAgentCredential,
+    newRandomSessionID,
+} from "./coValue";
+import { LocalNode } from "./node";
+
+test("Empty COJSON Map works", () => {
+    const agentCredential = newRandomAgentCredential("agent1");
+    const node = new LocalNode(
+        agentCredential,
+        newRandomSessionID(getAgentID(getAgent(agentCredential)))
+    );
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    expect(content.type).toEqual("comap");
+    expect([...content.keys()]).toEqual([]);
+    expect(content.toJSON()).toEqual({});
+});
+
+test("Can insert and delete Map entries in edit()", () => {
+    const agentCredential = newRandomAgentCredential("agent1");
+    const node = new LocalNode(
+        agentCredential,
+        newRandomSessionID(getAgentID(getAgent(agentCredential)))
+    );
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    expect(content.type).toEqual("comap");
+
+    content.edit((editable) => {
+        editable.set("hello", "world", "trusting");
+        expect(editable.get("hello")).toEqual("world");
+        editable.set("foo", "bar", "trusting");
+        expect(editable.get("foo")).toEqual("bar");
+        expect([...editable.keys()]).toEqual(["hello", "foo"]);
+        editable.delete("foo", "trusting");
+        expect(editable.get("foo")).toEqual(undefined);
+    });
+});
+
+test("Can get map entry values at different points in time", () => {
+    const agentCredential = newRandomAgentCredential("agent1");
+    const node = new LocalNode(
+        agentCredential,
+        newRandomSessionID(getAgentID(getAgent(agentCredential)))
+    );
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    expect(content.type).toEqual("comap");
+
+    content.edit((editable) => {
+        const beforeA = Date.now();
+        while(Date.now() < beforeA + 10){}
+        editable.set("hello", "A", "trusting");
+        const beforeB = Date.now();
+        while(Date.now() < beforeB + 10){}
+        editable.set("hello", "B", "trusting");
+        const beforeC = Date.now();
+        while(Date.now() < beforeC + 10){}
+        editable.set("hello", "C", "trusting");
+        expect(editable.get("hello")).toEqual("C");
+        expect(editable.getAtTime("hello", Date.now())).toEqual("C");
+        expect(editable.getAtTime("hello", beforeA)).toEqual(undefined);
+        expect(editable.getAtTime("hello", beforeB)).toEqual("A");
+        expect(editable.getAtTime("hello", beforeC)).toEqual("B");
+    });
+});
+
+test("Can get all historic values of key", () => {
+    const agentCredential = newRandomAgentCredential("agent1");
+    const node = new LocalNode(
+        agentCredential,
+        newRandomSessionID(getAgentID(getAgent(agentCredential)))
+    );
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    expect(content.type).toEqual("comap");
+
+    content.edit((editable) => {
+        editable.set("hello", "A", "trusting");
+        const txA = editable.getLastTxID("hello");
+        editable.set("hello", "B", "trusting");
+        const txB = editable.getLastTxID("hello");
+        editable.delete("hello", "trusting");
+        const txDel = editable.getLastTxID("hello");
+        editable.set("hello", "C", "trusting");
+        const txC = editable.getLastTxID("hello");
+        expect(
+            editable.getHistory("hello")
+        ).toEqual([
+            {
+                txID: txA,
+                value: "A",
+                at: txA && coValue.getTx(txA)?.madeAt,
+            },
+            {
+                txID: txB,
+                value: "B",
+                at: txB && coValue.getTx(txB)?.madeAt,
+            },
+            {
+                txID: txDel,
+                value: undefined,
+                at: txDel && coValue.getTx(txDel)?.madeAt,
+            },
+            {
+                txID: txC,
+                value: "C",
+                at: txC && coValue.getTx(txC)?.madeAt,
+            },
+        ]);
+    });
+});
+
+test("Can get last tx ID for a key", () => {
+    const agentCredential = newRandomAgentCredential("agent1");
+    const node = new LocalNode(
+        agentCredential,
+        newRandomSessionID(getAgentID(getAgent(agentCredential)))
+    );
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    expect(content.type).toEqual("comap");
+
+    content.edit((editable) => {
+        expect(editable.getLastTxID("hello")).toEqual(undefined);
+        editable.set("hello", "A", "trusting");
+        const sessionID = editable.getLastTxID("hello")?.sessionID;
+        expect(sessionID && agentIDfromSessionID(sessionID)).toEqual(
+            getAgentID(getAgent(agentCredential))
+        );
+        expect(editable.getLastTxID("hello")?.txIndex).toEqual(0);
+        editable.set("hello", "B", "trusting");
+        expect(editable.getLastTxID("hello")?.txIndex).toEqual(1);
+        editable.set("hello", "C", "trusting");
+        expect(editable.getLastTxID("hello")?.txIndex).toEqual(2);
+    });
+});

package/src/contentType.ts

@@ -0,0 +1,239 @@
+import { JsonAtom, JsonObject, JsonValue } from "./jsonValue";
+import { CoValue, RawCoValueID, TransactionID } from "./coValue";
+
+export type CoValueID<T extends ContentType> = RawCoValueID & {
+    readonly __type: T;
+};
+
+export type ContentType =
+    | CoMap<{[key: string]: JsonValue}, JsonValue>
+    | CoList<JsonValue, JsonValue>
+    | CoStream<JsonValue, JsonValue>
+    | Static<JsonValue>;
+
+type MapOp<K extends string, V extends JsonValue> = {
+    txID: TransactionID;
+    madeAt: number;
+    changeIdx: number;
+} & MapOpPayload<K, V>;
+
+// TODO: add after TransactionID[] for conflicts/ordering
+export type MapOpPayload<K extends string, V extends JsonValue> =
+    | {
+          op: "insert";
+          key: K;
+          value: V;
+      }
+    | {
+          op: "delete";
+          key: K;
+      };
+
+export class CoMap<
+    M extends {[key: string]: JsonValue},
+    Meta extends JsonValue,
+    K extends string = keyof M & string,
+    V extends JsonValue = M[K],
+    MM extends {[key: string]: JsonValue} = {[KK in K]: M[KK]}
+> {
+    id: CoValueID<CoMap<MM, Meta>>;
+    coValue: CoValue;
+    type: "comap" = "comap";
+    ops: {[KK in K]?: MapOp<K, M[KK]>[]};
+
+    constructor(coValue: CoValue) {
+        this.id = coValue.id as CoValueID<CoMap<MM, Meta>>;
+        this.coValue = coValue;
+        this.ops = {};
+
+        this.fillOpsFromCoValue();
+    }
+
+    protected fillOpsFromCoValue() {
+        this.ops = {};
+
+        for (const { txID, changes, madeAt } of this.coValue.getValidSortedTransactions()) {
+            for (const [changeIdx, changeUntyped] of (
+                changes
+            ).entries()) {
+                const change = changeUntyped as MapOpPayload<K, V>
+                let entries = this.ops[change.key];
+                if (!entries) {
+                    entries = [];
+                    this.ops[change.key] = entries;
+                }
+                entries.push({
+                    txID,
+                    madeAt,
+                    changeIdx,
+                    ...(change as any),
+                });
+            }
+        }
+    }
+
+    keys(): K[] {
+        return Object.keys(this.ops) as K[];
+    }
+
+    get<KK extends K>(key: KK): M[KK] | undefined {
+        const ops = this.ops[key];
+        if (!ops) {
+            return undefined;
+        }
+
+        const lastEntry = ops[ops.length - 1]!;
+
+        if (lastEntry.op === "delete") {
+            return undefined;
+        } else {
+            return lastEntry.value;
+        }
+    }
+
+    getAtTime<KK extends K>(key: KK, time: number): M[KK] | undefined {
+        const ops = this.ops[key];
+        if (!ops) {
+            return undefined;
+        }
+
+        const lastOpBeforeOrAtTime = ops.findLast((op) => op.madeAt <= time);
+
+        if (!lastOpBeforeOrAtTime) {
+            return undefined;
+        }
+
+        if (lastOpBeforeOrAtTime.op === "delete") {
+            return undefined;
+        } else {
+            return lastOpBeforeOrAtTime.value;
+        }
+    }
+
+    getLastTxID<KK extends K>(key: KK): TransactionID | undefined {
+        const ops = this.ops[key];
+        if (!ops) {
+            return undefined;
+        }
+
+        const lastEntry = ops[ops.length - 1]!;
+
+        return lastEntry.txID;
+    }
+
+    getHistory<KK extends K>(key: KK): {at: number, txID: TransactionID, value: M[KK] | undefined}[] {
+        const ops = this.ops[key];
+        if (!ops) {
+            return [];
+        }
+
+        const history: {at: number, txID: TransactionID, value: M[KK] | undefined}[] = [];
+
+        for (const op of ops) {
+            if (op.op === "delete") {
+                history.push({at: op.madeAt, txID: op.txID, value: undefined});
+            } else {
+                history.push({at: op.madeAt, txID: op.txID, value: op.value});
+            }
+        }
+
+        return history;
+    }
+
+    toJSON(): JsonObject {
+        const json: JsonObject = {};
+
+        for (const key of this.keys()) {
+            const value = this.get(key);
+            if (value !== undefined) {
+                json[key] = value;
+            }
+        }
+
+        return json;
+    }
+
+    edit(changer: (editable: WriteableCoMap<M, Meta>) => void): CoMap<M, Meta> {
+        const editable = new WriteableCoMap<M, Meta>(this.coValue);
+        changer(editable);
+        return new CoMap(this.coValue);
+    }
+}
+
+export class WriteableCoMap<
+    M extends {[key: string]: JsonValue},
+    Meta extends JsonValue,
+    K extends string = keyof M & string,
+    V extends JsonValue = M[K],
+    MM extends {[key: string]: JsonValue} = {[KK in K]: M[KK]}
+> extends CoMap<M, Meta, K, V, MM> {
+    set<KK extends K>(key: KK, value: M[KK], privacy: "private" | "trusting" = "private"): void {
+        this.coValue.makeTransaction([
+            {
+                op: "insert",
+                key,
+                value,
+            },
+        ], privacy);
+
+        this.fillOpsFromCoValue();
+    }
+
+    delete(key: K, privacy: "private" | "trusting" = "private"): void {
+        this.coValue.makeTransaction([
+            {
+                op: "delete",
+                key,
+            },
+        ], privacy);
+
+        this.fillOpsFromCoValue();
+    }
+}
+
+export class CoList<T extends JsonValue, Meta extends JsonValue> {
+    id: CoValueID<CoList<T, Meta>>;
+    type: "colist" = "colist";
+
+    constructor(coValue: CoValue) {
+        this.id = coValue.id as CoValueID<CoList<T, Meta>>;
+    }
+
+    toJSON(): JsonObject {
+        throw new Error("Method not implemented.");
+    }
+}
+
+export class CoStream<T extends JsonValue, Meta extends JsonValue> {
+    id: CoValueID<CoStream<T, Meta>>;
+    type: "costream" = "costream";
+
+    constructor(coValue: CoValue) {
+        this.id = coValue.id as CoValueID<CoStream<T, Meta>>;
+    }
+
+    toJSON(): JsonObject {
+        throw new Error("Method not implemented.");
+    }
+}
+
+export class Static<T extends JsonValue> {
+    id: CoValueID<Static<T>>;
+    type: "static" = "static";
+
+    constructor(coValue: CoValue) {
+        this.id = coValue.id as CoValueID<Static<T>>;
+    }
+
+    toJSON(): JsonObject {
+        throw new Error("Method not implemented.");
+    }
+}
+
+export function expectMap(content: ContentType): CoMap<{ [key: string]: string }, {}> {
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    return content as CoMap<{ [key: string]: string }, {}>;
+}

package/src/crypto.test.ts

@@ -0,0 +1,189 @@
+import {
+    getRecipientID,
+    getSignatoryID,
+    secureHash,
+    newRandomRecipient,
+    newRandomSignatory,
+    seal,
+    sign,
+    openAs,
+    verify,
+    shortHash,
+    newRandomKeySecret,
+    encryptForTransaction,
+    decryptForTransaction,
+    sealKeySecret,
+    unsealKeySecret,
+} from "./crypto";
+import { base58, base64url } from "@scure/base";
+import { x25519 } from "@noble/curves/ed25519";
+import { xsalsa20_poly1305 } from "@noble/ciphers/salsa";
+import { blake3 } from "@noble/hashes/blake3";
+import stableStringify from "fast-json-stable-stringify";
+
+test("Signatures round-trip and use stable stringify", () => {
+    const data = { b: "world", a: "hello" };
+    const signatory = newRandomSignatory();
+    const signature = sign(signatory, data);
+
+    expect(signature).toMatch(/^signature_z/);
+    expect(
+        verify(signature, { a: "hello", b: "world" }, getSignatoryID(signatory))
+    ).toBe(true);
+});
+
+test("Invalid signatures don't verify", () => {
+    const data = { b: "world", a: "hello" };
+    const signatory = newRandomSignatory();
+    const signatory2 = newRandomSignatory();
+    const wrongSignature = sign(signatory2, data);
+
+    expect(verify(wrongSignature, data, getSignatoryID(signatory))).toBe(false);
+});
+
+test("Sealing round-trips, but invalid receiver can't unseal", () => {
+    const data = { b: "world", a: "hello" };
+    const sender = newRandomRecipient();
+    const recipient1 = newRandomRecipient();
+    const recipient2 = newRandomRecipient();
+    const recipient3 = newRandomRecipient();
+
+    const nOnceMaterial = {
+        in: "co_zTEST",
+        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 0 },
+    } as const;
+
+    const sealed = seal(
+        data,
+        sender,
+        new Set([getRecipientID(recipient1), getRecipientID(recipient2)]),
+        nOnceMaterial
+    );
+
+    expect(sealed[getRecipientID(recipient1)]).toMatch(/^sealed_U/);
+    expect(sealed[getRecipientID(recipient2)]).toMatch(/^sealed_U/);
+    expect(
+        openAs(sealed, recipient1, getRecipientID(sender), nOnceMaterial)
+    ).toEqual(data);
+    expect(
+        openAs(sealed, recipient2, getRecipientID(sender), nOnceMaterial)
+    ).toEqual(data);
+    expect(
+        openAs(sealed, recipient3, getRecipientID(sender), nOnceMaterial)
+    ).toBeUndefined();
+
+    // trying with wrong recipient secret, by hand
+    const nOnce = blake3(
+        new TextEncoder().encode(stableStringify(nOnceMaterial))
+    ).slice(0, 24);
+    const recipient3priv = base58.decode(
+        recipient3.substring("recipientSecret_z".length)
+    );
+    const senderPub = base58.decode(
+        getRecipientID(sender).substring("recipient_z".length)
+    );
+    const sealedBytes = base64url.decode(
+        sealed[getRecipientID(recipient1)]!.substring("sealed_U".length)
+    );
+    const sharedSecret = x25519.getSharedSecret(recipient3priv, senderPub);
+
+    expect(() => {
+        const _ = xsalsa20_poly1305(sharedSecret, nOnce).decrypt(sealedBytes);
+    }).toThrow("Wrong tag");
+});
+
+test("Hashing is deterministic", () => {
+    expect(secureHash({ b: "world", a: "hello" })).toEqual(
+        secureHash({ a: "hello", b: "world" })
+    );
+
+    expect(shortHash({ b: "world", a: "hello" })).toEqual(
+        shortHash({ a: "hello", b: "world" })
+    );
+});
+
+test("Encryption for transactions round-trips", () => {
+    const { secret } = newRandomKeySecret();
+
+    const encrypted1 =  encryptForTransaction({ a: "hello" }, secret, {
+        in: "co_zTEST",
+        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 0 },
+    });
+
+    const encrypted2 = encryptForTransaction({ b: "world" }, secret, {
+        in: "co_zTEST",
+        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 1 },
+    });
+
+    const decrypted1 = decryptForTransaction(encrypted1, secret, {
+        in: "co_zTEST",
+        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 0 },
+    });
+
+    const decrypted2 =  decryptForTransaction(encrypted2, secret, {
+        in: "co_zTEST",
+        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 1 },
+    });
+
+    expect([decrypted1, decrypted2]).toEqual([{ a: "hello" }, { b: "world" }]);
+});
+
+test("Encryption for transactions doesn't decrypt with a wrong key", () => {
+    const { secret } = newRandomKeySecret();
+    const { secret: secret2 } = newRandomKeySecret();
+
+    const encrypted1 =  encryptForTransaction({ a: "hello" }, secret, {
+        in: "co_zTEST",
+        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 0 },
+    });
+
+    const encrypted2 = encryptForTransaction({ b: "world" }, secret, {
+        in: "co_zTEST",
+        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 1 },
+    });
+
+    const decrypted1 = decryptForTransaction(encrypted1, secret2, {
+        in: "co_zTEST",
+        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 0 },
+    });
+
+    const decrypted2 =  decryptForTransaction(encrypted2, secret2, {
+        in: "co_zTEST",
+        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 1 },
+    });
+
+    expect([decrypted1, decrypted2]).toEqual([undefined, undefined]);
+});
+
+test("Encryption of keySecrets round-trips", () => {
+    const toSeal = newRandomKeySecret();
+    const sealing = newRandomKeySecret();
+
+    const keys = {
+        toSeal,
+        sealing,
+    };
+
+    const sealed = sealKeySecret(keys);
+
+    const unsealed = unsealKeySecret(sealed, sealing.secret);
+
+    expect(unsealed).toEqual(toSeal.secret);
+});
+
+test("Encryption of keySecrets doesn't unseal with a wrong key", () => {
+    const toSeal = newRandomKeySecret();
+    const sealing = newRandomKeySecret();
+    const sealingWrong = newRandomKeySecret();
+
+    const keys = {
+        toSeal,
+        sealing,
+    };
+
+    const sealed = sealKeySecret(keys);
+
+    const unsealed = unsealKeySecret(sealed, sealingWrong.secret);
+
+    expect(unsealed).toBeUndefined();
+});