cojson 0.0.11 → 0.0.13

package/src/contentType.test.ts

@@ -1,25 +1,16 @@
-import {
-    agentIDfromSessionID,
-    getAgent,
-    getAgentID,
-    newRandomAgentCredential,
-    newRandomSessionID,
-} from './coValue.js';
+import { accountOrAgentIDfromSessionID } from "./coValue.js";
 import { createdNowUnique } from "./crypto.js";
 import { LocalNode } from "./node.js";
+import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
 
 test("Empty COJSON Map works", () => {
-    const agentCredential = newRandomAgentCredential("agent1");
-    const node = new LocalNode(
-        agentCredential,
-        newRandomSessionID(getAgentID(getAgent(agentCredential)))
-    );
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
         type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique()
+        ...createdNowUnique(),
     });
 
     const content = coValue.getCurrentContent();
@@ -34,17 +25,13 @@ test("Empty COJSON Map works", () => {
 });
 
 test("Can insert and delete Map entries in edit()", () => {
-    const agentCredential = newRandomAgentCredential("agent1");
-    const node = new LocalNode(
-        agentCredential,
-        newRandomSessionID(getAgentID(getAgent(agentCredential)))
-    );
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
         type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique()
+        ...createdNowUnique(),
     });
 
     const content = coValue.getCurrentContent();
@@ -67,17 +54,13 @@ test("Can insert and delete Map entries in edit()", () => {
 });
 
 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 node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
         type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique()
+        ...createdNowUnique(),
     });
 
     const content = coValue.getCurrentContent();
@@ -90,13 +73,13 @@ test("Can get map entry values at different points in time", () => {
 
     content.edit((editable) => {
         const beforeA = Date.now();
-        while(Date.now() < beforeA + 10){}
+        while (Date.now() < beforeA + 10) {}
         editable.set("hello", "A", "trusting");
         const beforeB = Date.now();
-        while(Date.now() < beforeB + 10){}
+        while (Date.now() < beforeB + 10) {}
         editable.set("hello", "B", "trusting");
         const beforeC = Date.now();
-        while(Date.now() < beforeC + 10){}
+        while (Date.now() < beforeC + 10) {}
         editable.set("hello", "C", "trusting");
         expect(editable.get("hello")).toEqual("C");
         expect(editable.getAtTime("hello", Date.now())).toEqual("C");
@@ -107,17 +90,13 @@ test("Can get map entry values at different points in time", () => {
 });
 
 test("Can get all historic values of key", () => {
-    const agentCredential = newRandomAgentCredential("agent1");
-    const node = new LocalNode(
-        agentCredential,
-        newRandomSessionID(getAgentID(getAgent(agentCredential)))
-    );
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
         type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique()
+        ...createdNowUnique(),
     });
 
     const content = coValue.getCurrentContent();
@@ -137,9 +116,7 @@ test("Can get all historic values of key", () => {
         const txDel = editable.getLastTxID("hello");
         editable.set("hello", "C", "trusting");
         const txC = editable.getLastTxID("hello");
-        expect(
-            editable.getHistory("hello")
-        ).toEqual([
+        expect(editable.getHistory("hello")).toEqual([
             {
                 txID: txA,
                 value: "A",
@@ -165,17 +142,13 @@ test("Can get all historic values of key", () => {
 });
 
 test("Can get last tx ID for a key", () => {
-    const agentCredential = newRandomAgentCredential("agent1");
-    const node = new LocalNode(
-        agentCredential,
-        newRandomSessionID(getAgentID(getAgent(agentCredential)))
-    );
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
         type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique()
+        ...createdNowUnique(),
     });
 
     const content = coValue.getCurrentContent();
@@ -190,8 +163,8 @@ test("Can get last tx ID for a key", () => {
         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(sessionID && accountOrAgentIDfromSessionID(sessionID)).toEqual(
+            node.account.id
         );
         expect(editable.getLastTxID("hello")?.txIndex).toEqual(0);
         editable.set("hello", "B", "trusting");

package/src/contentType.ts

@@ -1,24 +1,26 @@
-import { JsonValue } from './jsonValue.js';
-import { RawCoValueID } from './ids.js';
-import { CoMap } from './contentTypes/coMap.js';
-import { CoStream } from './contentTypes/coStream.js';
-import { Static } from './contentTypes/static.js';
-import { CoList } from './contentTypes/coList.js';
+import { JsonObject, JsonValue } from "./jsonValue.js";
+import { RawCoID } from "./ids.js";
+import { CoMap } from "./contentTypes/coMap.js";
+import { CoStream } from "./contentTypes/coStream.js";
+import { Static } from "./contentTypes/static.js";
+import { CoList } from "./contentTypes/coList.js";
 
-export type CoValueID<T extends ContentType> = RawCoValueID & {
+export type CoID<T extends ContentType> = RawCoID & {
     readonly __type: T;
 };
 
 export type ContentType =
-    | CoMap<{[key: string]: JsonValue}, JsonValue>
-    | CoList<JsonValue, JsonValue>
-    | CoStream<JsonValue, JsonValue>
-    | Static<JsonValue>;
+    | CoMap<{ [key: string]: JsonValue }, JsonObject | null>
+    | CoList<JsonValue, JsonObject | null>
+    | CoStream<JsonValue, JsonObject | null>
+    | Static<JsonObject>;
 
-export function expectMap(content: ContentType): CoMap<{ [key: string]: string }, {}> {
+export function expectMap(
+    content: ContentType
+): CoMap<{ [key: string]: string }, JsonObject | null> {
     if (content.type !== "comap") {
         throw new Error("Expected map");
     }
 
-    return content as CoMap<{ [key: string]: string }, {}>;
+    return content as CoMap<{ [key: string]: string }, JsonObject | null>;
 }

package/src/contentTypes/coList.ts

@@ -1,14 +1,14 @@
 import { JsonObject, JsonValue } from '../jsonValue.js';
-import { CoValueID } from '../contentType.js';
+import { CoID } from '../contentType.js';
 import { CoValue } from '../coValue.js';
 
-export class CoList<T extends JsonValue, Meta extends JsonValue> {
-    id: CoValueID<CoList<T, Meta>>;
+export class CoList<T extends JsonValue, Meta extends JsonObject | null = null> {
+    id: CoID<CoList<T, Meta>>;
     type = "colist" as const;
     coValue: CoValue;
 
     constructor(coValue: CoValue) {
-        this.id = coValue.id as CoValueID<CoList<T, Meta>>;
+        this.id = coValue.id as CoID<CoList<T, Meta>>;
         this.coValue = coValue;
     }
 

package/src/contentTypes/coMap.ts

@@ -1,7 +1,8 @@
 import { JsonObject, JsonValue } from '../jsonValue.js';
 import { TransactionID } from '../ids.js';
-import { CoValueID } from '../contentType.js';
-import { CoValue } from '../coValue.js';
+import { CoID } from '../contentType.js';
+import { CoValue, accountOrAgentIDfromSessionID } from '../coValue.js';
+import { AccountID, isAccountID } from '../account.js';
 
 type MapOp<K extends string, V extends JsonValue> = {
     txID: TransactionID;
@@ -20,24 +21,25 @@ export type MapOpPayload<K extends string, V extends JsonValue> = {
     key: K;
 };
 
+export type MapK<M extends { [key: string]: JsonValue; }> = keyof M & string;
+export type MapV<M extends { [key: string]: JsonValue; }> = M[MapK<M>];
+export type MapM<M extends { [key: string]: JsonValue; }> = {
+    [KK in MapK<M>]: M[KK];
+}
+
 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];
-    }
+    Meta extends JsonObject | null = null,
 > {
-    id: CoValueID<CoMap<MM, Meta>>;
+    id: CoID<CoMap<MapM<M>, Meta>>;
     coValue: CoValue;
     type = "comap" as const;
     ops: {
-        [KK in K]?: MapOp<K, M[KK]>[];
+        [KK in MapK<M>]?: MapOp<KK, M[KK]>[];
     };
 
     constructor(coValue: CoValue) {
-        this.id = coValue.id as CoValueID<CoMap<MM, Meta>>;
+        this.id = coValue.id as CoID<CoMap<MapM<M>, Meta>>;
         this.coValue = coValue;
         this.ops = {};
 
@@ -51,7 +53,7 @@ export class CoMap<
             for (const [changeIdx, changeUntyped] of (
                 changes
             ).entries()) {
-                const change = changeUntyped as MapOpPayload<K, V>;
+                const change = changeUntyped as MapOpPayload<MapK<M>, MapV<M>>;
                 let entries = this.ops[change.key];
                 if (!entries) {
                     entries = [];
@@ -61,17 +63,17 @@ export class CoMap<
                     txID,
                     madeAt,
                     changeIdx,
-                    ...(change as MapOpPayload<K, M[K]>),
+                    ...(change as MapOpPayload<MapK<M>, MapV<M>>),
                 });
             }
         }
     }
 
-    keys(): K[] {
-        return Object.keys(this.ops) as K[];
+    keys(): MapK<M>[] {
+        return Object.keys(this.ops) as MapK<M>[];
     }
 
-    get<KK extends K>(key: KK): M[KK] | undefined {
+    get<K extends MapK<M>>(key: K): M[K] | undefined {
         const ops = this.ops[key];
         if (!ops) {
             return undefined;
@@ -86,7 +88,7 @@ export class CoMap<
         }
     }
 
-    getAtTime<KK extends K>(key: KK, time: number): M[KK] | undefined {
+    getAtTime<K extends MapK<M>>(key: K, time: number): M[K] | undefined {
         const ops = this.ops[key];
         if (!ops) {
             return undefined;
@@ -105,7 +107,20 @@ export class CoMap<
         }
     }
 
-    getLastTxID<KK extends K>(key: KK): TransactionID | undefined {
+    getLastEditor<K extends MapK<M>>(key: K): AccountID | undefined {
+        const tx  = this.getLastTxID(key);
+        if (!tx) {
+            return undefined;
+        }
+        const accountID = accountOrAgentIDfromSessionID(tx.sessionID);
+        if (isAccountID(accountID)) {
+            return accountID;
+        } else {
+            return undefined;
+        }
+    }
+
+    getLastTxID<K extends MapK<M>>(key: K): TransactionID | undefined {
         const ops = this.ops[key];
         if (!ops) {
             return undefined;
@@ -116,13 +131,28 @@ export class CoMap<
         return lastEntry.txID;
     }
 
-    getHistory<KK extends K>(key: KK): { at: number; txID: TransactionID; value: M[KK] | undefined; }[] {
+    getLastEntry<K extends MapK<M>>(key: K): { at: number; txID: TransactionID; value: M[K]; } | undefined {
+        const ops = this.ops[key];
+        if (!ops) {
+            return undefined;
+        }
+
+        const lastEntry = ops[ops.length - 1]!;
+
+        if (lastEntry.op === "delete") {
+            return undefined;
+        } else {
+            return { at: lastEntry.madeAt, txID: lastEntry.txID, value: lastEntry.value };
+        }
+    }
+
+    getHistory<K extends MapK<M>>(key: K): { at: number; txID: TransactionID; value: M[K] | undefined; }[] {
         const ops = this.ops[key];
         if (!ops) {
             return [];
         }
 
-        const history: { at: number; txID: TransactionID; value: M[KK] | undefined; }[] = [];
+        const history: { at: number; txID: TransactionID; value: M[K] | undefined; }[] = [];
 
         for (const op of ops) {
             if (op.op === "delete") {
@@ -163,14 +193,10 @@ export class CoMap<
 
 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 {
+    Meta extends JsonObject | null = null,
+
+> extends CoMap<M, Meta> {
+    set<K extends MapK<M>>(key: K, value: M[K], privacy: "private" | "trusting" = "private"): void {
         this.coValue.makeTransaction([
             {
                 op: "insert",
@@ -182,7 +208,7 @@ export class WriteableCoMap<
         this.fillOpsFromCoValue();
     }
 
-    delete(key: K, privacy: "private" | "trusting" = "private"): void {
+    delete(key: MapK<M>, privacy: "private" | "trusting" = "private"): void {
         this.coValue.makeTransaction([
             {
                 op: "delete",

package/src/contentTypes/coStream.ts

@@ -1,14 +1,14 @@
 import { JsonObject, JsonValue } from '../jsonValue.js';
-import { CoValueID } from '../contentType.js';
+import { CoID } from '../contentType.js';
 import { CoValue } from '../coValue.js';
 
-export class CoStream<T extends JsonValue, Meta extends JsonValue> {
-    id: CoValueID<CoStream<T, Meta>>;
+export class CoStream<T extends JsonValue, Meta extends JsonObject | null = null> {
+    id: CoID<CoStream<T, Meta>>;
     type = "costream" as const;
     coValue: CoValue;
 
     constructor(coValue: CoValue) {
-        this.id = coValue.id as CoValueID<CoStream<T, Meta>>;
+        this.id = coValue.id as CoID<CoStream<T, Meta>>;
         this.coValue = coValue;
     }
 

package/src/contentTypes/static.ts

@@ -1,14 +1,14 @@
-import { JsonObject, JsonValue } from '../jsonValue.js';
-import { CoValueID } from '../contentType.js';
+import { JsonObject } from '../jsonValue.js';
+import { CoID } from '../contentType.js';
 import { CoValue } from '../coValue.js';
 
-export class Static<T extends JsonValue> {
-    id: CoValueID<Static<T>>;
+export class Static<T extends JsonObject> {
+    id: CoID<Static<T>>;
     type = "static" as const;
     coValue: CoValue;
 
     constructor(coValue: CoValue) {
-        this.id = coValue.id as CoValueID<Static<T>>;
+        this.id = coValue.id as CoID<Static<T>>;
         this.coValue = coValue;
     }
 

package/src/crypto.test.ts

@@ -1,19 +1,19 @@
 import {
-    getRecipientID,
-    getSignatoryID,
+    getSealerID,
+    getSignerID,
     secureHash,
-    newRandomRecipient,
-    newRandomSignatory,
+    newRandomSealer,
+    newRandomSigner,
     seal,
     sign,
-    openAs,
+    unseal,
     verify,
     shortHash,
     newRandomKeySecret,
     encryptForTransaction,
     decryptForTransaction,
-    sealKeySecret,
-    unsealKeySecret,
+    encryptKeySecret,
+    decryptKeySecret,
 } from './crypto.js';
 import { base58, base64url } from "@scure/base";
 import { x25519 } from "@noble/curves/ed25519";
@@ -23,69 +23,63 @@ 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);
+    const signer = newRandomSigner();
+    const signature = sign(signer, data);
 
     expect(signature).toMatch(/^signature_z/);
     expect(
-        verify(signature, { a: "hello", b: "world" }, getSignatoryID(signatory))
+        verify(signature, { a: "hello", b: "world" }, getSignerID(signer))
     ).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);
+    const signer = newRandomSigner();
+    const signer2 = newRandomSigner();
+    const wrongSignature = sign(signer2, data);
 
-    expect(verify(wrongSignature, data, getSignatoryID(signatory))).toBe(false);
+    expect(verify(wrongSignature, data, getSignerID(signer))).toBe(false);
 });
 
-test("Sealing round-trips, but invalid receiver can't unseal", () => {
+test("encrypting 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 sender = newRandomSealer();
+    const sealer = newRandomSealer();
+    const wrongSealer = newRandomSealer();
 
     const nOnceMaterial = {
         in: "co_zTEST",
-        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 0 },
+        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 0 },
     } as const;
 
     const sealed = seal(
         data,
         sender,
-        new Set([getRecipientID(recipient1), getRecipientID(recipient2)]),
+        getSealerID(sealer),
         nOnceMaterial
     );
 
-    expect(sealed[getRecipientID(recipient1)]).toMatch(/^sealed_U/);
-    expect(sealed[getRecipientID(recipient2)]).toMatch(/^sealed_U/);
     expect(
-        openAs(sealed, recipient1, getRecipientID(sender), nOnceMaterial)
+        unseal(sealed, sealer, getSealerID(sender), nOnceMaterial)
     ).toEqual(data);
     expect(
-        openAs(sealed, recipient2, getRecipientID(sender), nOnceMaterial)
-    ).toEqual(data);
-    expect(
-        openAs(sealed, recipient3, getRecipientID(sender), nOnceMaterial)
-    ).toBeUndefined();
+        () => unseal(sealed, wrongSealer, getSealerID(sender), nOnceMaterial)
+    ).toThrow(/Wrong tag/);
 
-    // trying with wrong recipient secret, by hand
+    // trying with wrong sealer secret, by hand
     const nOnce = blake3(
         new TextEncoder().encode(stableStringify(nOnceMaterial))
     ).slice(0, 24);
-    const recipient3priv = base58.decode(
-        recipient3.substring("recipientSecret_z".length)
+    const sealer3priv = base58.decode(
+        wrongSealer.substring("sealerSecret_z".length)
     );
     const senderPub = base58.decode(
-        getRecipientID(sender).substring("recipient_z".length)
+        getSealerID(sender).substring("sealer_z".length)
     );
     const sealedBytes = base64url.decode(
-        sealed[getRecipientID(recipient1)]!.substring("sealed_U".length)
+        sealed.substring("sealed_U".length)
     );
-    const sharedSecret = x25519.getSharedSecret(recipient3priv, senderPub);
+    const sharedSecret = x25519.getSharedSecret(sealer3priv, senderPub);
 
     expect(() => {
         const _ = xsalsa20_poly1305(sharedSecret, nOnce).decrypt(sealedBytes);
@@ -107,22 +101,22 @@ test("Encryption for transactions round-trips", () => {
 
     const encrypted1 =  encryptForTransaction({ a: "hello" }, secret, {
         in: "co_zTEST",
-        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 0 },
+        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 0 },
     });
 
     const encrypted2 = encryptForTransaction({ b: "world" }, secret, {
         in: "co_zTEST",
-        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 1 },
+        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 1 },
     });
 
     const decrypted1 = decryptForTransaction(encrypted1, secret, {
         in: "co_zTEST",
-        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 0 },
+        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 0 },
     });
 
     const decrypted2 =  decryptForTransaction(encrypted2, secret, {
         in: "co_zTEST",
-        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 1 },
+        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 1 },
     });
 
     expect([decrypted1, decrypted2]).toEqual([{ a: "hello" }, { b: "world" }]);
@@ -134,56 +128,56 @@ test("Encryption for transactions doesn't decrypt with a wrong key", () => {
 
     const encrypted1 =  encryptForTransaction({ a: "hello" }, secret, {
         in: "co_zTEST",
-        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 0 },
+        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 0 },
     });
 
     const encrypted2 = encryptForTransaction({ b: "world" }, secret, {
         in: "co_zTEST",
-        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 1 },
+        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 1 },
     });
 
     const decrypted1 = decryptForTransaction(encrypted1, secret2, {
         in: "co_zTEST",
-        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 0 },
+        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 0 },
     });
 
     const decrypted2 =  decryptForTransaction(encrypted2, secret2, {
         in: "co_zTEST",
-        tx: { sessionID: "co_agent_zTEST_session_zTEST", txIndex: 1 },
+        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 1 },
     });
 
     expect([decrypted1, decrypted2]).toEqual([undefined, undefined]);
 });
 
 test("Encryption of keySecrets round-trips", () => {
-    const toSeal = newRandomKeySecret();
-    const sealing = newRandomKeySecret();
+    const toEncrypt = newRandomKeySecret();
+    const encrypting = newRandomKeySecret();
 
     const keys = {
-        toSeal,
-        sealing,
+        toEncrypt,
+        encrypting,
     };
 
-    const sealed = sealKeySecret(keys);
+    const encrypted = encryptKeySecret(keys);
 
-    const unsealed = unsealKeySecret(sealed, sealing.secret);
+    const decrypted = decryptKeySecret(encrypted, encrypting.secret);
 
-    expect(unsealed).toEqual(toSeal.secret);
+    expect(decrypted).toEqual(toEncrypt.secret);
 });
 
-test("Encryption of keySecrets doesn't unseal with a wrong key", () => {
-    const toSeal = newRandomKeySecret();
-    const sealing = newRandomKeySecret();
-    const sealingWrong = newRandomKeySecret();
+test("Encryption of keySecrets doesn't decrypt with a wrong key", () => {
+    const toEncrypt = newRandomKeySecret();
+    const encrypting = newRandomKeySecret();
+    const encryptingWrong = newRandomKeySecret();
 
     const keys = {
-        toSeal,
-        sealing,
+        toEncrypt,
+        encrypting,
     };
 
-    const sealed = sealKeySecret(keys);
+    const encrypted = encryptKeySecret(keys);
 
-    const unsealed = unsealKeySecret(sealed, sealingWrong.secret);
+    const decrypted = decryptKeySecret(encrypted, encryptingWrong.secret);
 
-    expect(unsealed).toBeUndefined();
+    expect(decrypted).toBeUndefined();
 });