cojson 0.17.9 → 0.17.11

package/src/coValueCore/SessionMap.ts

@@ -0,0 +1,229 @@
+import { Result, err, ok } from "neverthrow";
+import { ControlledAccountOrAgent } from "../coValues/account.js";
+import type {
+  CryptoProvider,
+  Hash,
+  KeyID,
+  KeySecret,
+  SessionLogImpl,
+  Signature,
+  SignerID,
+} from "../crypto/crypto.js";
+import { RawCoID, SessionID } from "../ids.js";
+import { parseJSON, stableStringify, Stringified } from "../jsonStringify.js";
+import { JsonValue } from "../jsonValue.js";
+import { CoValueKnownState } from "../sync.js";
+import { TryAddTransactionsError } from "./coValueCore.js";
+import { Transaction } from "./verifiedState.js";
+import { exceedsRecommendedSize } from "../coValueContentMessage.js";
+
+export type SessionLog = {
+  signerID?: SignerID;
+  impl: SessionLogImpl;
+  transactions: Transaction[];
+  lastSignature: Signature | undefined;
+  signatureAfter: { [txIdx: number]: Signature | undefined };
+  txSizeSinceLastInbetweenSignature: number;
+};
+
+export class SessionMap {
+  sessions: Map<SessionID, SessionLog> = new Map();
+
+  constructor(
+    private readonly id: RawCoID,
+    private readonly crypto: CryptoProvider,
+  ) {}
+
+  get(sessionID: SessionID): SessionLog | undefined {
+    return this.sessions.get(sessionID);
+  }
+
+  private getOrCreateSessionLog(
+    sessionID: SessionID,
+    signerID?: SignerID,
+  ): SessionLog {
+    let sessionLog = this.sessions.get(sessionID);
+    if (!sessionLog) {
+      sessionLog = {
+        signerID,
+        impl: this.crypto.createSessionLog(this.id, sessionID, signerID),
+        transactions: [],
+        lastSignature: undefined,
+        signatureAfter: {},
+        txSizeSinceLastInbetweenSignature: 0,
+      };
+      this.sessions.set(sessionID, sessionLog);
+    }
+
+    return sessionLog;
+  }
+
+  signerID: SignerID | undefined;
+  addTransaction(
+    sessionID: SessionID,
+    signerID: SignerID | undefined,
+    newTransactions: Transaction[],
+    newSignature: Signature,
+    skipVerify: boolean = false,
+  ): Result<true, TryAddTransactionsError> {
+    const sessionLog = this.getOrCreateSessionLog(sessionID, signerID);
+
+    try {
+      sessionLog.impl.tryAdd(newTransactions, newSignature, skipVerify);
+
+      this.addTransactionsToJsLog(sessionLog, newTransactions, newSignature);
+
+      return ok(true as const);
+    } catch (e) {
+      return err({
+        type: "InvalidSignature",
+        id: this.id,
+        sessionID,
+        newSignature,
+        signerID,
+      } satisfies TryAddTransactionsError);
+    }
+  }
+
+  makeNewPrivateTransaction(
+    sessionID: SessionID,
+    signerAgent: ControlledAccountOrAgent,
+    changes: JsonValue[],
+    keyID: KeyID,
+    keySecret: KeySecret,
+  ): { signature: Signature; transaction: Transaction } {
+    const sessionLog = this.getOrCreateSessionLog(
+      sessionID,
+      signerAgent.currentSignerID(),
+    );
+    const madeAt = Date.now();
+
+    const result = sessionLog.impl.addNewPrivateTransaction(
+      signerAgent,
+      changes,
+      keyID,
+      keySecret,
+      madeAt,
+    );
+
+    this.addTransactionsToJsLog(
+      sessionLog,
+      [result.transaction],
+      result.signature,
+    );
+
+    return result;
+  }
+
+  makeNewTrustingTransaction(
+    sessionID: SessionID,
+    signerAgent: ControlledAccountOrAgent,
+    changes: JsonValue[],
+  ): { signature: Signature; transaction: Transaction } {
+    const sessionLog = this.getOrCreateSessionLog(
+      sessionID,
+      signerAgent.currentSignerID(),
+    );
+    const madeAt = Date.now();
+
+    const result = sessionLog.impl.addNewTrustingTransaction(
+      signerAgent,
+      changes,
+      madeAt,
+    );
+
+    this.addTransactionsToJsLog(
+      sessionLog,
+      [result.transaction],
+      result.signature,
+    );
+
+    return result;
+  }
+
+  private addTransactionsToJsLog(
+    sessionLog: SessionLog,
+    newTransactions: Transaction[],
+    signature: Signature,
+  ) {
+    for (const tx of newTransactions) {
+      sessionLog.transactions.push(tx);
+    }
+    sessionLog.lastSignature = signature;
+
+    sessionLog.txSizeSinceLastInbetweenSignature += newTransactions.reduce(
+      (sum, tx) =>
+        sum +
+        (tx.privacy === "private"
+          ? tx.encryptedChanges.length
+          : tx.changes.length),
+      0,
+    );
+
+    if (exceedsRecommendedSize(sessionLog.txSizeSinceLastInbetweenSignature)) {
+      sessionLog.signatureAfter[sessionLog.transactions.length - 1] = signature;
+      sessionLog.txSizeSinceLastInbetweenSignature = 0;
+    }
+  }
+
+  knownState(): CoValueKnownState {
+    const sessions: CoValueKnownState["sessions"] = {};
+    for (const [sessionID, sessionLog] of this.sessions.entries()) {
+      sessions[sessionID] = sessionLog.transactions.length;
+    }
+    return { id: this.id, header: true, sessions };
+  }
+
+  decryptTransaction(
+    sessionID: SessionID,
+    txIndex: number,
+    keySecret: KeySecret,
+  ): JsonValue[] | undefined {
+    const sessionLog = this.sessions.get(sessionID);
+    if (!sessionLog) {
+      return undefined;
+    }
+    const decrypted = sessionLog.impl.decryptNextTransactionChangesJson(
+      txIndex,
+      keySecret,
+    );
+    if (!decrypted) {
+      return undefined;
+    }
+    return parseJSON(decrypted as Stringified<JsonValue[] | undefined>);
+  }
+
+  get size() {
+    return this.sessions.size;
+  }
+
+  entries() {
+    return this.sessions.entries();
+  }
+
+  values() {
+    return this.sessions.values();
+  }
+
+  keys() {
+    return this.sessions.keys();
+  }
+
+  clone(): SessionMap {
+    const clone = new SessionMap(this.id, this.crypto);
+
+    for (const [sessionID, sessionLog] of this.sessions) {
+      clone.sessions.set(sessionID, {
+        impl: sessionLog.impl.clone(),
+        transactions: sessionLog.transactions.slice(),
+        lastSignature: sessionLog.lastSignature,
+        signatureAfter: { ...sessionLog.signatureAfter },
+        txSizeSinceLastInbetweenSignature:
+          sessionLog.txSizeSinceLastInbetweenSignature,
+        signerID: sessionLog.signerID,
+      });
+    }
+
+    return clone;
+  }
+}

package/src/coValueCore/coValueCore.ts

@@ -1,5 +1,5 @@
 import { UpDownCounter, ValueType, metrics } from "@opentelemetry/api";
-import { Result, err } from "neverthrow";
+import { Result, err, ok } from "neverthrow";
 import type { PeerState } from "../PeerState.js";
 import type { RawCoValue } from "../coValue.js";
 import type { ControlledAccountOrAgent } from "../coValues/account.js";
@@ -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,
     );
 
@@ -435,60 +431,67 @@ export class CoValueCore {
   tryAddTransactions(
     sessionID: SessionID,
     newTransactions: Transaction[],
-    givenExpectedNewHash: Hash | undefined,
     newSignature: Signature,
-    notifyMode: "immediate" | "deferred",
     skipVerify: boolean = false,
-    givenNewStreamingHash?: StreamingHash,
   ): Result<true, TryAddTransactionsError> {
-    return this.node
-      .resolveAccountAgent(
-        accountOrAgentIDfromSessionID(sessionID),
-        "Expected to know signer of transaction",
-      )
-      .andThen((agent) => {
-        if (!this.verified) {
-          return err({
-            type: "TriedToAddTransactionsWithoutVerifiedState",
-            id: this.id,
-          } satisfies TriedToAddTransactionsWithoutVerifiedStateErrpr);
-        }
+    let result: Result<SignerID | undefined, TryAddTransactionsError>;
 
-        const signerID = this.crypto.getAgentSignerID(agent);
-
-        const result = this.verified.tryAddTransactions(
-          sessionID,
-          signerID,
-          newTransactions,
-          givenExpectedNewHash,
-          newSignature,
-          skipVerify,
-          givenNewStreamingHash,
-        );
+    if (skipVerify) {
+      result = ok(undefined);
+    } else {
+      result = this.node
+        .resolveAccountAgent(
+          accountOrAgentIDfromSessionID(sessionID),
+          "Expected to know signer of transaction",
+        )
+        .andThen((agent) => {
+          return ok(this.crypto.getAgentSignerID(agent));
+        });
+    }
 
-        if (result.isOk()) {
-          if (
-            this._cachedContent &&
-            "processNewTransactions" in this._cachedContent &&
-            typeof this._cachedContent.processNewTransactions === "function"
-          ) {
-            this._cachedContent.processNewTransactions();
-          } else {
-            this._cachedContent = undefined;
-          }
+    return result.andThen((signerID) => {
+      if (!this.verified) {
+        return err({
+          type: "TriedToAddTransactionsWithoutVerifiedState",
+          id: this.id,
+        } satisfies TriedToAddTransactionsWithoutVerifiedStateErrpr);
+      }
 
-          this._cachedDependentOn = undefined;
+      const result = this.verified.tryAddTransactions(
+        sessionID,
+        signerID,
+        newTransactions,
+        newSignature,
+        skipVerify,
+      );
 
-          this.notifyUpdate(notifyMode);
-        }
+      if (result.isOk()) {
+        this.updateContentAndNotifyUpdate("immediate");
+      }
 
-        return result;
-      });
+      return result;
+    });
   }
 
   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 +559,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 +579,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 +643,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 +692,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;
       }
 
@@ -998,7 +976,7 @@ export type InvalidSignatureError = {
   id: RawCoID;
   newSignature: Signature;
   sessionID: SessionID;
-  signerID: SignerID;
+  signerID: SignerID | undefined;
 };
 
 export type TriedToAddTransactionsWithoutVerifiedStateErrpr = {
@@ -1006,8 +984,15 @@ export type TriedToAddTransactionsWithoutVerifiedStateErrpr = {
   id: RawCoID;
 };
 
+export type TriedToAddTransactionsWithoutSignerIDError = {
+  type: "TriedToAddTransactionsWithoutSignerID";
+  id: RawCoID;
+  sessionID: SessionID;
+};
+
 export type TryAddTransactionsError =
   | TriedToAddTransactionsWithoutVerifiedStateErrpr
+  | TriedToAddTransactionsWithoutSignerIDError
   | ResolveAccountAgentError
   | InvalidHashError
   | InvalidSignatureError;