cojson 0.0.11 → 0.0.13

package/dist/sync.test.js

@@ -1,11 +1,10 @@
-import { getAgent, getAgentID, newRandomAgentCredential, newRandomSessionID, } from './coValue.js';
-import { LocalNode } from './node.js';
-import { expectMap } from './contentType.js';
-import { ReadableStream, WritableStream, TransformStream, } from "isomorphic-streams";
+import { newRandomSessionID } from "./coValue.js";
+import { LocalNode } from "./node.js";
+import { expectMap } from "./contentType.js";
+import { connectedPeers, newStreamPair, randomAnonymousAccountAndSessionID, shouldNotResolve, } from "./testUtils.js";
 test("Node replies with initial tx and header to empty subscribe", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
     const team = node.createTeam();
     const map = team.createMap();
     map.edit((editable) => {
@@ -21,34 +20,33 @@ test("Node replies with initial tx and header to empty subscribe", async () => {
     });
     const writer = inTx.getWriter();
     await writer.write({
-        action: "subscribe",
-        coValueID: map.coValue.id,
+        action: "load",
+        id: map.coValue.id,
         header: false,
         sessions: {},
     });
     const reader = outRx.getReader();
-    expect((await reader.read()).value).toMatchObject(admStateEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamStateEx(team));
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
-        action: "tellKnownState",
+        action: "known",
         ...map.coValue.knownState(),
     });
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
     const newContentMsg = await reader.read();
     expect(newContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: {
             type: "comap",
             ruleset: { type: "ownedByTeam", team: team.id },
             meta: null,
             createdAt: map.coValue.header.createdAt,
             uniqueness: map.coValue.header.uniqueness,
-            publicNickname: "map",
         },
-        newContent: {
+        new: {
             [node.ownSessionID]: {
                 after: 0,
                 newTransactions: [
@@ -65,16 +63,14 @@ test("Node replies with initial tx and header to empty subscribe", async () => {
                         ],
                     },
                 ],
-                lastHash: map.coValue.sessions[node.ownSessionID].lastHash,
                 lastSignature: map.coValue.sessions[node.ownSessionID].lastSignature,
             },
         },
     });
 });
 test("Node replies with only new tx to subscribe with some known state", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
     const team = node.createTeam();
     const map = team.createMap();
     map.edit((editable) => {
@@ -91,29 +87,29 @@ test("Node replies with only new tx to subscribe with some known state", async (
     });
     const writer = inTx.getWriter();
     await writer.write({
-        action: "subscribe",
-        coValueID: map.coValue.id,
+        action: "load",
+        id: map.coValue.id,
         header: true,
         sessions: {
             [node.ownSessionID]: 1,
         },
     });
     const reader = outRx.getReader();
-    expect((await reader.read()).value).toMatchObject(admStateEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamStateEx(team));
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
-        action: "tellKnownState",
+        action: "known",
         ...map.coValue.knownState(),
     });
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
     const mapNewContentMsg = await reader.read();
     expect(mapNewContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: undefined,
-        newContent: {
+        new: {
             [node.ownSessionID]: {
                 after: 1,
                 newTransactions: [
@@ -130,7 +126,6 @@ test("Node replies with only new tx to subscribe with some known state", async (
                         ],
                     },
                 ],
-                lastHash: map.coValue.sessions[node.ownSessionID].lastHash,
                 lastSignature: map.coValue.sessions[node.ownSessionID].lastSignature,
             },
         },
@@ -138,9 +133,8 @@ test("Node replies with only new tx to subscribe with some known state", async (
 });
 test.todo("TODO: node only replies with new tx to subscribe with some known state, even in the depended on coValues");
 test("After subscribing, node sends own known state and new txs to peer", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
     const team = node.createTeam();
     const map = team.createMap();
     const [inRx, inTx] = newStreamPair();
@@ -153,38 +147,38 @@ test("After subscribing, node sends own known state and new txs to peer", async
     });
     const writer = inTx.getWriter();
     await writer.write({
-        action: "subscribe",
-        coValueID: map.coValue.id,
+        action: "load",
+        id: map.coValue.id,
         header: false,
         sessions: {
             [node.ownSessionID]: 0,
         },
     });
     const reader = outRx.getReader();
-    expect((await reader.read()).value).toMatchObject(admStateEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamStateEx(team));
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
-        action: "tellKnownState",
+        action: "known",
         ...map.coValue.knownState(),
     });
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
     const mapNewContentHeaderOnlyMsg = await reader.read();
     expect(mapNewContentHeaderOnlyMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {},
+        new: {},
     });
     map.edit((editable) => {
         editable.set("hello", "world", "trusting");
     });
     const mapEditMsg1 = await reader.read();
     expect(mapEditMsg1.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
-        newContent: {
+        action: "content",
+        id: map.coValue.id,
+        new: {
             [node.ownSessionID]: {
                 after: 0,
                 newTransactions: [
@@ -201,7 +195,6 @@ test("After subscribing, node sends own known state and new txs to peer", async
                         ],
                     },
                 ],
-                lastHash: map.coValue.sessions[node.ownSessionID].lastHash,
                 lastSignature: map.coValue.sessions[node.ownSessionID].lastSignature,
             },
         },
@@ -211,9 +204,9 @@ test("After subscribing, node sends own known state and new txs to peer", async
     });
     const mapEditMsg2 = await reader.read();
     expect(mapEditMsg2.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
-        newContent: {
+        action: "content",
+        id: map.coValue.id,
+        new: {
             [node.ownSessionID]: {
                 after: 1,
                 newTransactions: [
@@ -230,16 +223,14 @@ test("After subscribing, node sends own known state and new txs to peer", async
                         ],
                     },
                 ],
-                lastHash: map.coValue.sessions[node.ownSessionID].lastHash,
                 lastSignature: map.coValue.sessions[node.ownSessionID].lastSignature,
             },
         },
     });
 });
 test("Client replies with known new content to tellKnownState from server", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
     const team = node.createTeam();
     const map = team.createMap();
     map.edit((editable) => {
@@ -257,28 +248,28 @@ test("Client replies with known new content to tellKnownState from server", asyn
     // expect((await reader.read()).value).toMatchObject(teamStateEx(team));
     const writer = inTx.getWriter();
     await writer.write({
-        action: "tellKnownState",
-        coValueID: map.coValue.id,
+        action: "known",
+        id: map.coValue.id,
         header: false,
         sessions: {
             [node.ownSessionID]: 0,
         },
     });
-    expect((await reader.read()).value).toMatchObject(admStateEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamStateEx(team));
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
-        action: "tellKnownState",
+        action: "known",
         ...map.coValue.knownState(),
     });
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
     const mapNewContentMsg = await reader.read();
     expect(mapNewContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {
+        new: {
             [node.ownSessionID]: {
                 after: 0,
                 newTransactions: [
@@ -295,16 +286,14 @@ test("Client replies with known new content to tellKnownState from server", asyn
                         ],
                     },
                 ],
-                lastHash: map.coValue.sessions[node.ownSessionID].lastHash,
                 lastSignature: map.coValue.sessions[node.ownSessionID].lastSignature,
             },
         },
     });
 });
 test("No matter the optimistic known state, node respects invalid known state messages and resyncs", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
     const team = node.createTeam();
     const map = team.createMap();
     const [inRx, inTx] = newStreamPair();
@@ -317,29 +306,29 @@ test("No matter the optimistic known state, node respects invalid known state me
     });
     const writer = inTx.getWriter();
     await writer.write({
-        action: "subscribe",
-        coValueID: map.coValue.id,
+        action: "load",
+        id: map.coValue.id,
         header: false,
         sessions: {
             [node.ownSessionID]: 0,
         },
     });
     const reader = outRx.getReader();
-    expect((await reader.read()).value).toMatchObject(admStateEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamStateEx(team));
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
-        action: "tellKnownState",
+        action: "known",
         ...map.coValue.knownState(),
     });
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
     const mapNewContentHeaderOnlyMsg = await reader.read();
     expect(mapNewContentHeaderOnlyMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {},
+        new: {},
     });
     map.edit((editable) => {
         editable.set("hello", "world", "trusting");
@@ -350,8 +339,9 @@ test("No matter the optimistic known state, node respects invalid known state me
     const _mapEditMsg1 = await reader.read();
     const _mapEditMsg2 = await reader.read();
     await writer.write({
-        action: "wrongAssumedKnownState",
-        coValueID: map.coValue.id,
+        action: "known",
+        isCorrection: true,
+        id: map.coValue.id,
         header: true,
         sessions: {
             [node.ownSessionID]: 1,
@@ -359,10 +349,10 @@ test("No matter the optimistic known state, node respects invalid known state me
     });
     const newContentAfterWrongAssumedState = await reader.read();
     expect(newContentAfterWrongAssumedState.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: undefined,
-        newContent: {
+        new: {
             [node.ownSessionID]: {
                 after: 1,
                 newTransactions: [
@@ -379,16 +369,14 @@ test("No matter the optimistic known state, node respects invalid known state me
                         ],
                     },
                 ],
-                lastHash: map.coValue.sessions[node.ownSessionID].lastHash,
                 lastSignature: map.coValue.sessions[node.ownSessionID].lastSignature,
             },
         },
     });
 });
 test("If we add a peer, but it never subscribes to a coValue, it won't get any messages", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
     const team = node.createTeam();
     const map = team.createMap();
     const [inRx, _inTx] = newStreamPair();
@@ -406,9 +394,8 @@ test("If we add a peer, but it never subscribes to a coValue, it won't get any m
     await expect(shouldNotResolve(reader.read(), { timeout: 100 })).resolves.toBeUndefined();
 });
 test("If we add a server peer, all updates to all coValues are sent to it, even if it doesn't subscribe", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
     const team = node.createTeam();
     const map = team.createMap();
     const [inRx, _inTx] = newStreamPair();
@@ -420,32 +407,32 @@ test("If we add a server peer, all updates to all coValues are sent to it, even
         role: "server",
     });
     const reader = outRx.getReader();
+    // expect((await reader.read()).value).toMatchObject({
+    //     action: "load",
+    //     id: adminID,
+    // });
     expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: adminID,
-    });
-    expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: team.teamMap.coValue.id,
+        action: "load",
+        id: team.teamMap.coValue.id,
     });
     const mapSubscribeMsg = await reader.read();
     expect(mapSubscribeMsg.value).toEqual({
-        action: "subscribe",
-        coValueID: map.coValue.id,
+        action: "load",
+        id: map.coValue.id,
         header: true,
         sessions: {},
     });
     map.edit((editable) => {
         editable.set("hello", "world", "trusting");
     });
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
     const mapNewContentMsg = await reader.read();
     expect(mapNewContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {
+        new: {
             [node.ownSessionID]: {
                 after: 0,
                 newTransactions: [
@@ -462,16 +449,14 @@ test("If we add a server peer, all updates to all coValues are sent to it, even
                         ],
                     },
                 ],
-                lastHash: map.coValue.sessions[node.ownSessionID].lastHash,
                 lastSignature: map.coValue.sessions[node.ownSessionID].lastSignature,
             },
         },
     });
 });
 test("If we add a server peer, newly created coValues are auto-subscribed to", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
     const team = node.createTeam();
     const [inRx, _inTx] = newStreamPair();
     const [outRx, outTx] = newStreamPair();
@@ -482,35 +467,34 @@ test("If we add a server peer, newly created coValues are auto-subscribed to", a
         role: "server",
     });
     const reader = outRx.getReader();
+    // expect((await reader.read()).value).toMatchObject({
+    //     action: "load",
+    //     id: admin.id,
+    // });
     expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: adminID,
-    });
-    expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: team.teamMap.coValue.id,
+        action: "load",
+        id: team.teamMap.coValue.id,
     });
     const map = team.createMap();
     const mapSubscribeMsg = await reader.read();
     expect(mapSubscribeMsg.value).toEqual({
-        action: "subscribe",
+        action: "load",
         ...map.coValue.knownState(),
     });
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(adminID));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
     const mapContentMsg = await reader.read();
     expect(mapContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {},
+        new: {},
     });
 });
 test.todo("TODO: when receiving a subscribe response that is behind our optimistic state (due to already sent content), we ignore it");
 test("When we connect a new server peer, we try to sync all existing coValues to it", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
     const team = node.createTeam();
     const map = team.createMap();
     const [inRx, _inTx] = newStreamPair();
@@ -522,22 +506,21 @@ test("When we connect a new server peer, we try to sync all existing coValues to
         role: "server",
     });
     const reader = outRx.getReader();
-    const _adminSubscribeMessage = await reader.read();
+    // const _adminSubscribeMessage = await reader.read();
     const teamSubscribeMessage = await reader.read();
     expect(teamSubscribeMessage.value).toEqual({
-        action: "subscribe",
+        action: "load",
         ...team.teamMap.coValue.knownState(),
     });
     const secondMessage = await reader.read();
     expect(secondMessage.value).toEqual({
-        action: "subscribe",
+        action: "load",
         ...map.coValue.knownState(),
     });
 });
 test("When receiving a subscribe with a known state that is ahead of our own, peers should respond with a corresponding subscribe response message", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
     const team = node.createTeam();
     const map = team.createMap();
     const [inRx, inTx] = newStreamPair();
@@ -550,27 +533,26 @@ test("When receiving a subscribe with a known state that is ahead of our own, pe
     });
     const writer = inTx.getWriter();
     await writer.write({
-        action: "subscribe",
-        coValueID: map.coValue.id,
+        action: "load",
+        id: map.coValue.id,
         header: true,
         sessions: {
             [node.ownSessionID]: 1,
         },
     });
     const reader = outRx.getReader();
-    expect((await reader.read()).value).toMatchObject(admStateEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamStateEx(team));
     const mapTellKnownState = await reader.read();
     expect(mapTellKnownState.value).toEqual({
-        action: "tellKnownState",
+        action: "known",
         ...map.coValue.knownState(),
     });
 });
 test.skip("When replaying creation and transactions of a coValue as new content, the receiving peer integrates this information", async () => {
     // TODO: this test is mostly correct but also slightly unrealistic, make sure we pass all messages back and forth as expected and then it should work
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node1 = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node1 = new LocalNode(admin, session);
     const team = node1.createTeam();
     const [inRx1, inTx1] = newStreamPair();
     const [outRx1, outTx1] = newStreamPair();
@@ -582,7 +564,7 @@ test.skip("When replaying creation and transactions of a coValue as new content,
     });
     const to1 = inTx1.getWriter();
     const from1 = outRx1.getReader();
-    const node2 = new LocalNode(admin, newRandomSessionID(adminID));
+    const node2 = new LocalNode(admin, newRandomSessionID(admin.id));
     const [inRx2, inTx2] = newStreamPair();
     const [outRx2, outTx2] = newStreamPair();
     node2.sync.addPeer({
@@ -595,47 +577,47 @@ test.skip("When replaying creation and transactions of a coValue as new content,
     const from2 = outRx2.getReader();
     const adminSubscribeMessage = await from1.read();
     expect(adminSubscribeMessage.value).toMatchObject({
-        action: "subscribe",
-        coValueID: adminID,
+        action: "load",
+        id: admin.id,
     });
     const teamSubscribeMsg = await from1.read();
     expect(teamSubscribeMsg.value).toMatchObject({
-        action: "subscribe",
-        coValueID: team.teamMap.coValue.id,
+        action: "load",
+        id: team.teamMap.coValue.id,
     });
     await to2.write(adminSubscribeMessage.value);
     await to2.write(teamSubscribeMsg.value);
-    const adminTellKnownStateMsg = await from2.read();
-    expect(adminTellKnownStateMsg.value).toMatchObject(admStateEx(adminID));
+    // const adminTellKnownStateMsg = await from2.read();
+    // expect(adminTellKnownStateMsg.value).toMatchObject(admStateEx(admin.id));
     const teamTellKnownStateMsg = await from2.read();
     expect(teamTellKnownStateMsg.value).toMatchObject(teamStateEx(team));
     expect(node2.sync.peers["test1"].optimisticKnownStates[team.teamMap.coValue.id]).toBeDefined();
-    await to1.write(adminTellKnownStateMsg.value);
+    // await to1.write(adminTellKnownStateMsg.value!);
     await to1.write(teamTellKnownStateMsg.value);
-    const adminContentMsg = await from1.read();
-    expect(adminContentMsg.value).toMatchObject(admContEx(adminID));
+    // const adminContentMsg = await from1.read();
+    // expect(adminContentMsg.value).toMatchObject(admContEx(admin.id));
     const teamContentMsg = await from1.read();
     expect(teamContentMsg.value).toMatchObject(teamContentEx(team));
-    await to2.write(adminContentMsg.value);
+    // await to2.write(adminContentMsg.value!);
     await to2.write(teamContentMsg.value);
     const map = team.createMap();
     const mapSubscriptionMsg = await from1.read();
     expect(mapSubscriptionMsg.value).toMatchObject({
-        action: "subscribe",
-        coValueID: map.coValue.id,
+        action: "load",
+        id: map.coValue.id,
     });
     const mapNewContentMsg = await from1.read();
     expect(mapNewContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {},
+        new: {},
     });
     await to2.write(mapSubscriptionMsg.value);
     const mapTellKnownStateMsg = await from2.read();
     expect(mapTellKnownStateMsg.value).toEqual({
-        action: "tellKnownState",
-        coValueID: map.coValue.id,
+        action: "known",
+        id: map.coValue.id,
         header: false,
         sessions: {},
     });
@@ -651,15 +633,14 @@ test.skip("When replaying creation and transactions of a coValue as new content,
 });
 test.skip("When loading a coValue on one node, the server node it is requested from replies with all the necessary depended on coValues to make it work", async () => {
     // TODO: this test is mostly correct but also slightly unrealistic, make sure we pass all messages back and forth as expected and then it should work
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node1 = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node1 = new LocalNode(admin, session);
     const team = node1.createTeam();
     const map = team.createMap();
     map.edit((editable) => {
         editable.set("hello", "world", "trusting");
     });
-    const node2 = new LocalNode(admin, newRandomSessionID(adminID));
+    const node2 = new LocalNode(admin, newRandomSessionID(admin.id));
     const [node1asPeer, node2asPeer] = connectedPeers("peer1", "peer2");
     node1.sync.addPeer(node2asPeer);
     node2.sync.addPeer(node1asPeer);
@@ -667,24 +648,22 @@ test.skip("When loading a coValue on one node, the server node it is requested f
     expect(expectMap(node2.expectCoValueLoaded(map.coValue.id).getCurrentContent()).get("hello")).toEqual("world");
 });
 test("Can sync a coValue through a server to another client", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const client1 = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const client1 = new LocalNode(admin, session);
     const team = client1.createTeam();
     const map = team.createMap();
     map.edit((editable) => {
         editable.set("hello", "world", "trusting");
     });
-    const serverUser = newRandomAgentCredential("serverUser");
-    const serverUserID = getAgentID(getAgent(serverUser));
-    const server = new LocalNode(serverUser, newRandomSessionID(serverUserID));
+    const [serverUser, serverSession] = randomAnonymousAccountAndSessionID();
+    const server = new LocalNode(serverUser, serverSession);
     const [serverAsPeer, client1AsPeer] = connectedPeers("server", "client1", {
         peer1role: "server",
         peer2role: "client",
     });
     client1.sync.addPeer(serverAsPeer);
     server.sync.addPeer(client1AsPeer);
-    const client2 = new LocalNode(admin, newRandomSessionID(adminID));
+    const client2 = new LocalNode(admin, newRandomSessionID(admin.id));
     const [serverAsOtherPeer, client2AsPeer] = connectedPeers("server", "client2", { peer1role: "server", peer2role: "client" });
     client2.sync.addPeer(serverAsOtherPeer);
     server.sync.addPeer(client2AsPeer);
@@ -692,17 +671,15 @@ test("Can sync a coValue through a server to another client", async () => {
     expect(expectMap(mapOnClient2.getCurrentContent()).get("hello")).toEqual("world");
 });
 test("Can sync a coValue with private transactions through a server to another client", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const client1 = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const client1 = new LocalNode(admin, session);
     const team = client1.createTeam();
     const map = team.createMap();
     map.edit((editable) => {
         editable.set("hello", "world", "private");
     });
-    const serverUser = newRandomAgentCredential("serverUser");
-    const serverUserID = getAgentID(getAgent(serverUser));
-    const server = new LocalNode(serverUser, newRandomSessionID(serverUserID));
+    const [serverUser, serverSession] = randomAnonymousAccountAndSessionID();
+    const server = new LocalNode(serverUser, serverSession);
     const [serverAsPeer, client1AsPeer] = connectedPeers("server", "client1", {
         trace: true,
         peer1role: "server",
@@ -710,7 +687,7 @@ test("Can sync a coValue with private transactions through a server to another c
     });
     client1.sync.addPeer(serverAsPeer);
     server.sync.addPeer(client1AsPeer);
-    const client2 = new LocalNode(admin, newRandomSessionID(adminID));
+    const client2 = new LocalNode(admin, newRandomSessionID(admin.id));
     const [serverAsOtherPeer, client2AsPeer] = connectedPeers("server", "client2", { trace: true, peer1role: "server", peer2role: "client" });
     client2.sync.addPeer(serverAsOtherPeer);
     server.sync.addPeer(client2AsPeer);
@@ -718,9 +695,8 @@ test("Can sync a coValue with private transactions through a server to another c
     expect(expectMap(mapOnClient2.getCurrentContent()).get("hello")).toEqual("world");
 });
 test("When a peer's incoming/readable stream closes, we remove the peer", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
     const team = node.createTeam();
     const [inRx, inTx] = newStreamPair();
     const [outRx, outTx] = newStreamPair();
@@ -731,37 +707,36 @@ test("When a peer's incoming/readable stream closes, we remove the peer", async
         role: "server",
     });
     const reader = outRx.getReader();
+    // expect((await reader.read()).value).toMatchObject({
+    //     action: "load",
+    //     id: admin.id,
+    // });
     expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: adminID,
-    });
-    expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: team.teamMap.coValue.id,
+        action: "load",
+        id: team.teamMap.coValue.id,
     });
     const map = team.createMap();
     const mapSubscribeMsg = await reader.read();
     expect(mapSubscribeMsg.value).toEqual({
-        action: "subscribe",
+        action: "load",
         ...map.coValue.knownState(),
     });
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
     const mapContentMsg = await reader.read();
     expect(mapContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {},
+        new: {},
     });
     await inTx.abort();
     await new Promise((resolve) => setTimeout(resolve, 100));
     expect(node.sync.peers["test"]).toBeUndefined();
 });
 test("When a peer's outgoing/writable stream closes, we remove the peer", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
     const team = node.createTeam();
     const [inRx, inTx] = newStreamPair();
     const [outRx, outTx] = newStreamPair();
@@ -772,28 +747,28 @@ test("When a peer's outgoing/writable stream closes, we remove the peer", async
         role: "server",
     });
     const reader = outRx.getReader();
+    // expect((await reader.read()).value).toMatchObject({
+    //     action: "load",
+    //     id: admin.id,
+    // });
     expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: adminID,
-    });
-    expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: team.teamMap.coValue.id,
+        action: "load",
+        id: team.teamMap.coValue.id,
     });
     const map = team.createMap();
     const mapSubscribeMsg = await reader.read();
     expect(mapSubscribeMsg.value).toEqual({
-        action: "subscribe",
+        action: "load",
         ...map.coValue.knownState(),
     });
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
     const mapContentMsg = await reader.read();
     expect(mapContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {},
+        new: {},
     });
     reader.releaseLock();
     await outRx.cancel();
@@ -804,16 +779,19 @@ test("When a peer's outgoing/writable stream closes, we remove the peer", async
     expect(node.sync.peers["test"]).toBeUndefined();
 });
 test("If we start loading a coValue before connecting to a peer that has it, it will load it once we connect", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-    const node1 = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node1 = new LocalNode(admin, session);
     const team = node1.createTeam();
     const map = team.createMap();
     map.edit((editable) => {
         editable.set("hello", "world", "trusting");
     });
-    const node2 = new LocalNode(admin, newRandomSessionID(adminID));
-    const [node1asPeer, node2asPeer] = connectedPeers("peer1", "peer2", { peer1role: 'server', peer2role: 'client', trace: true });
+    const node2 = new LocalNode(admin, newRandomSessionID(admin.id));
+    const [node1asPeer, node2asPeer] = connectedPeers("peer1", "peer2", {
+        peer1role: "server",
+        peer2role: "client",
+        trace: true,
+    });
     node1.sync.addPeer(node2asPeer);
     const mapOnNode2Promise = node2.loadCoValue(map.coValue.id);
     expect(node2.coValues[map.coValue.id]?.state).toEqual("loading");
@@ -823,128 +801,26 @@ test("If we start loading a coValue before connecting to a peer that has it, it
 });
 function teamContentEx(team) {
     return {
-        action: "newContent",
-        coValueID: team.teamMap.coValue.id,
+        action: "content",
+        id: team.teamMap.coValue.id,
     };
 }
 function admContEx(adminID) {
     return {
-        action: "newContent",
-        coValueID: adminID,
+        action: "content",
+        id: adminID,
     };
 }
 function teamStateEx(team) {
     return {
-        action: "tellKnownState",
-        coValueID: team.teamMap.coValue.id,
+        action: "known",
+        id: team.teamMap.coValue.id,
     };
 }
 function admStateEx(adminID) {
     return {
-        action: "tellKnownState",
-        coValueID: adminID,
-    };
-}
-function newStreamPair() {
-    const queue = [];
-    let resolveNextItemReady = () => { };
-    let nextItemReady = new Promise((resolve) => {
-        resolveNextItemReady = resolve;
-    });
-    let writerClosed = false;
-    let readerClosed = false;
-    const readable = new ReadableStream({
-        async pull(controller) {
-            let retriesLeft = 3;
-            while (retriesLeft > 0) {
-                if (writerClosed) {
-                    controller.close();
-                    return;
-                }
-                retriesLeft--;
-                if (queue.length > 0) {
-                    controller.enqueue(queue.shift());
-                    if (queue.length === 0) {
-                        nextItemReady = new Promise((resolve) => {
-                            resolveNextItemReady = resolve;
-                        });
-                    }
-                    return;
-                }
-                else {
-                    await nextItemReady;
-                }
-            }
-            throw new Error("Should only use one retry to get next item in queue.");
-        },
-        cancel(reason) {
-            console.log("Manually closing reader");
-            readerClosed = true;
-        },
-    });
-    const writable = new WritableStream({
-        write(chunk, controller) {
-            if (readerClosed) {
-                console.log("Reader closed, not writing chunk", chunk);
-                throw new Error("Reader closed, not writing chunk");
-            }
-            queue.push(chunk);
-            if (queue.length === 1) {
-                // make sure that await write resolves before corresponding read
-                process.nextTick(() => resolveNextItemReady());
-            }
-        },
-        abort(reason) {
-            console.log("Manually closing writer");
-            writerClosed = true;
-            resolveNextItemReady();
-            return Promise.resolve();
-        },
-    });
-    return [readable, writable];
-}
-function shouldNotResolve(promise, ops) {
-    return new Promise((resolve, reject) => {
-        promise
-            .then((v) => reject(new Error("Should not have resolved, but resolved to " +
-            JSON.stringify(v))))
-            .catch(reject);
-        setTimeout(resolve, ops.timeout);
-    });
-}
-function connectedPeers(peer1id, peer2id, { trace = false, peer1role = "peer", peer2role = "peer", } = {}) {
-    const [inRx1, inTx1] = newStreamPair();
-    const [outRx1, outTx1] = newStreamPair();
-    const [inRx2, inTx2] = newStreamPair();
-    const [outRx2, outTx2] = newStreamPair();
-    void outRx2
-        .pipeThrough(new TransformStream({
-        transform(chunk, controller) {
-            trace && console.log(`${peer2id} -> ${peer1id}`, chunk);
-            controller.enqueue(chunk);
-        },
-    }))
-        .pipeTo(inTx1);
-    void outRx1
-        .pipeThrough(new TransformStream({
-        transform(chunk, controller) {
-            trace && console.log(`${peer1id} -> ${peer2id}`, chunk);
-            controller.enqueue(chunk);
-        },
-    }))
-        .pipeTo(inTx2);
-    const peer2AsPeer = {
-        id: peer2id,
-        incoming: inRx1,
-        outgoing: outTx1,
-        role: peer2role,
-    };
-    const peer1AsPeer = {
-        id: peer1id,
-        incoming: inRx2,
-        outgoing: outTx2,
-        role: peer1role,
+        action: "known",
+        id: adminID,
     };
-    return [peer1AsPeer, peer2AsPeer];
 }
 //# sourceMappingURL=sync.test.js.map