cojson 0.7.0-alpha.36 → 0.7.0-alpha.38

package/src/coValueCore.ts

@@ -5,17 +5,9 @@ import {
     KeySecret,
     Signature,
     StreamingHash,
-    unseal,
-    shortHash,
-    sign,
-    verify,
-    encryptForTransaction,
     KeyID,
-    decryptKeySecret,
-    getAgentSignerID,
-    getAgentSealerID,
-    decryptRawForTransaction,
-} from "./crypto.js";
+    CryptoProvider,
+} from "./crypto/crypto.js";
 import { JsonObject, JsonValue } from "./jsonValue.js";
 import { base58 } from "@scure/base";
 import {
@@ -44,15 +36,18 @@ export type CoValueHeader = {
     uniqueness: `z${string}` | null;
 };
 
-export function idforHeader(header: CoValueHeader): RawCoID {
-    const hash = shortHash(header);
+export function idforHeader(
+    header: CoValueHeader,
+    crypto: CryptoProvider,
+): RawCoID {
+    const hash = crypto.shortHash(header);
     return `co_z${hash.slice("shortHash_z".length)}`;
 }
 
 export function newRandomSessionID(accountID: AccountID | AgentID): SessionID {
     return `${accountID}_session_z${base58.encode(
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (globalThis as any).crypto.getRandomValues(new Uint8Array(8))
+        (globalThis as any).crypto.getRandomValues(new Uint8Array(8)),
     )}`;
 }
 
@@ -93,6 +88,7 @@ const readKeyCache = new WeakMap<CoValueCore, { [id: KeyID]: KeySecret }>();
 export class CoValueCore {
     id: RawCoID;
     node: LocalNode;
+    crypto: CryptoProvider;
     header: CoValueHeader;
     _sessionLogs: Map<SessionID, SessionLog>;
     _cachedContent?: RawCoValue;
@@ -108,9 +104,10 @@ export class CoValueCore {
     constructor(
         header: CoValueHeader,
         node: LocalNode,
-        internalInitSessions: Map<SessionID, SessionLog> = new Map()
+        internalInitSessions: Map<SessionID, SessionLog> = new Map(),
     ) {
-        this.id = idforHeader(header);
+        this.crypto = node.crypto;
+        this.id = idforHeader(header, node.crypto);
         this.header = header;
         this._sessionLogs = internalInitSessions;
         this.node = node;
@@ -134,11 +131,11 @@ export class CoValueCore {
 
     testWithDifferentAccount(
         account: ControlledAccountOrAgent,
-        currentSessionID: SessionID
+        currentSessionID: SessionID,
     ): CoValueCore {
         const newNode = this.node.testWithDifferentAccount(
             account,
-            currentSessionID
+            currentSessionID,
         );
 
         return newNode.expectCoValueLoaded(this.id);
@@ -163,7 +160,7 @@ export class CoValueCore {
                 [...this.sessionLogs.entries()].map(([k, v]) => [
                     k,
                     v.transactions.length,
-                ])
+                ]),
             ),
         };
     }
@@ -178,7 +175,7 @@ export class CoValueCore {
             this.header.meta?.type === "account"
                 ? (this.node.currentSessionID.replace(
                       this.node.account.id,
-                      this.node.account.currentAgentID()
+                      this.node.account.currentAgentID(),
                   ) as SessionID)
                 : this.node.currentSessionID;
 
@@ -192,19 +189,19 @@ export class CoValueCore {
         sessionID: SessionID,
         newTransactions: Transaction[],
         givenExpectedNewHash: Hash | undefined,
-        newSignature: Signature
+        newSignature: Signature,
     ): boolean {
-        const signerID = getAgentSignerID(
+        const signerID = this.crypto.getAgentSignerID(
             this.node.resolveAccountAgent(
                 accountOrAgentIDfromSessionID(sessionID),
-                "Expected to know signer of transaction"
-            )
+                "Expected to know signer of transaction",
+            ),
         );
 
         if (!signerID) {
             console.warn(
                 "Unknown agent",
-                accountOrAgentIDfromSessionID(sessionID)
+                accountOrAgentIDfromSessionID(sessionID),
             );
             return false;
         }
@@ -212,7 +209,7 @@ export class CoValueCore {
         // const beforeHash = performance.now();
         const { expectedNewHash, newStreamingHash } = this.expectedNewHashAfter(
             sessionID,
-            newTransactions
+            newTransactions,
         );
         // const afterHash = performance.now();
         // console.log(
@@ -229,13 +226,13 @@ export class CoValueCore {
         }
 
         // const beforeVerify = performance.now();
-        if (!verify(newSignature, expectedNewHash, signerID)) {
+        if (!this.crypto.verify(newSignature, expectedNewHash, signerID)) {
             console.warn(
                 "Invalid signature in",
                 this.id,
                 newSignature,
                 expectedNewHash,
-                signerID
+                signerID,
             );
             return false;
         }
@@ -251,7 +248,7 @@ export class CoValueCore {
             newSignature,
             expectedNewHash,
             newStreamingHash,
-            "immediate"
+            "immediate",
         );
 
         return true;
@@ -261,7 +258,7 @@ export class CoValueCore {
         sessionID: SessionID,
         newTransactions: Transaction[],
         givenExpectedNewHash: Hash | undefined,
-        newSignature: Signature
+        newSignature: Signature,
     ): Promise<boolean> {
         if (this.currentlyAsyncApplyingTxDone) {
             await this.currentlyAsyncApplyingTxDone;
@@ -272,17 +269,17 @@ export class CoValueCore {
             resolveDone = resolve;
         });
 
-        const signerID = getAgentSignerID(
+        const signerID = this.crypto.getAgentSignerID(
             await this.node.resolveAccountAgentAsync(
                 accountOrAgentIDfromSessionID(sessionID),
-                "Expected to know signer of transaction"
-            )
+                "Expected to know signer of transaction",
+            ),
         );
 
         if (!signerID) {
             console.warn(
                 "Unknown agent",
-                accountOrAgentIDfromSessionID(sessionID)
+                accountOrAgentIDfromSessionID(sessionID),
             );
             resolveDone();
             return false;
@@ -324,13 +321,13 @@ export class CoValueCore {
         }
 
         performance.mark("verifyStart" + this.id);
-        if (!verify(newSignature, expectedNewHash, signerID)) {
+        if (!this.crypto.verify(newSignature, expectedNewHash, signerID)) {
             console.warn(
                 "Invalid signature in",
                 this.id,
                 newSignature,
                 expectedNewHash,
-                signerID
+                signerID,
             );
             resolveDone();
             return false;
@@ -339,7 +336,7 @@ export class CoValueCore {
         performance.measure(
             "verify" + this.id,
             "verifyStart" + this.id,
-            "verifyEnd" + this.id
+            "verifyEnd" + this.id,
         );
 
         this.doAddTransactions(
@@ -348,7 +345,7 @@ export class CoValueCore {
             newSignature,
             expectedNewHash,
             newStreamingHash,
-            "deferred"
+            "deferred",
         );
 
         resolveDone();
@@ -361,7 +358,7 @@ export class CoValueCore {
         newSignature: Signature,
         expectedNewHash: Hash,
         newStreamingHash: StreamingHash,
-        notifyMode: "immediate" | "deferred"
+        notifyMode: "immediate" | "deferred",
     ) {
         const transactions =
             this.sessionLogs.get(sessionID)?.transactions ?? [];
@@ -372,7 +369,7 @@ export class CoValueCore {
 
         const lastInbetweenSignatureIdx = Object.keys(signatureAfter).reduce(
             (max, idx) => (parseInt(idx) > max ? parseInt(idx) : max),
-            -1
+            -1,
         );
 
         const sizeOfTxsSinceLastInbetweenSignature = transactions
@@ -383,7 +380,7 @@ export class CoValueCore {
                     (tx.privacy === "private"
                         ? tx.encryptedChanges.length
                         : tx.changes.length),
-                0
+                0,
             );
 
         if (sizeOfTxsSinceLastInbetweenSignature > 100 * 1024) {
@@ -448,11 +445,11 @@ export class CoValueCore {
 
     expectedNewHashAfter(
         sessionID: SessionID,
-        newTransactions: Transaction[]
+        newTransactions: Transaction[],
     ): { expectedNewHash: Hash; newStreamingHash: StreamingHash } {
         const streamingHash =
             this.sessionLogs.get(sessionID)?.streamingHash.clone() ??
-            new StreamingHash();
+            new StreamingHash(this.crypto);
         for (const transaction of newTransactions) {
             streamingHash.update(transaction);
         }
@@ -467,11 +464,11 @@ export class CoValueCore {
 
     async expectedNewHashAfterAsync(
         sessionID: SessionID,
-        newTransactions: Transaction[]
+        newTransactions: Transaction[],
     ): Promise<{ expectedNewHash: Hash; newStreamingHash: StreamingHash }> {
         const streamingHash =
             this.sessionLogs.get(sessionID)?.streamingHash.clone() ??
-            new StreamingHash();
+            new StreamingHash(this.crypto);
         let before = performance.now();
         for (const transaction of newTransactions) {
             streamingHash.update(transaction);
@@ -493,7 +490,7 @@ export class CoValueCore {
 
     makeTransaction(
         changes: JsonValue[],
-        privacy: "private" | "trusting"
+        privacy: "private" | "trusting",
     ): boolean {
         const madeAt = Date.now();
 
@@ -504,14 +501,18 @@ export class CoValueCore {
 
             if (!keySecret) {
                 throw new Error(
-                    "Can't make transaction without read key secret"
+                    "Can't make transaction without read key secret",
                 );
             }
 
-            const encrypted = encryptForTransaction(changes, keySecret, {
-                in: this.id,
-                tx: this.nextTransactionID(),
-            });
+            const encrypted = this.crypto.encryptForTransaction(
+                changes,
+                keySecret,
+                {
+                    in: this.id,
+                    tx: this.nextTransactionID(),
+                },
+            );
 
             this._decryptionCache[encrypted] = changes;
 
@@ -534,7 +535,7 @@ export class CoValueCore {
             this.header.meta?.type === "account"
                 ? (this.node.currentSessionID.replace(
                       this.node.account.id,
-                      this.node.account.currentAgentID()
+                      this.node.account.currentAgentID(),
                   ) as SessionID)
                 : this.node.currentSessionID;
 
@@ -542,16 +543,16 @@ export class CoValueCore {
             transaction,
         ]);
 
-        const signature = sign(
+        const signature = this.crypto.sign(
             this.node.account.currentSignerSecret(),
-            expectedNewHash
+            expectedNewHash,
         );
 
         const success = this.tryAddTransactions(
             sessionID,
             [transaction],
             expectedNewHash,
-            signature
+            signature,
         );
 
         if (success) {
@@ -603,14 +604,15 @@ export class CoValueCore {
                             this._decryptionCache[tx.encryptedChanges];
 
                         if (!decrytedChanges) {
-                            const decryptedString = decryptRawForTransaction(
-                                tx.encryptedChanges,
-                                readKey,
-                                {
-                                    in: this.id,
-                                    tx: txID,
-                                }
-                            );
+                            const decryptedString =
+                                this.crypto.decryptRawForTransaction(
+                                    tx.encryptedChanges,
+                                    readKey,
+                                    {
+                                        in: this.id,
+                                        tx: txID,
+                                    },
+                                );
                             decrytedChanges =
                                 decryptedString && parseJSON(decryptedString);
                             this._decryptionCache[tx.encryptedChanges] =
@@ -619,7 +621,7 @@ export class CoValueCore {
 
                         if (!decrytedChanges) {
                             console.error(
-                                "Failed to decrypt transaction despite having key"
+                                "Failed to decrypt transaction despite having key",
                             );
                             return undefined;
                         }
@@ -636,7 +638,7 @@ export class CoValueCore {
             (a, b) =>
                 a.madeAt - b.madeAt ||
                 (a.txID.sessionID < b.txID.sessionID ? -1 : 1) ||
-                a.txID.txIndex - b.txID.txIndex
+                a.txID.txIndex - b.txID.txIndex,
         );
 
         return allTransactions;
@@ -664,7 +666,7 @@ export class CoValueCore {
                 .getCurrentReadKey();
         } else {
             throw new Error(
-                "Only groups or values owned by groups have read secrets"
+                "Only groups or values owned by groups have read secrets",
             );
         }
     }
@@ -688,7 +690,7 @@ export class CoValueCore {
     getUncachedReadKey(keyID: KeyID): KeySecret | undefined {
         if (this.header.ruleset.type === "group") {
             const content = expectGroup(
-                this.getCurrentContent({ ignorePrivateTransactions: true })
+                this.getCurrentContent({ ignorePrivateTransactions: true }),
             );
 
             const keyForEveryone = content.get(`${keyID}_for_everyone`);
@@ -701,24 +703,24 @@ export class CoValueCore {
                     : this.node.account.id;
 
             const lastReadyKeyEdit = content.lastEditAt(
-                `${keyID}_for_${lookupAccountOrAgentID}`
+                `${keyID}_for_${lookupAccountOrAgentID}`,
             );
 
             if (lastReadyKeyEdit?.value) {
                 const revealer = lastReadyKeyEdit.by;
                 const revealerAgent = this.node.resolveAccountAgent(
                     revealer,
-                    "Expected to know revealer"
+                    "Expected to know revealer",
                 );
 
-                const secret = unseal(
+                const secret = this.crypto.unseal(
                     lastReadyKeyEdit.value,
                     this.node.account.currentSealerSecret(),
-                    getAgentSealerID(revealerAgent),
+                    this.crypto.getAgentSealerID(revealerAgent),
                     {
                         in: this.id,
                         tx: lastReadyKeyEdit.tx,
-                    }
+                    },
                 );
 
                 if (secret) {
@@ -740,20 +742,20 @@ export class CoValueCore {
 
                     const encryptedPreviousKey = content.get(co)!;
 
-                    const secret = decryptKeySecret(
+                    const secret = this.crypto.decryptKeySecret(
                         {
                             encryptedID: keyID,
                             encryptingID: encryptingKeyID,
                             encrypted: encryptedPreviousKey,
                         },
-                        encryptingKeySecret
+                        encryptingKeySecret,
                     );
 
                     if (secret) {
                         return secret as KeySecret;
                     } else {
                         console.error(
-                            `Encrypting ${encryptingKeyID} key didn't decrypt ${keyID}`
+                            `Encrypting ${encryptingKeyID} key didn't decrypt ${keyID}`,
                         );
                     }
                 }
@@ -766,7 +768,7 @@ export class CoValueCore {
                 .getReadKey(keyID);
         } else {
             throw new Error(
-                "Only groups or values owned by groups have read secrets"
+                "Only groups or values owned by groups have read secrets",
             );
         }
     }
@@ -779,7 +781,7 @@ export class CoValueCore {
         return expectGroup(
             this.node
                 .expectCoValueLoaded(this.header.ruleset.group)
-                .getCurrentContent()
+                .getCurrentContent(),
         );
     }
 
@@ -788,7 +790,7 @@ export class CoValueCore {
     }
 
     newContentSince(
-        knownState: CoValueKnownState | undefined
+        knownState: CoValueKnownState | undefined,
     ): NewContentMessage[] | undefined {
         const isKnownStateEmpty = !knownState?.header && !knownState?.sessions;
 
@@ -829,7 +831,7 @@ export class CoValueCore {
                 const nextKnownSignatureIdx = getNextKnownSignatureIdx(
                     log,
                     knownStateForSessionID,
-                    sentStateForSessionID
+                    sentStateForSessionID,
                 );
 
                 const firstNewTxIdx =
@@ -911,7 +913,7 @@ export class CoValueCore {
         }
 
         const piecesWithContent = pieces.filter(
-            (piece) => Object.keys(piece.new).length > 0 || piece.header
+            (piece) => Object.keys(piece.new).length > 0 || piece.header,
         );
 
         if (piecesWithContent.length === 0) {
@@ -948,13 +950,13 @@ export class CoValueCore {
                         [...this.sessionLogs.keys()]
                             .map((sessionID) =>
                                 accountOrAgentIDfromSessionID(
-                                    sessionID as SessionID
-                                )
+                                    sessionID as SessionID,
+                                ),
                             )
                             .filter(
                                 (session): session is AccountID =>
-                                    isAccountID(session) && session !== this.id
-                            )
+                                    isAccountID(session) && session !== this.id,
+                            ),
                     ),
                 ]
               : [];
@@ -964,13 +966,13 @@ export class CoValueCore {
 function getNextKnownSignatureIdx(
     log: SessionLog,
     knownStateForSessionID?: number,
-    sentStateForSessionID?: number
+    sentStateForSessionID?: number,
 ) {
     return Object.keys(log.signatureAfter)
         .map(Number)
         .sort((a, b) => a - b)
         .find(
             (idx) =>
-                idx >= (sentStateForSessionID ?? knownStateForSessionID ?? -1)
+                idx >= (sentStateForSessionID ?? knownStateForSessionID ?? -1),
         );
 }

package/src/coValues/account.ts

@@ -2,16 +2,12 @@ import { CoValueCore, CoValueHeader } from "../coValueCore.js";
 import { CoID, RawCoValue } from "../coValue.js";
 import {
     AgentSecret,
+    CryptoProvider,
     SealerID,
     SealerSecret,
     SignerID,
     SignerSecret,
-    getAgentID,
-    getAgentSealerID,
-    getAgentSealerSecret,
-    getAgentSignerID,
-    getAgentSignerSecret,
-} from "../crypto.js";
+} from "../crypto/crypto.js";
 import { AgentID } from "../ids.js";
 import { RawCoMap } from "./coMap.js";
 import { RawGroup, InviteSecret } from "./group.js";
@@ -19,9 +15,10 @@ import { LocalNode } from "../index.js";
 import { JsonObject } from "../jsonValue.js";
 
 export function accountHeaderForInitialAgentSecret(
-    agentSecret: AgentSecret
+    agentSecret: AgentSecret,
+    crypto: CryptoProvider,
 ): CoValueHeader {
-    const agent = getAgentID(agentSecret);
+    const agent = crypto.getAgentID(agentSecret);
     return {
         type: "comap",
         ruleset: { type: "group", initialAdmin: agent },
@@ -38,12 +35,12 @@ export class RawAccount<
 > extends RawGroup<Meta> {
     currentAgentID(): AgentID {
         const agents = this.keys().filter((k): k is AgentID =>
-            k.startsWith("sealer_")
+            k.startsWith("sealer_"),
         );
 
         if (agents.length !== 1) {
             throw new Error(
-                "Expected exactly one agent in account, got " + agents.length
+                "Expected exactly one agent in account, got " + agents.length,
             );
         }
 
@@ -68,11 +65,13 @@ export class RawControlledAccount<Meta extends AccountMeta = AccountMeta>
     implements ControlledAccountOrAgent
 {
     agentSecret: AgentSecret;
+    crypto: CryptoProvider;
 
     constructor(core: CoValueCore, agentSecret: AgentSecret) {
         super(core);
 
         this.agentSecret = agentSecret;
+        this.crypto = core.node.crypto;
     }
 
     /**
@@ -85,62 +84,61 @@ export class RawControlledAccount<Meta extends AccountMeta = AccountMeta>
 
     async acceptInvite<T extends RawCoValue>(
         groupOrOwnedValueID: CoID<T>,
-        inviteSecret: InviteSecret
+        inviteSecret: InviteSecret,
     ): Promise<void> {
         return this.core.node.acceptInvite(groupOrOwnedValueID, inviteSecret);
     }
 
     currentAgentID(): AgentID {
-        return getAgentID(this.agentSecret);
+        return this.crypto.getAgentID(this.agentSecret);
     }
 
     currentSignerID(): SignerID {
-        return getAgentSignerID(this.currentAgentID());
+        return this.crypto.getAgentSignerID(this.currentAgentID());
     }
 
     currentSignerSecret(): SignerSecret {
-        return getAgentSignerSecret(this.agentSecret);
+        return this.crypto.getAgentSignerSecret(this.agentSecret);
     }
 
     currentSealerID(): SealerID {
-        return getAgentSealerID(this.currentAgentID());
+        return this.crypto.getAgentSealerID(this.currentAgentID());
     }
 
     currentSealerSecret(): SealerSecret {
-        return getAgentSealerSecret(this.agentSecret);
+        return this.crypto.getAgentSealerSecret(this.agentSecret);
     }
 }
 
 /** @hidden */
 export class ControlledAgent implements ControlledAccountOrAgent {
-    agentSecret: AgentSecret;
-
-    constructor(agentSecret: AgentSecret) {
-        this.agentSecret = agentSecret;
-    }
+    constructor(
+        public agentSecret: AgentSecret,
+        public crypto: CryptoProvider,
+    ) {}
 
     get id(): AgentID {
-        return getAgentID(this.agentSecret);
+        return this.crypto.getAgentID(this.agentSecret);
     }
 
     currentAgentID(): AgentID {
-        return getAgentID(this.agentSecret);
+        return this.crypto.getAgentID(this.agentSecret);
     }
 
     currentSignerID(): SignerID {
-        return getAgentSignerID(this.currentAgentID());
+        return this.crypto.getAgentSignerID(this.currentAgentID());
     }
 
     currentSignerSecret(): SignerSecret {
-        return getAgentSignerSecret(this.agentSecret);
+        return this.crypto.getAgentSignerSecret(this.agentSecret);
     }
 
     currentSealerID(): SealerID {
-        return getAgentSealerID(this.currentAgentID());
+        return this.crypto.getAgentSealerID(this.currentAgentID());
     }
 
     currentSealerSecret(): SealerSecret {
-        return getAgentSealerSecret(this.agentSecret);
+        return this.crypto.getAgentSealerSecret(this.agentSecret);
     }
 }
 
@@ -159,5 +157,5 @@ export class RawProfile<
 export type RawAccountMigration<Meta extends AccountMeta = AccountMeta> = (
     account: RawControlledAccount<Meta>,
     localNode: LocalNode,
-    creationProps?: { name: string }
+    creationProps?: { name: string },
 ) => void | Promise<void>;