cojson 0.17.11 → 0.17.13

package/src/coValueCore/SessionMap.ts

@@ -11,7 +11,7 @@ import type {
 } from "../crypto/crypto.js";
 import { RawCoID, SessionID } from "../ids.js";
 import { parseJSON, stableStringify, Stringified } from "../jsonStringify.js";
-import { JsonValue } from "../jsonValue.js";
+import { JsonObject, JsonValue } from "../jsonValue.js";
 import { CoValueKnownState } from "../sync.js";
 import { TryAddTransactionsError } from "./coValueCore.js";
 import { Transaction } from "./verifiedState.js";
@@ -91,6 +91,7 @@ export class SessionMap {
     changes: JsonValue[],
     keyID: KeyID,
     keySecret: KeySecret,
+    meta: JsonObject | undefined,
   ): { signature: Signature; transaction: Transaction } {
     const sessionLog = this.getOrCreateSessionLog(
       sessionID,
@@ -104,6 +105,7 @@ export class SessionMap {
       keyID,
       keySecret,
       madeAt,
+      meta,
     );
 
     this.addTransactionsToJsLog(
@@ -119,6 +121,7 @@ export class SessionMap {
     sessionID: SessionID,
     signerAgent: ControlledAccountOrAgent,
     changes: JsonValue[],
+    meta: JsonObject | undefined,
   ): { signature: Signature; transaction: Transaction } {
     const sessionLog = this.getOrCreateSessionLog(
       sessionID,
@@ -130,6 +133,7 @@ export class SessionMap {
       signerAgent,
       changes,
       madeAt,
+      meta,
     );
 
     this.addTransactionsToJsLog(
@@ -193,6 +197,25 @@ export class SessionMap {
     return parseJSON(decrypted as Stringified<JsonValue[] | undefined>);
   }
 
+  decryptTransactionMeta(
+    sessionID: SessionID,
+    txIndex: number,
+    keySecret: KeySecret,
+  ): JsonObject | undefined {
+    const sessionLog = this.sessions.get(sessionID);
+    if (!sessionLog?.transactions[txIndex]?.meta) {
+      return undefined;
+    }
+    const decrypted = sessionLog.impl.decryptNextTransactionMetaJson(
+      txIndex,
+      keySecret,
+    );
+    if (!decrypted) {
+      return undefined;
+    }
+    return parseJSON(decrypted as Stringified<JsonObject | undefined>);
+  }
+
   get size() {
     return this.sessions.size;
   }

package/src/coValueCore/coValueCore.ts

@@ -14,11 +14,10 @@ import {
   KeySecret,
   Signature,
   SignerID,
-  StreamingHash,
 } from "../crypto/crypto.js";
 import { RawCoID, SessionID, TransactionID } from "../ids.js";
-import { parseJSON, stableStringify } from "../jsonStringify.js";
-import { JsonValue } from "../jsonValue.js";
+import { JsonObject, JsonValue } from "../jsonValue.js";
+import { parseJSON } from "../jsonStringify.js";
 import { LocalNode, ResolveAccountAgentError } from "../localNode.js";
 import { logger } from "../logger.js";
 import { determineValidTransactions } from "../permissions.js";
@@ -85,6 +84,7 @@ export class CoValueCore {
     new Set();
   private readonly _decryptionCache: {
     [key: Encrypted<JsonValue[], JsonValue>]: JsonValue[] | undefined;
+    [key: Encrypted<JsonObject, JsonValue>]: JsonObject | undefined;
   } = {};
   private _cachedDependentOn?: Set<RawCoID>;
   private counter: UpDownCounter;
@@ -552,6 +552,7 @@ export class CoValueCore {
   makeTransaction(
     changes: JsonValue[],
     privacy: "private" | "trusting",
+    meta?: JsonObject,
   ): boolean {
     if (!this.verified) {
       throw new Error(
@@ -585,16 +586,22 @@ export class CoValueCore {
         changes,
         keyID,
         keySecret,
+        meta,
       );
 
       if (result.transaction.privacy === "private") {
         this._decryptionCache[result.transaction.encryptedChanges] = changes;
+
+        if (result.transaction.meta) {
+          this._decryptionCache[result.transaction.meta] = meta;
+        }
       }
     } else {
       result = this.verified.makeNewTrustingTransaction(
         sessionID,
         signerAgent,
         changes,
+        meta,
       );
     }
 
@@ -661,57 +668,55 @@ export class CoValueCore {
         continue;
       }
 
-      if (tx.privacy === "trusting") {
-        try {
-          allTransactions.push({
-            txID,
-            madeAt: tx.madeAt,
-            changes: parseJSON(tx.changes),
-            trusting: true,
-          });
-        } catch (e) {
-          logger.error("Failed to parse trusting transaction on " + this.id, {
-            err: e,
-            txID,
-            changes: tx.changes.slice(0, 50),
-          });
+      let changes: JsonValue[];
+
+      if (tx.privacy === "private") {
+        if (options?.ignorePrivateTransactions) {
+          continue;
         }
-        continue;
-      }
 
-      if (options?.ignorePrivateTransactions) {
-        continue;
-      }
+        const readKey = this.getReadKey(tx.keyUsed);
 
-      const readKey = this.getReadKey(tx.keyUsed);
+        if (!readKey) {
+          continue;
+        }
 
-      if (!readKey) {
-        continue;
-      }
+        let decryptedChanges = this._decryptionCache[tx.encryptedChanges];
 
-      let decryptedChanges = this._decryptionCache[tx.encryptedChanges];
+        if (!decryptedChanges) {
+          decryptedChanges = this.verified.decryptTransaction(
+            txID.sessionID,
+            txID.txIndex,
+            readKey,
+          );
 
-      if (!decryptedChanges) {
-        decryptedChanges = this.verified.decryptTransaction(
-          txID.sessionID,
-          txID.txIndex,
-          readKey,
-        );
+          this._decryptionCache[tx.encryptedChanges] = decryptedChanges;
+        }
 
-        this._decryptionCache[tx.encryptedChanges] = decryptedChanges;
-      }
+        if (!decryptedChanges) {
+          logger.error("Failed to decrypt transaction despite having key", {
+            err: new Error("Failed to decrypt transaction despite having key"),
+          });
+          continue;
+        }
 
-      if (!decryptedChanges) {
-        logger.error("Failed to decrypt transaction despite having key", {
-          err: new Error("Failed to decrypt transaction despite having key"),
-        });
-        continue;
+        changes = decryptedChanges;
+      } else {
+        try {
+          changes = parseJSON(tx.changes);
+        } catch (e) {
+          logger.error("Failed to parse trusting transaction on " + this.id, {
+            err: e,
+          });
+          continue;
+        }
       }
 
       allTransactions.push({
         txID,
         madeAt: tx.madeAt,
-        changes: decryptedChanges,
+        changes,
+        trusting: tx.privacy === "trusting",
       });
     }
 

package/src/coValueCore/utils.ts

@@ -2,7 +2,6 @@ import { getGroupDependentKey } from "../ids.js";
 import { RawCoID, SessionID } from "../ids.js";
 import { Stringified, parseJSON } from "../jsonStringify.js";
 import { JsonValue } from "../jsonValue.js";
-import { NewContentMessage } from "../sync.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
 import { isAccountID } from "../typeUtils/isAccountID.js";
 import { CoValueHeader, Transaction } from "./verifiedState.js";

package/src/coValueCore/verifiedState.ts

@@ -8,19 +8,16 @@ import {
 import {
   CryptoProvider,
   Encrypted,
-  Hash,
   KeyID,
   KeySecret,
   Signature,
   SignerID,
-  StreamingHash,
 } from "../crypto/crypto.js";
 import { RawCoID, SessionID, TransactionID } from "../ids.js";
 import { Stringified } from "../jsonStringify.js";
 import { JsonObject, JsonValue } from "../jsonValue.js";
 import { PermissionsDef as RulesetDef } from "../permissions.js";
 import { CoValueKnownState, NewContentMessage } from "../sync.js";
-import { InvalidHashError, InvalidSignatureError } from "./coValueCore.js";
 import { TryAddTransactionsError } from "./coValueCore.js";
 import { SessionLog, SessionMap } from "./SessionMap.js";
 import { ControlledAccountOrAgent } from "../coValues/account.js";
@@ -41,12 +38,14 @@ export type PrivateTransaction = {
   madeAt: number;
   keyUsed: KeyID;
   encryptedChanges: Encrypted<JsonValue[], { in: RawCoID; tx: TransactionID }>;
+  meta?: Encrypted<JsonObject, { in: RawCoID; tx: TransactionID }>;
 };
 
 export type TrustingTransaction = {
   privacy: "trusting";
   madeAt: number;
   changes: Stringified<JsonValue[]>;
+  meta?: Stringified<JsonObject>;
 };
 
 export type Transaction = PrivateTransaction | TrustingTransaction;
@@ -114,11 +113,13 @@ export class VerifiedState {
     sessionID: SessionID,
     signerAgent: ControlledAccountOrAgent,
     changes: JsonValue[],
+    meta: JsonObject | undefined,
   ) {
     const result = this.sessions.makeNewTrustingTransaction(
       sessionID,
       signerAgent,
       changes,
+      meta,
     );
 
     this._cachedNewContentSinceEmpty = undefined;
@@ -133,6 +134,7 @@ export class VerifiedState {
     changes: JsonValue[],
     keyID: KeyID,
     keySecret: KeySecret,
+    meta: JsonObject | undefined,
   ) {
     const result = this.sessions.makeNewPrivateTransaction(
       sessionID,
@@ -140,6 +142,7 @@ export class VerifiedState {
       changes,
       keyID,
       keySecret,
+      meta,
     );
 
     this._cachedNewContentSinceEmpty = undefined;
@@ -353,6 +356,14 @@ export class VerifiedState {
   ): JsonValue[] | undefined {
     return this.sessions.decryptTransaction(sessionID, txIndex, keySecret);
   }
+
+  decryptTransactionMeta(
+    sessionID: SessionID,
+    txIndex: number,
+    keySecret: KeySecret,
+  ): JsonObject | undefined {
+    return this.sessions.decryptTransactionMeta(sessionID, txIndex, keySecret);
+  }
 }
 
 function getNextKnownSignatureIdx(

package/src/crypto/PureJSCrypto.ts

@@ -10,7 +10,7 @@ import {
 } from "../coValueCore/verifiedState.js";
 import { RawCoID, SessionID, TransactionID } from "../ids.js";
 import { Stringified, stableStringify } from "../jsonStringify.js";
-import { JsonValue } from "../jsonValue.js";
+import { JsonObject, JsonValue } from "../jsonValue.js";
 import { logger } from "../logger.js";
 import {
   CryptoProvider,
@@ -328,16 +328,26 @@ export class PureJSSessionLog implements SessionLogImpl {
     keyID: KeyID,
     keySecret: KeySecret,
     madeAt: number,
+    meta: JsonObject | undefined,
   ): { signature: Signature; transaction: PrivateTransaction } {
     const encryptedChanges = this.crypto.encrypt(changes, keySecret, {
       in: this.coID,
       tx: { sessionID: this.sessionID, txIndex: this.transactions.length },
     });
+
+    const encryptedMeta = meta
+      ? this.crypto.encrypt(meta, keySecret, {
+          in: this.coID,
+          tx: { sessionID: this.sessionID, txIndex: this.transactions.length },
+        })
+      : undefined;
+
     const tx = {
       encryptedChanges: encryptedChanges,
       madeAt: madeAt,
       privacy: "private",
       keyUsed: keyID,
+      meta: encryptedMeta,
     } satisfies Transaction;
     const signature = this.internalAddNewTransaction(
       stableStringify(tx),
@@ -353,11 +363,13 @@ export class PureJSSessionLog implements SessionLogImpl {
     signerAgent: ControlledAccountOrAgent,
     changes: JsonValue[],
     madeAt: number,
+    meta: JsonObject | undefined,
   ): { signature: Signature; transaction: TrustingTransaction } {
     const tx = {
       changes: stableStringify(changes),
       madeAt: madeAt,
       privacy: "trusting",
+      meta: meta ? stableStringify(meta) : undefined,
     } satisfies Transaction;
     const signature = this.internalAddNewTransaction(
       stableStringify(tx),
@@ -400,6 +412,42 @@ export class PureJSSessionLog implements SessionLogImpl {
     }
   }
 
+  decryptNextTransactionMetaJson(
+    txIndex: number,
+    keySecret: KeySecret,
+  ): string | undefined {
+    const txJson = this.transactions[txIndex];
+    if (!txJson) {
+      throw new Error("Transaction not found");
+    }
+    const tx = JSON.parse(txJson) as Transaction;
+
+    if (!tx.meta) {
+      return undefined;
+    }
+
+    if (tx.privacy === "private") {
+      const nOnceMaterial = {
+        in: this.coID,
+        tx: { sessionID: this.sessionID, txIndex: txIndex },
+      };
+
+      const nOnce = this.crypto.generateJsonNonce(nOnceMaterial);
+
+      const ciphertext = base64URLtoBytes(
+        tx.meta.substring("encrypted_U".length),
+      );
+      const keySecretBytes = base58.decode(
+        keySecret.substring("keySecret_z".length),
+      );
+      const plaintext = xsalsa20(keySecretBytes, nOnce, ciphertext);
+
+      return textDecoder.decode(plaintext);
+    } else {
+      return tx.meta;
+    }
+  }
+
   free(): void {
     // no-op
   }

package/src/crypto/WasmCrypto.ts

@@ -19,7 +19,7 @@ import {
 import { base64URLtoBytes, bytesToBase64url } from "../base64url.js";
 import { RawCoID, SessionID, TransactionID } from "../ids.js";
 import { Stringified, stableStringify } from "../jsonStringify.js";
-import { JsonValue } from "../jsonValue.js";
+import { JsonObject, JsonValue } from "../jsonValue.js";
 import { logger } from "../logger.js";
 import { PureJSCrypto } from "./PureJSCrypto.js";
 import {
@@ -231,6 +231,7 @@ class SessionLogAdapter {
     keyID: KeyID,
     keySecret: KeySecret,
     madeAt: number,
+    meta: JsonObject | undefined,
   ): { signature: Signature; transaction: PrivateTransaction } {
     const output = this.sessionLog.addNewPrivateTransaction(
       stableStringify(changes),
@@ -238,6 +239,7 @@ class SessionLogAdapter {
       keySecret,
       keyID,
       madeAt,
+      meta ? stableStringify(meta) : undefined,
     );
     const parsedOutput = JSON.parse(output);
     const transaction: PrivateTransaction = {
@@ -245,6 +247,7 @@ class SessionLogAdapter {
       madeAt,
       encryptedChanges: parsedOutput.encrypted_changes,
       keyUsed: keyID,
+      meta: parsedOutput.meta,
     };
     return { signature: parsedOutput.signature, transaction };
   }
@@ -253,17 +256,21 @@ class SessionLogAdapter {
     signerAgent: ControlledAccountOrAgent,
     changes: JsonValue[],
     madeAt: number,
+    meta: JsonObject | undefined,
   ): { signature: Signature; transaction: TrustingTransaction } {
     const stringifiedChanges = stableStringify(changes);
+    const stringifiedMeta = meta ? stableStringify(meta) : undefined;
     const output = this.sessionLog.addNewTrustingTransaction(
       stringifiedChanges,
       signerAgent.currentSignerSecret(),
       madeAt,
+      stringifiedMeta,
     );
     const transaction: TrustingTransaction = {
       privacy: "trusting",
       madeAt,
       changes: stringifiedChanges,
+      meta: stringifiedMeta,
     };
     return { signature: output as Signature, transaction };
   }
@@ -279,6 +286,13 @@ class SessionLogAdapter {
     return output;
   }
 
+  decryptNextTransactionMetaJson(
+    txIndex: number,
+    keySecret: KeySecret,
+  ): string | undefined {
+    return this.sessionLog.decryptNextTransactionMetaJson(txIndex, keySecret);
+  }
+
   free() {
     this.sessionLog.free();
   }

package/src/crypto/crypto.ts

@@ -3,7 +3,7 @@ import { ControlledAccountOrAgent, RawAccountID } from "../coValues/account.js";
 import { AgentID, RawCoID, TransactionID } from "../ids.js";
 import { SessionID } from "../ids.js";
 import { Stringified, parseJSON, stableStringify } from "../jsonStringify.js";
-import { JsonValue } from "../jsonValue.js";
+import { JsonObject, JsonValue } from "../jsonValue.js";
 import { logger } from "../logger.js";
 import {
   PrivateTransaction,
@@ -366,15 +366,21 @@ export interface SessionLogImpl {
     keyID: KeyID,
     keySecret: KeySecret,
     madeAt: number,
+    meta: JsonObject | undefined,
   ): { signature: Signature; transaction: PrivateTransaction };
   addNewTrustingTransaction(
     signerAgent: ControlledAccountOrAgent,
     changes: JsonValue[],
     madeAt: number,
+    meta: JsonObject | undefined,
   ): { signature: Signature; transaction: TrustingTransaction };
   decryptNextTransactionChangesJson(
     tx_index: number,
     key_secret: KeySecret,
   ): string;
   free(): void;
+  decryptNextTransactionMetaJson(
+    tx_index: number,
+    key_secret: KeySecret,
+  ): string | undefined;
 }

package/src/localNode.ts

@@ -408,7 +408,7 @@ export class LocalNode {
         coValue.loadingState === "unknown" ||
         coValue.loadingState === "unavailable"
       ) {
-        const peers = this.syncManager.getServerPeers(skipLoadingFromPeer);
+        const peers = this.syncManager.getServerPeers(id, skipLoadingFromPeer);
 
         if (!this.storage && peers.length === 0) {
           return coValue;

package/src/queue/LocalTransactionsSyncQueue.ts

@@ -4,7 +4,7 @@ import {
 } from "../coValueContentMessage.js";
 import { Transaction, VerifiedState } from "../coValueCore/verifiedState.js";
 import { Signature } from "../crypto/crypto.js";
-import { SessionID } from "../ids.js";
+import { RawCoID, SessionID } from "../ids.js";
 import { NewContentMessage } from "../sync.js";
 import { LinkedList } from "./LinkedList.js";
 
@@ -73,8 +73,39 @@ export class LocalTransactionsSyncQueue {
     this.queue.push(content);
 
     this.processPendingSyncs();
+
+    for (const trackingSet of this.dirtyCoValuesTrackingSets) {
+      trackingSet.add(content.id);
+    }
   }
 
+  private dirtyCoValuesTrackingSets: Set<Set<RawCoID>> = new Set();
+
+  /**
+   * It starts tracking all changed CoValues. Returns a `done()` function that returns a set of coValues' ids that have been modified since the start.
+   *
+   * @example
+   * ```ts
+   * const tracking = node.syncManager.trackDirtyCoValues();
+   * // Any CoValue mutation
+   * const tracked = tracking.done();
+   * console.log("CoValue mutated: " Array.from(tracked))
+   * ```
+   */
+  trackDirtyCoValues = () => {
+    const trackingSet = new Set<RawCoID>();
+
+    this.dirtyCoValuesTrackingSets.add(trackingSet);
+
+    return {
+      done: () => {
+        this.dirtyCoValuesTrackingSets.delete(trackingSet);
+
+        return trackingSet;
+      },
+    };
+  };
+
   private processingSyncs = false;
   processPendingSyncs() {
     if (this.processingSyncs) return;