cojson 0.18.19 → 0.18.20

package/dist/tests/permissions.test.js

@@ -11,45 +11,45 @@ test("Initial admin can add another admin to a group", () => {
 test("Initial admin can add another admin to a group (high level)", () => {
     groupWithTwoAdminsHighLevel();
 });
-test("Added admin can add a third admin to a group", () => {
+test("Added admin can add a third admin to a group", async () => {
     const { groupCore, otherAdmin, node } = groupWithTwoAdmins();
-    const groupAsOtherAdmin = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(otherAdmin));
+    const groupAsOtherAdmin = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(otherAdmin));
     expect(groupAsOtherAdmin.get(otherAdmin.id)).toEqual("admin");
     const thirdAdmin = createAccountInNode(groupAsOtherAdmin.core.node);
     groupAsOtherAdmin.set(thirdAdmin.id, "admin", "trusting");
     expect(groupAsOtherAdmin.get(thirdAdmin.id)).toEqual("admin");
 });
-test("Added adming can add a third admin to a group (high level)", () => {
+test("Added adming can add a third admin to a group (high level)", async () => {
     const { group, otherAdmin } = groupWithTwoAdminsHighLevel();
-    const groupAsOtherAdmin = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(otherAdmin));
+    const groupAsOtherAdmin = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(otherAdmin));
     const thirdAdmin = createAccountInNode(groupAsOtherAdmin.core.node);
     groupAsOtherAdmin.addMember(thirdAdmin, "admin");
     expect(groupAsOtherAdmin.get(thirdAdmin.id)).toEqual("admin");
 });
-test("Admins can't demote other admins in a group", () => {
+test("Admins can't demote other admins in a group", async () => {
     const { groupCore, admin, otherAdmin } = groupWithTwoAdmins();
     const groupContent = expectGroup(groupCore.getCurrentContent());
     groupContent.set(otherAdmin.id, "writer", "trusting");
     expect(groupContent.get(otherAdmin.id)).toEqual("admin");
     expect(groupContent.get(otherAdmin.id)).toEqual("admin");
-    const groupAsOtherAdmin = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(otherAdmin));
+    const groupAsOtherAdmin = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(otherAdmin));
     groupAsOtherAdmin.set(admin.id, "writer", "trusting");
     expect(groupAsOtherAdmin.get(admin.id)).toEqual("admin");
 });
-test("Admins can't demote other admins in a group (high level)", () => {
+test("Admins can't demote other admins in a group (high level)", async () => {
     const { group, admin, otherAdmin } = groupWithTwoAdminsHighLevel();
-    const groupAsOtherAdmin = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(otherAdmin));
+    const groupAsOtherAdmin = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(otherAdmin));
     expect(() => groupAsOtherAdmin.addMemberInternal(admin.id, "writer")).toThrow("Administrators cannot demote other administrators in a group");
     expect(groupAsOtherAdmin.get(admin.id)).toEqual("admin");
 });
-test("Admins an add writers to a group, who can't add admins, writers, or readers", () => {
+test("Admins an add writers to a group, who can't add admins, writers, or readers", async () => {
     const { groupCore, node } = newGroup();
     const writer = createAccountInNode(node);
     const groupContent = expectGroup(groupCore.getCurrentContent());
     groupContent.set(writer.id, "writer", "trusting");
     expect(groupContent.get(writer.id)).toEqual("writer");
     expect(groupContent.get(writer.id)).toEqual("writer");
-    const groupAsWriter = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(writer));
+    const groupAsWriter = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(writer));
     expect(groupAsWriter.get(writer.id)).toEqual("writer");
     const otherAgent = createAccountInNode(node);
     groupAsWriter.set(otherAgent.id, "admin", "trusting");
@@ -59,12 +59,12 @@ test("Admins an add writers to a group, who can't add admins, writers, or reader
     groupAsWriter.set(otherAgent.id, "reader", "trusting");
     expect(groupAsWriter.get(otherAgent.id)).toBeUndefined();
 });
-test("Admins an add writers to a group, who can't add admins, writers, or readers (high level)", () => {
+test("Admins an add writers to a group, who can't add admins, writers, or readers (high level)", async () => {
     const { group, node } = newGroupHighLevel();
     const writer = createAccountInNode(node);
     group.addMember(writer, "writer");
     expect(group.get(writer.id)).toEqual("writer");
-    const groupAsWriter = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(writer));
+    const groupAsWriter = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(writer));
     expect(groupAsWriter.get(writer.id)).toEqual("writer");
     const otherAgent = createAccountInNode(groupAsWriter.core.node);
     expect(() => groupAsWriter.addMember(otherAgent, "admin")).toThrow("Failed to set role due to insufficient permissions (role of current account is writer)");
@@ -72,13 +72,13 @@ test("Admins an add writers to a group, who can't add admins, writers, or reader
     expect(() => groupAsWriter.addMember(otherAgent, "reader")).toThrow("Failed to set role due to insufficient permissions (role of current account is writer)");
     expect(groupAsWriter.get(otherAgent.id)).toBeUndefined();
 });
-test("Admins can add readers to a group, who can't add admins, writers, or readers", () => {
+test("Admins can add readers to a group, who can't add admins, writers, or readers", async () => {
     const { groupCore, node } = newGroup();
     const reader = createAccountInNode(node);
     const groupContent = expectGroup(groupCore.getCurrentContent());
     groupContent.set(reader.id, "reader", "trusting");
     expect(groupContent.get(reader.id)).toEqual("reader");
-    const groupAsReader = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(reader));
+    const groupAsReader = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(reader));
     expect(groupAsReader.get(reader.id)).toEqual("reader");
     const otherAgent = createAccountInNode(node);
     groupAsReader.set(otherAgent.id, "admin", "trusting");
@@ -88,12 +88,12 @@ test("Admins can add readers to a group, who can't add admins, writers, or reade
     groupAsReader.set(otherAgent.id, "reader", "trusting");
     expect(groupAsReader.get(otherAgent.id)).toBeUndefined();
 });
-test("Admins can add readers to a group, who can't add admins, writers, or readers (high level)", () => {
+test("Admins can add readers to a group, who can't add admins, writers, or readers (high level)", async () => {
     const { group, node } = newGroupHighLevel();
     const reader = createAccountInNode(node);
     group.addMember(reader, "reader");
     expect(group.get(reader.id)).toEqual("reader");
-    const groupAsReader = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(reader));
+    const groupAsReader = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(reader));
     expect(groupAsReader.get(reader.id)).toEqual("reader");
     const otherAgent = createAccountInNode(groupAsReader.core.node);
     expect(() => groupAsReader.addMember(otherAgent, "admin")).toThrow("Failed to set role due to insufficient permissions (role of current account is reader)");
@@ -119,7 +119,7 @@ test("Admins can write to an object that is owned by their group (high level)",
     childObject.set("foo", "bar", "trusting");
     expect(childObject.get("foo")).toEqual("bar");
 });
-test("Writers can write to an object that is owned by their group", () => {
+test("Writers can write to an object that is owned by their group", async () => {
     const { node, groupCore } = newGroup();
     const writer = createAccountInNode(node);
     const group = expectGroup(groupCore.getCurrentContent());
@@ -131,20 +131,20 @@ test("Writers can write to an object that is owned by their group", () => {
         meta: null,
         ...Crypto.createdNowUnique(),
     });
-    const childObjectAsWriter = expectMap(childObject.contentInClonedNodeWithDifferentAccount(writer));
+    const childObjectAsWriter = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(writer));
     childObjectAsWriter.set("foo", "bar", "trusting");
     expect(childObjectAsWriter.get("foo")).toEqual("bar");
 });
-test("Writers can write to an object that is owned by their group (high level)", () => {
+test("Writers can write to an object that is owned by their group (high level)", async () => {
     const { node, group } = newGroupHighLevel();
     const writer = createAccountInNode(node);
     group.addMember(writer, "writer");
     const childObject = group.createMap();
-    const childObjectAsWriter = expectMap(childObject.core.contentInClonedNodeWithDifferentAccount(writer));
+    const childObjectAsWriter = expectMap(await childObject.core.contentInClonedNodeWithDifferentAccount(writer));
     childObjectAsWriter.set("foo", "bar", "trusting");
     expect(childObjectAsWriter.get("foo")).toEqual("bar");
 });
-test("Readers can not write to an object that is owned by their group", () => {
+test("Readers can not write to an object that is owned by their group", async () => {
     const { node, groupCore } = newGroup();
     const reader = createAccountInNode(node);
     const group = expectGroup(groupCore.getCurrentContent());
@@ -156,17 +156,17 @@ test("Readers can not write to an object that is owned by their group", () => {
         meta: null,
         ...Crypto.createdNowUnique(),
     });
-    const childObjectAsReader = expectMap(childObject.contentInClonedNodeWithDifferentAccount(reader));
+    const childObjectAsReader = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(reader));
     childObjectAsReader.set("foo", "bar", "trusting");
     childObjectAsReader.set("foo", "bar", "trusting");
     expect(childObjectAsReader.get("foo")).toBeUndefined();
 });
-test("Readers can not write to an object that is owned by their group (high level)", () => {
+test("Readers can not write to an object that is owned by their group (high level)", async () => {
     const { node, group } = newGroupHighLevel();
     const reader = createAccountInNode(node);
     group.addMember(reader, "reader");
     const childObject = group.createMap();
-    const childObjectAsReader = expectMap(childObject.core.contentInClonedNodeWithDifferentAccount(reader));
+    const childObjectAsReader = expectMap(await childObject.core.contentInClonedNodeWithDifferentAccount(reader));
     childObjectAsReader.set("foo", "bar", "trusting");
     expect(childObjectAsReader.get("foo")).toBeUndefined();
 });
@@ -204,7 +204,7 @@ test("Admins can set group read key and then use it to create and read private t
     childObject.set("foo", "bar", "private");
     expect(childObject.get("foo")).toEqual("bar");
 });
-test("Admins can set group read key and then writers can use it to create and read private transactions in owned objects", () => {
+test("Admins can set group read key and then writers can use it to create and read private transactions in owned objects", async () => {
     const { node, groupCore, admin } = newGroup();
     const writer = createAccountInNode(node);
     const { secret: readKey, id: readKeyID } = Crypto.newRandomKeySecret();
@@ -238,22 +238,22 @@ test("Admins can set group read key and then writers can use it to create and re
         meta: null,
         ...Crypto.createdNowUnique(),
     });
-    const childObjectAsWriter = expectMap(childObject.contentInClonedNodeWithDifferentAccount(writer));
+    const childObjectAsWriter = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(writer));
     expect(childObject.getCurrentReadKey().secret).toEqual(readKey);
     expect(childObjectAsWriter.core.getCurrentReadKey().secret).toEqual(readKey);
     childObjectAsWriter.set("foo", "bar", "private");
     expect(childObjectAsWriter.get("foo")).toEqual("bar");
 });
-test("Admins can set group read key and then writers can use it to create and read private transactions in owned objects (high level)", () => {
+test("Admins can set group read key and then writers can use it to create and read private transactions in owned objects (high level)", async () => {
     const { node, group } = newGroupHighLevel();
     const writer = createAccountInNode(node);
     group.addMember(writer, "writer");
     const childObject = group.createMap();
-    const childObjectAsWriter = expectMap(childObject.core.contentInClonedNodeWithDifferentAccount(writer));
+    const childObjectAsWriter = expectMap(await childObject.core.contentInClonedNodeWithDifferentAccount(writer));
     childObjectAsWriter.set("foo", "bar", "private");
     expect(childObjectAsWriter.get("foo")).toEqual("bar");
 });
-test("Admins can set group read key and then use it to create private transactions in owned objects, which readers can read", () => {
+test("Admins can set group read key and then use it to create private transactions in owned objects, which readers can read", async () => {
     const { node, groupCore, admin } = newGroup();
     const reader = createAccountInNode(node);
     const { secret: readKey, id: readKeyID } = Crypto.newRandomKeySecret();
@@ -290,21 +290,21 @@ test("Admins can set group read key and then use it to create private transactio
     const childContent = expectMap(childObject.getCurrentContent());
     childContent.set("foo", "bar", "private");
     expect(childContent.get("foo")).toEqual("bar");
-    const childObjectAsReader = expectMap(childObject.contentInClonedNodeWithDifferentAccount(reader));
+    const childObjectAsReader = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(reader));
     expect(childObjectAsReader.core.getCurrentReadKey().secret).toEqual(readKey);
     expect(childObjectAsReader.get("foo")).toEqual("bar");
 });
-test("Admins can set group read key and then use it to create private transactions in owned objects, which readers can read (high level)", () => {
+test("Admins can set group read key and then use it to create private transactions in owned objects, which readers can read (high level)", async () => {
     const { node, group } = newGroupHighLevel();
     const reader = createAccountInNode(node);
     group.addMember(reader, "reader");
     const childObject = group.createMap();
     childObject.set("foo", "bar", "private");
     expect(childObject.get("foo")).toEqual("bar");
-    const childContentAsReader = expectMap(childObject.core.contentInClonedNodeWithDifferentAccount(reader));
+    const childContentAsReader = expectMap(await childObject.core.contentInClonedNodeWithDifferentAccount(reader));
     expect(childContentAsReader.get("foo")).toEqual("bar");
 });
-test("Admins can set group read key and then use it to create private transactions in owned objects, which readers can read, even with a separate later revelation for the same read key", () => {
+test("Admins can set group read key and then use it to create private transactions in owned objects, which readers can read, even with a separate later revelation for the same read key", async () => {
     const { node, groupCore, admin } = newGroup();
     const reader1 = createAccountInNode(node);
     const reader2 = createAccountInNode(node);
@@ -342,7 +342,7 @@ test("Admins can set group read key and then use it to create private transactio
     const childContent = expectMap(childObject.getCurrentContent());
     childContent.set("foo", "bar", "private");
     expect(childContent.get("foo")).toEqual("bar");
-    const childObjectAsReader1 = expectMap(childObject.contentInClonedNodeWithDifferentAccount(reader1));
+    const childObjectAsReader1 = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(reader1));
     expect(childObjectAsReader1.core.getCurrentReadKey().secret).toEqual(readKey);
     expect(childObjectAsReader1.get("foo")).toEqual("bar");
     const revelation3 = Crypto.seal({
@@ -355,13 +355,13 @@ test("Admins can set group read key and then use it to create private transactio
         },
     });
     groupContent.set(`${readKeyID}_for_${reader2.id}`, revelation3, "trusting");
-    const childObjectAsReader2 = expectMap(childObject.contentInClonedNodeWithDifferentAccount(reader2));
+    const childObjectAsReader2 = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(reader2));
     // Need to copy the account coValue to the new node to be able to read the readKey
-    childObjectAsReader2.core.node.cloneVerifiedStateFrom(node, reader2.id);
+    await childObjectAsReader2.core.node.loadVerifiedStateFrom(node, reader2.id);
     expect(childObjectAsReader2.core.getCurrentReadKey().secret).toEqual(readKey);
     expect(childObjectAsReader2.get("foo")).toEqual("bar");
 });
-test("Admins can set group read key and then use it to create private transactions in owned objects, which readers can read, even with a separate later revelation for the same read key (high level)", () => {
+test("Admins can set group read key and then use it to create private transactions in owned objects, which readers can read, even with a separate later revelation for the same read key (high level)", async () => {
     const { node, group } = newGroupHighLevel();
     const reader1 = createAccountInNode(node);
     const reader2 = createAccountInNode(node);
@@ -369,10 +369,10 @@ test("Admins can set group read key and then use it to create private transactio
     const childObject = group.createMap();
     childObject.set("foo", "bar", "private");
     expect(childObject.get("foo")).toEqual("bar");
-    const childContentAsReader1 = expectMap(childObject.core.contentInClonedNodeWithDifferentAccount(reader1));
+    const childContentAsReader1 = expectMap(await childObject.core.contentInClonedNodeWithDifferentAccount(reader1));
     expect(childContentAsReader1.get("foo")).toEqual("bar");
     group.addMember(reader2, "reader");
-    const childContentAsReader2 = expectMap(childObject.core.contentInClonedNodeWithDifferentAccount(reader2));
+    const childContentAsReader2 = expectMap(await childObject.core.contentInClonedNodeWithDifferentAccount(reader2));
     expect(childContentAsReader2.get("foo")).toEqual("bar");
 });
 test("Admins can set group read key, make a private transaction in an owned object, rotate the read key, make another private transaction, and both can be read by the admin", () => {
@@ -430,7 +430,7 @@ test("Admins can set group read key, make a private transaction in an owned obje
     childObject.set("foo2", "bar2", "private");
     expect(childObject.get("foo2")).toEqual("bar2");
 });
-test("Admins can set group read key, make a private transaction in an owned object, rotate the read key, add a reader, make another private transaction in the owned object, and both can be read by the reader", () => {
+test("Admins can set group read key, make a private transaction in an owned object, rotate the read key, add a reader, make another private transaction in the owned object, and both can be read by the reader", async () => {
     const { node, groupCore, admin } = newGroup();
     const childObject = node.createCoValue({
         type: "comap",
@@ -490,12 +490,12 @@ test("Admins can set group read key, make a private transaction in an owned obje
     expect(groupContent.get(reader.id)).toEqual("reader");
     childContent.set("foo2", "bar2", "private");
     expect(childContent.get("foo2")).toEqual("bar2");
-    const childObjectAsReader = expectMap(childObject.contentInClonedNodeWithDifferentAccount(reader));
+    const childObjectAsReader = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(reader));
     expect(childObjectAsReader.core.getCurrentReadKey().secret).toEqual(readKey2);
     expect(childObjectAsReader.get("foo")).toEqual("bar");
     expect(childObjectAsReader.get("foo2")).toEqual("bar2");
 });
-test("Admins can set group read key, make a private transaction in an owned object, rotate the read key, add a reader, make another private transaction in the owned object, and both can be read by the reader (high level)", () => {
+test("Admins can set group read key, make a private transaction in an owned object, rotate the read key, add a reader, make another private transaction in the owned object, and both can be read by the reader (high level)", async () => {
     const { node, group } = newGroupHighLevel();
     const childObject = group.createMap();
     const firstReadKey = childObject.core.getCurrentReadKey();
@@ -508,19 +508,19 @@ test("Admins can set group read key, make a private transaction in an owned obje
     group.addMember(reader, "reader");
     childObject.set("foo2", "bar2", "private");
     expect(childObject.get("foo2")).toEqual("bar2");
-    const childContentAsReader = expectMap(childObject.core.contentInClonedNodeWithDifferentAccount(reader));
+    const childContentAsReader = expectMap(await childObject.core.contentInClonedNodeWithDifferentAccount(reader));
     expect(childContentAsReader.get("foo")).toEqual("bar");
     expect(childContentAsReader.get("foo2")).toEqual("bar2");
 });
-test("only admins can add agent ids", () => {
+test("only admins can add agent ids", async () => {
     const { groupCore } = newGroup();
     const inviteSecret = Crypto.newRandomAgentSecret();
     const inviteID = Crypto.getAgentID(inviteSecret);
-    const groupAsInvite = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
+    const groupAsInvite = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
     groupAsInvite.set(inviteID, "adminInvite", "trusting");
     expect(groupAsInvite.get(inviteID)).toEqual(undefined);
 });
-test("Admins can set group read rey, make a private transaction in an owned object, rotate the read key, add two readers, rotate the read key again to kick out one reader, make another private transaction in the owned object, and only the remaining reader can read both transactions", () => {
+test("Admins can set group read rey, make a private transaction in an owned object, rotate the read key, add two readers, rotate the read key again to kick out one reader, make another private transaction in the owned object, and only the remaining reader can read both transactions", async () => {
     const { node, groupCore, admin } = newGroup();
     const childObject = node.createCoValue({
         type: "comap",
@@ -572,9 +572,9 @@ test("Admins can set group read rey, make a private transaction in an owned obje
     const childContent = expectMap(childObject.getCurrentContent());
     childContent.set("foo", "bar", "private");
     expect(childContent.get("foo")).toEqual("bar");
-    let childObjectAsReader = expectMap(childObject.contentInClonedNodeWithDifferentAccount(reader));
+    let childObjectAsReader = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(reader));
     expect(childObjectAsReader.get("foo")).toEqual("bar");
-    let childObjectAsReader2 = expectMap(childObject.contentInClonedNodeWithDifferentAccount(reader2));
+    let childObjectAsReader2 = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(reader2));
     expect(childObjectAsReader2.get("foo")).toEqual("bar");
     const { secret: readKey2, id: readKeyID2 } = Crypto.newRandomKeySecret();
     const newRevelation1 = Crypto.seal({
@@ -606,8 +606,8 @@ test("Admins can set group read rey, make a private transaction in an owned obje
     childContent.set("foo2", "bar2", "private");
     expect(childContent.get("foo2")).toEqual("bar2");
     // TODO: make sure these instances of coValues sync between each other so this isn't necessary?
-    childObjectAsReader = expectMap(childObject.contentInClonedNodeWithDifferentAccount(reader));
-    childObjectAsReader2 = expectMap(childObject.contentInClonedNodeWithDifferentAccount(reader2));
+    childObjectAsReader = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(reader));
+    childObjectAsReader2 = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(reader2));
     expect(childObjectAsReader.get("foo2")).toBeUndefined();
     expect(childObjectAsReader2.get("foo2")).toEqual("bar2");
 });
@@ -629,11 +629,11 @@ test("Admins can set group read rey, make a private transaction in an owned obje
     expect(childObject.core.getCurrentReadKey()).not.toEqual(secondReadKey);
     childObject.set("foo3", "bar3", "private");
     expect(childObject.get("foo3")).toEqual("bar3");
-    const childContentAsReader2 = expectMap(childObject.core.contentInClonedNodeWithDifferentAccount(reader2));
+    const childContentAsReader2 = expectMap(await childObject.core.contentInClonedNodeWithDifferentAccount(reader2));
     expect(childContentAsReader2.get("foo")).toEqual("bar");
     expect(childContentAsReader2.get("foo2")).toEqual("bar2");
     expect(childContentAsReader2.get("foo3")).toEqual("bar3");
-    expect(expectMap(childObject.core.contentInClonedNodeWithDifferentAccount(reader)).get("foo3")).toBeUndefined();
+    expect(expectMap(await childObject.core.contentInClonedNodeWithDifferentAccount(reader)).get("foo3")).toBeUndefined();
 });
 test("Can create two owned objects in the same group and they will have different ids", () => {
     const { node, groupCore } = newGroup();
@@ -651,7 +651,7 @@ test("Can create two owned objects in the same group and they will have differen
     });
     expect(childObject1.id).not.toEqual(childObject2.id);
 });
-test("Admins can create an adminInvite, which can add an admin", () => {
+test("Admins can create an adminInvite, which can add an admin", async () => {
     const { groupCore, admin } = newGroup();
     const inviteSecret = Crypto.newRandomAgentSecret();
     const inviteID = Crypto.getAgentID(inviteSecret);
@@ -680,7 +680,7 @@ test("Admins can create an adminInvite, which can add an admin", () => {
         },
     });
     group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
-    const groupAsInvite = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
+    const groupAsInvite = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
     const invitedAdminSecret = Crypto.newRandomAgentSecret();
     const invitedAdminID = Crypto.getAgentID(invitedAdminSecret);
     groupAsInvite.set(invitedAdminID, "admin", "trusting");
@@ -704,7 +704,7 @@ test("Admins can create an adminInvite, which can add an admin (high-level)", as
     const inviteSecret = group.createInvite("admin");
     const invitedAdminSecret = Crypto.newRandomAgentSecret();
     const invitedAdminID = Crypto.getAgentID(invitedAdminSecret);
-    const nodeAsInvitedAdmin = node.loadCoValueAsDifferentAgent(group.id, invitedAdminSecret).node;
+    const nodeAsInvitedAdmin = (await node.loadCoValueAsDifferentAgent(group.id, invitedAdminSecret)).node;
     await nodeAsInvitedAdmin.acceptInvite(group.id, inviteSecret);
     const thirdAdmin = Crypto.newRandomAgentSecret();
     const thirdAdminID = Crypto.getAgentID(thirdAdmin);
@@ -717,7 +717,7 @@ test("Admins can create an adminInvite, which can add an admin (high-level)", as
     groupAsInvitedAdmin.addMemberInternal(thirdAdminID, "admin");
     expect(groupAsInvitedAdmin.get(thirdAdminID)).toEqual("admin");
 });
-test("Admins can create a writerInvite, which can add a writer", () => {
+test("Admins can create a writerInvite, which can add a writer", async () => {
     const { groupCore, admin } = newGroup();
     const inviteSecret = Crypto.newRandomAgentSecret();
     const inviteID = Crypto.getAgentID(inviteSecret);
@@ -746,7 +746,7 @@ test("Admins can create a writerInvite, which can add a writer", () => {
         },
     });
     group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
-    const groupAsInvite = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
+    const groupAsInvite = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
     const invitedWriterSecret = Crypto.newRandomAgentSecret();
     const invitedWriterID = Crypto.getAgentID(invitedWriterSecret);
     groupAsInvite.set(invitedWriterID, "writer", "trusting");
@@ -770,7 +770,7 @@ test("Admins can create a writerInvite, which can add a writer (high-level)", as
     const inviteSecret = group.createInvite("writer");
     const invitedWriterSecret = Crypto.newRandomAgentSecret();
     const invitedWriterID = Crypto.getAgentID(invitedWriterSecret);
-    const nodeAsInvitedWriter = node.loadCoValueAsDifferentAgent(group.id, invitedWriterSecret).node;
+    const nodeAsInvitedWriter = (await node.loadCoValueAsDifferentAgent(group.id, invitedWriterSecret)).node;
     await nodeAsInvitedWriter.acceptInvite(group.id, inviteSecret);
     const groupAsInvitedWriter = await nodeAsInvitedWriter.load(group.id);
     if (groupAsInvitedWriter === "unavailable") {
@@ -779,7 +779,7 @@ test("Admins can create a writerInvite, which can add a writer (high-level)", as
     expect(groupAsInvitedWriter.get(invitedWriterID)).toEqual("writer");
     expect(groupAsInvitedWriter.core.getCurrentReadKey().secret).toBeDefined();
 });
-test("Admins can create a readerInvite, which can add a reader", () => {
+test("Admins can create a readerInvite, which can add a reader", async () => {
     const { groupCore, admin } = newGroup();
     const inviteSecret = Crypto.newRandomAgentSecret();
     const inviteID = Crypto.getAgentID(inviteSecret);
@@ -808,7 +808,7 @@ test("Admins can create a readerInvite, which can add a reader", () => {
         },
     });
     group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
-    const groupAsInvite = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
+    const groupAsInvite = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
     const invitedReaderSecret = Crypto.newRandomAgentSecret();
     const invitedReaderID = Crypto.getAgentID(invitedReaderSecret);
     groupAsInvite.set(invitedReaderID, "reader", "trusting");
@@ -823,7 +823,7 @@ test("Admins can create a readerInvite, which can add a reader (high-level)", as
     const inviteSecret = group.createInvite("reader");
     const invitedReaderSecret = Crypto.newRandomAgentSecret();
     const invitedReaderID = Crypto.getAgentID(invitedReaderSecret);
-    const nodeAsInvitedReader = node.loadCoValueAsDifferentAgent(group.id, invitedReaderSecret).node;
+    const nodeAsInvitedReader = (await node.loadCoValueAsDifferentAgent(group.id, invitedReaderSecret)).node;
     await nodeAsInvitedReader.acceptInvite(group.id, inviteSecret);
     const groupAsInvitedReader = await nodeAsInvitedReader.load(group.id);
     if (groupAsInvitedReader === "unavailable") {
@@ -832,7 +832,7 @@ test("Admins can create a readerInvite, which can add a reader (high-level)", as
     expect(groupAsInvitedReader.get(invitedReaderID)).toEqual("reader");
     expect(groupAsInvitedReader.core.getCurrentReadKey().secret).toBeDefined();
 });
-test("WriterInvites can not invite admins", () => {
+test("WriterInvites can not invite admins", async () => {
     const { groupCore, admin } = newGroup();
     const inviteSecret = Crypto.newRandomAgentSecret();
     const inviteID = Crypto.getAgentID(inviteSecret);
@@ -861,13 +861,13 @@ test("WriterInvites can not invite admins", () => {
         },
     });
     group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
-    const groupAsInvite = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
+    const groupAsInvite = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
     const invitedAdminSecret = Crypto.newRandomAgentSecret();
     const invitedAdminID = Crypto.getAgentID(invitedAdminSecret);
     groupAsInvite.set(invitedAdminID, "admin", "trusting");
     expect(groupAsInvite.get(invitedAdminID)).toBeUndefined();
 });
-test("ReaderInvites can not invite admins", () => {
+test("ReaderInvites can not invite admins", async () => {
     const { groupCore, admin } = newGroup();
     const inviteSecret = Crypto.newRandomAgentSecret();
     const inviteID = Crypto.getAgentID(inviteSecret);
@@ -896,13 +896,13 @@ test("ReaderInvites can not invite admins", () => {
         },
     });
     group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
-    const groupAsInvite = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
+    const groupAsInvite = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
     const invitedAdminSecret = Crypto.newRandomAgentSecret();
     const invitedAdminID = Crypto.getAgentID(invitedAdminSecret);
     groupAsInvite.set(invitedAdminID, "admin", "trusting");
     expect(groupAsInvite.get(invitedAdminID)).toBeUndefined();
 });
-test("ReaderInvites can not invite writers", () => {
+test("ReaderInvites can not invite writers", async () => {
     const { groupCore, admin } = newGroup();
     const inviteSecret = Crypto.newRandomAgentSecret();
     const inviteID = Crypto.getAgentID(inviteSecret);
@@ -931,13 +931,13 @@ test("ReaderInvites can not invite writers", () => {
         },
     });
     group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
-    const groupAsInvite = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
+    const groupAsInvite = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
     const invitedWriterSecret = Crypto.newRandomAgentSecret();
     const invitedWriterID = Crypto.getAgentID(invitedWriterSecret);
     groupAsInvite.set(invitedWriterID, "writer", "trusting");
     expect(groupAsInvite.get(invitedWriterID)).toBeUndefined();
 });
-test("WriteOnlyInvites can not invite writers", () => {
+test("WriteOnlyInvites can not invite writers", async () => {
     const { groupCore, admin } = newGroup();
     const inviteSecret = Crypto.newRandomAgentSecret();
     const inviteID = Crypto.getAgentID(inviteSecret);
@@ -966,13 +966,13 @@ test("WriteOnlyInvites can not invite writers", () => {
         },
     });
     group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
-    const groupAsInvite = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
+    const groupAsInvite = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
     const invitedWriterSecret = Crypto.newRandomAgentSecret();
     const invitedWriterID = Crypto.getAgentID(invitedWriterSecret);
     groupAsInvite.set(invitedWriterID, "writer", "trusting");
     expect(groupAsInvite.get(invitedWriterID)).toBeUndefined();
 });
-test("WriteOnlyInvites can not invite admins", () => {
+test("WriteOnlyInvites can not invite admins", async () => {
     const { groupCore, admin } = newGroup();
     const inviteSecret = Crypto.newRandomAgentSecret();
     const inviteID = Crypto.getAgentID(inviteSecret);
@@ -1001,13 +1001,13 @@ test("WriteOnlyInvites can not invite admins", () => {
         },
     });
     group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
-    const groupAsInvite = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
+    const groupAsInvite = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
     const invitedWriterSecret = Crypto.newRandomAgentSecret();
     const invitedWriterID = Crypto.getAgentID(invitedWriterSecret);
     groupAsInvite.set(invitedWriterID, "admin", "trusting");
     expect(groupAsInvite.get(invitedWriterID)).toBeUndefined();
 });
-test("WriteOnlyInvites can invite writeOnly", () => {
+test("WriteOnlyInvites can invite writeOnly", async () => {
     const { groupCore, admin } = newGroup();
     const inviteSecret = Crypto.newRandomAgentSecret();
     const inviteID = Crypto.getAgentID(inviteSecret);
@@ -1036,13 +1036,13 @@ test("WriteOnlyInvites can invite writeOnly", () => {
         },
     });
     group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
-    const groupAsInvite = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
+    const groupAsInvite = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
     const invitedWriterSecret = Crypto.newRandomAgentSecret();
     const invitedWriterID = Crypto.getAgentID(invitedWriterSecret);
     groupAsInvite.set(invitedWriterID, "writeOnly", "trusting");
     expect(groupAsInvite.get(invitedWriterID)).toEqual("writeOnly");
 });
-test("WriteOnlyInvites can set writeKeys", () => {
+test("WriteOnlyInvites can set writeKeys", async () => {
     const { groupCore, admin } = newGroup();
     const inviteSecret = Crypto.newRandomAgentSecret();
     const inviteID = Crypto.getAgentID(inviteSecret);
@@ -1071,11 +1071,11 @@ test("WriteOnlyInvites can set writeKeys", () => {
         },
     });
     group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
-    const groupAsInvite = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
+    const groupAsInvite = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
     groupAsInvite.set(`writeKeyFor_${admin.id}`, readKeyID, "trusting");
     expect(groupAsInvite.get(`writeKeyFor_${admin.id}`)).toEqual(readKeyID);
 });
-test("WriteOnlyInvites can't override writeKeys", () => {
+test("WriteOnlyInvites can't override writeKeys", async () => {
     const { groupCore, admin } = newGroup();
     const inviteSecret = Crypto.newRandomAgentSecret();
     const inviteID = Crypto.getAgentID(inviteSecret);
@@ -1104,12 +1104,12 @@ test("WriteOnlyInvites can't override writeKeys", () => {
         },
     });
     group.set(`${readKeyID}_for_${inviteID}`, revelationForInvite, "trusting");
-    const groupAsInvite = expectGroup(groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
+    const groupAsInvite = expectGroup(await groupCore.contentInClonedNodeWithDifferentAccount(new ControlledAgent(inviteSecret, Crypto)));
     groupAsInvite.set(`writeKeyFor_${admin.id}`, readKeyID, "trusting");
     groupAsInvite.set(`writeKeyFor_${admin.id}`, "Evil change", "trusting");
     expect(groupAsInvite.get(`writeKeyFor_${admin.id}`)).toEqual(readKeyID);
 });
-test("Can give read permission to 'everyone'", () => {
+test("Can give read permission to 'everyone'", async () => {
     const { node, groupCore } = newGroup();
     const childObject = node.createCoValue({
         type: "comap",
@@ -1127,7 +1127,7 @@ test("Can give read permission to 'everyone'", () => {
     childContent.set("foo", "bar", "private");
     expect(childContent.get("foo")).toEqual("bar");
     const newAccount = new ControlledAgent(Crypto.newRandomAgentSecret(), Crypto);
-    const childContent2 = expectMap(childObject.contentInClonedNodeWithDifferentAccount(newAccount));
+    const childContent2 = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(newAccount));
     expect(childContent2.get("foo")).toEqual("bar");
 });
 test("Can give read permissions to 'everyone' (high-level)", async () => {
@@ -1138,7 +1138,7 @@ test("Can give read permissions to 'everyone' (high-level)", async () => {
     childObject.set("foo", "bar", "private");
     expect(childObject.get("foo")).toEqual("bar");
     const newAccount = new ControlledAgent(Crypto.newRandomAgentSecret(), Crypto);
-    const childContent2 = expectMap(childObject.core.contentInClonedNodeWithDifferentAccount(newAccount));
+    const childContent2 = expectMap(await childObject.core.contentInClonedNodeWithDifferentAccount(newAccount));
     expect(childContent2.get("foo")).toEqual("bar");
 });
 test("Can give write permission to 'everyone'", async () => {
@@ -1159,7 +1159,7 @@ test("Can give write permission to 'everyone'", async () => {
     childContent.set("foo", "bar", "private");
     expect(childContent.get("foo")).toEqual("bar");
     const newAccount = new ControlledAgent(Crypto.newRandomAgentSecret(), Crypto);
-    const childContent2 = expectMap(childObject.contentInClonedNodeWithDifferentAccount(newAccount));
+    const childContent2 = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(newAccount));
     // TODO: resolve race condition
     await new Promise((resolve) => setTimeout(resolve, 50));
     expect(childContent2.get("foo")).toEqual("bar");
@@ -1174,7 +1174,7 @@ test("Can give write permissions to 'everyone' (high-level)", async () => {
     childObject.set("foo", "bar", "private");
     expect(childObject.get("foo")).toEqual("bar");
     const newAccount = new ControlledAgent(Crypto.newRandomAgentSecret(), Crypto);
-    const childContent2 = expectMap(childObject.core.contentInClonedNodeWithDifferentAccount(newAccount));
+    const childContent2 = expectMap(await childObject.core.contentInClonedNodeWithDifferentAccount(newAccount));
     connectTwoPeers(group.core.node, childContent2.core.node, "server", "server");
     // Ensure that the group is available to newAccount
     await group.core.waitForSync();
@@ -1188,7 +1188,7 @@ test("Admins can set parent extensions", () => {
     group.set(`parent_${parentGroup.id}`, "extend", "trusting");
     expect(group.get(`parent_${parentGroup.id}`)).toEqual("extend");
 });
-test("Writers, readers and invitees can not set parent extensions", () => {
+test("Writers, readers and invitees can not set parent extensions", async () => {
     const { group, node } = newGroupHighLevel();
     const parentGroup = node.createGroup();
     const writer = createAccountInNode(node);
@@ -1201,19 +1201,19 @@ test("Writers, readers and invitees can not set parent extensions", () => {
     group.addMember(adminInvite, "adminInvite");
     group.addMember(writerInvite, "writerInvite");
     group.addMember(readerInvite, "readerInvite");
-    const groupAsWriter = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(writer));
+    const groupAsWriter = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(writer));
     groupAsWriter.set(`parent_${parentGroup.id}`, "extend", "trusting");
     expect(groupAsWriter.get(`parent_${parentGroup.id}`)).toBeUndefined();
-    const groupAsReader = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(reader));
+    const groupAsReader = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(reader));
     groupAsReader.set(`parent_${parentGroup.id}`, "extend", "trusting");
     expect(groupAsReader.get(`parent_${parentGroup.id}`)).toBeUndefined();
-    const groupAsAdminInvite = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(adminInvite));
+    const groupAsAdminInvite = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(adminInvite));
     groupAsAdminInvite.set(`parent_${parentGroup.id}`, "extend", "trusting");
     expect(groupAsAdminInvite.get(`parent_${parentGroup.id}`)).toBeUndefined();
-    const groupAsWriterInvite = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(writerInvite));
+    const groupAsWriterInvite = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(writerInvite));
     groupAsWriterInvite.set(`parent_${parentGroup.id}`, "extend", "trusting");
     expect(groupAsWriterInvite.get(`parent_${parentGroup.id}`)).toBeUndefined();
-    const groupAsReaderInvite = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(readerInvite));
+    const groupAsReaderInvite = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(readerInvite));
     groupAsReaderInvite.set(`parent_${parentGroup.id}`, "extend", "trusting");
     expect(groupAsReaderInvite.get(`parent_${parentGroup.id}`)).toBeUndefined();
 });
@@ -1237,7 +1237,7 @@ test("Admins can set child extensions when the admin role is inherited", async (
     expect(childGroupOnNode1.get(`child_${grandChildGroup.id}`)).toEqual("extend");
     expect(grandChildGroup.get(`parent_${childGroupOnNode1.id}`)).toEqual("extend");
 });
-test("Writers, readers and writeOnly can set child extensions", () => {
+test("Writers, readers and writeOnly can set child extensions", async () => {
     const { group, node } = newGroupHighLevel();
     const childGroup = node.createGroup();
     const writer = createAccountInNode(node);
@@ -1246,10 +1246,10 @@ test("Writers, readers and writeOnly can set child extensions", () => {
     group.addMember(writer, "writer");
     group.addMember(reader, "reader");
     group.addMember(writeOnly, "writeOnly");
-    const groupAsWriter = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(writer));
+    const groupAsWriter = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(writer));
     groupAsWriter.set(`child_${childGroup.id}`, "extend", "trusting");
     expect(groupAsWriter.get(`child_${childGroup.id}`)).toEqual("extend");
-    const groupAsReader = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(reader));
+    const groupAsReader = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(reader));
     groupAsReader.set(`child_${childGroup.id}`, "extend", "trusting");
     expect(groupAsReader.get(`child_${childGroup.id}`)).toEqual("extend");
 });
@@ -1313,7 +1313,7 @@ test("Admins can reveal parent read keys to child groups", () => {
     group.set(`${readKeyID}_for_${parentReadKeyID}`, encrypted, "trusting");
     expect(group.get(`${readKeyID}_for_${parentReadKeyID}`)).toEqual(encrypted);
 });
-test("Writers can't reveal parent read keys to child groups", () => {
+test("Writers can't reveal parent read keys to child groups", async () => {
     const { group, node } = newGroupHighLevel();
     const parentGroup = node.createGroup();
     const parentReadKeyID = parentGroup.get("readKey");
@@ -1328,11 +1328,11 @@ test("Writers can't reveal parent read keys to child groups", () => {
     const encrypted = "fake_encrypted_key_secret";
     const writer = createAccountInNode(node);
     group.addMember(writer, "writer");
-    const groupAsWriter = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(writer));
+    const groupAsWriter = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(writer));
     groupAsWriter.set(`${readKeyID}_for_${parentReadKeyID}`, encrypted, "trusting");
     expect(groupAsWriter.get(`${readKeyID}_for_${parentReadKeyID}`)).toBeUndefined();
 });
-test("Readers can't reveal parent read keys to child groups", () => {
+test("Readers can't reveal parent read keys to child groups", async () => {
     const { group, node } = newGroupHighLevel();
     const parentGroup = node.createGroup();
     const parentReadKeyID = parentGroup.get("readKey");
@@ -1347,11 +1347,11 @@ test("Readers can't reveal parent read keys to child groups", () => {
     const encrypted = "fake_encrypted_key_secret";
     const reader = createAccountInNode(node);
     group.addMember(reader, "reader");
-    const groupAsReader = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(reader));
+    const groupAsReader = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(reader));
     groupAsReader.set(`${readKeyID}_for_${parentReadKeyID}`, encrypted, "trusting");
     expect(groupAsReader.get(`${readKeyID}_for_${parentReadKeyID}`)).toBeUndefined();
 });
-test.skip("Admin invites can't reveal parent read keys to child groups", () => {
+test.skip("Admin invites can't reveal parent read keys to child groups", async () => {
     const { group, node } = newGroupHighLevel();
     const parentGroup = node.createGroup();
     const parentReadKeyID = parentGroup.get("readKey");
@@ -1366,11 +1366,11 @@ test.skip("Admin invites can't reveal parent read keys to child groups", () => {
     const encrypted = "fake_encrypted_key_secret";
     const adminInvite = createAccountInNode(node);
     group.addMember(adminInvite, "adminInvite");
-    const groupAsAdminInvite = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(adminInvite));
+    const groupAsAdminInvite = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(adminInvite));
     groupAsAdminInvite.set(`${readKeyID}_for_${parentReadKeyID}`, encrypted, "trusting");
     expect(groupAsAdminInvite.get(`${readKeyID}_for_${parentReadKeyID}`)).toBeUndefined();
 });
-test.skip("Writer invites can't reveal parent read keys to child groups", () => {
+test.skip("Writer invites can't reveal parent read keys to child groups", async () => {
     const { group, node } = newGroupHighLevel();
     const parentGroup = node.createGroup();
     const parentReadKeyID = parentGroup.get("readKey");
@@ -1385,11 +1385,11 @@ test.skip("Writer invites can't reveal parent read keys to child groups", () =>
     const encrypted = "fake_encrypted_key_secret";
     const writerInvite = createAccountInNode(node);
     group.addMember(writerInvite, "writerInvite");
-    const groupAsWriterInvite = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(writerInvite));
+    const groupAsWriterInvite = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(writerInvite));
     groupAsWriterInvite.set(`${readKeyID}_for_${parentReadKeyID}`, encrypted, "trusting");
     expect(groupAsWriterInvite.get(`${readKeyID}_for_${parentReadKeyID}`)).toBeUndefined();
 });
-test.skip("Reader invites can't reveal parent read keys to child groups", () => {
+test.skip("Reader invites can't reveal parent read keys to child groups", async () => {
     const { group, node } = newGroupHighLevel();
     const parentGroup = node.createGroup();
     const parentReadKeyID = parentGroup.get("readKey");
@@ -1404,11 +1404,11 @@ test.skip("Reader invites can't reveal parent read keys to child groups", () =>
     const encrypted = "fake_encrypted_key_secret";
     const readerInvite = createAccountInNode(node);
     group.addMember(readerInvite, "readerInvite");
-    const groupAsReaderInvite = expectGroup(group.core.contentInClonedNodeWithDifferentAccount(readerInvite));
+    const groupAsReaderInvite = expectGroup(await group.core.contentInClonedNodeWithDifferentAccount(readerInvite));
     groupAsReaderInvite.set(`${readKeyID}_for_${parentReadKeyID}`, encrypted, "trusting");
     expect(groupAsReaderInvite.get(`${readKeyID}_for_${parentReadKeyID}`)).toBeUndefined();
 });
-test("Writers and readers in a parent group can read from an object owned by a child group", () => {
+test("Writers and readers in a parent group can read from an object owned by a child group", async () => {
     const { group, node } = newGroupHighLevel();
     const parentGroup = node.createGroup();
     group.set(`parent_${parentGroup.id}`, "extend", "trusting");
@@ -1446,12 +1446,12 @@ test("Writers and readers in a parent group can read from an object owned by a c
     const childContent = expectMap(childObject.getCurrentContent());
     childContent.set("foo", "bar", "private");
     expect(childContent.get("foo")).toEqual("bar");
-    const childContentAsWriter = expectMap(childObject.contentInClonedNodeWithDifferentAccount(writer));
+    const childContentAsWriter = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(writer));
     expect(childContentAsWriter.get("foo")).toEqual("bar");
-    const childContentAsReader = expectMap(childObject.contentInClonedNodeWithDifferentAccount(reader));
+    const childContentAsReader = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(reader));
     expect(childContentAsReader.get("foo")).toEqual("bar");
 });
-test("Writers in a parent group can write to an object owned by a child group", () => {
+test("Writers in a parent group can write to an object owned by a child group", async () => {
     const { group, node } = newGroupHighLevel();
     const parentGroup = node.createGroup();
     group.set(`parent_${parentGroup.id}`, "extend", "trusting");
@@ -1484,7 +1484,7 @@ test("Writers in a parent group can write to an object owned by a child group",
         meta: null,
         ...Crypto.createdNowUnique(),
     });
-    const childContentAsWriter = expectMap(childObject.contentInClonedNodeWithDifferentAccount(writer));
+    const childContentAsWriter = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(writer));
     childContentAsWriter.set("foo", "bar", "private");
     expect(childContentAsWriter.get("foo")).toEqual("bar");
 });
@@ -1581,7 +1581,7 @@ test("When rotating the key of a grand-parent group, the keys of all child and g
     }
     expect(newChildReadKeyID).not.toEqual(currentChildReadKeyID);
 });
-test("Calling extend on group sets up parent and child references and reveals child key to parent", () => {
+test("Calling extend on group sets up parent and child references and reveals child key to parent", async () => {
     const { group, node } = newGroupHighLevel();
     const parentGroup = node.createGroup();
     group.extend(parentGroup);
@@ -1606,10 +1606,10 @@ test("Calling extend on group sets up parent and child references and reveals ch
     });
     const childMap = expectMap(childObject.getCurrentContent());
     childMap.set("foo", "bar", "private");
-    const childContentAsReader = expectMap(childObject.contentInClonedNodeWithDifferentAccount(reader));
+    const childContentAsReader = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(reader));
     expect(childContentAsReader.get("foo")).toEqual("bar");
 });
-test("Calling extend to create grand-child groups parent and child references and reveals child key to parent(s)", () => {
+test("Calling extend to create grand-child groups parent and child references and reveals child key to parent(s)", async () => {
     const { group, node } = newGroupHighLevel();
     const parentGroup = node.createGroup();
     const grandParentGroup = node.createGroup();
@@ -1629,7 +1629,7 @@ test("Calling extend to create grand-child groups parent and child references an
     });
     const childMap = expectMap(childObject.getCurrentContent());
     childMap.set("foo", "bar", "private");
-    const childContentAsReader = expectMap(childObject.contentInClonedNodeWithDifferentAccount(reader));
+    const childContentAsReader = expectMap(await childObject.contentInClonedNodeWithDifferentAccount(reader));
     expect(childContentAsReader.get("foo")).toEqual("bar");
 });
 test("revoking access on a child group doesn't block access to that group if a more permissive role is inheritable", async () => {
@@ -1700,12 +1700,12 @@ test("revoking write access to parent group", async () => {
         meta: null,
         ...Crypto.createdNowUnique(),
     });
-    const bobMap = expectMap(mapCore.contentInClonedNodeWithDifferentAccount(bob));
+    const bobMap = expectMap(await mapCore.contentInClonedNodeWithDifferentAccount(bob));
     // `bob` sets `foo` to `bar`
     bobMap.set("foo", "bar", "private");
     // `bob`'s change is made successfully
     expect(bobMap.get("foo")).toEqual("bar");
-    const aliceMap = expectMap(mapCore.contentInClonedNodeWithDifferentAccount(alice));
+    const aliceMap = expectMap(await mapCore.contentInClonedNodeWithDifferentAccount(alice));
     // `alice` sets `foo` to `baz`
     aliceMap.set("foo", "baz", "private");
     // `alice`'s change is made successfully
@@ -1716,7 +1716,7 @@ test("revoking write access to parent group", async () => {
     bobMap.set("foo", "abc", "private");
     // `bob`'s change is made successfully
     expect(bobMap.get("foo")).toEqual("abc");
-    const aliceMapAfterUnextend = expectMap(mapCore.contentInClonedNodeWithDifferentAccount(alice));
+    const aliceMapAfterUnextend = expectMap(await mapCore.contentInClonedNodeWithDifferentAccount(alice));
     // `alice` attempts to set `foo` to `def`, but fails
     expect(() => aliceMapAfterUnextend.set("foo", "def", "private")).toThrow("Can't make transaction without read key secret");
     // `alice`'s change is not made successfully
@@ -1826,14 +1826,14 @@ test("High-level permissions work correctly when a group is extended", async ()
     });
     const map = expectMap(mapCore.getCurrentContent());
     map.set("foo", "bar", "private");
-    const mapAsReader = expectMap(mapCore.contentInClonedNodeWithDifferentAccount(reader));
+    const mapAsReader = expectMap(await mapCore.contentInClonedNodeWithDifferentAccount(reader));
     expect(mapAsReader.get("foo")).toEqual("bar");
     const groupKeyBeforeRemove = group.core.getCurrentReadKey().id;
     await parentGroup.removeMember(reader);
     const groupKeyAfterRemove = group.core.getCurrentReadKey().id;
     expect(groupKeyAfterRemove).not.toEqual(groupKeyBeforeRemove);
     map.set("foo", "baz", "private");
-    const mapAsReaderAfterRemove = expectMap(mapCore.contentInClonedNodeWithDifferentAccount(reader));
+    const mapAsReaderAfterRemove = expectMap(await mapCore.contentInClonedNodeWithDifferentAccount(reader));
     expect(mapAsReaderAfterRemove.get("foo")).not.toEqual("baz");
 });
 test("self-extensions should not break the permissions checks", () => {
@@ -1890,7 +1890,7 @@ test("Can revoke read permission from 'everyone'", async () => {
     expect(childObject.get("foo")).toEqual("bar");
     // Create a new account to verify access
     const newAccount = new ControlledAgent(Crypto.newRandomAgentSecret(), Crypto);
-    const childContent = expectMap(childObject.core.contentInClonedNodeWithDifferentAccount(newAccount));
+    const childContent = expectMap(await childObject.core.contentInClonedNodeWithDifferentAccount(newAccount));
     // Verify the new account can read
     expect(childContent.get("foo")).toEqual("bar");
     // Revoke everyone's access
@@ -1898,7 +1898,7 @@ test("Can revoke read permission from 'everyone'", async () => {
     childObject.set("foo", "updated after revoke", "private");
     // Create another new account to verify access is revoked
     const newAccount2 = new ControlledAgent(Crypto.newRandomAgentSecret(), Crypto);
-    const childContent2 = expectMap(childObject.core.contentInClonedNodeWithDifferentAccount(newAccount2));
+    const childContent2 = expectMap(await childObject.core.contentInClonedNodeWithDifferentAccount(newAccount2));
     // Verify the new account cannot read after revocation
     expect(childContent2.get("foo")).toEqual("bar");
 });