cojson 0.7.0-alpha.37 → 0.7.0-alpha.38

package/src/tests/cryptoImpl.test.ts

@@ -0,0 +1,183 @@
+import { KeySecret } from "../crypto/crypto.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
+import { PureJSCrypto } from "../crypto/PureJSCrypto.js";
+import { describe, test, expect } from "vitest";
+import { SessionID } from "../index.js";
+
+describe.each([
+    { impl: await WasmCrypto.create(), name: "Wasm" },
+    { impl: await PureJSCrypto.create(), name: "PureJS" },
+])("Crypto $name", ({ impl }) => {
+    test("randomBytes", () => {
+        expect(impl.randomBytes(32).length).toEqual(32);
+    });
+
+    test("blake3HashOnce", () => {
+        const data = new Uint8Array([1, 2, 3, 4, 5]);
+        const hash = impl.blake3HashOnce(data);
+        // prettier-ignore
+        expect(hash).toEqual(new Uint8Array([2,79,103,192,66,90,61,192,47,186,245,140,185,61,229,19,46,61,117,197,25,250,160,186,218,33,73,29,136,201,112,87]));
+    });
+
+    test("blake3HashOnceWithContext", () => {
+        const data = new Uint8Array([1, 2, 3, 4, 5]);
+        const context = new Uint8Array([6, 7, 8, 9, 10]);
+        const hash = impl.blake3HashOnceWithContext(data, { context });
+        // prettier-ignore
+        expect(hash).toEqual(new Uint8Array([26,197,20,5,159,115,36,109,188,32,237,183,252,248,89,48,212,51,102,180,94,56,201,33,196,52,222,121,103,112,153,98]));
+    });
+
+    test("incrementalBlake3", () => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const state = impl.emptyBlake3State() as any;
+        const data = new Uint8Array([1, 2, 3, 4, 5]);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const state2 = impl.blake3IncrementalUpdate(state, data) as any;
+        expect(impl.blake3DigestForState(state2)).toEqual(
+            // prettier-ignore
+            new Uint8Array([2,79,103,192,66,90,61,192,47,186,245,140,185,61,229,19,46,61,117,197,25,250,160,186,218,33,73,29,136,201,112,87]),
+        );
+        const data2 = new Uint8Array([6, 7, 8, 9, 10]);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const state3 = impl.blake3IncrementalUpdate(state2, data2) as any;
+        expect(impl.blake3DigestForState(state3)).toEqual(
+            // prettier-ignore
+            new Uint8Array([165,131,141,69,2,69,39,236,196,244,180,213,147,124,222,39,68,223,54,176,242,97,200,101,204,79,21,233,56,51,1,199]),
+        );
+    });
+
+    test("newEd25519SigningKey", () => {
+        expect(impl.newEd25519SigningKey().length).toEqual(32);
+    });
+
+    test("getSignerID", () => {
+        const secret = impl.signerSecretFromBytes(
+            new Uint8Array(Array.from({ length: 32 }, (_, i) => i * 2)),
+        );
+        const id = impl.getSignerID(secret);
+        expect(id).toEqual(
+            "signer_z8wDhwtSA2twZvmz8J3Df63TdCBxC7ta9hFASV9cZC9xw",
+        );
+    });
+
+    test("sign and verify", () => {
+        const secret = impl.signerSecretFromBytes(
+            new Uint8Array(Array.from({ length: 32 }, (_, i) => i * 2)),
+        );
+        const wrongSecret = impl.signerSecretFromBytes(
+            new Uint8Array(
+                Array.from({ length: 32 }, (_, i) => (i === 0 ? 1 : i * 2)),
+            ),
+        );
+        const message = { foo: "bar" };
+        const wrongMessage = { foo: "baz" };
+        const signature = impl.sign(secret, message);
+        const wrongSignature = impl.sign(wrongSecret, message);
+        expect(signature).toEqual(
+            "signature_zHH7trJJ4iJFgYv9B8QtF96qcG7PbPJcfojy9ACtJc6z9FqzbJNM6xeqVLxCEK1oSj1oSYAgy2V3CW5SzjYDh8ax",
+        );
+        expect(
+            impl.verify(signature, message, impl.getSignerID(secret)),
+        ).toBeTruthy();
+        expect(
+            impl.verify(wrongSignature, message, impl.getSignerID(secret)),
+        ).toBeFalsy();
+        expect(
+            impl.verify(signature, wrongMessage, impl.getSignerID(secret)),
+        ).toBeFalsy();
+    });
+
+    test("newX25519StaticSecret", () => {
+        expect(impl.newX25519StaticSecret().length).toEqual(32);
+    });
+
+    test("getSealerID", () => {
+        const secret = impl.sealerSecretFromBytes(
+            new Uint8Array(Array.from({ length: 32 }, (_, i) => i * 2)),
+        );
+        const id = impl.getSealerID(secret);
+        expect(id).toEqual(
+            "sealer_zBvzQipsgJZwgy4rN5dfnWQWQNrV4PnJpWfDjZkJ5iYqy",
+        );
+    });
+
+    test("encrypt and decrypt", () => {
+        const secret: KeySecret =
+            "keySecret_zyRhQCZGM3LwEjB2nXTktyBQ56JiDBHbRtYjjddiugjT";
+        const data = { foo: "bar" };
+        const nOnceMaterial = { bar: "foo" };
+        const encrypted = impl.encrypt(data, secret, nOnceMaterial);
+        expect(encrypted).toEqual("encrypted_UDrVbWTATlj-ECtLqJQ==");
+        const decrypted = impl.decrypt(encrypted, secret, nOnceMaterial);
+        expect(decrypted).toEqual(data);
+        const wrongSecret =
+            "keySecret_zyRhQCZGM3LwEjB2nXTktyBQ56JiDBHbRtYjjddingjT";
+        expect(
+            impl.decrypt(encrypted, wrongSecret, nOnceMaterial),
+        ).toBeUndefined();
+        const wrongNOnceMaterial = { bar: "baz" };
+        expect(
+            impl.decrypt(encrypted, secret, wrongNOnceMaterial),
+        ).toBeUndefined();
+    });
+
+    test("seal and unseal", () => {
+        const senderSecret =
+            "sealerSecret_zFffKAY7Ln5ouAbmC6K21N6uPs1RQXyhpcuQzK3kPWhhg";
+        const recipientSecret =
+            "sealerSecret_z3K6m9AHmEJeTrCQW4zY5vicneorj9sVQasA7E8FYvDQa";
+        const message = { foo: "bar" };
+        const nOnceMaterial = {
+            in: "co_zSomeCoValue" as const,
+            tx: {
+                sessionID: "co_zSomeAccount_session_zSomeSession" as SessionID,
+                txIndex: 42,
+            },
+        };
+
+        const sealed = impl.seal({
+            message,
+            from: senderSecret,
+            to: impl.getSealerID(recipientSecret),
+            nOnceMaterial,
+        });
+
+        expect(sealed).toEqual(
+            "sealed_UtuddAQjop6zMR47aI7HOqj-f0kR2tdFvRxzDe4I=",
+        );
+
+        const unsealed = impl.unseal(
+            sealed,
+            recipientSecret,
+            impl.getSealerID(senderSecret),
+            nOnceMaterial,
+        );
+        expect(unsealed).toEqual(message);
+
+        const wrongRecipientSecret =
+            "sealerSecret_zHV1Y1VPbc31B8bi7yw4oL5CPPnPFspKwUjkFErgJFuoB";
+        expect(() =>
+            impl.unseal(
+                sealed,
+                wrongRecipientSecret,
+                impl.getSealerID(senderSecret),
+                nOnceMaterial,
+            ),
+        ).toThrow();
+        const wrongNOnceMaterial = {
+            in: "co_zSomeCoValue" as const,
+            tx: {
+                sessionID: "co_zSomeAccount_session_zSomeSession" as SessionID,
+                txIndex: 43,
+            },
+        };
+        expect(() =>
+            impl.unseal(
+                sealed,
+                recipientSecret,
+                impl.getSealerID(senderSecret),
+                wrongNOnceMaterial,
+            ),
+        ).toThrow();
+    });
+});

package/src/tests/group.test.ts

@@ -1,19 +1,18 @@
-import { expect, test, beforeEach } from "vitest";
-import { LocalNode, RawCoMap, RawCoList, RawCoStream, RawBinaryCoStream, cojsonReady } from "../index";
+import { expect, test } from "vitest";
+import {
+    LocalNode,
+    RawCoMap,
+    RawCoList,
+    RawCoStream,
+    RawBinaryCoStream,
+    WasmCrypto,
+} from "../index.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
 
-import { webcrypto } from "node:crypto";
-if (!("crypto" in globalThis)) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (globalThis as any).crypto = webcrypto;
-}
-
-beforeEach(async () => {
-    await cojsonReady;
-});
+const Crypto = await WasmCrypto.create();
 
 test("Can create a RawCoMap in a group", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
     const group = node.createGroup();
 
@@ -24,7 +23,7 @@ test("Can create a RawCoMap in a group", () => {
 });
 
 test("Can create a CoList in a group", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
     const group = node.createGroup();
 
@@ -32,10 +31,10 @@ test("Can create a CoList in a group", () => {
 
     expect(list.core.getCurrentContent().type).toEqual("colist");
     expect(list instanceof RawCoList).toEqual(true);
-})
+});
 
 test("Can create a CoStream in a group", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
     const group = node.createGroup();
 
@@ -46,7 +45,7 @@ test("Can create a CoStream in a group", () => {
 });
 
 test("Can create a BinaryCoStream in a group", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
     const group = node.createGroup();
 
@@ -55,4 +54,4 @@ test("Can create a BinaryCoStream in a group", () => {
     expect(stream.core.getCurrentContent().type).toEqual("costream");
     expect(stream.headerMeta.type).toEqual("binary");
     expect(stream instanceof RawBinaryCoStream).toEqual(true);
-})
+});