cojson 0.20.7 → 0.20.9

package/src/coValueCore/verifiedState.ts

@@ -4,7 +4,6 @@ import {
   exceedsRecommendedSize,
   getTransactionSize,
   addTransactionToContentMessage,
-  knownStateFromContent,
 } from "../coValueContentMessage.js";
 import {
   CryptoProvider,
@@ -13,6 +12,7 @@ import {
   KeySecret,
   Signature,
   SignerID,
+  SessionMapImpl,
 } from "../crypto/crypto.js";
 import {
   isDeleteSessionID,
@@ -20,17 +20,17 @@ import {
   SessionID,
   TransactionID,
 } from "../ids.js";
-import { Stringified } from "../jsonStringify.js";
+import { Stringified, parseJSON } from "../jsonStringify.js";
 import { JsonObject, JsonValue } from "../jsonValue.js";
 import { PermissionsDef as RulesetDef } from "../permissions.js";
 import { NewContentMessage } from "../sync.js";
-import { SessionMap } from "./SessionMap.js";
 import { ControlledAccountOrAgent } from "../coValues/account.js";
 import {
   CoValueKnownState,
   getKnownStateToSend,
   KnownStateSessions,
 } from "../knownState.js";
+import { TRANSACTION_CONFIG } from "../config.js";
 
 export type CoValueHeader = {
   type: AnyRawCoValue["type"];
@@ -68,42 +68,197 @@ export type TrustingTransaction = {
 
 export type Transaction = PrivateTransaction | TrustingTransaction;
 
+export type SessionLog = {
+  signerID?: SignerID;
+  transactions: Transaction[];
+  lastSignature: Signature | undefined;
+  signatureAfter: { [txIdx: number]: Signature | undefined };
+  sessionID: SessionID;
+};
+
 export class VerifiedState {
   readonly id: RawCoID;
   readonly crypto: CryptoProvider;
   readonly header: CoValueHeader;
-  readonly sessions: SessionMap;
+  private readonly impl: SessionMapImpl;
   public lastAccessed: number | undefined;
   public branchSourceId?: RawCoID;
   public branchName?: string;
   private isDeleted: boolean = false;
 
+  // Cache for SessionLog objects to avoid re-parsing on every access
+  private sessionLogCache: Map<SessionID, SessionLog> = new Map();
+  private sessionLogCacheValid: Map<SessionID, number> = new Map(); // txCount when cached
+
+  // Cache for known state to avoid repeated FFI calls between mutations
+  private cachedKnownState: CoValueKnownState | undefined;
+  private cachedKnownStateWithStreaming: CoValueKnownState | undefined;
+
   constructor(
     id: RawCoID,
     crypto: CryptoProvider,
     header: CoValueHeader,
-    sessions?: SessionMap,
+    streamingKnownState?: KnownStateSessions,
+    skipVerify?: boolean,
   ) {
     this.id = id;
     this.crypto = crypto;
     this.header = header;
-    this.sessions = sessions ?? new SessionMap(id, crypto);
     this.branchSourceId = header.meta?.source as RawCoID | undefined;
     this.branchName = header.meta?.branch as string | undefined;
-  }
 
-  clone(): VerifiedState {
-    return new VerifiedState(
-      this.id,
-      this.crypto,
-      this.header,
-      this.sessions.clone(),
+    this.impl = crypto.createSessionMap(
+      id,
+      JSON.stringify(header),
+      TRANSACTION_CONFIG.MAX_RECOMMENDED_TX_SIZE,
+      skipVerify,
     );
+
+    // Set streaming known state if provided
+    if (streamingKnownState) {
+      this.impl.setStreamingKnownState(JSON.stringify(streamingKnownState));
+    }
+  }
+
+  private invalidateCache() {
+    this.sessionLogCache.clear();
+    this.sessionLogCacheValid.clear();
+    this.invalidateKnownStateCache();
+  }
+
+  private invalidateKnownStateCache() {
+    this.cachedKnownState = undefined;
+    this.cachedKnownStateWithStreaming = undefined;
+  }
+
+  /**
+   * Update the session log cache directly when adding transactions.
+   * This avoids round-trips to Rust on subsequent reads.
+   */
+  private updateSessionLogCache(
+    sessionID: SessionID,
+    signerID: SignerID | undefined,
+    newTransactions: Transaction[],
+    newSignature: Signature,
+  ) {
+    const cached = this.sessionLogCache.get(sessionID);
+    const currentTxCount = this.impl.getTransactionCount(sessionID);
+
+    if (cached) {
+      // Append to existing cache
+      for (const tx of newTransactions) {
+        cached.transactions.push(tx);
+      }
+      cached.lastSignature = newSignature;
+      if (signerID) {
+        cached.signerID = signerID;
+      }
+      // Check if we need to update signatureAfter (in-between signature)
+      this.updateLastCheckpointSignature(sessionID, cached.signatureAfter);
+      this.sessionLogCacheValid.set(sessionID, currentTxCount);
+    } else {
+      // Create new cache entry
+      const signatureAfter: { [txIdx: number]: Signature | undefined } = {};
+      this.updateLastCheckpointSignature(sessionID, signatureAfter);
+      const sessionLog: SessionLog = {
+        signerID,
+        transactions: newTransactions.slice(),
+        lastSignature: newSignature,
+        signatureAfter,
+        sessionID,
+      };
+      this.sessionLogCache.set(sessionID, sessionLog);
+      this.sessionLogCacheValid.set(sessionID, currentTxCount);
+    }
+  }
+
+  /**
+   * Update the signatureAfter map with the latest checkpoint signature.
+   * Used when updating cache incrementally.
+   */
+  private updateLastCheckpointSignature(
+    sessionID: SessionID,
+    signatureAfter: { [txIdx: number]: Signature | undefined },
+  ): void {
+    const lastCheckpoint = this.impl.getLastSignatureCheckpoint(sessionID);
+    if (
+      lastCheckpoint !== undefined &&
+      lastCheckpoint !== null &&
+      lastCheckpoint >= 0
+    ) {
+      const sig = this.impl.getSignatureAfter(sessionID, lastCheckpoint);
+      if (sig) {
+        signatureAfter[lastCheckpoint] = sig as Signature;
+      }
+    }
+  }
+
+  /**
+   * Build the signatureAfter map for a session by iterating through all checkpoints.
+   * Used when building a fresh SessionLog from Rust data.
+   */
+  private buildSignatureAfterMap(sessionID: SessionID): {
+    [txIdx: number]: Signature | undefined;
+  } {
+    const signatureAfter: { [txIdx: number]: Signature | undefined } = {};
+    const lastCheckpoint = this.impl.getLastSignatureCheckpoint(sessionID);
+    if (
+      lastCheckpoint !== undefined &&
+      lastCheckpoint !== null &&
+      lastCheckpoint >= 0
+    ) {
+      for (let i = 0; i <= lastCheckpoint; i++) {
+        const sig = this.impl.getSignatureAfter(sessionID, i);
+        if (sig) {
+          signatureAfter[i] = sig as Signature;
+        }
+      }
+    }
+    return signatureAfter;
+  }
+
+  private getSessionLog(sessionID: SessionID): SessionLog {
+    const currentTxCount = this.impl.getTransactionCount(sessionID);
+    const cachedTxCount = this.sessionLogCacheValid.get(sessionID);
+
+    // Check if cache is valid
+    if (cachedTxCount === currentTxCount) {
+      const cached = this.sessionLogCache.get(sessionID);
+      if (cached) return cached;
+    }
+
+    // Fetch all transactions from Rust
+    const transactions: Transaction[] =
+      currentTxCount > 0
+        ? (this.impl.getSessionTransactions(sessionID, 0) ?? [])
+        : [];
+
+    // Build signatureAfter map
+    const signatureAfter = this.buildSignatureAfterMap(sessionID);
+
+    const lastSignature = this.impl.getLastSignature(sessionID) as
+      | Signature
+      | undefined;
+
+    const sessionLog: SessionLog = {
+      signerID: undefined, // We don't track this in Rust currently
+      transactions,
+      lastSignature,
+      signatureAfter,
+      sessionID,
+    };
+
+    // Cache the result
+    this.sessionLogCache.set(sessionID, sessionLog);
+    this.sessionLogCacheValid.set(sessionID, currentTxCount);
+
+    return sessionLog;
   }
 
   markAsDeleted() {
     this.isDeleted = true;
-    this.sessions.markAsDeleted();
+    this.impl.markAsDeleted();
+    this.invalidateCache();
   }
 
   tryAddTransactions(
@@ -113,13 +268,29 @@ export class VerifiedState {
     newSignature: Signature,
     skipVerify: boolean = false,
   ) {
-    this.sessions.addTransaction(
+    if (this.isDeleted && !isDeleteSessionID(sessionID)) {
+      throw new Error("Cannot add transactions to a deleted coValue");
+    }
+
+    // Convert transactions to JSON array
+    const txJson = JSON.stringify(newTransactions);
+
+    this.impl.addTransactions(
       sessionID,
       signerID,
-      newTransactions,
+      txJson,
       newSignature,
       skipVerify,
     );
+
+    // Update cache directly instead of invalidating
+    this.updateSessionLogCache(
+      sessionID,
+      signerID,
+      newTransactions,
+      newSignature,
+    );
+    this.invalidateKnownStateCache();
   }
 
   makeNewTrustingTransaction(
@@ -128,16 +299,45 @@ export class VerifiedState {
     changes: JsonValue[],
     meta: JsonObject | undefined,
     madeAt: number,
-  ) {
-    const result = this.sessions.makeNewTrustingTransaction(
+  ): { signature: Signature; transaction: Transaction } {
+    if (this.isDeleted) {
+      throw new Error(
+        "Cannot make new trusting transaction on a deleted coValue",
+      );
+    }
+
+    const changesJson = JSON.stringify(changes);
+    const metaJson = meta ? JSON.stringify(meta) : undefined;
+    const signerSecret = signerAgent.currentSignerSecret();
+
+    const resultJson = this.impl.makeNewTrustingTransaction(
       sessionID,
-      signerAgent,
-      changes,
-      meta,
+      signerSecret,
+      changesJson,
+      metaJson,
       madeAt,
     );
 
-    return result;
+    const result = JSON.parse(resultJson) as {
+      signature: string;
+      transaction: Transaction;
+    };
+
+    const signature = result.signature as Signature;
+
+    // Update cache directly instead of invalidating
+    this.updateSessionLogCache(
+      sessionID,
+      signerAgent.id as unknown as SignerID,
+      [result.transaction],
+      signature,
+    );
+    this.invalidateKnownStateCache();
+
+    return {
+      signature,
+      transaction: result.transaction,
+    };
   }
 
   makeNewPrivateTransaction(
@@ -148,33 +348,92 @@ export class VerifiedState {
     keySecret: KeySecret,
     meta: JsonObject | undefined,
     madeAt: number,
-  ) {
-    const result = this.sessions.makeNewPrivateTransaction(
+  ): { signature: Signature; transaction: Transaction } {
+    if (this.isDeleted) {
+      throw new Error(
+        "Cannot make new private transaction on a deleted coValue",
+      );
+    }
+
+    const changesJson = JSON.stringify(changes);
+    const metaJson = meta ? JSON.stringify(meta) : undefined;
+    const signerSecret = signerAgent.currentSignerSecret();
+
+    const resultJson = this.impl.makeNewPrivateTransaction(
       sessionID,
-      signerAgent,
-      changes,
+      signerSecret,
+      changesJson,
       keyID,
       keySecret,
-      meta,
+      metaJson,
       madeAt,
     );
 
-    return result;
-  }
-
-  getLastSignatureCheckpoint(sessionID: SessionID): number {
-    const sessionLog = this.sessions.get(sessionID);
+    const result = JSON.parse(resultJson) as {
+      signature: string;
+      transaction: Transaction;
+    };
 
-    if (!sessionLog?.signatureAfter) return -1;
+    const signature = result.signature as Signature;
 
-    return Object.keys(sessionLog.signatureAfter).reduce(
-      (max, idx) => Math.max(max, parseInt(idx)),
-      -1,
+    // Update cache directly instead of invalidating
+    this.updateSessionLogCache(
+      sessionID,
+      signerAgent.id as unknown as SignerID,
+      [result.transaction],
+      signature,
     );
+    this.invalidateKnownStateCache();
+
+    return {
+      signature,
+      transaction: result.transaction,
+    };
   }
 
   setStreamingKnownState(streamingKnownState: KnownStateSessions) {
-    this.sessions.setStreamingKnownState(streamingKnownState);
+    if (this.isDeleted) {
+      return;
+    }
+    this.impl.setStreamingKnownState(JSON.stringify(streamingKnownState));
+    this.cachedKnownStateWithStreaming = undefined;
+  }
+
+  getSession(sessionID: SessionID): SessionLog | undefined {
+    const txCount = this.impl.getTransactionCount(sessionID);
+    if (txCount === -1) {
+      return undefined;
+    }
+    return this.getSessionLog(sessionID);
+  }
+
+  getTransactionsCount(sessionID: SessionID): number | undefined {
+    const txCount = this.impl.getTransactionCount(sessionID);
+    if (txCount === -1) {
+      return undefined;
+    }
+    return txCount;
+  }
+
+  get sessionCount(): number {
+    return this.impl.getSessionIds().length;
+  }
+
+  getSessions(): Map<SessionID, SessionLog> {
+    // Build a Map from all sessions
+    const map = new Map<SessionID, SessionLog>();
+    const sessionIds = this.impl.getSessionIds() as SessionID[];
+    for (const sessionID of sessionIds) {
+      map.set(sessionID, this.getSessionLog(sessionID));
+    }
+    return map;
+  }
+
+  *sessionEntries(): IterableIterator<[SessionID, SessionLog]> {
+    const sessionIds = this.impl.getSessionIds() as SessionID[];
+    for (const sessionID of sessionIds) {
+      yield [sessionID, this.getSessionLog(sessionID)];
+    }
   }
 
   newContentSince(
@@ -217,7 +476,7 @@ export class VerifiedState {
 
     const sessionSent = knownState?.sessions;
 
-    for (const [sessionID, log] of this.sessions.sessions) {
+    for (const [sessionID, log] of this.getSessions()) {
       if (this.isDeleted && !isDeleteSessionID(sessionID)) {
         continue;
       }
@@ -329,24 +588,27 @@ export class VerifiedState {
     return piecesWithContent;
   }
 
-  knownState() {
-    return this.sessions.knownState;
-  }
-
-  knownStateWithStreaming() {
-    return this.sessions.knownStateWithStreaming ?? this.knownState();
-  }
-
-  immutableKnownState() {
-    return this.sessions.getImmutableKnownState();
+  knownState(): CoValueKnownState {
+    if (!this.cachedKnownState) {
+      this.cachedKnownState = this.impl.getKnownState() as CoValueKnownState;
+    }
+    return this.cachedKnownState;
   }
 
-  immutableKnownStateWithStreaming() {
-    return this.sessions.getImmutableKnownStateWithStreaming();
+  knownStateWithStreaming(): CoValueKnownState {
+    if (!this.cachedKnownStateWithStreaming) {
+      const result = this.impl.getKnownStateWithStreaming();
+      if (!result || result === undefined) {
+        this.cachedKnownStateWithStreaming = this.knownState();
+      } else {
+        this.cachedKnownStateWithStreaming = result as CoValueKnownState;
+      }
+    }
+    return this.cachedKnownStateWithStreaming;
   }
 
   isStreaming(): boolean {
-    return Boolean(this.sessions.knownStateWithStreaming);
+    return Boolean(this.impl.getKnownStateWithStreaming());
   }
 
   decryptTransaction(
@@ -354,7 +616,15 @@ export class VerifiedState {
     txIndex: number,
     keySecret: KeySecret,
   ): JsonValue[] | undefined {
-    return this.sessions.decryptTransaction(sessionID, txIndex, keySecret);
+    const decrypted = this.impl.decryptTransaction(
+      sessionID,
+      txIndex,
+      keySecret,
+    );
+    if (!decrypted) {
+      return undefined;
+    }
+    return parseJSON(decrypted as Stringified<JsonValue[]>);
   }
 
   decryptTransactionMeta(
@@ -362,7 +632,19 @@ export class VerifiedState {
     txIndex: number,
     keySecret: KeySecret,
   ): JsonObject | undefined {
-    return this.sessions.decryptTransactionMeta(sessionID, txIndex, keySecret);
+    const sessionLog = this.getSession(sessionID);
+    if (!sessionLog?.transactions[txIndex]?.meta) {
+      return undefined;
+    }
+    const decrypted = this.impl.decryptTransactionMeta(
+      sessionID,
+      txIndex,
+      keySecret,
+    );
+    if (!decrypted) {
+      return undefined;
+    }
+    return parseJSON(decrypted as Stringified<JsonObject>);
   }
 }