cojson 0.7.0-alpha.5 → 0.7.0

package/src/tests/coStream.test.ts

@@ -0,0 +1,246 @@
+import { expect, test } from "vitest";
+import { expectStream } from "../coValue.js";
+import { RawBinaryCoStream } from "../coValues/coStream.js";
+import { MAX_RECOMMENDED_TX_SIZE, WasmCrypto } from "../index.js";
+import { LocalNode } from "../localNode.js";
+import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+
+const Crypto = await WasmCrypto.create();
+
+test("Empty CoStream works", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "costream",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = expectStream(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("costream");
+    expect(content.toJSON()).toEqual({});
+    expect(content.getSingleStream()).toEqual(undefined);
+});
+
+test("Can push into CoStream", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "costream",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = expectStream(coValue.getCurrentContent());
+
+    content.push({ hello: "world" }, "trusting");
+    expect(content.toJSON()).toEqual({
+        [node.currentSessionID]: [{ hello: "world" }],
+    });
+    content.push({ foo: "bar" }, "trusting");
+    expect(content.toJSON()).toEqual({
+        [node.currentSessionID]: [{ hello: "world" }, { foo: "bar" }],
+    });
+    expect(content.getSingleStream()).toEqual([
+        { hello: "world" },
+        { foo: "bar" },
+    ]);
+});
+
+test("Empty RawBinaryCoStream works", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "costream",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: { type: "binary" },
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (
+        content.type !== "costream" ||
+        content.headerMeta?.type !== "binary" ||
+        !(content instanceof RawBinaryCoStream)
+    ) {
+        throw new Error("Expected binary stream");
+    }
+
+    expect(content.type).toEqual("costream");
+    expect(content.headerMeta.type).toEqual("binary");
+    expect(content.toJSON()).toEqual({});
+    expect(content.getBinaryChunks()).toEqual(undefined);
+});
+
+test("Can push into RawBinaryCoStream", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "costream",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: { type: "binary" },
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (
+        content.type !== "costream" ||
+        content.headerMeta?.type !== "binary" ||
+        !(content instanceof RawBinaryCoStream)
+    ) {
+        throw new Error("Expected binary stream");
+    }
+
+    content.startBinaryStream(
+        { mimeType: "text/plain", fileName: "test.txt" },
+        "trusting",
+    );
+    content.pushBinaryStreamChunk(new Uint8Array([1, 2, 3]), "trusting");
+    content.pushBinaryStreamChunk(new Uint8Array([4, 5, 6]), "trusting");
+
+    content.endBinaryStream("trusting");
+    expect(content.getBinaryChunks()).toEqual({
+        mimeType: "text/plain",
+        fileName: "test.txt",
+        chunks: [new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6])],
+        finished: true,
+    });
+});
+
+test("When adding large transactions (small fraction of MAX_RECOMMENDED_TX_SIZE), we store an inbetween signature every time we reach MAX_RECOMMENDED_TX_SIZE and split up newContentSince accordingly", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "costream",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: { type: "binary" },
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (
+        content.type !== "costream" ||
+        content.headerMeta?.type !== "binary" ||
+        !(content instanceof RawBinaryCoStream)
+    ) {
+        throw new Error("Expected binary stream");
+    }
+
+    content.startBinaryStream(
+        { mimeType: "text/plain", fileName: "test.txt" },
+        "trusting",
+    );
+
+    for (let i = 0; i < 10; i++) {
+        const chunk = new Uint8Array(MAX_RECOMMENDED_TX_SIZE / 3 + 100);
+
+        content.pushBinaryStreamChunk(chunk, "trusting");
+    }
+
+    content.endBinaryStream("trusting");
+
+    const sessionEntry = coValue.sessionLogs.get(node.currentSessionID)!;
+    expect(sessionEntry.transactions.length).toEqual(12);
+    expect(sessionEntry.signatureAfter[0]).not.toBeDefined();
+    expect(sessionEntry.signatureAfter[1]).not.toBeDefined();
+    expect(sessionEntry.signatureAfter[2]).not.toBeDefined();
+    expect(sessionEntry.signatureAfter[3]).toBeDefined();
+    expect(sessionEntry.signatureAfter[4]).not.toBeDefined();
+    expect(sessionEntry.signatureAfter[5]).not.toBeDefined();
+    expect(sessionEntry.signatureAfter[6]).toBeDefined();
+    expect(sessionEntry.signatureAfter[7]).not.toBeDefined();
+    expect(sessionEntry.signatureAfter[8]).not.toBeDefined();
+    expect(sessionEntry.signatureAfter[9]).toBeDefined();
+    expect(sessionEntry.signatureAfter[10]).not.toBeDefined();
+    expect(sessionEntry.signatureAfter[11]).not.toBeDefined();
+
+    const newContent = coValue.newContentSince({
+        id: coValue.id,
+        header: false,
+        sessions: {},
+    })!;
+
+    expect(newContent.length).toEqual(5);
+    expect(newContent[0]!.header).toBeDefined();
+    expect(newContent[1]!.new[node.currentSessionID]!.lastSignature).toEqual(
+        sessionEntry.signatureAfter[3],
+    );
+    expect(newContent[2]!.new[node.currentSessionID]!.lastSignature).toEqual(
+        sessionEntry.signatureAfter[6],
+    );
+    expect(newContent[3]!.new[node.currentSessionID]!.lastSignature).toEqual(
+        sessionEntry.signatureAfter[9],
+    );
+    expect(newContent[4]!.new[node.currentSessionID]!.lastSignature).toEqual(
+        sessionEntry.lastSignature,
+    );
+});
+
+test("When adding large transactions (bigger than MAX_RECOMMENDED_TX_SIZE), we store an inbetween signature after every large transaction and split up newContentSince accordingly", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "costream",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: { type: "binary" },
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (
+        content.type !== "costream" ||
+        content.headerMeta?.type !== "binary" ||
+        !(content instanceof RawBinaryCoStream)
+    ) {
+        throw new Error("Expected binary stream");
+    }
+
+    content.startBinaryStream(
+        { mimeType: "text/plain", fileName: "test.txt" },
+        "trusting",
+    );
+
+    const chunk = new Uint8Array(MAX_RECOMMENDED_TX_SIZE + 100);
+
+    for (let i = 0; i < 3; i++) {
+        content.pushBinaryStreamChunk(chunk, "trusting");
+    }
+
+    content.endBinaryStream("trusting");
+
+    const sessionEntry = coValue.sessionLogs.get(node.currentSessionID)!;
+    expect(sessionEntry.transactions.length).toEqual(5);
+    expect(sessionEntry.signatureAfter[0]).not.toBeDefined();
+    expect(sessionEntry.signatureAfter[1]).toBeDefined();
+    expect(sessionEntry.signatureAfter[2]).toBeDefined();
+    expect(sessionEntry.signatureAfter[3]).toBeDefined();
+    expect(sessionEntry.signatureAfter[4]).not.toBeDefined();
+
+    const newContent = coValue.newContentSince({
+        id: coValue.id,
+        header: false,
+        sessions: {},
+    })!;
+
+    expect(newContent.length).toEqual(5);
+    expect(newContent[0]!.header).toBeDefined();
+    expect(newContent[1]!.new[node.currentSessionID]!.lastSignature).toEqual(
+        sessionEntry.signatureAfter[1],
+    );
+    expect(newContent[2]!.new[node.currentSessionID]!.lastSignature).toEqual(
+        sessionEntry.signatureAfter[2],
+    );
+    expect(newContent[3]!.new[node.currentSessionID]!.lastSignature).toEqual(
+        sessionEntry.signatureAfter[3],
+    );
+    expect(newContent[4]!.new[node.currentSessionID]!.lastSignature).toEqual(
+        sessionEntry.lastSignature,
+    );
+});

package/src/tests/coValueCore.test.ts

@@ -1,32 +1,23 @@
-import { expect, test, beforeEach } from "vitest";
+import { expect, test, vi } from "vitest";
 import { Transaction } from "../coValueCore.js";
 import { LocalNode } from "../localNode.js";
-import { createdNowUnique, getAgentSignerSecret, newRandomAgentSecret, sign } from "../crypto.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
 import { MapOpPayload } from "../coValues/coMap.js";
 import { Role } from "../permissions.js";
-import { cojsonReady } from "../index.js";
 import { stableStringify } from "../jsonStringify.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.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 coValue with new agent credentials and add transaction to it", () => {
     const [account, sessionID] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(account, sessionID);
+    const node = new LocalNode(account, sessionID, Crypto);
 
     const coValue = node.createCoValue({
         type: "costream",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique(),
+        ...Crypto.createdNowUnique(),
     });
 
     const transaction: Transaction = {
@@ -41,7 +32,7 @@ test("Can create coValue with new agent credentials and add transaction to it",
 
     const { expectedNewHash } = coValue.expectedNewHashAfter(
         node.currentSessionID,
-        [transaction]
+        [transaction],
     );
 
     expect(
@@ -49,21 +40,21 @@ test("Can create coValue with new agent credentials and add transaction to it",
             node.currentSessionID,
             [transaction],
             expectedNewHash,
-            sign(account.currentSignerSecret(), expectedNewHash)
-        )
+            Crypto.sign(account.currentSignerSecret(), expectedNewHash),
+        ),
     ).toBe(true);
 });
 
 test("transactions with wrong signature are rejected", () => {
-    const wrongAgent = newRandomAgentSecret();
+    const wrongAgent = Crypto.newRandomAgentSecret();
     const [agentSecret, sessionID] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(agentSecret, sessionID);
+    const node = new LocalNode(agentSecret, sessionID, Crypto);
 
     const coValue = node.createCoValue({
         type: "costream",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique(),
+        ...Crypto.createdNowUnique(),
     });
 
     const transaction: Transaction = {
@@ -78,7 +69,7 @@ test("transactions with wrong signature are rejected", () => {
 
     const { expectedNewHash } = coValue.expectedNewHashAfter(
         node.currentSessionID,
-        [transaction]
+        [transaction],
     );
 
     expect(
@@ -86,20 +77,23 @@ test("transactions with wrong signature are rejected", () => {
             node.currentSessionID,
             [transaction],
             expectedNewHash,
-            sign(getAgentSignerSecret(wrongAgent), expectedNewHash)
-        )
+            Crypto.sign(
+                Crypto.getAgentSignerSecret(wrongAgent),
+                expectedNewHash,
+            ),
+        ),
     ).toBe(false);
 });
 
 test("transactions with correctly signed, but wrong hash are rejected", () => {
     const [account, sessionID] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(account, sessionID);
+    const node = new LocalNode(account, sessionID, Crypto);
 
     const coValue = node.createCoValue({
         type: "costream",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique(),
+        ...Crypto.createdNowUnique(),
     });
 
     const transaction: Transaction = {
@@ -124,7 +118,7 @@ test("transactions with correctly signed, but wrong hash are rejected", () => {
                     },
                 ]),
             },
-        ]
+        ],
     );
 
     expect(
@@ -132,14 +126,14 @@ test("transactions with correctly signed, but wrong hash are rejected", () => {
             node.currentSessionID,
             [transaction],
             expectedNewHash,
-            sign(account.currentSignerSecret(), expectedNewHash)
-        )
+            Crypto.sign(account.currentSignerSecret(), expectedNewHash),
+        ),
     ).toBe(false);
 });
 
 test("New transactions in a group correctly update owned values, including subscriptions", async () => {
     const [account, sessionID] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(account, sessionID);
+    const node = new LocalNode(account, sessionID, Crypto);
 
     const group = node.createGroup();
 
@@ -147,11 +141,11 @@ test("New transactions in a group correctly update owned values, including subsc
 
     await new Promise((resolve) => setTimeout(resolve, 10));
 
-    let map = group.createMap();
+    const map = group.createMap();
 
     map.set("hello", "world");
 
-    const listener = jest.fn().mockImplementation();
+    const listener = vi.fn();
 
     map.subscribe(listener);
 
@@ -164,23 +158,28 @@ test("New transactions in a group correctly update owned values, including subsc
             {
                 op: "set",
                 key: account.id,
-                value: "revoked"
-            } satisfies MapOpPayload<typeof account.id, Role>
-        ])
+                value: "revoked",
+            } satisfies MapOpPayload<typeof account.id, Role>,
+        ]),
     } satisfies Transaction;
 
     const { expectedNewHash } = group.core.expectedNewHashAfter(sessionID, [
         resignationThatWeJustLearnedAbout,
     ]);
 
-    const signature = sign(
+    const signature = Crypto.sign(
         node.account.currentSignerSecret(),
-        expectedNewHash
+        expectedNewHash,
     );
 
     expect(map.core.getValidSortedTransactions().length).toBe(1);
 
-    const manuallyAdddedTxSuccess = group.core.tryAddTransactions(node.currentSessionID, [resignationThatWeJustLearnedAbout], expectedNewHash, signature);
+    const manuallyAdddedTxSuccess = group.core.tryAddTransactions(
+        node.currentSessionID,
+        [resignationThatWeJustLearnedAbout],
+        expectedNewHash,
+        signature,
+    );
 
     expect(manuallyAdddedTxSuccess).toBe(true);
 

package/src/tests/crypto.test.ts

@@ -1,93 +1,84 @@
-import { expect, test, beforeEach } from "vitest";
-import {
-    getSealerID,
-    getSignerID,
-    secureHash,
-    newRandomSealer,
-    newRandomSigner,
-    seal,
-    sign,
-    unseal,
-    verify,
-    shortHash,
-    newRandomKeySecret,
-    encryptForTransaction,
-    decryptForTransaction,
-    encryptKeySecret,
-    decryptKeySecret,
-} from "../crypto.js";
+import { expect, test } from "vitest";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
 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";
 import { SessionID } from "../ids.js";
-import { cojsonReady } from "../index.js";
+import { stableStringify } from "../jsonStringify.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("Signatures round-trip and use stable stringify", () => {
     const data = { b: "world", a: "hello" };
-    const signer = newRandomSigner();
-    const signature = sign(signer, data);
+    const signer = Crypto.newRandomSigner();
+    const signature = Crypto.sign(signer, data);
 
     expect(signature).toMatch(/^signature_z/);
     expect(
-        verify(signature, { a: "hello", b: "world" }, getSignerID(signer))
+        Crypto.verify(
+            signature,
+            { a: "hello", b: "world" },
+            Crypto.getSignerID(signer),
+        ),
     ).toBe(true);
 });
 
 test("Invalid signatures don't verify", () => {
     const data = { b: "world", a: "hello" };
-    const signer = newRandomSigner();
-    const signer2 = newRandomSigner();
-    const wrongSignature = sign(signer2, data);
+    const signer = Crypto.newRandomSigner();
+    const signer2 = Crypto.newRandomSigner();
+    const wrongSignature = Crypto.sign(signer2, data);
 
-    expect(verify(wrongSignature, data, getSignerID(signer))).toBe(false);
+    expect(
+        Crypto.verify(wrongSignature, data, Crypto.getSignerID(signer)),
+    ).toBe(false);
 });
 
 test("encrypting round-trips, but invalid receiver can't unseal", () => {
     const data = { b: "world", a: "hello" };
-    const sender = newRandomSealer();
-    const sealer = newRandomSealer();
-    const wrongSealer = newRandomSealer();
+    const sender = Crypto.newRandomSealer();
+    const sealer = Crypto.newRandomSealer();
+    const wrongSealer = Crypto.newRandomSealer();
 
     const nOnceMaterial = {
         in: "co_zTEST",
         tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 0 },
     } as const;
 
-    const sealed = seal({
+    const sealed = Crypto.seal({
         message: data,
         from: sender,
-        to: getSealerID(sealer),
+        to: Crypto.getSealerID(sealer),
         nOnceMaterial,
     });
 
-    expect(unseal(sealed, sealer, getSealerID(sender), nOnceMaterial)).toEqual(
-        data
-    );
+    expect(
+        Crypto.unseal(
+            sealed,
+            sealer,
+            Crypto.getSealerID(sender),
+            nOnceMaterial,
+        ),
+    ).toEqual(data);
     expect(() =>
-        unseal(sealed, wrongSealer, getSealerID(sender), nOnceMaterial)
+        Crypto.unseal(
+            sealed,
+            wrongSealer,
+            Crypto.getSealerID(sender),
+            nOnceMaterial,
+        ),
     ).toThrow(/Wrong tag/);
 
     // trying with wrong sealer secret, by hand
     const nOnce = blake3(
-        new TextEncoder().encode(stableStringify(nOnceMaterial))
+        new TextEncoder().encode(stableStringify(nOnceMaterial)),
     ).slice(0, 24);
     const sealer3priv = base58.decode(
-        wrongSealer.substring("sealerSecret_z".length)
+        wrongSealer.substring("sealerSecret_z".length),
     );
     const senderPub = base58.decode(
-        getSealerID(sender).substring("sealer_z".length)
+        Crypto.getSealerID(sender).substring("sealer_z".length),
     );
     const sealedBytes = base64url.decode(sealed.substring("sealed_U".length));
     const sharedSecret = x25519.getSharedSecret(sealer3priv, senderPub);
@@ -98,34 +89,34 @@ test("encrypting round-trips, but invalid receiver can't unseal", () => {
 });
 
 test("Hashing is deterministic", () => {
-    expect(secureHash({ b: "world", a: "hello" })).toEqual(
-        secureHash({ a: "hello", b: "world" })
+    expect(Crypto.secureHash({ b: "world", a: "hello" })).toEqual(
+        Crypto.secureHash({ a: "hello", b: "world" }),
     );
 
-    expect(shortHash({ b: "world", a: "hello" })).toEqual(
-        shortHash({ a: "hello", b: "world" })
+    expect(Crypto.shortHash({ b: "world", a: "hello" })).toEqual(
+        Crypto.shortHash({ a: "hello", b: "world" }),
     );
 });
 
 test("Encryption for transactions round-trips", () => {
-    const { secret } = newRandomKeySecret();
+    const { secret } = Crypto.newRandomKeySecret();
 
-    const encrypted1 = encryptForTransaction({ a: "hello" }, secret, {
+    const encrypted1 = Crypto.encryptForTransaction({ a: "hello" }, secret, {
         in: "co_zTEST",
         tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 0 },
     });
 
-    const encrypted2 = encryptForTransaction({ b: "world" }, secret, {
+    const encrypted2 = Crypto.encryptForTransaction({ b: "world" }, secret, {
         in: "co_zTEST",
         tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 1 },
     });
 
-    const decrypted1 = decryptForTransaction(encrypted1, secret, {
+    const decrypted1 = Crypto.decryptForTransaction(encrypted1, secret, {
         in: "co_zTEST",
         tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 0 },
     });
 
-    const decrypted2 = decryptForTransaction(encrypted2, secret, {
+    const decrypted2 = Crypto.decryptForTransaction(encrypted2, secret, {
         in: "co_zTEST",
         tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 1 },
     });
@@ -134,25 +125,25 @@ test("Encryption for transactions round-trips", () => {
 });
 
 test("Encryption for transactions doesn't decrypt with a wrong key", () => {
-    const { secret } = newRandomKeySecret();
-    const { secret: secret2 } = newRandomKeySecret();
+    const { secret } = Crypto.newRandomKeySecret();
+    const { secret: secret2 } = Crypto.newRandomKeySecret();
 
-    const encrypted1 = encryptForTransaction({ a: "hello" }, secret, {
+    const encrypted1 = Crypto.encryptForTransaction({ a: "hello" }, secret, {
         in: "co_zTEST",
         tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 0 },
     });
 
-    const encrypted2 = encryptForTransaction({ b: "world" }, secret, {
+    const encrypted2 = Crypto.encryptForTransaction({ b: "world" }, secret, {
         in: "co_zTEST",
         tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 1 },
     });
 
-    const decrypted1 = decryptForTransaction(encrypted1, secret2, {
+    const decrypted1 = Crypto.decryptForTransaction(encrypted1, secret2, {
         in: "co_zTEST",
         tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 0 },
     });
 
-    const decrypted2 = decryptForTransaction(encrypted2, secret2, {
+    const decrypted2 = Crypto.decryptForTransaction(encrypted2, secret2, {
         in: "co_zTEST",
         tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 1 },
     });
@@ -161,34 +152,37 @@ test("Encryption for transactions doesn't decrypt with a wrong key", () => {
 });
 
 test("Encryption of keySecrets round-trips", () => {
-    const toEncrypt = newRandomKeySecret();
-    const encrypting = newRandomKeySecret();
+    const toEncrypt = Crypto.newRandomKeySecret();
+    const encrypting = Crypto.newRandomKeySecret();
 
     const keys = {
         toEncrypt,
         encrypting,
     };
 
-    const encrypted = encryptKeySecret(keys);
+    const encrypted = Crypto.encryptKeySecret(keys);
 
-    const decrypted = decryptKeySecret(encrypted, encrypting.secret);
+    const decrypted = Crypto.decryptKeySecret(encrypted, encrypting.secret);
 
     expect(decrypted).toEqual(toEncrypt.secret);
 });
 
 test("Encryption of keySecrets doesn't decrypt with a wrong key", () => {
-    const toEncrypt = newRandomKeySecret();
-    const encrypting = newRandomKeySecret();
-    const encryptingWrong = newRandomKeySecret();
+    const toEncrypt = Crypto.newRandomKeySecret();
+    const encrypting = Crypto.newRandomKeySecret();
+    const encryptingWrong = Crypto.newRandomKeySecret();
 
     const keys = {
         toEncrypt,
         encrypting,
     };
 
-    const encrypted = encryptKeySecret(keys);
+    const encrypted = Crypto.encryptKeySecret(keys);
 
-    const decrypted = decryptKeySecret(encrypted, encryptingWrong.secret);
+    const decrypted = Crypto.decryptKeySecret(
+        encrypted,
+        encryptingWrong.secret,
+    );
 
     expect(decrypted).toBeUndefined();
 });