cojson 0.17.14 → 0.18.1

package/src/coValues/coStream.ts

@@ -13,6 +13,7 @@ import { isAccountID } from "../typeUtils/isAccountID.js";
 import { isCoValue } from "../typeUtils/isCoValue.js";
 import { RawAccountID } from "./account.js";
 import { RawGroup } from "./group.js";
+import { Transaction } from "../coValueCore/verifiedState.js";
 
 export type BinaryStreamInfo = {
   mimeType: string;
@@ -58,15 +59,18 @@ export class RawCoStreamView<
     [key: SessionID]: CoStreamItem<Item>[];
   };
   /** @internal */
-  knownTransactions: CoValueKnownState["sessions"];
-  totalValidTransactions = 0;
+  knownTransactions: Set<Transaction>;
   readonly _item!: Item;
 
+  get totalValidTransactions() {
+    return this.knownTransactions.size;
+  }
+
   constructor(core: AvailableCoValueCore) {
     this.id = core.id as CoID<this>;
     this.core = core;
     this.items = {};
-    this.knownTransactions = {};
+    this.knownTransactions = new Set<Transaction>();
     this.processNewTransactions();
   }
 
@@ -113,7 +117,6 @@ export class RawCoStreamView<
     }
 
     for (const { txID, madeAt, changes } of newValidTransactions) {
-      this.totalValidTransactions++;
       for (const changeUntyped of changes) {
         const change = changeUntyped as Item;
         let entries = this.items[txID.sessionID];
@@ -124,10 +127,6 @@ export class RawCoStreamView<
         entries.push({ value: change, madeAt, tx: txID });
         changeEntries.add(entries);
       }
-      this.knownTransactions[txID.sessionID] = Math.max(
-        this.knownTransactions[txID.sessionID] ?? 0,
-        txID.txIndex,
-      );
     }
 
     for (const entries of changeEntries) {

package/src/ids.ts

@@ -20,7 +20,10 @@ export function rawCoIDfromBytes(bytes: Uint8Array): RawCoID {
   return `co_z${base58.encode(bytes.slice(0, shortHashLength))}` as RawCoID;
 }
 
-export type TransactionID = { sessionID: SessionID; txIndex: number };
+export type TransactionID = {
+  sessionID: SessionID;
+  txIndex: number;
+};
 
 export type AgentID = `sealer_z${string}/signer_z${string}`;
 

package/src/jsonStringify.ts

@@ -66,3 +66,11 @@ export function stableStringify<T>(
 export function parseJSON<T>(json: Stringified<T>): T {
   return JSON.parse(json);
 }
+
+export function safeParseJSON<T>(json: Stringified<T>): T | undefined {
+  try {
+    return JSON.parse(json);
+  } catch (e) {
+    return undefined;
+  }
+}

package/src/permissions.ts

@@ -77,10 +77,7 @@ function logPermissionError(
   logger.debug("Permission error: " + message, attributes);
 }
 
-export function determineValidTransactions(
-  coValue: CoValueCore,
-  knownTransactions?: CoValueKnownState["sessions"],
-): { txID: TransactionID; tx: Transaction }[] {
+export function determineValidTransactions(coValue: CoValueCore) {
   if (!coValue.isAvailable()) {
     throw new Error("determineValidTransactions CoValue is not available");
   }
@@ -91,8 +88,7 @@ export function determineValidTransactions(
       throw new Error("Group must have initialAdmin");
     }
 
-    return determineValidTransactionsForGroup(coValue, initialAdmin)
-      .validTransactions;
+    determineValidTransactionsForGroup(coValue, initialAdmin);
   } else if (coValue.verified.header.ruleset.type === "ownedByGroup") {
     const groupContent = expectGroup(
       coValue.node
@@ -107,58 +103,44 @@ export function determineValidTransactions(
       throw new Error("Group must be a map");
     }
 
-    const validTransactions: ValidTransactionsResult[] = [];
-
-    for (const [sessionID, sessionLog] of coValue.verified.sessions.entries()) {
-      const transactor = accountOrAgentIDfromSessionID(sessionID);
-      const knownTransactionsForSession = knownTransactions?.[sessionID] ?? -1;
+    for (const tx of coValue.verifiedTransactions) {
+      if (tx.isValidated) {
+        continue;
+      }
 
-      sessionLog.transactions.forEach((tx, txIndex) => {
-        if (knownTransactionsForSession >= txIndex) {
-          return;
-        }
+      tx.isValidated = true;
+      const wasValid = tx.isValid;
 
-        const groupAtTime = groupContent.atTime(tx.madeAt);
-        const effectiveTransactor = agentInAccountOrMemberInGroup(
-          transactor,
-          groupAtTime,
-        );
+      const groupAtTime = groupContent.atTime(tx.madeAt);
+      const effectiveTransactor = agentInAccountOrMemberInGroup(
+        tx.author,
+        groupAtTime,
+      );
 
-        if (!effectiveTransactor) {
-          return;
-        }
+      if (!effectiveTransactor) {
+        tx.isValid = false;
+        continue;
+      }
 
-        const transactorRoleAtTxTime =
-          groupAtTime.roleOfInternal(effectiveTransactor);
+      const transactorRoleAtTxTime =
+        groupAtTime.roleOfInternal(effectiveTransactor);
 
-        if (
-          transactorRoleAtTxTime !== "admin" &&
-          transactorRoleAtTxTime !== "writer" &&
-          transactorRoleAtTxTime !== "writeOnly"
-        ) {
-          return;
-        }
+      if (
+        transactorRoleAtTxTime !== "admin" &&
+        transactorRoleAtTxTime !== "writer" &&
+        transactorRoleAtTxTime !== "writeOnly"
+      ) {
+        tx.isValid = false;
+        continue;
+      }
 
-        validTransactions.push({ txID: { sessionID, txIndex }, tx });
-      });
+      tx.isValid = true;
     }
-
-    return validTransactions;
   } else if (coValue.verified.header.ruleset.type === "unsafeAllowAll") {
-    const validTransactions: ValidTransactionsResult[] = [];
-
-    for (const [sessionID, sessionLog] of coValue.verified.sessions.entries()) {
-      const knownTransactionsForSession = knownTransactions?.[sessionID] ?? -1;
-
-      sessionLog.transactions.forEach((tx, txIndex) => {
-        if (knownTransactionsForSession >= txIndex) {
-          return;
-        }
-
-        validTransactions.push({ txID: { sessionID, txIndex }, tx });
-      });
+    for (const tx of coValue.verifiedTransactions) {
+      tx.isValid = true;
+      tx.isValidated = true;
     }
-    return validTransactions;
   } else {
     throw new Error(
       "Unknown ruleset type " +
@@ -228,22 +210,9 @@ function determineValidTransactionsForGroup(
   coValue: CoValueCore,
   initialAdmin: RawAccountID | AgentID,
   extendChain?: Set<CoValueCore["id"]>,
-): { validTransactions: ValidTransactionsResult[]; memberState: MemberState } {
-  const allTransactionsSorted: {
-    sessionID: SessionID;
-    txIndex: number;
-    tx: Transaction;
-  }[] = [];
-
-  for (const [sessionID, sessionLog] of coValue.verified?.sessions.entries() ??
-    []) {
-    sessionLog.transactions.forEach((tx, txIndex) => {
-      allTransactionsSorted.push({ sessionID, txIndex, tx });
-    });
-  }
-
-  allTransactionsSorted.sort((a, b) => {
-    return a.tx.madeAt - b.tx.madeAt;
+): { memberState: MemberState } {
+  coValue.verifiedTransactions.sort((a, b) => {
+    return a.madeAt - b.madeAt;
   });
 
   const memberState: MemberState = {};
@@ -252,15 +221,16 @@ function determineValidTransactionsForGroup(
 
   const writeKeys = new Set<string>();
 
-  for (const { sessionID, txIndex, tx } of allTransactionsSorted) {
-    const transactor = accountOrAgentIDfromSessionID(sessionID);
+  for (const transaction of coValue.verifiedTransactions) {
+    const transactor = transaction.author;
+
+    transaction.isValidated = true;
+
+    const tx = transaction.tx;
 
     if (tx.privacy === "private") {
       if (memberState[transactor] === "admin") {
-        validTransactions.push({
-          txID: { sessionID, txIndex },
-          tx,
-        });
+        transaction.isValid = true;
         continue;
       } else {
         logPermissionError(
@@ -270,16 +240,20 @@ function determineValidTransactionsForGroup(
       }
     }
 
-    let changes;
+    let changes = transaction.changes;
 
-    try {
-      changes = parseJSON(tx.changes);
-    } catch (e) {
-      logPermissionError("Invalid JSON in transaction", {
-        id: coValue.id,
-        tx,
-      });
-      continue;
+    if (!changes) {
+      try {
+        changes = parseJSON(tx.changes);
+        transaction.changes = changes;
+      } catch (e) {
+        logPermissionError("Invalid JSON in transaction", {
+          id: coValue.id,
+          tx,
+        });
+        transaction.hasInvalidChanges = true;
+        continue;
+      }
     }
 
     const change = changes[0] as
@@ -292,29 +266,33 @@ function determineValidTransactionsForGroup(
 
     if (changes.length !== 1) {
       logPermissionError("Group transaction must have exactly one change");
+      transaction.isValid = false;
       continue;
     }
 
     if (change.op !== "set") {
       logPermissionError("Group transaction must set a role or readKey");
+      transaction.isValid = false;
       continue;
     }
 
     if (change.key === "readKey") {
       if (memberState[transactor] !== "admin") {
         logPermissionError("Only admins can set readKeys");
+        transaction.isValid = false;
         continue;
       }
 
-      validTransactions.push({ txID: { sessionID, txIndex }, tx });
+      transaction.isValid = true;
       continue;
     } else if (change.key === "profile") {
       if (memberState[transactor] !== "admin") {
         logPermissionError("Only admins can set profile");
+        transaction.isValid = false;
         continue;
       }
 
-      validTransactions.push({ txID: { sessionID, txIndex }, tx });
+      transaction.isValid = true;
       continue;
     } else if (change.key === "root") {
       if (memberState[transactor] !== "admin") {
@@ -322,7 +300,7 @@ function determineValidTransactionsForGroup(
         continue;
       }
 
-      validTransactions.push({ txID: { sessionID, txIndex }, tx });
+      transaction.isValid = true;
       continue;
     } else if (
       isKeyForKeyField(change.key) ||
@@ -337,15 +315,17 @@ function determineValidTransactionsForGroup(
         !isOwnWriteKeyRevelation(change.key, transactor, writeOnlyKeys)
       ) {
         logPermissionError("Only admins can reveal keys");
+        transaction.isValid = false;
         continue;
       }
 
       // TODO: check validity of agents who the key is revealed to?
-      validTransactions.push({ txID: { sessionID, txIndex }, tx });
+      transaction.isValid = true;
       continue;
     } else if (isParentExtension(change.key)) {
       if (memberState[transactor] !== "admin") {
         logPermissionError("Only admins can set parent extensions");
+        transaction.isValid = false;
         continue;
       }
 
@@ -364,13 +344,14 @@ function determineValidTransactionsForGroup(
         logPermissionError(
           "Circular extend detected, dropping the transaction",
         );
+        transaction.isValid = false;
         continue;
       }
 
-      validTransactions.push({ txID: { sessionID, txIndex }, tx });
+      transaction.isValid = true;
       continue;
     } else if (isChildExtension(change.key)) {
-      validTransactions.push({ txID: { sessionID, txIndex }, tx });
+      transaction.isValid = true;
       continue;
     } else if (isWriteKeyForMember(change.key)) {
       const memberKey = getAccountOrAgentFromWriteKeyForMember(change.key);
@@ -381,6 +362,7 @@ function determineValidTransactionsForGroup(
         memberKey !== transactor
       ) {
         logPermissionError("Only admins can set writeKeys");
+        transaction.isValid = false;
         continue;
       }
 
@@ -398,12 +380,13 @@ function determineValidTransactionsForGroup(
         logPermissionError(
           "Write key already exists and can't be overridden by invite",
         );
+        transaction.isValid = false;
         continue;
       }
 
       writeKeys.add(change.key);
 
-      validTransactions.push({ txID: { sessionID, txIndex }, tx });
+      transaction.isValid = true;
       continue;
     }
 
@@ -422,6 +405,7 @@ function determineValidTransactionsForGroup(
       change.value !== "writeOnlyInvite"
     ) {
       logPermissionError("Group transaction must set a valid role");
+      transaction.isValid = false;
       continue;
     }
 
@@ -437,6 +421,7 @@ function determineValidTransactionsForGroup(
       logPermissionError(
         "Everyone can only be set to reader, writer, writeOnly or revoked",
       );
+      transaction.isValid = false;
       continue;
     }
 
@@ -460,41 +445,47 @@ function determineValidTransactionsForGroup(
           assignedRole !== "admin"
         ) {
           logPermissionError("Admins can only demote themselves.");
+          transaction.isValid = false;
           continue;
         }
       } else if (memberState[transactor] === "adminInvite") {
         if (change.value !== "admin") {
           logPermissionError("AdminInvites can only create admins.");
+          transaction.isValid = false;
           continue;
         }
       } else if (memberState[transactor] === "writerInvite") {
         if (change.value !== "writer") {
           logPermissionError("WriterInvites can only create writers.");
+          transaction.isValid = false;
           continue;
         }
       } else if (memberState[transactor] === "readerInvite") {
         if (change.value !== "reader") {
           logPermissionError("ReaderInvites can only create reader.");
+          transaction.isValid = false;
           continue;
         }
       } else if (memberState[transactor] === "writeOnlyInvite") {
         if (change.value !== "writeOnly") {
           logPermissionError("WriteOnlyInvites can only create writeOnly.");
+          transaction.isValid = false;
           continue;
         }
       } else {
         logPermissionError(
           "Group transaction must be made by current admin or invite",
         );
+        transaction.isValid = false;
         continue;
       }
     }
 
     memberState[affectedMember] = change.value;
-    validTransactions.push({ txID: { sessionID, txIndex }, tx });
+    transaction.isValid = true;
   }
 
-  return { validTransactions, memberState };
+  return { memberState };
 }
 
 function agentInAccountOrMemberInGroup(

package/src/sync.ts

@@ -279,17 +279,32 @@ export class SyncManager {
     peer.trackToldKnownState(id);
   }
 
+  reconcileServerPeers() {
+    const serverPeers = Object.values(this.peers).filter(
+      (peer) => peer.role === "server",
+    );
+    for (const peer of serverPeers) {
+      this.startPeerReconciliation(peer);
+    }
+  }
+
   startPeerReconciliation(peer: PeerState) {
     const coValuesOrderedByDependency: CoValueCore[] = [];
 
-    const gathered = new Set<string>();
-
+    const seen = new Set<string>();
     const buildOrderedCoValueList = (coValue: CoValueCore) => {
-      if (gathered.has(coValue.id)) {
+      if (seen.has(coValue.id)) {
         return;
       }
+      seen.add(coValue.id);
 
-      gathered.add(coValue.id);
+      // Ignore the covalue if this peer isn't relevant to it
+      if (
+        this.getServerPeers(coValue.id).find((p) => p.id === peer.id) ===
+        undefined
+      ) {
+        return;
+      }
 
       for (const id of coValue.getDependedOnCoValues()) {
         const coValue = this.local.getCoValue(id);
@@ -355,7 +370,7 @@ export class SyncManager {
     });
   }
 
-  addPeer(peer: Peer) {
+  addPeer(peer: Peer, skipReconciliation: boolean = false) {
     const prevPeer = this.peers[peer.id];
 
     if (prevPeer && !prevPeer.closed) {
@@ -373,7 +388,7 @@ export class SyncManager {
       },
     );
 
-    if (peerState.role === "server") {
+    if (!skipReconciliation && peerState.role === "server") {
       void this.startPeerReconciliation(peerState);
     }
 

package/src/tests/account.test.ts

@@ -137,6 +137,30 @@ test("Should migrate the root from private to trusting", async () => {
   expect(account3.ops).toEqual(account2.ops); // No new transactions were made
 });
 
+test("myRole returns 'admin' for the current account", async () => {
+  const { node, accountID } = await LocalNode.withNewlyCreatedAccount({
+    creationProps: { name: "Hermes Puggington" },
+    crypto: Crypto,
+  });
+
+  const account = await node.load(accountID);
+  if (account === "unavailable") throw new Error("Account unavailable");
+
+  expect(account.myRole()).toEqual("admin");
+});
+
+test("roleOf returns 'admin' when the accountID is the same as the receiver account", async () => {
+  const { node, accountID } = await LocalNode.withNewlyCreatedAccount({
+    creationProps: { name: "Hermes Puggington" },
+    crypto: Crypto,
+  });
+
+  const account = await node.load(accountID);
+  if (account === "unavailable") throw new Error("Account unavailable");
+
+  expect(account.roleOf(accountID)).toEqual("admin");
+});
+
 test("throws an error if the user tried to add a member to an account", async () => {
   const { node, accountID } = await LocalNode.withNewlyCreatedAccount({
     creationProps: { name: "Hermes Puggington" },

package/src/tests/branching.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test } from "vitest";
+import { createTestNode } from "./testUtils.js";
+import { expectMap } from "../coValue.js";
+
+describe("Branching Logic", () => {
+  describe("Branch Operations with Transactions", () => {
+    test("should maintain separate transaction histories", async () => {
+      const node = createTestNode();
+      const group = node.createGroup();
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      // Add transactions to original map
+      originalMap.set("originalKey1", "value1", "trusting");
+      originalMap.set("originalKey2", "value2", "trusting");
+
+      const branch = expectMap(
+        originalMap.core.createBranch(branchName, group.id).getCurrentContent(),
+      );
+
+      // Add transactions to branch
+      branch.set("branchKey1", "branchValue1", "trusting");
+      branch.set("branchKey2", "branchValue2", "trusting");
+
+      expect(originalMap.get("branchKey1")).toBe(undefined);
+      expect(originalMap.get("branchKey2")).toBe(undefined);
+      expect(branch.get("branchKey2")).toBe("branchValue2");
+      expect(branch.get("branchKey1")).toBe("branchValue1");
+      expect(branch.get("originalKey1")).toBe("value1");
+      expect(branch.get("originalKey2")).toBe("value2");
+    });
+  });
+
+  describe("Branch Merging", () => {
+    test("should merge branch transactions back to source", () => {
+      const node = createTestNode();
+      const group = node.createGroup();
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      // Add transactions to original map
+      originalMap.set("key1", "value1", "trusting");
+      originalMap.set("key2", "value2", "trusting");
+
+      // Create branch
+      const branch = expectMap(
+        originalMap.core.createBranch(branchName, group.id).getCurrentContent(),
+      );
+
+      // Add transactions to branch
+      branch.set("key1", "branchValue1", "trusting");
+
+      // Merge branch
+      const result = expectMap(branch.core.mergeBranch().getCurrentContent());
+
+      // Check that source now has branch transactions
+      expect(result.get("key1")).toBe("branchValue1");
+      expect(result.get("key2")).toBe("value2");
+    });
+
+    test("should not merge branch transactions back to source if they are already merged", () => {
+      const node = createTestNode();
+      const group = node.createGroup();
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      // Add transactions to original map
+      originalMap.set("key1", "value1", "trusting");
+      originalMap.set("key2", "value2", "trusting");
+
+      // Create branch
+      const branch = expectMap(
+        originalMap.core.createBranch(branchName, group.id).getCurrentContent(),
+      );
+
+      // Add transactions to branch
+      branch.set("key1", "branchValue1", "trusting");
+
+      // Merge branch twice
+      expectMap(branch.core.mergeBranch().getCurrentContent());
+      const result = expectMap(branch.core.mergeBranch().getCurrentContent());
+
+      expect(result.core.mergeCommits.length).toBe(1);
+
+      // Check that source now has branch transactions
+      expect(result.get("key1")).toBe("branchValue1");
+      expect(result.get("key2")).toBe("value2");
+    });
+
+    test("should not create a merge commit if the branch is empty", () => {
+      const node = createTestNode();
+      const group = node.createGroup();
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      // Add transactions to original map
+      originalMap.set("key1", "value1", "trusting");
+      originalMap.set("key2", "value2", "trusting");
+
+      // Create branch
+      const branch = expectMap(
+        originalMap.core.createBranch(branchName, group.id).getCurrentContent(),
+      );
+
+      // Merge branch twice
+      const result = expectMap(branch.core.mergeBranch().getCurrentContent());
+
+      expect(result.core.mergeCommits.length).toBe(0);
+    });
+
+    test("should merge the new changes from the branch after the last merge", () => {
+      const node = createTestNode();
+      const group = node.createGroup();
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      originalMap.set("key1", "value1", "trusting");
+      originalMap.set("key2", "value2", "trusting");
+
+      const branch = expectMap(
+        originalMap.core.createBranch(branchName, group.id).getCurrentContent(),
+      );
+
+      branch.set("key1", "branchValue1", "trusting");
+
+      branch.core.mergeBranch();
+
+      expect(originalMap.get("key1")).toBe("branchValue1");
+      expect(originalMap.get("key2")).toBe("value2");
+
+      branch.set("key2", "branchValue2", "trusting");
+
+      branch.core.mergeBranch();
+
+      expect(originalMap.core.mergeCommits.length).toBe(2);
+
+      expect(originalMap.get("key1")).toBe("branchValue1");
+      expect(originalMap.get("key2")).toBe("branchValue2");
+    });
+  });
+});

package/src/tests/coValueCore.test.ts

@@ -277,9 +277,8 @@ test("creates a transaction with trusting meta information", async () => {
     meta: true,
   });
 
-  const validTransactions = determineValidTransactions(map.core);
-
-  expect(validTransactions[0]?.tx.meta).toBe(`{"meta":true}`);
+  expect(map.core.verifiedTransactions[0]?.tx.meta).toBe(`{"meta":true}`);
+  expect(map.core.verifiedTransactions[0]?.meta).toEqual({ meta: true });
 });
 
 test("creates a transaction with private meta information", async () => {