cojson 0.20.16 → 0.20.18

package/src/tests/clockDrift.integration.test.ts

@@ -0,0 +1,261 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { logger } from "../logger.js";
+import {
+  loadCoValueOrFail,
+  setupTestAccount,
+  setupTestNode,
+  waitFor,
+} from "./testUtils.js";
+
+const CLIENT_SKEW_MS = 20_000;
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("clock drift across peers with clock sync enabled", () => {
+  test("worker can publish and self-remove after a skewed client with clock sync creates group, grant and chat", async () => {
+    const errorSpy = vi.spyOn(logger, "error");
+
+    const realNow = Math.floor(performance.timeOrigin + performance.now());
+
+    vi.spyOn(Date, "now").mockImplementation(() => {
+      const real = performance.timeOrigin + performance.now();
+      return Math.floor(real) + CLIENT_SKEW_MS;
+    });
+
+    const worker = await setupTestAccount({
+      isSyncServer: true,
+    });
+
+    const client = await setupTestAccount({
+      connected: true,
+      experimental_clockSyncFromServerPings: true,
+    });
+
+    const skewedNow = Date.now();
+    client.node.clockOffset.addSample({
+      serverTime: skewedNow - CLIENT_SKEW_MS,
+      localReceiveTime: skewedNow,
+    });
+
+    const group = client.node.createGroup();
+
+    const workerAccountOnClient = await loadCoValueOrFail(
+      client.node,
+      worker.accountID,
+    );
+    group.addMember(workerAccountOnClient, "admin");
+
+    const oneToOneChat = group.createMap();
+    oneToOneChat.set("kind", "OneToOneChat", "trusting");
+    oneToOneChat.set("published", false, "trusting");
+
+    await oneToOneChat.core.waitForSync();
+    await group.core.waitForSync();
+
+    const clientGroupTxs = group.core.getValidSortedTransactions();
+    const maxClientGroupMadeAt = Math.max(
+      ...clientGroupTxs.map((tx) => tx.madeAt),
+    );
+    expect(maxClientGroupMadeAt).toBeLessThan(realNow + CLIENT_SKEW_MS - 5_000);
+
+    vi.restoreAllMocks();
+    const errorSpyAfter = vi.spyOn(logger, "error");
+
+    const chatOnWorker = await loadCoValueOrFail(worker.node, oneToOneChat.id);
+    const groupOnWorker = await loadCoValueOrFail(worker.node, group.id);
+    const workerAccountOnWorker = await loadCoValueOrFail(
+      worker.node,
+      worker.accountID,
+    );
+
+    await waitFor(() => {
+      expect(chatOnWorker.get("kind")).toBe("OneToOneChat");
+      expect(groupOnWorker.roleOf(worker.accountID)).toBe("admin");
+    });
+
+    chatOnWorker.set("published", true, "trusting");
+    groupOnWorker.removeMember(workerAccountOnWorker);
+
+    await chatOnWorker.core.waitForSync();
+    await groupOnWorker.core.waitForSync();
+
+    await waitFor(() => {
+      expect(oneToOneChat.get("published")).toBe(true);
+      expect(group.roleOf(worker.accountID)).not.toBe("admin");
+      expect(chatOnWorker.get("published")).toBe(true);
+      expect(groupOnWorker.roleOf(worker.accountID)).not.toBe("admin");
+    });
+
+    expect(oneToOneChat.get("published")).toBe(true);
+    expect(chatOnWorker.get("published")).toBe(true);
+    expect(group.roleOf(worker.accountID)).not.toBe("admin");
+    expect(groupOnWorker.roleOf(worker.accountID)).not.toBe("admin");
+
+    const forbiddenFragments = [
+      "invalid transaction",
+      "permission",
+      "rejected",
+      "not authorized",
+      "not authorised",
+    ];
+    const offendingCalls = [...errorSpy.mock.calls, ...errorSpyAfter.mock.calls]
+      .map((call) => call.map((arg) => String(arg)).join(" "))
+      .filter((line) =>
+        forbiddenFragments.some((f) => line.toLowerCase().includes(f)),
+      );
+    expect(offendingCalls).toEqual([]);
+  });
+});
+
+describe("experimental_clockSyncFromServerPings flag wiring", () => {
+  function seedOffset(
+    clockOffset: {
+      addSample: (s: { serverTime: number; localReceiveTime: number }) => void;
+    },
+    offsetMs: number,
+  ) {
+    const localReceiveTime = Date.now();
+    clockOffset.addSample({
+      serverTime: localReceiveTime + offsetMs,
+      localReceiveTime,
+    });
+  }
+
+  test("with the flag on, a seeded +10_000 ms offset pulls locally-stamped madeAt forward", () => {
+    const { node } = setupTestNode({
+      experimental_clockSyncFromServerPings: true,
+    });
+
+    seedOffset(node.clockOffset, 10_000);
+
+    const group = node.createGroup();
+    const map = group.createMap();
+
+    const before = Date.now();
+    map.set("k", "v", "trusting");
+    const after = Date.now();
+
+    const txs = map.core.getValidSortedTransactions();
+    const lastTx = txs.at(-1);
+    expect(lastTx).toBeDefined();
+    expect(lastTx!.madeAt).toBeGreaterThanOrEqual(before + 9_900);
+    expect(lastTx!.madeAt).toBeLessThanOrEqual(after + 10_100);
+  });
+
+  test("without the flag, a seeded +10_000 ms offset does NOT shift locally-stamped madeAt", () => {
+    const { node } = setupTestNode({
+      experimental_clockSyncFromServerPings: false,
+    });
+
+    seedOffset(node.clockOffset, 10_000);
+
+    const group = node.createGroup();
+    const map = group.createMap();
+
+    const before = Date.now();
+    map.set("k", "v", "trusting");
+    const after = Date.now();
+
+    const txs = map.core.getValidSortedTransactions();
+    const lastTx = txs.at(-1);
+    expect(lastTx).toBeDefined();
+    expect(lastTx!.madeAt).toBeGreaterThanOrEqual(before);
+    expect(lastTx!.madeAt).toBeLessThanOrEqual(after + 100);
+  });
+});
+
+describe("clock sync pulls skewed client stamps toward server time", () => {
+  test("with both nodes flag-on, a client whose wall clock is 20s ahead authors transactions that land near real time on the worker", async () => {
+    const errorSpy = vi.spyOn(logger, "error");
+
+    const worker = await setupTestAccount({
+      isSyncServer: true,
+      experimental_clockSyncFromServerPings: true,
+    });
+
+    const realNowBeforeClient = Date.now();
+
+    const SKEW_MS = 20_000;
+    vi.spyOn(Date, "now").mockImplementation(() => {
+      const real = Math.floor(performance.timeOrigin + performance.now());
+      return real + SKEW_MS;
+    });
+
+    const client = await setupTestAccount({
+      connected: true,
+      experimental_clockSyncFromServerPings: true,
+    });
+
+    const localReceiveTime = Date.now();
+    client.node.clockOffset.addSample({
+      serverTime: localReceiveTime - SKEW_MS,
+      localReceiveTime,
+    });
+
+    expect(client.node.clockOffset.currentOffset()).toBeLessThanOrEqual(
+      -SKEW_MS + 100,
+    );
+    expect(client.node.clockOffset.currentOffset()).toBeGreaterThanOrEqual(
+      -SKEW_MS - 100,
+    );
+
+    const group = client.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const map = group.createMap();
+    map.set("from", "skewed-client", "trusting");
+
+    await map.core.waitForSync();
+    await group.core.waitForSync();
+
+    vi.restoreAllMocks();
+    const errorSpyAfter = vi.spyOn(logger, "error");
+
+    const realNowAfter = Date.now();
+
+    const mapOnWorker = await loadCoValueOrFail(worker.node, map.id);
+
+    await waitFor(() => {
+      expect(mapOnWorker.get("from")).toBe("skewed-client");
+    });
+
+    const clientTxsOnWorker = mapOnWorker.core.getValidSortedTransactions();
+    const setTx = clientTxsOnWorker.find((tx) => {
+      const changes = tx.changes as ReadonlyArray<{
+        op?: string;
+        key?: string;
+        value?: unknown;
+      }>;
+      return (
+        changes?.[0]?.key === "from" && changes[0]?.value === "skewed-client"
+      );
+    });
+
+    expect(setTx).toBeDefined();
+
+    const TOLERANCE_MS = 2_000;
+    expect(setTx!.madeAt).toBeGreaterThanOrEqual(
+      realNowBeforeClient - TOLERANCE_MS,
+    );
+    expect(setTx!.madeAt).toBeLessThanOrEqual(realNowAfter + TOLERANCE_MS);
+
+    expect(setTx!.madeAt).toBeLessThan(realNowAfter + SKEW_MS - 5_000);
+
+    const forbiddenFragments = [
+      "invalid transaction",
+      "permission",
+      "rejected",
+      "not authorized",
+      "not authorised",
+      "out of order",
+    ];
+    const offendingCalls = [...errorSpy.mock.calls, ...errorSpyAfter.mock.calls]
+      .map((call) => call.map((arg) => String(arg)).join(" "))
+      .filter((line) =>
+        forbiddenFragments.some((f) => line.toLowerCase().includes(f)),
+      );
+    expect(offendingCalls).toEqual([]);
+  });
+});

package/src/tests/localNode.clockOffset.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from "vitest";
+import { ClockOffset } from "../ClockOffset.js";
+import { LocalNode } from "../localNode.js";
+import { randomAgentAndSessionID } from "./testUtils.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
+
+const Crypto = await WasmCrypto.create();
+
+function makeNode(opts: { experimental_clockSyncFromServerPings?: boolean }) {
+  const [admin, session] = randomAgentAndSessionID();
+  return new LocalNode(
+    admin.agentSecret,
+    session,
+    Crypto,
+    undefined,
+    undefined,
+    opts,
+  );
+}
+
+describe("LocalNode clock offset wiring", () => {
+  test("clockOffset is always present on the node, regardless of flag state", () => {
+    const withFlag = makeNode({ experimental_clockSyncFromServerPings: true });
+    const withoutFlag = makeNode({
+      experimental_clockSyncFromServerPings: false,
+    });
+
+    expect(withFlag.clockOffset).toBeInstanceOf(ClockOffset);
+    expect(withoutFlag.clockOffset).toBeInstanceOf(ClockOffset);
+  });
+
+  test("with the flag enabled, seeding clockOffset with a +10_000 ms sample pulls stampNow() forward by ~10_000 ms", () => {
+    const flagged = makeNode({ experimental_clockSyncFromServerPings: true });
+    const control = makeNode({
+      experimental_clockSyncFromServerPings: false,
+    });
+
+    const localReceiveTime = Date.now();
+    flagged.clockOffset.addSample({
+      serverTime: localReceiveTime + 10_000,
+      localReceiveTime,
+    });
+
+    const controlStamp = control.stampNow();
+    const flaggedStamp = flagged.stampNow();
+
+    const delta = flaggedStamp - controlStamp;
+    expect(delta).toBeGreaterThanOrEqual(9_900);
+    expect(delta).toBeLessThanOrEqual(10_100);
+  });
+
+  test("getClockOffsetDiagnostics() reflects current offset and sample count", () => {
+    const node = makeNode({ experimental_clockSyncFromServerPings: true });
+
+    expect(node.getClockOffsetDiagnostics()).toEqual({
+      currentOffset: 0,
+      sampleCount: 0,
+    });
+
+    const base = Date.now();
+    node.clockOffset.addSample({
+      serverTime: base + 400,
+      localReceiveTime: base,
+    });
+    node.clockOffset.addSample({
+      serverTime: base + 600,
+      localReceiveTime: base,
+    });
+
+    expect(node.getClockOffsetDiagnostics()).toEqual({
+      currentOffset: 500,
+      sampleCount: 2,
+    });
+  });
+
+  test("without the flag, seeding clockOffset with a +10_000 ms sample does NOT affect stampNow()", () => {
+    const node = makeNode({ experimental_clockSyncFromServerPings: false });
+
+    const localReceiveTime = Date.now();
+    node.clockOffset.addSample({
+      serverTime: localReceiveTime + 10_000,
+      localReceiveTime,
+    });
+
+    const before = Date.now();
+    const stamp = node.stampNow();
+    const after = Date.now();
+
+    expect(stamp).toBeGreaterThanOrEqual(before);
+    expect(stamp).toBeLessThanOrEqual(after + 100);
+  });
+});

package/src/tests/testUtils.ts

@@ -452,6 +452,7 @@ export function setupTestNode(
     secret?: AgentSecret;
     syncWhen?: SyncWhen;
     enableFullStorageReconciliation?: boolean;
+    experimental_clockSyncFromServerPings?: boolean;
   } = {},
 ) {
   const [admin, session] = opts.secret
@@ -464,6 +465,10 @@ export function setupTestNode(
     Crypto,
     opts.syncWhen,
     opts.enableFullStorageReconciliation,
+    {
+      experimental_clockSyncFromServerPings:
+        opts.experimental_clockSyncFromServerPings,
+    },
   );
 
   if (opts.isSyncServer) {
@@ -542,6 +547,10 @@ export function setupTestNode(
         Crypto,
         opts.syncWhen,
         opts.enableFullStorageReconciliation,
+        {
+          experimental_clockSyncFromServerPings:
+            opts.experimental_clockSyncFromServerPings,
+        },
       );
 
       if (opts.isSyncServer) {
@@ -556,6 +565,8 @@ export function setupTestNode(
         connected: opts.connected,
         isSyncServer: opts.isSyncServer,
         enableFullStorageReconciliation: opts.enableFullStorageReconciliation,
+        experimental_clockSyncFromServerPings:
+          opts.experimental_clockSyncFromServerPings,
       });
     },
     disconnect: () => {
@@ -577,6 +588,7 @@ export async function setupTestAccount(
     storage?: StorageAPI;
     accountID?: RawAccountID;
     accountSecret?: AgentSecret;
+    experimental_clockSyncFromServerPings?: boolean;
   } = {},
 ) {
   const ctx =
@@ -593,6 +605,8 @@ export async function setupTestAccount(
             accountID: opts.accountID,
             accountSecret: opts.accountSecret,
             sessionID: Crypto.newRandomSessionID(opts.accountID),
+            experimental_clockSyncFromServerPings:
+              opts.experimental_clockSyncFromServerPings,
           }),
           accountID: opts.accountID,
           accountSecret: opts.accountSecret,
@@ -602,6 +616,8 @@ export async function setupTestAccount(
           crypto: Crypto,
           creationProps: { name: "Client" },
           storage: opts.storage,
+          experimental_clockSyncFromServerPings:
+            opts.experimental_clockSyncFromServerPings,
         });
 
   if (opts.isSyncServer) {