cojson 0.20.7 → 0.20.9

package/src/crypto/RNCrypto.ts

@@ -1,7 +1,6 @@
 import {
   JsonValue,
   RawCoID,
-  SessionID,
   Stringified,
   base64URLtoBytes,
   bytesToBase64url,
@@ -9,23 +8,16 @@ import {
 import { CojsonInternalTypes } from "../exports.js";
 import { TransactionID } from "../ids.js";
 import { stableStringify } from "../jsonStringify.js";
-import { JsonObject } from "../jsonValue.js";
 import { logger } from "../logger.js";
-import { ControlledAccountOrAgent } from "../coValues/account.js";
-import {
-  PrivateTransaction,
-  Transaction,
-  TrustingTransaction,
-} from "../coValueCore/verifiedState.js";
+import { Transaction } from "../coValueCore/verifiedState.js";
 import {
   CryptoProvider,
-  KeyID,
-  KeySecret,
   Sealed,
+  SealedForGroup,
   SealerID,
   SealerSecret,
-  SessionLogImpl,
-  Signature,
+  SessionMapImpl,
+  ShortHash,
   SignerID,
   SignerSecret,
   textDecoder,
@@ -41,13 +33,19 @@ import {
   newX25519PrivateKey,
   getSealerId,
   getSignerId,
+  shortHash,
   sign,
   seal,
+  sealForGroup,
   unseal,
+  unsealForGroup,
   Blake3Hasher,
-  SessionLog,
+  bytesToBase64url as nativeBytesToBase64url,
+  base64urlToBytes as nativeBase64urlToBytes,
+  bytesToBase64 as nativeBytesToBase64,
+  SessionMap as RNSessionMap,
 } from "cojson-core-rn";
-import { WasmCrypto } from "./WasmCrypto.js";
+import { setNativeBase64Implementation } from "../base64url.js";
 
 type Blake3State = Blake3Hasher;
 
@@ -94,6 +92,11 @@ export class RNCrypto extends CryptoProvider<Blake3State> {
       blake3HashOnceWithContext(toArrayBuffer(data), toArrayBuffer(context)),
     );
   }
+
+  shortHash(value: JsonValue): ShortHash {
+    return shortHash(stableStringify(value)) as ShortHash;
+  }
+
   seal<T extends JsonValue>({
     message,
     from,
@@ -137,15 +140,75 @@ export class RNCrypto extends CryptoProvider<Blake3State> {
       return undefined;
     }
   }
-  createSessionLog(
+
+  sealForGroup<T extends JsonValue>({
+    message,
+    to,
+    nOnceMaterial,
+  }: {
+    message: T;
+    to: SealerID;
+    nOnceMaterial: { in: RawCoID; tx: TransactionID };
+  }): SealedForGroup<T> {
+    const messageBuffer = toArrayBuffer(
+      textEncoder.encode(stableStringify(message)),
+    );
+    const nOnceBuffer = toArrayBuffer(
+      textEncoder.encode(stableStringify(nOnceMaterial)),
+    );
+
+    return `sealedForGroup_U${bytesToBase64url(
+      new Uint8Array(sealForGroup(messageBuffer, to, nOnceBuffer)),
+    )}` as SealedForGroup<T>;
+  }
+
+  unsealForGroup<T extends JsonValue>(
+    sealed: SealedForGroup<T>,
+    groupSealerSecret: SealerSecret,
+    nOnceMaterial: { in: RawCoID; tx: TransactionID },
+  ): T | undefined {
+    try {
+      const sealedBytes = base64URLtoBytes(
+        sealed.substring("sealedForGroup_U".length),
+      );
+      const nonceBuffer = toArrayBuffer(
+        textEncoder.encode(stableStringify(nOnceMaterial)),
+      );
+
+      const plaintext = textDecoder.decode(
+        unsealForGroup(
+          toArrayBuffer(sealedBytes),
+          groupSealerSecret,
+          nonceBuffer,
+        ),
+      );
+      return JSON.parse(plaintext) as T;
+    } catch (e) {
+      logger.error("Failed to decrypt/parse sealed for group message", {
+        err: e,
+      });
+      return undefined;
+    }
+  }
+
+  createSessionMap(
     coID: RawCoID,
-    sessionID: SessionID,
-    signerID?: SignerID,
-  ): SessionLogImpl {
-    return new SessionLogAdapter(new SessionLog(coID, sessionID, signerID));
+    headerJson: string,
+    maxTxSize?: number,
+    skipVerify?: boolean,
+  ): SessionMapImpl {
+    return new SessionMapAdapter(
+      new RNSessionMap(coID, headerJson, maxTxSize, skipVerify),
+    );
   }
 
   static async create(): Promise<RNCrypto> {
+    // Register native base64 implementation for React Native
+    setNativeBase64Implementation({
+      bytesToBase64url: nativeBytesToBase64url,
+      base64urlToBytes: nativeBase64urlToBytes,
+      bytesToBase64: nativeBytesToBase64,
+    });
     return new RNCrypto();
   }
 
@@ -214,112 +277,176 @@ export class RNCrypto extends CryptoProvider<Blake3State> {
   }
 }
 
-class SessionLogAdapter implements SessionLogImpl {
-  constructor(private readonly sessionLog: SessionLog) {}
+/**
+ * Adapter wrapping RNSessionMap to implement SessionMapImpl interface
+ */
+class SessionMapAdapter implements SessionMapImpl {
+  constructor(private readonly sessionMap: RNSessionMap) {}
+
+  // === Header ===
+  getHeader(): string {
+    return this.sessionMap.getHeader();
+  }
 
-  tryAdd(
-    transactions: Transaction[],
-    newSignature: Signature,
+  // === Transaction Operations ===
+  addTransactions(
+    sessionId: string,
+    signerId: string | undefined,
+    transactionsJson: string,
+    signature: string,
     skipVerify: boolean,
   ): void {
-    // Use direct calls instead of JSON.stringify for better performance
-    for (const tx of transactions) {
-      if (tx.privacy === "private") {
-        this.sessionLog.addExistingPrivateTransaction(
-          tx.encryptedChanges,
-          tx.keyUsed,
-          tx.madeAt,
-          tx.meta,
-        );
-      } else {
-        this.sessionLog.addExistingTrustingTransaction(
-          tx.changes,
-          tx.madeAt,
-          tx.meta,
-        );
-      }
-    }
-    this.sessionLog.commitTransactions(newSignature, skipVerify);
+    this.sessionMap.addTransactions(
+      sessionId,
+      signerId,
+      transactionsJson,
+      signature,
+      skipVerify,
+    );
   }
 
-  addNewPrivateTransaction(
-    signerAgent: ControlledAccountOrAgent,
-    changes: JsonValue[],
-    keyID: KeyID,
-    keySecret: KeySecret,
+  makeNewPrivateTransaction(
+    sessionId: string,
+    signerSecret: string,
+    changesJson: string,
+    keyId: string,
+    keySecret: string,
+    metaJson: string | undefined,
     madeAt: number,
-    meta: JsonObject | undefined,
-  ) {
-    const output = this.sessionLog.addNewPrivateTransaction(
-      // We can avoid stableStringify because it will be encrypted.
-      JSON.stringify(changes),
-      signerAgent.currentSignerSecret(),
+  ): string {
+    return this.sessionMap.makeNewPrivateTransaction(
+      sessionId,
+      signerSecret,
+      changesJson,
+      keyId,
       keySecret,
-      keyID,
+      metaJson,
       madeAt,
-      // We can avoid stableStringify because it will be encrypted.
-      meta ? JSON.stringify(meta) : undefined,
     );
-    const parsedOutput = JSON.parse(output);
-    const transaction: PrivateTransaction = {
-      privacy: "private",
-      madeAt,
-      encryptedChanges: parsedOutput.encrypted_changes,
-      keyUsed: keyID,
-      meta: parsedOutput.meta,
-    };
-    return { signature: parsedOutput.signature as Signature, transaction };
   }
 
-  addNewTrustingTransaction(
-    signerAgent: ControlledAccountOrAgent,
-    changes: JsonValue[],
+  makeNewTrustingTransaction(
+    sessionId: string,
+    signerSecret: string,
+    changesJson: string,
+    metaJson: string | undefined,
     madeAt: number,
-    meta: JsonObject | undefined,
-  ) {
-    // We can avoid stableStringify because the changes will be in a string format already.
-    const stringifiedChanges = JSON.stringify(changes);
-    // We can avoid stableStringify because the meta will be in a string format already.
-    const stringifiedMeta = meta ? JSON.stringify(meta) : undefined;
-    const output = this.sessionLog.addNewTrustingTransaction(
-      stringifiedChanges,
-      signerAgent.currentSignerSecret(),
+  ): string {
+    return this.sessionMap.makeNewTrustingTransaction(
+      sessionId,
+      signerSecret,
+      changesJson,
+      metaJson,
       madeAt,
-      stringifiedMeta,
     );
-    const transaction: TrustingTransaction = {
-      privacy: "trusting",
-      madeAt,
-      changes: stringifiedChanges as Stringified<JsonValue[]>,
-      meta: stringifiedMeta as Stringified<JsonObject> | undefined,
+  }
+
+  // === Session Queries ===
+  getSessionIds(): string[] {
+    return this.sessionMap.getSessionIds();
+  }
+
+  getTransactionCount(sessionId: string): number {
+    return this.sessionMap.getTransactionCount(sessionId);
+  }
+
+  getTransaction(sessionId: string, txIndex: number): Transaction | undefined {
+    const result = this.sessionMap.getTransaction(sessionId, txIndex);
+    if (!result) return undefined;
+    return JSON.parse(result) as Transaction;
+  }
+
+  getSessionTransactions(
+    sessionId: string,
+    fromIndex: number,
+  ): Transaction[] | undefined {
+    const result = this.sessionMap.getSessionTransactions(sessionId, fromIndex);
+    if (!result) return undefined;
+    return result.map((tx) => JSON.parse(tx) as Transaction);
+  }
+
+  getLastSignature(sessionId: string): string | undefined {
+    return this.sessionMap.getLastSignature(sessionId) ?? undefined;
+  }
+
+  getSignatureAfter(sessionId: string, txIndex: number): string | undefined {
+    return this.sessionMap.getSignatureAfter(sessionId, txIndex) ?? undefined;
+  }
+
+  getLastSignatureCheckpoint(sessionId: string): number | undefined {
+    return this.sessionMap.getLastSignatureCheckpoint(sessionId) ?? undefined;
+  }
+
+  // === Known State ===
+  getKnownState(): {
+    id: string;
+    header: boolean;
+    sessions: Record<string, number>;
+  } {
+    // Uniffi returns a Record with Map<string, number> for sessions
+    // Convert Map to Record for consistency
+    // Type assertion needed until Uniffi types are regenerated
+    const ks = this.sessionMap.getKnownState() as unknown as {
+      id: string;
+      header: boolean;
+      sessions: Map<string, number>;
+    };
+    return {
+      id: ks.id,
+      header: ks.header,
+      sessions: Object.fromEntries(ks.sessions),
     };
-    return { signature: output as Signature, transaction };
   }
 
-  decryptNextTransactionChangesJson(
-    txIndex: number,
-    keySecret: KeySecret,
-  ): string {
-    return this.sessionLog.decryptNextTransactionChangesJson(
-      txIndex,
-      keySecret,
-    );
+  getKnownStateWithStreaming():
+    | { id: string; header: boolean; sessions: Record<string, number> }
+    | undefined {
+    // Uniffi returns a Record with Map<string, number> for sessions
+    // Type assertion needed until Uniffi types are regenerated
+    const ks = this.sessionMap.getKnownStateWithStreaming() as unknown as
+      | { id: string; header: boolean; sessions: Map<string, number> }
+      | undefined;
+    if (!ks || ks === undefined) return undefined;
+    return {
+      id: ks.id,
+      header: ks.header,
+      sessions: Object.fromEntries(ks.sessions),
+    };
   }
 
-  decryptNextTransactionMetaJson(
-    txIndex: number,
-    keySecret: KeySecret,
-  ): string | undefined {
-    return this.sessionLog.decryptNextTransactionMetaJson(txIndex, keySecret);
+  setStreamingKnownState(streamingJson: string): void {
+    this.sessionMap.setStreamingKnownState(streamingJson);
   }
 
-  free(): void {
-    this.sessionLog.uniffiDestroy();
+  // === Deletion ===
+  markAsDeleted(): void {
+    this.sessionMap.markAsDeleted();
   }
 
-  clone(): SessionLogImpl {
-    return new SessionLogAdapter(
-      this.sessionLog.cloneSessionLog() as SessionLog,
+  isDeleted(): boolean {
+    return this.sessionMap.isDeleted();
+  }
+
+  // === Decryption ===
+  decryptTransaction(
+    sessionId: string,
+    txIndex: number,
+    keySecret: string,
+  ): string | undefined {
+    return (
+      this.sessionMap.decryptTransaction(sessionId, txIndex, keySecret) ??
+      undefined
+    );
+  }
+
+  decryptTransactionMeta(
+    sessionId: string,
+    txIndex: number,
+    keySecret: string,
+  ): string | undefined {
+    return (
+      this.sessionMap.decryptTransactionMeta(sessionId, txIndex, keySecret) ??
+      undefined
     );
   }
 }