cojson 0.13.5 → 0.13.7

package/dist/tests/sync.test.js

@@ -1,388 +1,17 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, test, vi, } from "vitest";
 import { expectMap } from "../coValue.js";
 import { RawCoMap } from "../coValues/coMap.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
-import { stableStringify } from "../jsonStringify.js";
 import { LocalNode } from "../localNode.js";
-import { getPriorityFromHeader } from "../priority.js";
 import { connectedPeers, newQueuePair } from "../streamUtils.js";
-import { blockMessageTypeOnOutgoingPeer, connectNodeToSyncServer, connectTwoPeers, createConnectedTestAgentNode, createConnectedTestNode, createTestMetricReader, createTestNode, loadCoValueOrFail, randomAnonymousAccountAndSessionID, setupSyncServer, tearDownTestMetricReader, waitFor, } from "./testUtils.js";
+import { blockMessageTypeOnOutgoingPeer, connectTwoPeers, createTestMetricReader, createTestNode, loadCoValueOrFail, randomAnonymousAccountAndSessionID, setupTestAccount, setupTestNode, tearDownTestMetricReader, waitFor, } from "./testUtils.js";
 const Crypto = await WasmCrypto.create();
-let jazzCloud = setupSyncServer();
-beforeEach(async () => {
-    jazzCloud = setupSyncServer();
-});
-test("Node replies with initial tx and header to empty subscribe", async () => {
-    const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session, Crypto);
-    const group = node.createGroup();
-    const map = group.createMap();
-    map.set("hello", "world", "trusting");
-    const [inRx, inTx] = newQueuePair();
-    const [outRx, outTx] = newQueuePair();
-    const outRxQ = outRx[Symbol.asyncIterator]();
-    node.syncManager.addPeer({
-        id: "test",
-        incoming: inRx,
-        outgoing: outTx,
-        role: "peer",
-        crashOnClose: true,
-    });
-    await inTx.push({
-        action: "load",
-        id: map.core.id,
-        header: false,
-        sessions: {},
-    });
-    // expect((await outRxQ.next()).value).toMatchObject(admStateEx(admin.id));
-    expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
-    const mapTellKnownStateMsg = (await outRxQ.next()).value;
-    expect(mapTellKnownStateMsg).toEqual({
-        action: "known",
-        ...map.core.knownState(),
-    });
-    // expect((await outRxQ.next()).value).toMatchObject(admContEx(admin.id));
-    expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
-    const newContentMsg = (await outRxQ.next()).value;
-    const expectedHeader = {
-        type: "comap",
-        ruleset: { type: "ownedByGroup", group: group.id },
-        meta: null,
-        createdAt: map.core.header.createdAt,
-        uniqueness: map.core.header.uniqueness,
-    };
-    expect(newContentMsg).toEqual({
-        action: "content",
-        id: map.core.id,
-        header: expectedHeader,
-        new: {
-            [node.currentSessionID]: {
-                after: 0,
-                newTransactions: [
-                    {
-                        privacy: "trusting",
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)
-                            .transactions[0].madeAt,
-                        changes: stableStringify([
-                            {
-                                op: "set",
-                                key: "hello",
-                                value: "world",
-                            },
-                        ]),
-                    },
-                ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)
-                    .lastSignature,
-            },
-        },
-        priority: getPriorityFromHeader(map.core.header),
-    });
-});
-test("Node replies with only new tx to subscribe with some known state", async () => {
-    const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session, Crypto);
-    const group = node.createGroup();
-    const map = group.createMap();
-    map.set("hello", "world", "trusting");
-    map.set("goodbye", "world", "trusting");
-    const [inRx, inTx] = newQueuePair();
-    const [outRx, outTx] = newQueuePair();
-    const outRxQ = outRx[Symbol.asyncIterator]();
-    node.syncManager.addPeer({
-        id: "test",
-        incoming: inRx,
-        outgoing: outTx,
-        role: "peer",
-        crashOnClose: true,
-    });
-    await inTx.push({
-        action: "load",
-        id: map.core.id,
-        header: true,
-        sessions: {
-            [node.currentSessionID]: 1,
-        },
-    });
-    // expect((await outRxQ.next()).value).toMatchObject(admStateEx(admin.id));
-    expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
-    const mapTellKnownStateMsg = (await outRxQ.next()).value;
-    expect(mapTellKnownStateMsg).toEqual({
-        action: "known",
-        ...map.core.knownState(),
-    });
-    // expect((await outRxQ.next()).value).toMatchObject(admContEx(admin.id));
-    expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
-    const mapNewContentMsg = (await outRxQ.next()).value;
-    expect(mapNewContentMsg).toEqual({
-        action: "content",
-        id: map.core.id,
-        header: undefined,
-        new: {
-            [node.currentSessionID]: {
-                after: 1,
-                newTransactions: [
-                    {
-                        privacy: "trusting",
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)
-                            .transactions[1].madeAt,
-                        changes: stableStringify([
-                            {
-                                op: "set",
-                                key: "goodbye",
-                                value: "world",
-                            },
-                        ]),
-                    },
-                ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)
-                    .lastSignature,
-            },
-        },
-        priority: getPriorityFromHeader(map.core.header),
-    });
-});
-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, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session, Crypto);
-    const group = node.createGroup();
-    const map = group.createMap();
-    const [inRx, inTx] = newQueuePair();
-    const [outRx, outTx] = newQueuePair();
-    const outRxQ = outRx[Symbol.asyncIterator]();
-    node.syncManager.addPeer({
-        id: "test",
-        incoming: inRx,
-        outgoing: outTx,
-        role: "peer",
-        crashOnClose: true,
-    });
-    await inTx.push({
-        action: "load",
-        id: map.core.id,
-        header: false,
-        sessions: {
-            [node.currentSessionID]: 0,
-        },
-    });
-    // expect((await outRxQ.next()).value).toMatchObject(admStateEx(admin.id));
-    expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
-    const mapTellKnownStateMsg = (await outRxQ.next()).value;
-    expect(mapTellKnownStateMsg).toEqual({
-        action: "known",
-        ...map.core.knownState(),
-    });
-    // expect((await outRxQ.next()).value).toMatchObject(admContEx(admin.id));
-    expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
-    const mapNewContentHeaderOnlyMsg = (await outRxQ.next()).value;
-    expect(mapNewContentHeaderOnlyMsg).toEqual({
-        action: "content",
-        id: map.core.id,
-        header: map.core.header,
-        new: {},
-        priority: getPriorityFromHeader(map.core.header),
-    });
-    map.set("hello", "world", "trusting");
-    const mapEditMsg1 = (await outRxQ.next()).value;
-    expect(mapEditMsg1).toEqual({
-        action: "content",
-        id: map.core.id,
-        new: {
-            [node.currentSessionID]: {
-                after: 0,
-                newTransactions: [
-                    {
-                        privacy: "trusting",
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)
-                            .transactions[0].madeAt,
-                        changes: stableStringify([
-                            {
-                                op: "set",
-                                key: "hello",
-                                value: "world",
-                            },
-                        ]),
-                    },
-                ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)
-                    .lastSignature,
-            },
-        },
-        priority: getPriorityFromHeader(map.core.header),
-    });
-    map.set("goodbye", "world", "trusting");
-    const mapEditMsg2 = (await outRxQ.next()).value;
-    expect(mapEditMsg2).toEqual({
-        action: "content",
-        id: map.core.id,
-        new: {
-            [node.currentSessionID]: {
-                after: 1,
-                newTransactions: [
-                    {
-                        privacy: "trusting",
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)
-                            .transactions[1].madeAt,
-                        changes: stableStringify([
-                            {
-                                op: "set",
-                                key: "goodbye",
-                                value: "world",
-                            },
-                        ]),
-                    },
-                ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)
-                    .lastSignature,
-            },
-        },
-        priority: getPriorityFromHeader(map.core.header),
-    });
+let jazzCloud = setupTestNode({
+    isSyncServer: true,
 });
-test("Client replies with known new content to tellKnownState from server", async () => {
-    const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session, Crypto);
-    const group = node.createGroup();
-    const map = group.createMap();
-    map.set("hello", "world", "trusting");
-    const [inRx, inTx] = newQueuePair();
-    const [outRx, outTx] = newQueuePair();
-    const outRxQ = outRx[Symbol.asyncIterator]();
-    node.syncManager.addPeer({
-        id: "test",
-        incoming: inRx,
-        outgoing: outTx,
-        role: "peer",
-        crashOnClose: true,
-    });
-    // expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
-    await inTx.push({
-        action: "known",
-        id: map.core.id,
-        header: false,
-        sessions: {
-            [node.currentSessionID]: 0,
-        },
-    });
-    // expect((await outRxQ.next()).value).toMatchObject(admStateEx(admin.id));
-    expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
-    const mapTellKnownStateMsg = (await outRxQ.next()).value;
-    expect(mapTellKnownStateMsg).toEqual({
-        action: "known",
-        ...map.core.knownState(),
-    });
-    // expect((await outRxQ.next()).value).toMatchObject(admContEx(admin.id));
-    expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
-    const mapNewContentMsg = (await outRxQ.next()).value;
-    expect(mapNewContentMsg).toEqual({
-        action: "content",
-        id: map.core.id,
-        header: map.core.header,
-        new: {
-            [node.currentSessionID]: {
-                after: 0,
-                newTransactions: [
-                    {
-                        privacy: "trusting",
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)
-                            .transactions[0].madeAt,
-                        changes: stableStringify([
-                            {
-                                op: "set",
-                                key: "hello",
-                                value: "world",
-                            },
-                        ]),
-                    },
-                ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)
-                    .lastSignature,
-            },
-        },
-        priority: getPriorityFromHeader(map.core.header),
-    });
-});
-test("No matter the optimistic known state, node respects invalid known state messages and resyncs", async () => {
-    const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session, Crypto);
-    const group = node.createGroup();
-    const map = group.createMap();
-    const [inRx, inTx] = newQueuePair();
-    const [outRx, outTx] = newQueuePair();
-    const outRxQ = outRx[Symbol.asyncIterator]();
-    node.syncManager.addPeer({
-        id: "test",
-        incoming: inRx,
-        outgoing: outTx,
-        role: "peer",
-        crashOnClose: true,
-    });
-    await inTx.push({
-        action: "load",
-        id: map.core.id,
-        header: false,
-        sessions: {
-            [node.currentSessionID]: 0,
-        },
-    });
-    // expect((await outRxQ.next()).value).toMatchObject(admStateEx(admin.id));
-    expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
-    const mapTellKnownStateMsg = (await outRxQ.next()).value;
-    expect(mapTellKnownStateMsg).toEqual({
-        action: "known",
-        ...map.core.knownState(),
-    });
-    // expect((await outRxQ.next()).value).toMatchObject(admContEx(admin.id));
-    expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
-    const mapNewContentHeaderOnlyMsg = (await outRxQ.next()).value;
-    expect(mapNewContentHeaderOnlyMsg).toEqual({
-        action: "content",
-        id: map.core.id,
-        header: map.core.header,
-        new: {},
-        priority: getPriorityFromHeader(map.core.header),
-    });
-    map.set("hello", "world", "trusting");
-    map.set("goodbye", "world", "trusting");
-    const _mapEditMsgs = (await outRxQ.next()).value;
-    console.log("Sending correction");
-    await inTx.push({
-        action: "known",
-        isCorrection: true,
-        id: map.core.id,
-        header: true,
-        sessions: {
-            [node.currentSessionID]: 1,
-        },
-    });
-    const newContentAfterWrongAssumedState = (await outRxQ.next()).value;
-    expect(newContentAfterWrongAssumedState).toEqual({
-        action: "content",
-        id: map.core.id,
-        header: undefined,
-        new: {
-            [node.currentSessionID]: {
-                after: 1,
-                newTransactions: [
-                    {
-                        privacy: "trusting",
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)
-                            .transactions[1].madeAt,
-                        changes: stableStringify([
-                            {
-                                op: "set",
-                                key: "goodbye",
-                                value: "world",
-                            },
-                        ]),
-                    },
-                ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)
-                    .lastSignature,
-            },
-        },
-        priority: getPriorityFromHeader(map.core.header),
+beforeEach(async () => {
+    jazzCloud = setupTestNode({
+        isSyncServer: true,
     });
 });
 test("If we add a peer, but it never subscribes to a coValue, it won't get any messages", async () => {
@@ -408,376 +37,59 @@ test("If we add a peer, but it never subscribes to a coValue, it won't get any m
     ]);
     expect(result).toEqual("neverHappened");
 });
-test.todo("If we add a server peer, all updates to all coValues are sent to it, even if it doesn't subscribe", async () => {
-    const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session, Crypto);
-    const group = node.createGroup();
-    const map = group.createMap();
-    const [inRx, _inTx] = newQueuePair();
-    const [outRx, outTx] = newQueuePair();
-    const outRxQ = outRx[Symbol.asyncIterator]();
-    node.syncManager.addPeer({
-        id: "test",
-        incoming: inRx,
-        outgoing: outTx,
-        role: "server",
-        crashOnClose: true,
-    });
-    // expect((await outRxQ.next()).value).toMatchObject({
-    //     action: "load",
-    //     id: adminID,
-    // });
-    expect((await outRxQ.next()).value).toMatchObject({
-        action: "load",
-        id: group.core.id,
-    });
-    const mapSubscribeMsg = (await outRxQ.next()).value;
-    expect(mapSubscribeMsg).toEqual({
-        action: "load",
-        id: map.core.id,
-        header: true,
-        sessions: {},
-    });
-    map.set("hello", "world", "trusting");
-    // expect((await outRxQ.next()).value).toMatchObject(admContEx(admin.id));
-    expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
-    const mapNewContentMsg = (await outRxQ.next()).value;
-    expect(mapNewContentMsg).toEqual({
-        action: "content",
-        id: map.core.id,
-        header: map.core.header,
-        new: {
-            [node.currentSessionID]: {
-                after: 0,
-                newTransactions: [
-                    {
-                        privacy: "trusting",
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)
-                            .transactions[0].madeAt,
-                        changes: stableStringify([
-                            {
-                                op: "set",
-                                key: "hello",
-                                value: "world",
-                            },
-                        ]),
-                    },
-                ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)
-                    .lastSignature,
-            },
-        },
-        priority: getPriorityFromHeader(map.core.header),
-    });
-});
-test.skip("If we add a server peer, newly created coValues are auto-subscribed to", async () => {
-    const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session, Crypto);
-    const group = node.createGroup();
-    const [inRx, _inTx] = newQueuePair();
-    const [outRx, outTx] = newQueuePair();
-    const outRxQ = outRx[Symbol.asyncIterator]();
-    node.syncManager.addPeer({
-        id: "test",
-        incoming: inRx,
-        outgoing: outTx,
-        role: "server",
-        crashOnClose: true,
-    });
-    // expect((await outRxQ.next()).value).toMatchObject({
-    //     action: "load",
-    //     id: admin.id,
-    // });
-    expect((await outRxQ.next()).value).toMatchObject({
-        action: "load",
-        id: group.core.id,
-    });
-    const map = group.createMap();
-    const mapSubscribeMsg = (await outRxQ.next()).value;
-    expect(mapSubscribeMsg).toEqual({
-        action: "load",
-        ...map.core.knownState(),
-    });
-    // expect((await outRxQ.next()).value).toMatchObject(admContEx(adminID));
-    expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
-    const mapContentMsg = (await outRxQ.next()).value;
-    expect(mapContentMsg).toEqual({
-        action: "content",
-        id: map.core.id,
-        header: map.core.header,
-        new: {},
-        priority: getPriorityFromHeader(map.core.header),
-    });
-});
-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, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session, Crypto);
-    const group = node.createGroup();
-    const map = group.createMap();
-    const [inRx, _inTx] = newQueuePair();
-    const [outRx, outTx] = newQueuePair();
-    const outRxQ = outRx[Symbol.asyncIterator]();
-    node.syncManager.addPeer({
-        id: "test",
-        incoming: inRx,
-        outgoing: outTx,
-        role: "server",
-        crashOnClose: true,
-    });
-    // const _adminSubscribeMessage = await outRxQ.next();
-    const groupSubscribeMessage = (await outRxQ.next()).value;
-    expect(groupSubscribeMessage).toEqual({
-        action: "load",
-        ...group.core.knownState(),
-    });
-    const secondMessage = (await outRxQ.next()).value;
-    expect(secondMessage).toEqual({
-        action: "load",
-        ...map.core.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, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session, Crypto);
-    const group = node.createGroup();
-    const map = group.createMap();
-    const [inRx, inTx] = newQueuePair();
-    const [outRx, outTx] = newQueuePair();
-    const outRxQ = outRx[Symbol.asyncIterator]();
-    node.syncManager.addPeer({
-        id: "test",
-        incoming: inRx,
-        outgoing: outTx,
-        role: "peer",
-        crashOnClose: true,
-    });
-    await inTx.push({
-        action: "load",
-        id: map.core.id,
-        header: true,
-        sessions: {
-            [node.currentSessionID]: 1,
-        },
-    });
-    // expect((await outRxQ.next()).value).toMatchObject(admStateEx(admin.id));
-    expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
-    const mapTellKnownState = (await outRxQ.next()).value;
-    expect(mapTellKnownState).toEqual({
-        action: "known",
-        ...map.core.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, session] = randomAnonymousAccountAndSessionID();
-    const node1 = new LocalNode(admin, session, Crypto);
-    const group = node1.createGroup();
-    const [inRx1, inTx1] = newQueuePair();
-    const [outRx1, outTx1] = newQueuePair();
-    const outRxQ1 = outRx1[Symbol.asyncIterator]();
-    node1.syncManager.addPeer({
-        id: "test2",
-        incoming: inRx1,
-        outgoing: outTx1,
-        role: "server",
-        crashOnClose: true,
-    });
-    const node2 = new LocalNode(admin, Crypto.newRandomSessionID(admin.id), Crypto);
-    const [inRx2, inTx2] = newQueuePair();
-    const [outRx2, outTx2] = newQueuePair();
-    const outRxQ2 = outRx2[Symbol.asyncIterator]();
-    node2.syncManager.addPeer({
-        id: "test1",
-        incoming: inRx2,
-        outgoing: outTx2,
-        role: "client",
-        crashOnClose: true,
-    });
-    const adminSubscribeMessage = (await outRxQ1.next()).value;
-    expect(adminSubscribeMessage).toMatchObject({
-        action: "load",
-        id: admin.id,
-    });
-    const groupSubscribeMsg = (await outRxQ1.next()).value;
-    expect(groupSubscribeMsg).toMatchObject({
-        action: "load",
-        id: group.core.id,
-    });
-    await inTx2.push(adminSubscribeMessage);
-    await inTx2.push(groupSubscribeMsg);
-    // const adminTellKnownStateMsg = (await outRxQ2.next()).value;
-    // expect(adminTellKnownStateMsg).toMatchObject(admStateEx(admin.id));
-    const groupTellKnownStateMsg = (await outRxQ2.next()).value;
-    expect(groupTellKnownStateMsg).toMatchObject(groupStateEx(group));
-    expect(node2.syncManager.peers["test1"].optimisticKnownStates.has(group.core.id)).toBeDefined();
-    // await inTx1.push(adminTellKnownStateMsg);
-    await inTx1.push(groupTellKnownStateMsg);
-    // const adminContentMsg = (await outRxQ1.next()).value;
-    // expect(adminContentMsg).toMatchObject(admContEx(admin.id));
-    const groupContentMsg = (await outRxQ1.next()).value;
-    expect(groupContentMsg).toMatchObject(groupContentEx(group));
-    // await inTx2.push(adminContentMsg);
-    await inTx2.push(groupContentMsg);
-    const map = group.createMap();
-    const mapSubscriptionMsg = (await outRxQ1.next()).value;
-    expect(mapSubscriptionMsg).toMatchObject({
-        action: "load",
-        id: map.core.id,
-    });
-    const mapNewContentMsg = (await outRxQ1.next()).value;
-    expect(mapNewContentMsg).toEqual({
-        action: "content",
-        id: map.core.id,
-        header: map.core.header,
-        new: {},
-        priority: getPriorityFromHeader(map.core.header),
-    });
-    await inTx2.push(mapSubscriptionMsg);
-    const mapTellKnownStateMsg = (await outRxQ2.next()).value;
-    expect(mapTellKnownStateMsg).toEqual({
-        action: "known",
-        id: map.core.id,
-        header: false,
-        sessions: {},
-    });
-    expect(node2.coValuesStore.get(map.core.id).state.type).toEqual("loading");
-    await inTx2.push(mapNewContentMsg);
-    map.set("hello", "world", "trusting");
-    const mapEditMsg = (await outRxQ1.next()).value;
-    await inTx2.push(mapEditMsg);
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    expect(expectMap(node2.expectCoValueLoaded(map.core.id).getCurrentContent()).get("hello")).toEqual("world");
-});
-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, session] = randomAnonymousAccountAndSessionID();
-  
-      const node1 = new LocalNode(admin, session, Crypto);
-  
-      const group = node1.createGroup();
-  
-      const map = group.createMap();
-      map.set("hello", "world", "trusting");
-  
-      const node2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
-  
-      const [node1asPeer, node2asPeer] = connectedPeers("peer1", "peer2");
-  
-      node1.syncManager.addPeer(node2asPeer);
-      node2.syncManager.addPeer(node1asPeer);
-  
-      await node2.loadCoValueCore(map.core.id);
-  
-      expect(
-          expectMap(
-              node2.expectCoValueLoaded(map.core.id).getCurrentContent(),
-          ).get("hello"),
-      ).toEqual("world");
-      */
-});
 test("Can sync a coValue through a server to another client", async () => {
-    const { node: client1 } = await createConnectedTestNode();
+    const { node: client1 } = await setupTestAccount({
+        connected: true,
+    });
     const group = client1.createGroup();
     const map = group.createMap();
     map.set("hello", "world", "trusting");
-    const { node: client2 } = await createConnectedTestNode();
+    const { node: client2 } = await setupTestAccount({
+        connected: true,
+    });
     const mapOnClient2 = await loadCoValueOrFail(client2, map.id);
     expect(mapOnClient2.get("hello")).toEqual("world");
 });
 test("Can sync a coValue with private transactions through a server to another client", async () => {
-    const { node: client1 } = await createConnectedTestNode();
+    const { node: client1 } = await setupTestAccount({
+        connected: true,
+    });
     const group = client1.createGroup();
     const map = group.createMap();
     map.set("hello", "world", "private");
     group.addMember("everyone", "reader");
-    const { node: client2 } = await createConnectedTestNode();
+    const { node: client2 } = await setupTestAccount({
+        connected: true,
+    });
     const mapOnClient2 = await loadCoValueOrFail(client2, map.id);
     expect(mapOnClient2.get("hello")).toEqual("world");
 });
-test.skip("When a peer's incoming/readable stream closes, we remove the peer", async () => {
-    /*
-      const [admin, session] = randomAnonymousAccountAndSessionID();
-      const node = new LocalNode(admin, session, Crypto);
-  
-      const group = node.createGroup();
-  
-      const [inRx, inTx] = await Effect.runPromise(newStreamPair());
-      const [outRx, outTx] = await Effect.runPromise(newStreamPair());
-  
-      node.syncManager.addPeer({
-          id: "test",
-          incoming: inRx,
-          outgoing: outTx,
-          role: "server",
-      });
-  
-      // expect(yield* Queue.take(outRxQ)).toMatchObject({
-      //     action: "load",
-      //     id: admin.id,
-      // });
-      expect(yield * Queue.take(outRxQ)).toMatchObject({
-          action: "load",
-          id: group.core.id,
-      });
-  
-      const map = group.createMap();
-  
-      const mapSubscribeMsg = await reader.read();
-  
-      expect(mapSubscribeMsg.value).toEqual({
-          action: "load",
-          ...map.core.knownState(),
-      } satisfies SyncMessage);
-  
-      // expect(yield* Queue.take(outRxQ)).toMatchObject(admContEx(admin.id));
-      expect(yield * Queue.take(outRxQ)).toMatchObject(groupContentEx(group));
-  
-      const mapContentMsg = await reader.read();
-  
-      expect(mapContentMsg.value).toEqual({
-          action: "content",
-          id: map.core.id,
-          header: map.core.header,
-          new: {},
-      } satisfies SyncMessage);
-  
-      await inTx.abort();
-  
-      await new Promise((resolve) => setTimeout(resolve, 100));
-  
-      expect(node.syncManager.peers["test"]).toBeUndefined();
-      */
-});
 test("should keep the peer state when the peer closes", async () => {
-    const client = createTestNode();
-    const { nodeToServerPeer, serverToNodePeer } = connectNodeToSyncServer(client);
-    const group = jazzCloud.createGroup();
+    const client = setupTestNode();
+    const { peer, peerState } = client.connectToSyncServer();
+    const group = jazzCloud.node.createGroup();
     const map = group.createMap();
     map.set("hello", "world", "trusting");
-    await client.loadCoValueCore(map.core.id);
-    const syncManager = client.syncManager;
-    const peerState = syncManager.peers[nodeToServerPeer.id];
+    await client.node.loadCoValueCore(map.core.id);
+    const syncManager = client.node.syncManager;
     // @ts-expect-error Simulating a peer closing, leveraging the direct connection between the client/server peers
-    await serverToNodePeer.outgoing.push("Disconnected");
+    await peer.outgoing.push("Disconnected");
     await waitFor(() => peerState?.closed);
-    expect(syncManager.peers[nodeToServerPeer.id]).not.toBeUndefined();
+    expect(syncManager.peers[peer.id]).not.toBeUndefined();
 });
 test("should delete the peer state when the peer closes if deletePeerStateOnClose is true", async () => {
-    const client = createTestNode();
-    const { nodeToServerPeer, serverToNodePeer } = connectNodeToSyncServer(client);
-    nodeToServerPeer.deletePeerStateOnClose = true;
-    const group = jazzCloud.createGroup();
+    const client = setupTestNode();
+    const { peer, peerState } = client.connectToSyncServer();
+    peer.deletePeerStateOnClose = true;
+    const group = jazzCloud.node.createGroup();
     const map = group.createMap();
     map.set("hello", "world", "trusting");
-    await client.loadCoValueCore(map.core.id);
-    const syncManager = client.syncManager;
-    const peerState = syncManager.peers[nodeToServerPeer.id];
+    await client.node.loadCoValueCore(map.core.id);
+    const syncManager = client.node.syncManager;
     // @ts-expect-error Simulating a peer closing, leveraging the direct connection between the client/server peers
-    await serverToNodePeer.outgoing.push("Disconnected");
+    await peer.outgoing.push("Disconnected");
     await waitFor(() => peerState?.closed);
-    expect(syncManager.peers[nodeToServerPeer.id]).toBeUndefined();
+    expect(syncManager.peers[peer.id]).toBeUndefined();
 });
 describe("sync - extra tests", () => {
     test("Node handles disconnection and reconnection of a peer gracefully", async () => {
@@ -915,58 +227,6 @@ describe("sync - extra tests", () => {
         expect(finalStateNode2.toJSON()).toEqual(expectedState);
         expect(finalStateNode3.toJSON()).toEqual(expectedState);
     });
-    test.skip("Large coValues are synced efficiently in chunks", async () => {
-        // Create two nodes
-        const [admin1, session1] = randomAnonymousAccountAndSessionID();
-        const node1 = new LocalNode(admin1, session1, Crypto);
-        const [admin2, session2] = randomAnonymousAccountAndSessionID();
-        const node2 = new LocalNode(admin2, session2, Crypto);
-        // Create a group and a large map on node1
-        const group = node1.createGroup();
-        group.addMember("everyone", "writer");
-        const largeMap = group.createMap();
-        // Generate a large amount of data (about 10MB)
-        const dataSize = 1 * 1024 * 1024;
-        const chunkSize = 1024; // 1KB chunks
-        const chunks = dataSize / chunkSize;
-        for (let i = 0; i < chunks; i++) {
-            const key = `key${i}`;
-            const value = Buffer.alloc(chunkSize, `value${i}`).toString("base64");
-            largeMap.set(key, value, "trusting");
-        }
-        // Connect the nodes
-        const [node1AsPeer, node2AsPeer] = connectedPeers("node1", "node2", {
-            peer1role: "server",
-            peer2role: "client",
-        });
-        node1.syncManager.addPeer(node2AsPeer);
-        node2.syncManager.addPeer(node1AsPeer);
-        await new Promise((resolve) => setTimeout(resolve, 4000));
-        // Measure sync time
-        const startSync = performance.now();
-        // Load the large map on node2
-        const largeMapOnNode2 = await node2.loadCoValueCore(largeMap.core.id);
-        if (largeMapOnNode2 === "unavailable") {
-            throw new Error("Large map is unavailable on node2");
-        }
-        const endSync = performance.now();
-        const syncTime = endSync - startSync;
-        // Verify that all data was synced correctly
-        const syncedMap = new RawCoMap(largeMapOnNode2);
-        expect(Object.keys(largeMapOnNode2.getCurrentContent().toJSON() || {}).length).toBe(chunks);
-        for (let i = 0; i < chunks; i++) {
-            const key = `key${i}`;
-            const expectedValue = Buffer.alloc(chunkSize, `value${i}`).toString("base64");
-            expect(syncedMap.get(key)).toBe(expectedValue);
-        }
-        // Check that sync time is reasonable (this threshold may need adjustment)
-        const reasonableSyncTime = 10; // 30 seconds
-        expect(syncTime).toBeLessThan(reasonableSyncTime);
-        // Check memory usage (this threshold may need adjustment)
-        const memoryUsage = process.memoryUsage().heapUsed / 1024 / 1024; // in MB
-        const reasonableMemoryUsage = 1; // 500 MB
-        expect(memoryUsage).toBeLessThan(reasonableMemoryUsage);
-    });
     test("Node correctly handles and recovers from network partitions", async () => {
         // Create three nodes
         const [admin1, session1] = randomAnonymousAccountAndSessionID();
@@ -1094,7 +354,9 @@ test("a value created on one node can be loaded on anotehr node even if not dire
 });
 describe("SyncManager - knownStates vs optimisticKnownStates", () => {
     test("knownStates and optimisticKnownStates are the same when the coValue is fully synced", async () => {
-        const { node: client } = await createConnectedTestNode();
+        const { node: client } = await setupTestAccount({
+            connected: true,
+        });
         // Create test data
         const group = client.createGroup();
         const mapOnClient = group.createMap();
@@ -1103,31 +365,31 @@ describe("SyncManager - knownStates vs optimisticKnownStates", () => {
         // Wait for the full sync to complete
         await mapOnClient.core.waitForSync();
         const peerStateClient = client.syncManager.getPeers()[0];
-        const peerStateJazzCloud = jazzCloud.syncManager.getPeers()[0];
+        const peerStateJazzCloud = jazzCloud.node.syncManager.getPeers()[0];
         // The optimisticKnownStates should be the same as the knownStates after the full sync is complete
         expect(peerStateClient.optimisticKnownStates.get(mapOnClient.core.id)).toEqual(peerStateClient.knownStates.get(mapOnClient.core.id));
         // On the other node the knownStates should be updated correctly based on the messages we received
         expect(peerStateJazzCloud.optimisticKnownStates.get(mapOnClient.core.id)).toEqual(peerStateJazzCloud.knownStates.get(mapOnClient.core.id));
     });
     test("optimisticKnownStates is updated as new transactions are sent, while knownStates only when the updates are acknowledged", async () => {
-        const { node: client, nodeToServerPeer } = await createConnectedTestNode();
+        const client = await setupTestAccount();
+        const { peer, peerState } = client.connectToSyncServer();
         // Create test data and sync the first change
         // We want that both the nodes know about the coValue so we can test
         // the content acknowledgement flow.
-        const group = client.createGroup();
+        const group = client.node.createGroup();
         const map = group.createMap();
         map.set("key1", "value1", "trusting");
-        await client.syncManager.actuallySyncCoValue(map.core);
+        await client.node.syncManager.actuallySyncCoValue(map.core);
         await map.core.waitForSync();
         // Block the content messages
         // The main difference between optimisticKnownStates and knownStates is that
         // optimisticKnownStates is updated when the content messages are sent,
         // while knownStates is only updated when we receive the "known" messages
         // that are acknowledging the receipt of the content messages
-        const outgoing = blockMessageTypeOnOutgoingPeer(nodeToServerPeer, "content");
+        const outgoing = blockMessageTypeOnOutgoingPeer(peer, "content");
         map.set("key2", "value2", "trusting");
-        await client.syncManager.actuallySyncCoValue(map.core);
-        const peerState = client.syncManager.peers[nodeToServerPeer.id];
+        await client.node.syncManager.actuallySyncCoValue(map.core);
         expect(peerState.optimisticKnownStates.get(map.core.id)).not.toEqual(peerState.knownStates.get(map.core.id));
         // Restore the implementation of push and send the blocked messages
         // After this the full sync can be completed and the other node will
@@ -1140,37 +402,35 @@ describe("SyncManager - knownStates vs optimisticKnownStates", () => {
 });
 describe("SyncManager.addPeer", () => {
     test("new peer gets a copy of previous peer's knownStates when replacing it", async () => {
-        const { node: client } = await createConnectedTestNode();
+        const client = await setupTestAccount();
+        const { peerState: firstPeerState, getCurrentPeerState } = client.connectToSyncServer();
         // Create test data
-        const group = client.createGroup();
+        const group = client.node.createGroup();
         const map = group.createMap();
         map.set("key1", "value1", "trusting");
-        await client.syncManager.actuallySyncCoValue(map.core);
+        await client.node.syncManager.actuallySyncCoValue(map.core);
         // Wait for initial sync
         await map.core.waitForSync();
-        const firstPeerState = client.syncManager.getPeers()[0];
         // Store the initial known states
         const initialKnownStates = firstPeerState.knownStates;
         // Create new connection with same ID
-        const [secondPeer] = connectedPeers(firstPeerState.id, "unusedPeer", {
-            peer1role: "server",
-            peer2role: "client",
-        });
-        // Add new peer with same ID
-        client.syncManager.addPeer(secondPeer);
-        const newPeerState = client.syncManager.getPeers()[0];
+        client.connectToSyncServer();
+        // Wait for the new peer to be added
+        await waitFor(() => expect(getCurrentPeerState()).not.toBe(firstPeerState));
         // Verify that the new peer has a copy of the previous known states
-        const newPeerKnownStates = newPeerState.knownStates;
+        const newPeerKnownStates = getCurrentPeerState().knownStates;
         expect(newPeerKnownStates).not.toBe(initialKnownStates); // Should be a different instance
         expect(newPeerKnownStates.get(map.core.id)).toEqual(initialKnownStates.get(map.core.id));
     });
     test("new peer with new ID starts with empty knownStates", async () => {
-        const { node: client } = await createConnectedTestNode();
+        const client = await setupTestAccount({
+            connected: true,
+        });
         // Create test data
-        const group = client.createGroup();
+        const group = client.node.createGroup();
         const map = group.createMap();
         map.set("key1", "value1", "trusting");
-        await client.syncManager.actuallySyncCoValue(map.core);
+        await client.node.syncManager.actuallySyncCoValue(map.core);
         // Wait for initial sync
         await map.core.waitForSync();
         // Connect second peer with different ID
@@ -1179,72 +439,82 @@ describe("SyncManager.addPeer", () => {
             peer2role: "server",
         });
         // Add new peer with different ID
-        client.syncManager.addPeer(brandNewPeer);
+        client.node.syncManager.addPeer(brandNewPeer);
         // Verify that the new peer starts with empty known states
-        const newPeerKnownStates = client.syncManager.peers["brandNewPeer"].knownStates;
+        const newPeerKnownStates = client.node.syncManager.peers["brandNewPeer"].knownStates;
         expect(newPeerKnownStates.get(map.core.id)).toBe(undefined);
     });
     test("when adding a peer with the same ID as a previous peer, the previous peer is closed", async () => {
-        const { node: client } = await createConnectedTestNode();
+        const client = await setupTestAccount({});
+        const { peerState: firstPeerState } = client.connectToSyncServer();
         // Store reference to first peer
-        const firstPeer = client.syncManager.getPeers()[0];
-        const closeSpy = vi.spyOn(firstPeer, "gracefulShutdown");
+        const closeSpy = vi.spyOn(firstPeerState, "gracefulShutdown");
         // Create and add replacement peer
-        const [secondPeer] = connectedPeers(firstPeer.id, "unusedPeer", {
+        const [secondPeer] = connectedPeers(firstPeerState.id, "unusedPeer", {
             peer1role: "server",
             peer2role: "client",
         });
-        client.syncManager.addPeer(secondPeer);
+        client.node.syncManager.addPeer(secondPeer);
         // Verify thet the first peer had ben closed correctly
         expect(closeSpy).toHaveBeenCalled();
-        expect(firstPeer.closed).toBe(true);
+        expect(firstPeerState.closed).toBe(true);
     });
     test("when adding a peer with the same ID as a previous peer and the previous peer is closed, do not attempt to close it again", async () => {
-        const { node: client } = await createConnectedTestNode();
+        const client = await setupTestAccount({
+            connected: true,
+        });
         // Store reference to first peer
-        const firstPeer = client.syncManager.getPeers()[0];
-        firstPeer.gracefulShutdown();
-        const closeSpy = vi.spyOn(firstPeer, "gracefulShutdown");
+        const { peerState: firstPeerState } = client.connectToSyncServer();
+        firstPeerState.gracefulShutdown();
+        const closeSpy = vi.spyOn(firstPeerState, "gracefulShutdown");
         // Create and add replacement peer
-        const [secondPeer] = connectedPeers(firstPeer.id, "unusedPeer", {
+        const [secondPeer] = connectedPeers(firstPeerState.id, "unusedPeer", {
             peer1role: "server",
             peer2role: "client",
         });
-        client.syncManager.addPeer(secondPeer);
+        client.node.syncManager.addPeer(secondPeer);
         // Verify thet the first peer had not been closed again
         expect(closeSpy).not.toHaveBeenCalled();
-        expect(firstPeer.closed).toBe(true);
+        expect(firstPeerState.closed).toBe(true);
     });
     test("when adding a server peer the local coValues should be sent to it", async () => {
-        const { node: client, addServerPeer } = await createConnectedTestNode({
+        const client = await setupTestAccount({
             connected: false,
         });
-        const group = client.createGroup();
+        const group = client.node.createGroup();
         const map = group.createMap();
         map.set("key1", "value1", "trusting");
-        addServerPeer();
+        client.connectToSyncServer();
         await map.core.waitForSync();
-        expect(jazzCloud.coValuesStore.get(map.id).state.type).toBe("available");
+        expect(jazzCloud.node.coValuesStore.get(map.id).state.type).toBe("available");
     });
 });
 describe("loadCoValueCore with retry", () => {
     test("should load the value if available on the server", async () => {
-        const { node: client } = await createConnectedTestNode();
-        const { node: anotherClient } = await createConnectedTestNode();
-        const group = anotherClient.createGroup();
+        const client = await setupTestAccount({
+            connected: true,
+        });
+        const anotherClient = await setupTestAccount({
+            connected: true,
+        });
+        const group = anotherClient.node.createGroup();
         const map = group.createMap();
         map.set("key1", "value1", "trusting");
-        const promise = client.loadCoValueCore(map.id);
+        const promise = client.node.loadCoValueCore(map.id);
         await expect(promise).resolves.not.toBe("unavailable");
     });
     test("should handle correctly two subsequent loads", async () => {
-        const { node: client } = await createConnectedTestNode();
-        const { node: anotherClient } = await createConnectedTestNode();
-        const group = anotherClient.createGroup();
+        const client = await setupTestAccount({
+            connected: true,
+        });
+        const anotherClient = await setupTestAccount({
+            connected: true,
+        });
+        const group = anotherClient.node.createGroup();
         const map = group.createMap();
         map.set("key1", "value1", "trusting");
-        const promise1 = client.loadCoValueCore(map.id);
-        const promise2 = client.loadCoValueCore(map.id);
+        const promise1 = client.node.loadCoValueCore(map.id);
+        const promise2 = client.node.loadCoValueCore(map.id);
         await expect(promise1).resolves.not.toBe("unavailable");
         await expect(promise2).resolves.not.toBe("unavailable");
     });
@@ -1278,46 +548,44 @@ describe("loadCoValueCore with retry", () => {
 });
 describe("waitForSyncWithPeer", () => {
     test("should resolve when the coValue is fully uploaded into the peer", async () => {
-        const { node: client } = await createConnectedTestNode();
+        const client = await setupTestAccount();
+        const { peerState } = client.connectToSyncServer();
         // Create test data
-        const group = client.createGroup();
+        const group = client.node.createGroup();
         const map = group.createMap();
         map.set("key1", "value1", "trusting");
-        await client.syncManager.actuallySyncCoValue(map.core);
-        const peer = client.syncManager.getPeers()[0];
-        if (!peer) {
-            throw new Error("No peer found");
-        }
-        await expect(client.syncManager.waitForSyncWithPeer(peer.id, map.core.id, 100)).resolves.toBe(true);
+        await client.node.syncManager.actuallySyncCoValue(map.core);
+        await expect(client.node.syncManager.waitForSyncWithPeer(peerState.id, map.core.id, 100)).resolves.toBe(true);
     });
     test("should not resolve when the coValue is not synced", async () => {
-        const { node: client } = await createConnectedTestNode();
-        const peer = client.syncManager.getPeers()[0];
-        if (!peer) {
-            throw new Error("No peer found");
-        }
+        const client = await setupTestAccount();
+        const { peerState } = client.connectToSyncServer();
         // Create test data
-        const group = client.createGroup();
+        const group = client.node.createGroup();
         const map = group.createMap();
         map.set("key1", "value1", "trusting");
-        vi.spyOn(peer, "pushOutgoingMessage").mockImplementation(async () => {
+        vi.spyOn(peerState, "pushOutgoingMessage").mockImplementation(async () => {
             return Promise.resolve();
         });
-        await client.syncManager.actuallySyncCoValue(map.core);
-        await expect(client.syncManager.waitForSyncWithPeer(peer.id, map.core.id, 100)).rejects.toThrow("Timeout");
+        await client.node.syncManager.actuallySyncCoValue(map.core);
+        await expect(client.node.syncManager.waitForSyncWithPeer(peerState.id, map.core.id, 100)).rejects.toThrow("Timeout");
     });
 });
 test("Should not crash when syncing an unknown coValue type", async () => {
-    const { node: client } = await createConnectedTestNode();
-    const coValue = client.createCoValue({
+    const client = await setupTestAccount({
+        connected: true,
+    });
+    const coValue = client.node.createCoValue({
         type: "ooops",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
         ...Crypto.createdNowUnique(),
     });
     await coValue.waitForSync();
-    const { node: anotherClient } = await createConnectedTestNode();
-    const coValueOnTheOtherNode = await loadCoValueOrFail(anotherClient, coValue.getCurrentContent().id);
+    const anotherClient = await setupTestAccount({
+        connected: true,
+    });
+    const coValueOnTheOtherNode = await loadCoValueOrFail(anotherClient.node, coValue.getCurrentContent().id);
     expect(coValueOnTheOtherNode.id).toBe(coValue.id);
 });
 describe("metrics", () => {
@@ -1395,183 +663,6 @@ describe("metrics", () => {
         expect(connectedServerPeers).toBe(0);
     });
 });
-describe("sync protocol", () => {
-    test("should have the correct messages exchanged between client and server", async () => {
-        // Creating the account from agent to simplify the messages exchange
-        const { node: client, messages } = await createConnectedTestAgentNode();
-        const group = client.createGroup();
-        const map = group.createMap();
-        map.set("hello", "world", "trusting");
-        await map.core.waitForSync();
-        const mapOnJazzCloud = await loadCoValueOrFail(jazzCloud, map.id);
-        expect(mapOnJazzCloud.get("hello")).toEqual("world");
-        expect(messages).toEqual([
-            {
-                from: "client",
-                msg: {
-                    action: "load",
-                    header: true,
-                    id: group.id,
-                    sessions: {
-                        [client.currentSessionID]: 3,
-                    },
-                },
-            },
-            {
-                from: "server",
-                msg: {
-                    action: "load",
-                    header: false,
-                    id: group.id,
-                    sessions: {},
-                },
-            },
-            {
-                from: "client",
-                msg: {
-                    action: "load",
-                    header: true,
-                    id: map.id,
-                    sessions: {
-                        [client.currentSessionID]: 1,
-                    },
-                },
-            },
-            {
-                from: "server",
-                msg: {
-                    action: "load",
-                    header: false,
-                    id: map.id,
-                    sessions: {},
-                },
-            },
-            {
-                from: "client",
-                msg: {
-                    action: "content",
-                    header: {
-                        createdAt: expect.any(String),
-                        meta: null,
-                        ruleset: {
-                            initialAdmin: client.account.id,
-                            type: "group",
-                        },
-                        type: "comap",
-                        uniqueness: expect.any(String),
-                    },
-                    id: group.id,
-                    new: {
-                        [client.currentSessionID]: {
-                            after: 0,
-                            lastSignature: expect.any(String),
-                            newTransactions: expect.any(Array),
-                        },
-                    },
-                    priority: 0,
-                },
-            },
-            {
-                from: "client",
-                msg: {
-                    action: "content",
-                    header: {
-                        createdAt: expect.any(String),
-                        meta: null,
-                        ruleset: {
-                            group: group.id,
-                            type: "ownedByGroup",
-                        },
-                        type: "comap",
-                        uniqueness: expect.any(String),
-                    },
-                    id: map.id,
-                    new: {
-                        [client.currentSessionID]: {
-                            after: 0,
-                            lastSignature: expect.any(String),
-                            newTransactions: expect.any(Array),
-                        },
-                    },
-                    priority: 3,
-                },
-            },
-            {
-                from: "server",
-                msg: {
-                    action: "known",
-                    header: true,
-                    id: group.id,
-                    sessions: {
-                        [client.currentSessionID]: 3,
-                    },
-                },
-            },
-            {
-                // TODO: This is a redundant message, we should remove it
-                from: "client",
-                msg: {
-                    action: "content",
-                    header: {
-                        createdAt: expect.any(String),
-                        meta: null,
-                        ruleset: {
-                            group: group.id,
-                            type: "ownedByGroup",
-                        },
-                        type: "comap",
-                        uniqueness: expect.any(String),
-                    },
-                    id: map.id,
-                    new: {
-                        [client.currentSessionID]: {
-                            after: 0,
-                            lastSignature: expect.any(String),
-                            newTransactions: expect.any(Array),
-                        },
-                    },
-                    priority: 3,
-                },
-            },
-            {
-                // TODO: This is a redundant message, we should remove it
-                from: "server",
-                msg: {
-                    action: "known",
-                    asDependencyOf: undefined,
-                    header: true,
-                    id: group.id,
-                    sessions: {
-                        [client.currentSessionID]: 3,
-                    },
-                },
-            },
-            {
-                from: "server",
-                msg: {
-                    action: "known",
-                    header: true,
-                    id: map.id,
-                    sessions: {
-                        [client.currentSessionID]: 1,
-                    },
-                },
-            },
-            {
-                from: "server",
-                msg: {
-                    action: "known",
-                    asDependencyOf: undefined,
-                    header: true,
-                    id: map.id,
-                    sessions: {
-                        [client.currentSessionID]: 1,
-                    },
-                },
-            },
-        ]);
-    });
-});
 function groupContentEx(group) {
     return {
         action: "content",
@@ -1586,20 +677,20 @@ function groupStateEx(group) {
 }
 describe("LocalNode.load", () => {
     test("should throw error when trying to load with undefined ID", async () => {
-        const { node } = await createConnectedTestNode();
+        const client = await setupTestAccount();
         // @ts-expect-error Testing with undefined ID
-        await expect(node.load(undefined)).rejects.toThrow("Trying to load CoValue with undefined id");
+        await expect(client.node.load(undefined)).rejects.toThrow("Trying to load CoValue with undefined id");
     });
     test("should throw error when trying to load with invalid ID format", async () => {
-        const { node } = await createConnectedTestNode();
+        const client = await setupTestAccount();
         // @ts-expect-error Testing with invalid ID format
-        await expect(node.load("invalid_id")).rejects.toThrow("Trying to load CoValue with invalid id invalid_id");
+        await expect(client.node.load("invalid_id")).rejects.toThrow("Trying to load CoValue with invalid id invalid_id");
     });
 });
 describe("SyncManager.handleSyncMessage", () => {
     test("should ignore messages with undefined ID", async () => {
-        const { node: client } = await createConnectedTestNode();
-        const peer = client.syncManager.getPeers()[0];
+        const client = await setupTestAccount();
+        const { peerState } = client.connectToSyncServer();
         // Create an invalid message with undefined ID
         const invalidMessage = {
             action: "load",
@@ -1607,14 +698,14 @@ describe("SyncManager.handleSyncMessage", () => {
             header: false,
             sessions: {},
         };
-        await client.syncManager.handleSyncMessage(invalidMessage, peer);
+        await client.node.syncManager.handleSyncMessage(invalidMessage, peerState);
         // Verify that no state changes occurred
-        expect(peer.knownStates.has(invalidMessage.id)).toBe(false);
-        expect(peer.optimisticKnownStates.has(invalidMessage.id)).toBe(false);
+        expect(peerState.knownStates.has(invalidMessage.id)).toBe(false);
+        expect(peerState.optimisticKnownStates.has(invalidMessage.id)).toBe(false);
     });
     test("should ignore messages with invalid ID format", async () => {
-        const { node: client } = await createConnectedTestNode();
-        const peer = client.syncManager.getPeers()[0];
+        const client = await setupTestAccount();
+        const { peerState } = client.connectToSyncServer();
         // Create an invalid message with wrong ID format
         const invalidMessage = {
             action: "load",
@@ -1622,41 +713,41 @@ describe("SyncManager.handleSyncMessage", () => {
             header: false,
             sessions: {},
         };
-        await client.syncManager.handleSyncMessage(invalidMessage, peer);
+        await client.node.syncManager.handleSyncMessage(invalidMessage, peerState);
         // Verify that no state changes occurred
-        expect(peer.knownStates.has(invalidMessage.id)).toBe(false);
-        expect(peer.optimisticKnownStates.has(invalidMessage.id)).toBe(false);
+        expect(peerState.knownStates.has(invalidMessage.id)).toBe(false);
+        expect(peerState.optimisticKnownStates.has(invalidMessage.id)).toBe(false);
     });
     test("should ignore messages for errored coValues", async () => {
-        const { node: client } = await createConnectedTestNode();
-        const peer = client.syncManager.getPeers()[0];
+        const client = await setupTestAccount();
+        const { peerState } = client.connectToSyncServer();
         // Add a coValue to the errored set
         const erroredId = "co_z123";
-        peer.erroredCoValues.set(erroredId, new Error("Test error"));
+        peerState.erroredCoValues.set(erroredId, new Error("Test error"));
         const message = {
             action: "load",
             id: erroredId,
             header: false,
             sessions: {},
         };
-        await client.syncManager.handleSyncMessage(message, peer);
+        await client.node.syncManager.handleSyncMessage(message, peerState);
         // Verify that no state changes occurred
-        expect(peer.knownStates.has(message.id)).toBe(false);
-        expect(peer.optimisticKnownStates.has(message.id)).toBe(false);
+        expect(peerState.knownStates.has(message.id)).toBe(false);
+        expect(peerState.optimisticKnownStates.has(message.id)).toBe(false);
     });
     test("should process valid messages", async () => {
-        const { node: client } = await createConnectedTestNode();
-        const group = client.createGroup();
-        const peer = client.syncManager.getPeers()[0];
+        const client = await setupTestAccount();
+        const { peerState } = client.connectToSyncServer();
+        const group = client.node.createGroup();
         const validMessage = {
             action: "load",
             id: group.id,
             header: false,
             sessions: {},
         };
-        await client.syncManager.handleSyncMessage(validMessage, peer);
+        await client.node.syncManager.handleSyncMessage(validMessage, peerState);
         // Verify that the message was processed
-        expect(peer.knownStates.has(group.id)).toBe(true);
+        expect(peerState.knownStates.has(group.id)).toBe(true);
     });
 });
 //# sourceMappingURL=sync.test.js.map