cojson 0.17.8 → 0.17.10

package/src/coValueCore/coValueCore.ts

@@ -27,6 +27,7 @@ import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfrom
 import { expectGroup } from "../typeUtils/expectGroup.js";
 import { getDependedOnCoValuesFromRawData } from "./utils.js";
 import { CoValueHeader, Transaction, VerifiedState } from "./verifiedState.js";
+import { SessionMap } from "./SessionMap.js";
 
 export function idforHeader(
   header: CoValueHeader,
@@ -95,12 +96,7 @@ export class CoValueCore {
     this.crypto = node.crypto;
     if ("header" in init) {
       this.id = idforHeader(init.header, node.crypto);
-      this._verified = new VerifiedState(
-        this.id,
-        node.crypto,
-        init.header,
-        new Map(),
-      );
+      this._verified = new VerifiedState(this.id, node.crypto, init.header);
     } else {
       this.id = init.id;
       this._verified = null;
@@ -298,7 +294,7 @@ export class CoValueCore {
       this.id,
       this.node.crypto,
       header,
-      new Map(),
+      new SessionMap(this.id, this.node.crypto),
       streamingKnownState,
     );
 
@@ -467,19 +463,7 @@ export class CoValueCore {
         );
 
         if (result.isOk()) {
-          if (
-            this._cachedContent &&
-            "processNewTransactions" in this._cachedContent &&
-            typeof this._cachedContent.processNewTransactions === "function"
-          ) {
-            this._cachedContent.processNewTransactions();
-          } else {
-            this._cachedContent = undefined;
-          }
-
-          this._cachedDependentOn = undefined;
-
-          this.notifyUpdate(notifyMode);
+          this.updateContentAndNotifyUpdate(notifyMode);
         }
 
         return result;
@@ -489,6 +473,22 @@ export class CoValueCore {
   deferredUpdates = 0;
   nextDeferredNotify: Promise<void> | undefined;
 
+  updateContentAndNotifyUpdate(notifyMode: "immediate" | "deferred") {
+    if (
+      this._cachedContent &&
+      "processNewTransactions" in this._cachedContent &&
+      typeof this._cachedContent.processNewTransactions === "function"
+    ) {
+      this._cachedContent.processNewTransactions();
+    } else {
+      this._cachedContent = undefined;
+    }
+
+    this._cachedDependentOn = undefined;
+
+    this.notifyUpdate(notifyMode);
+  }
+
   notifyUpdate(notifyMode: "immediate" | "deferred") {
     if (this.listeners.size === 0) {
       return;
@@ -556,9 +556,18 @@ export class CoValueCore {
       );
     }
 
-    const madeAt = Date.now();
+    // This is an ugly hack to get a unique but stable session ID for editing the current account
+    const sessionID =
+      this.verified.header.meta?.type === "account"
+        ? (this.node.currentSessionID.replace(
+            this.node.getCurrentAgent().id,
+            this.node.getCurrentAgent().currentAgentID(),
+          ) as SessionID)
+        : this.node.currentSessionID;
+
+    const signerAgent = this.node.getCurrentAgent();
 
-    let transaction: Transaction;
+    let result: { signature: Signature; transaction: Transaction };
 
     if (privacy === "private") {
       const { secret: keySecret, id: keyID } = this.getCurrentReadKey();
@@ -567,69 +576,42 @@ export class CoValueCore {
         throw new Error("Can't make transaction without read key secret");
       }
 
-      const encrypted = this.crypto.encryptForTransaction(changes, keySecret, {
-        in: this.id,
-        tx: this.nextTransactionID(),
-      });
-
-      this._decryptionCache[encrypted] = changes;
+      result = this.verified.makeNewPrivateTransaction(
+        sessionID,
+        signerAgent,
+        changes,
+        keyID,
+        keySecret,
+      );
 
-      transaction = {
-        privacy: "private",
-        madeAt,
-        keyUsed: keyID,
-        encryptedChanges: encrypted,
-      };
+      if (result.transaction.privacy === "private") {
+        this._decryptionCache[result.transaction.encryptedChanges] = changes;
+      }
     } else {
-      transaction = {
-        privacy: "trusting",
-        madeAt,
-        changes: stableStringify(changes),
-      };
+      result = this.verified.makeNewTrustingTransaction(
+        sessionID,
+        signerAgent,
+        changes,
+      );
     }
 
-    // This is an ugly hack to get a unique but stable session ID for editing the current account
-    const sessionID =
-      this.verified.header.meta?.type === "account"
-        ? (this.node.currentSessionID.replace(
-            this.node.getCurrentAgent().id,
-            this.node.getCurrentAgent().currentAgentID(),
-          ) as SessionID)
-        : this.node.currentSessionID;
+    const { transaction, signature } = result;
 
-    const { expectedNewHash, newStreamingHash } =
-      this.verified.expectedNewHashAfter(sessionID, [transaction]);
+    this.node.syncManager.recordTransactionsSize([transaction], "local");
 
-    const signature = this.crypto.sign(
-      this.node.getCurrentAgent().currentSignerSecret(),
-      expectedNewHash,
-    );
+    const session = this.verified.sessions.get(sessionID);
+    const txIdx = session ? session.transactions.length - 1 : 0;
 
-    const success = this.tryAddTransactions(
+    this.updateContentAndNotifyUpdate("immediate");
+    this.node.syncManager.syncLocalTransaction(
+      this.verified,
+      transaction,
       sessionID,
-      [transaction],
-      expectedNewHash,
       signature,
-      "immediate",
-      true,
-      newStreamingHash,
-    )._unsafeUnwrap({ withStackTrace: true });
-
-    if (success) {
-      const session = this.verified.sessions.get(sessionID);
-      const txIdx = session ? session.transactions.length - 1 : 0;
-
-      this.node.syncManager.recordTransactionsSize([transaction], "local");
-      this.node.syncManager.syncLocalTransaction(
-        this.verified,
-        transaction,
-        sessionID,
-        signature,
-        txIdx,
-      );
-    }
+      txIdx,
+    );
 
-    return success;
+    return true;
   }
 
   getCurrentContent(options?: { ignorePrivateTransactions: true }): RawCoValue {
@@ -658,6 +640,12 @@ export class CoValueCore {
     ignorePrivateTransactions: boolean;
     knownTransactions?: CoValueKnownState["sessions"];
   }): DecryptedTransaction[] {
+    if (!this.verified) {
+      throw new Error(
+        "CoValueCore: getValidTransactions called on coValue without verified state",
+      );
+    }
+
     const validTransactions = determineValidTransactions(
       this,
       options?.knownTransactions,
@@ -701,25 +689,12 @@ export class CoValueCore {
       let decryptedChanges = this._decryptionCache[tx.encryptedChanges];
 
       if (!decryptedChanges) {
-        const decryptedString = this.crypto.decryptRawForTransaction(
-          tx.encryptedChanges,
+        decryptedChanges = this.verified.decryptTransaction(
+          txID.sessionID,
+          txID.txIndex,
           readKey,
-          {
-            in: this.id,
-            tx: txID,
-          },
         );
 
-        try {
-          decryptedChanges = decryptedString && parseJSON(decryptedString);
-        } catch (e) {
-          logger.error("Failed to parse private transaction on " + this.id, {
-            err: e,
-            txID,
-            changes: decryptedString?.slice(0, 50),
-          });
-          continue;
-        }
         this._decryptionCache[tx.encryptedChanges] = decryptedChanges;
       }
 

package/src/coValueCore/verifiedState.ts

@@ -10,6 +10,7 @@ import {
   Encrypted,
   Hash,
   KeyID,
+  KeySecret,
   Signature,
   SignerID,
   StreamingHash,
@@ -21,6 +22,8 @@ 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";
 
 export type CoValueHeader = {
   type: AnyRawCoValue["type"];
@@ -48,20 +51,11 @@ export type TrustingTransaction = {
 
 export type Transaction = PrivateTransaction | TrustingTransaction;
 
-type SessionLog = {
-  readonly transactions: Transaction[];
-  streamingHash?: StreamingHash;
-  readonly signatureAfter: { [txIdx: number]: Signature | undefined };
-  lastSignature: Signature;
-};
-
-export type ValidatedSessions = Map<SessionID, SessionLog>;
-
 export class VerifiedState {
   readonly id: RawCoID;
   readonly crypto: CryptoProvider;
   readonly header: CoValueHeader;
-  readonly sessions: ValidatedSessions;
+  readonly sessions: SessionMap;
   private _cachedKnownState?: CoValueKnownState;
   private _cachedNewContentSinceEmpty: NewContentMessage[] | undefined;
   private streamingKnownState?: CoValueKnownState["sessions"];
@@ -71,35 +65,25 @@ export class VerifiedState {
     id: RawCoID,
     crypto: CryptoProvider,
     header: CoValueHeader,
-    sessions: ValidatedSessions,
+    sessions?: SessionMap,
     streamingKnownState?: CoValueKnownState["sessions"],
   ) {
     this.id = id;
     this.crypto = crypto;
     this.header = header;
-    this.sessions = sessions;
+    this.sessions = sessions ?? new SessionMap(id, crypto);
     this.streamingKnownState = streamingKnownState
       ? { ...streamingKnownState }
       : undefined;
   }
 
   clone(): VerifiedState {
-    // do a deep clone, including the sessions
-    const clonedSessions = new Map();
-    for (let [sessionID, sessionLog] of this.sessions) {
-      clonedSessions.set(sessionID, {
-        lastSignature: sessionLog.lastSignature,
-        streamingHash: sessionLog.streamingHash?.clone(),
-        signatureAfter: { ...sessionLog.signatureAfter },
-        transactions: sessionLog.transactions.slice(),
-      } satisfies SessionLog);
-    }
     return new VerifiedState(
       this.id,
       this.crypto,
       this.header,
-      clonedSessions,
-      this.streamingKnownState,
+      this.sessions.clone(),
+      this.streamingKnownState ? { ...this.streamingKnownState } : undefined,
     );
   }
 
@@ -112,130 +96,69 @@ export class VerifiedState {
     skipVerify: boolean = false,
     givenNewStreamingHash?: StreamingHash,
   ): Result<true, TryAddTransactionsError> {
-    if (skipVerify === true) {
-      this.doAddTransactions(
-        sessionID,
-        newTransactions,
-        newSignature,
-        givenNewStreamingHash,
-      );
-    } else {
-      const { expectedNewHash, newStreamingHash } = this.expectedNewHashAfter(
-        sessionID,
-        newTransactions,
-      );
-
-      if (givenExpectedNewHash && givenExpectedNewHash !== expectedNewHash) {
-        return err({
-          type: "InvalidHash",
-          id: this.id,
-          expectedNewHash,
-          givenExpectedNewHash,
-        } satisfies InvalidHashError);
-      }
-
-      if (!this.crypto.verify(newSignature, expectedNewHash, signerID)) {
-        return err({
-          type: "InvalidSignature",
-          id: this.id,
-          newSignature,
-          sessionID,
-          signerID,
-        } satisfies InvalidSignatureError);
-      }
+    const result = this.sessions.addTransaction(
+      sessionID,
+      signerID,
+      newTransactions,
+      newSignature,
+      skipVerify,
+    );
 
-      this.doAddTransactions(
-        sessionID,
-        newTransactions,
-        newSignature,
-        newStreamingHash,
-      );
+    if (result.isOk()) {
+      this._cachedNewContentSinceEmpty = undefined;
+      this._cachedKnownState = undefined;
     }
 
-    return ok(true as const);
+    return result;
   }
 
-  getLastSignatureCheckpoint(sessionID: SessionID): number {
-    const sessionLog = this.sessions.get(sessionID);
+  makeNewTrustingTransaction(
+    sessionID: SessionID,
+    signerAgent: ControlledAccountOrAgent,
+    changes: JsonValue[],
+  ) {
+    const result = this.sessions.makeNewTrustingTransaction(
+      sessionID,
+      signerAgent,
+      changes,
+    );
 
-    if (!sessionLog?.signatureAfter) return -1;
+    this._cachedNewContentSinceEmpty = undefined;
+    this._cachedKnownState = undefined;
 
-    return Object.keys(sessionLog.signatureAfter).reduce(
-      (max, idx) => Math.max(max, parseInt(idx)),
-      -1,
-    );
+    return result;
   }
 
-  private doAddTransactions(
+  makeNewPrivateTransaction(
     sessionID: SessionID,
-    newTransactions: Transaction[],
-    newSignature: Signature,
-    newStreamingHash?: StreamingHash,
+    signerAgent: ControlledAccountOrAgent,
+    changes: JsonValue[],
+    keyID: KeyID,
+    keySecret: KeySecret,
   ) {
-    const sessionLog = this.sessions.get(sessionID);
-    const transactions = sessionLog?.transactions ?? [];
-
-    for (const tx of newTransactions) {
-      transactions.push(tx);
-    }
-
-    const signatureAfter = sessionLog?.signatureAfter ?? {};
-    const lastInbetweenSignatureIdx =
-      this.getLastSignatureCheckpoint(sessionID);
-
-    const sizeOfTxsSinceLastInbetweenSignature = transactions
-      .slice(lastInbetweenSignatureIdx + 1)
-      .reduce((sum, tx) => sum + getTransactionSize(tx), 0);
-
-    if (exceedsRecommendedSize(sizeOfTxsSinceLastInbetweenSignature)) {
-      signatureAfter[transactions.length - 1] = newSignature;
-    }
-
-    this.sessions.set(sessionID, {
-      transactions,
-      streamingHash: newStreamingHash,
-      lastSignature: newSignature,
-      signatureAfter: signatureAfter,
-    });
+    const result = this.sessions.makeNewPrivateTransaction(
+      sessionID,
+      signerAgent,
+      changes,
+      keyID,
+      keySecret,
+    );
 
     this._cachedNewContentSinceEmpty = undefined;
     this._cachedKnownState = undefined;
+
+    return result;
   }
 
-  expectedNewHashAfter(
-    sessionID: SessionID,
-    newTransactions: Transaction[],
-  ): { expectedNewHash: Hash; newStreamingHash: StreamingHash } {
+  getLastSignatureCheckpoint(sessionID: SessionID): number {
     const sessionLog = this.sessions.get(sessionID);
 
-    if (!sessionLog?.streamingHash) {
-      const streamingHash = new StreamingHash(this.crypto);
-      const oldTransactions = sessionLog?.transactions ?? [];
-
-      for (const transaction of oldTransactions) {
-        streamingHash.update(transaction);
-      }
-
-      for (const transaction of newTransactions) {
-        streamingHash.update(transaction);
-      }
-
-      return {
-        expectedNewHash: streamingHash.digest(),
-        newStreamingHash: streamingHash,
-      };
-    }
-
-    const streamingHash = sessionLog.streamingHash.clone();
-
-    for (const transaction of newTransactions) {
-      streamingHash.update(transaction);
-    }
+    if (!sessionLog?.signatureAfter) return -1;
 
-    return {
-      expectedNewHash: streamingHash.digest(),
-      newStreamingHash: streamingHash,
-    };
+    return Object.keys(sessionLog.signatureAfter).reduce(
+      (max, idx) => Math.max(max, parseInt(idx)),
+      -1,
+    );
   }
 
   newContentSince(
@@ -424,6 +347,14 @@ export class VerifiedState {
       sessions,
     };
   }
+
+  decryptTransaction(
+    sessionID: SessionID,
+    txIndex: number,
+    keySecret: KeySecret,
+  ): JsonValue[] | undefined {
+    return this.sessions.decryptTransaction(sessionID, txIndex, keySecret);
+  }
 }
 
 function getNextKnownSignatureIdx(

package/src/coValues/account.ts

@@ -92,6 +92,10 @@ export class ControlledAccount implements ControlledAccountOrAgent {
   account: RawAccount<AccountMeta>;
   agentSecret: AgentSecret;
   _cachedCurrentAgentID: AgentID | undefined;
+  _cachedCurrentSignerID: SignerID | undefined;
+  _cachedCurrentSignerSecret: SignerSecret | undefined;
+  _cachedCurrentSealerID: SealerID | undefined;
+  _cachedCurrentSealerSecret: SealerSecret | undefined;
   crypto: CryptoProvider;
 
   constructor(account: RawAccount<AccountMeta>, agentSecret: AgentSecret) {
@@ -114,19 +118,39 @@ export class ControlledAccount implements ControlledAccountOrAgent {
   }
 
   currentSignerID() {
-    return this.crypto.getAgentSignerID(this.currentAgentID());
+    if (this._cachedCurrentSignerID) {
+      return this._cachedCurrentSignerID;
+    }
+    const signerID = this.crypto.getAgentSignerID(this.currentAgentID());
+    this._cachedCurrentSignerID = signerID;
+    return signerID;
   }
 
   currentSignerSecret(): SignerSecret {
-    return this.crypto.getAgentSignerSecret(this.agentSecret);
+    if (this._cachedCurrentSignerSecret) {
+      return this._cachedCurrentSignerSecret;
+    }
+    const signerSecret = this.crypto.getAgentSignerSecret(this.agentSecret);
+    this._cachedCurrentSignerSecret = signerSecret;
+    return signerSecret;
   }
 
   currentSealerID() {
-    return this.crypto.getAgentSealerID(this.currentAgentID());
+    if (this._cachedCurrentSealerID) {
+      return this._cachedCurrentSealerID;
+    }
+    const sealerID = this.crypto.getAgentSealerID(this.currentAgentID());
+    this._cachedCurrentSealerID = sealerID;
+    return sealerID;
   }
 
   currentSealerSecret(): SealerSecret {
-    return this.crypto.getAgentSealerSecret(this.agentSecret);
+    if (this._cachedCurrentSealerSecret) {
+      return this._cachedCurrentSealerSecret;
+    }
+    const sealerSecret = this.crypto.getAgentSealerSecret(this.agentSecret);
+    this._cachedCurrentSealerSecret = sealerSecret;
+    return sealerSecret;
   }
 }