cojson 0.7.0-alpha.5 → 0.7.0

package/src/localNode.ts

@@ -1,14 +1,4 @@
-import {
-    AgentSecret,
-    agentSecretFromSecretSeed,
-    createdNowUnique,
-    getAgentID,
-    getAgentSealerID,
-    getAgentSealerSecret,
-    newRandomAgentSecret,
-    newRandomKeySecret,
-    seal,
-} from "./crypto.js";
+import { AgentSecret, CryptoProvider } from "./crypto/crypto.js";
 import {
     CoValueCore,
     CoValueHeader,
@@ -33,8 +23,7 @@ import {
     RawProfile,
     RawAccountMigration,
 } from "./coValues/account.js";
-import { RawCoMap } from "./coValues/coMap.js";
-import { RawCoValue } from "./index.js";
+import { Profile, RawCoValue } from "./index.js";
 import { expectGroup } from "./typeUtils/expectGroup.js";
 
 /** A `LocalNode` represents a local view of a set of loaded `CoValue`s, from the perspective of a particular account (or primitive cryptographic agent).
@@ -49,6 +38,8 @@ const { localNode } = useJazz();
 ```
 */
 export class LocalNode {
+    /** @internal */
+    crypto: CryptoProvider;
     /** @internal */
     coValues: { [key: RawCoID]: CoValueState } = {};
     /** @category 3. Low-level */
@@ -61,24 +52,28 @@ export class LocalNode {
     /** @category 3. Low-level */
     constructor(
         account: ControlledAccountOrAgent,
-        currentSessionID: SessionID
+        currentSessionID: SessionID,
+        crypto: CryptoProvider,
     ) {
         this.account = account;
         this.currentSessionID = currentSessionID;
+        this.crypto = crypto;
     }
 
     /** @category 2. Node Creation */
     static async withNewlyCreatedAccount<
-        Meta extends AccountMeta = AccountMeta
+        Meta extends AccountMeta = AccountMeta,
     >({
-        name,
+        creationProps,
         peersToLoadFrom,
         migration,
-        initialAgentSecret = newRandomAgentSecret(),
+        crypto,
+        initialAgentSecret = crypto.newRandomAgentSecret(),
     }: {
-        name: string;
+        creationProps: { name: string };
         peersToLoadFrom?: Peer[];
         migration?: RawAccountMigration<Meta>;
+        crypto: CryptoProvider;
         initialAgentSecret?: AgentSecret;
     }): Promise<{
         node: LocalNode;
@@ -86,27 +81,23 @@ export class LocalNode {
         accountSecret: AgentSecret;
         sessionID: SessionID;
     }> {
-        const throwawayAgent = newRandomAgentSecret();
+        const throwawayAgent = crypto.newRandomAgentSecret();
         const setupNode = new LocalNode(
-            new ControlledAgent(throwawayAgent),
-            newRandomSessionID(getAgentID(throwawayAgent))
+            new ControlledAgent(throwawayAgent, crypto),
+            newRandomSessionID(crypto.getAgentID(throwawayAgent)),
+            crypto,
         );
 
-        const account = setupNode.createAccount(name, initialAgentSecret);
+        const account = setupNode.createAccount(initialAgentSecret);
 
         const nodeWithAccount = account.core.node.testWithDifferentAccount(
             account,
-            newRandomSessionID(account.id)
+            newRandomSessionID(account.id),
         );
 
         const accountOnNodeWithAccount =
             nodeWithAccount.account as RawControlledAccount<Meta>;
 
-        const profile = nodeWithAccount.expectProfileLoaded(
-            accountOnNodeWithAccount.id,
-            "After creating account"
-        );
-
         if (peersToLoadFrom) {
             for (const peer of peersToLoadFrom) {
                 nodeWithAccount.syncManager.addPeer(peer);
@@ -114,29 +105,44 @@ export class LocalNode {
         }
 
         if (migration) {
-            await migration(accountOnNodeWithAccount, profile, nodeWithAccount);
+            await migration(
+                accountOnNodeWithAccount,
+                nodeWithAccount,
+                creationProps,
+            );
+        } else {
+            const profileGroup = accountOnNodeWithAccount.createGroup();
+            profileGroup.addMember("everyone", "reader");
+            const profile = profileGroup.createMap<Profile>({
+                name: creationProps.name,
+            });
+            accountOnNodeWithAccount.set("profile", profile.id, "trusting");
         }
 
         const controlledAccount = new RawControlledAccount(
             accountOnNodeWithAccount.core,
-            accountOnNodeWithAccount.agentSecret
+            accountOnNodeWithAccount.agentSecret,
         );
 
-        nodeWithAccount.account = controlledAccount
+        nodeWithAccount.account = controlledAccount;
         nodeWithAccount.coValues[controlledAccount.id] = {
             state: "loaded",
             coValue: controlledAccount.core,
         };
         controlledAccount.core._cachedContent = undefined;
 
+        if (!controlledAccount.get("profile")) {
+            throw new Error("Must set account profile in initial migration");
+        }
+
         // we shouldn't need this, but it fixes account data not syncing for new accounts
         function syncAllCoValuesAfterCreateAccount() {
             for (const coValueEntry of Object.values(
-                nodeWithAccount.coValues
+                nodeWithAccount.coValues,
             )) {
                 if (coValueEntry.state === "loaded") {
                     void nodeWithAccount.syncManager.syncCoValue(
-                        coValueEntry.coValue
+                        coValueEntry.coValue,
                     );
                 }
             }
@@ -160,17 +166,20 @@ export class LocalNode {
         accountSecret,
         sessionID,
         peersToLoadFrom,
+        crypto,
         migration,
     }: {
         accountID: AccountID;
         accountSecret: AgentSecret;
-        sessionID: SessionID;
+        sessionID: SessionID | undefined;
         peersToLoadFrom: Peer[];
+        crypto: CryptoProvider;
         migration?: RawAccountMigration<Meta>;
     }): Promise<LocalNode> {
         const loadingNode = new LocalNode(
-            new ControlledAgent(accountSecret),
-            newRandomSessionID(accountID)
+            new ControlledAgent(accountSecret, crypto),
+            newRandomSessionID(accountID),
+            crypto,
         );
 
         for (const peer of peersToLoadFrom) {
@@ -187,13 +196,13 @@ export class LocalNode {
 
         const controlledAccount = new RawControlledAccount(
             account.core,
-            accountSecret
+            accountSecret,
         );
 
         // since this is all synchronous, we can just swap out nodes for the SyncManager
         const node = loadingNode.testWithDifferentAccount(
             controlledAccount,
-            sessionID
+            sessionID || newRandomSessionID(accountID),
         );
         node.syncManager = loadingNode.syncManager;
         node.syncManager.local = node;
@@ -218,12 +227,11 @@ export class LocalNode {
         if (migration) {
             await migration(
                 controlledAccount as RawControlledAccount<Meta>,
-                profile,
-                node
+                node,
             );
             node.account = new RawControlledAccount(
                 controlledAccount.core,
-                controlledAccount.agentSecret
+                controlledAccount.agentSecret,
             );
         }
 
@@ -247,14 +255,14 @@ export class LocalNode {
             dontLoadFrom?: PeerID;
             dontWaitFor?: PeerID;
             onProgress?: (progress: number) => void;
-        } = {}
+        } = {},
     ): Promise<CoValueCore | "unavailable"> {
         let entry = this.coValues[id];
         if (!entry) {
             const peersToWaitFor = new Set(
                 Object.values(this.syncManager.peers)
                     .filter((peer) => peer.role === "server")
-                    .map((peer) => peer.id)
+                    .map((peer) => peer.id),
             );
             if (options.dontWaitFor) peersToWaitFor.delete(options.dontWaitFor);
             entry = newLoadingState(peersToWaitFor, options.onProgress);
@@ -268,7 +276,7 @@ export class LocalNode {
                         "Error loading from peers",
                         id,
 
-                        e
+                        e,
                     );
                 });
         }
@@ -287,7 +295,7 @@ export class LocalNode {
      */
     async load<T extends RawCoValue>(
         id: CoID<T>,
-        onProgress?: (progress: number) => void
+        onProgress?: (progress: number) => void,
     ): Promise<T | "unavailable"> {
         const core = await this.loadCoValueCore(id, { onProgress });
 
@@ -312,7 +320,7 @@ export class LocalNode {
     /** @category 3. Low-level */
     subscribe<T extends RawCoValue>(
         id: CoID<T>,
-        callback: (update: T | "unavailable") => void
+        callback: (update: T | "unavailable") => void,
     ): () => void {
         let stopped = false;
         let unsubscribe!: () => void;
@@ -344,20 +352,20 @@ export class LocalNode {
     /** @deprecated Use Account.acceptInvite instead */
     async acceptInvite<T extends RawCoValue>(
         groupOrOwnedValueID: CoID<T>,
-        inviteSecret: InviteSecret
+        inviteSecret: InviteSecret,
     ): Promise<void> {
         const groupOrOwnedValue = await this.load(groupOrOwnedValueID);
 
         if (groupOrOwnedValue === "unavailable") {
             throw new Error(
-                "Trying to accept invite: Group/owned value unavailable from all peers"
+                "Trying to accept invite: Group/owned value unavailable from all peers",
             );
         }
 
         if (groupOrOwnedValue.core.header.ruleset.type === "ownedByGroup") {
             return this.acceptInvite(
                 groupOrOwnedValue.core.header.ruleset.group as CoID<RawGroup>,
-                inviteSecret
+                inviteSecret,
             );
         } else if (groupOrOwnedValue.core.header.ruleset.type !== "group") {
             throw new Error("Can only accept invites to groups");
@@ -365,10 +373,10 @@ export class LocalNode {
 
         const group = expectGroup(groupOrOwnedValue);
 
-        const inviteAgentSecret = agentSecretFromSecretSeed(
-            secretSeedFromInviteSecret(inviteSecret)
+        const inviteAgentSecret = this.crypto.agentSecretFromSecretSeed(
+            secretSeedFromInviteSecret(inviteSecret),
         );
-        const inviteAgentID = getAgentID(inviteAgentSecret);
+        const inviteAgentID = this.crypto.getAgentID(inviteAgentSecret);
 
         const inviteRole = await new Promise((resolve, reject) => {
             group.subscribe((groupUpdate) => {
@@ -379,7 +387,7 @@ export class LocalNode {
             });
             setTimeout(
                 () => reject(new Error("Couldn't find invite before timeout")),
-                2000
+                2000,
             );
         });
 
@@ -396,7 +404,7 @@ export class LocalNode {
             (existingRole === "reader" && inviteRole === "readerInvite")
         ) {
             console.debug(
-                "Not accepting invite that would replace or downgrade role"
+                "Not accepting invite that would replace or downgrade role",
             );
             return;
         }
@@ -404,10 +412,10 @@ export class LocalNode {
         const groupAsInvite = expectGroup(
             group.core
                 .testWithDifferentAccount(
-                    new ControlledAgent(inviteAgentSecret),
-                    newRandomSessionID(inviteAgentID)
+                    new ControlledAgent(inviteAgentSecret, this.crypto),
+                    newRandomSessionID(inviteAgentID),
                 )
-                .getCurrentContent()
+                .getCurrentContent(),
         );
 
         groupAsInvite.addMemberInternal(
@@ -415,8 +423,8 @@ export class LocalNode {
             inviteRole === "adminInvite"
                 ? "admin"
                 : inviteRole === "writerInvite"
-                ? "writer"
-                : "reader"
+                  ? "writer"
+                  : "reader",
         );
 
         group.core._sessionLogs = groupAsInvite.core.sessionLogs;
@@ -432,14 +440,14 @@ export class LocalNode {
         const entry = this.coValues[id];
         if (!entry) {
             throw new Error(
-                `${expectation ? expectation + ": " : ""}Unknown CoValue ${id}`
+                `${expectation ? expectation + ": " : ""}Unknown CoValue ${id}`,
             );
         }
         if (entry.state === "loading") {
             throw new Error(
                 `${
                     expectation ? expectation + ": " : ""
-                }CoValue ${id} not yet loaded`
+                }CoValue ${id} not yet loaded`,
             );
         }
         return entry.coValue;
@@ -449,44 +457,45 @@ export class LocalNode {
     expectProfileLoaded(id: AccountID, expectation?: string): RawProfile {
         const account = this.expectCoValueLoaded(id, expectation);
         const profileID = expectGroup(account.getCurrentContent()).get(
-            "profile"
+            "profile",
         );
         if (!profileID) {
             throw new Error(
                 `${
                     expectation ? expectation + ": " : ""
-                }Account ${id} has no profile`
+                }Account ${id} has no profile`,
             );
         }
         return this.expectCoValueLoaded(
             profileID,
-            expectation
+            expectation,
         ).getCurrentContent() as RawProfile;
     }
 
     /** @internal */
     createAccount(
-        name: string,
-        agentSecret = newRandomAgentSecret()
+        agentSecret = this.crypto.newRandomAgentSecret(),
     ): RawControlledAccount {
-        const accountAgentID = getAgentID(agentSecret);
-        let account = expectGroup(
-            this.createCoValue(accountHeaderForInitialAgentSecret(agentSecret))
+        const accountAgentID = this.crypto.getAgentID(agentSecret);
+        const account = expectGroup(
+            this.createCoValue(
+                accountHeaderForInitialAgentSecret(agentSecret, this.crypto),
+            )
                 .testWithDifferentAccount(
-                    new ControlledAgent(agentSecret),
-                    newRandomSessionID(accountAgentID)
+                    new ControlledAgent(agentSecret, this.crypto),
+                    newRandomSessionID(accountAgentID),
                 )
-                .getCurrentContent()
+                .getCurrentContent(),
         );
 
         account.set(accountAgentID, "admin", "trusting");
 
-        const readKey = newRandomKeySecret();
+        const readKey = this.crypto.newRandomKeySecret();
 
-        const sealed = seal({
+        const sealed = this.crypto.seal({
             message: readKey.secret,
-            from: getAgentSealerSecret(agentSecret),
-            to: getAgentSealerID(accountAgentID),
+            from: this.crypto.getAgentSealerSecret(agentSecret),
+            to: this.crypto.getAgentSealerID(accountAgentID),
             nOnceMaterial: {
                 in: account.id,
                 tx: account.core.nextTransactionID(),
@@ -497,34 +506,19 @@ export class LocalNode {
 
         account.set("readKey", readKey.id, "trusting");
 
-        const profile = account.createMap<RawProfile>(
-            { name },
-            {
-                type: "profile",
-            },
-            "trusting"
-        );
-
-        account.set("profile", profile.id, "trusting");
-
         const accountOnThisNode = this.expectCoValueLoaded(account.id);
 
         accountOnThisNode._sessionLogs = new Map(account.core.sessionLogs);
 
         accountOnThisNode._cachedContent = undefined;
 
-        const profileOnThisNode = this.createCoValue(profile.core.header);
-
-        profileOnThisNode._sessionLogs = new Map(profile.core.sessionLogs);
-        profileOnThisNode._cachedContent = undefined;
-
         return new RawControlledAccount(accountOnThisNode, agentSecret);
     }
 
     /** @internal */
     resolveAccountAgent(
         id: AccountID | AgentID,
-        expectation?: string
+        expectation?: string,
     ): AgentID {
         if (isAgentID(id)) {
             return id;
@@ -542,16 +536,16 @@ export class LocalNode {
             throw new Error(
                 `${
                     expectation ? expectation + ": " : ""
-                }CoValue ${id} is not an account`
+                }CoValue ${id} is not an account`,
             );
         }
 
-        return new RawAccount(coValue).currentAgentID();
+        return (coValue.getCurrentContent() as RawAccount).currentAgentID();
     }
 
     async resolveAccountAgentAsync(
         id: AccountID | AgentID,
-        expectation?: string
+        expectation?: string,
     ): Promise<AgentID> {
         if (isAgentID(id)) {
             return id;
@@ -563,7 +557,7 @@ export class LocalNode {
             throw new Error(
                 `${
                     expectation ? expectation + ": " : ""
-                }Account ${id} is unavailable from all peers`
+                }Account ${id} is unavailable from all peers`,
             );
         }
 
@@ -577,11 +571,11 @@ export class LocalNode {
             throw new Error(
                 `${
                     expectation ? expectation + ": " : ""
-                }CoValue ${id} is not an account`
+                }CoValue ${id} is not an account`,
             );
         }
 
-        return new RawAccount(coValue).currentAgentID();
+        return (coValue.getCurrentContent() as RawAccount).currentAgentID();
     }
 
     /**
@@ -592,18 +586,18 @@ export class LocalNode {
             type: "comap",
             ruleset: { type: "group", initialAdmin: this.account.id },
             meta: null,
-            ...createdNowUnique(),
+            ...this.crypto.createdNowUnique(),
         });
 
-        let group = expectGroup(groupCoValue.getCurrentContent());
+        const group = expectGroup(groupCoValue.getCurrentContent());
 
         group.set(this.account.id, "admin", "trusting");
 
-        const readKey = newRandomKeySecret();
+        const readKey = this.crypto.newRandomKeySecret();
 
         group.set(
             `${readKey.id}_for_${this.account.id}`,
-            seal({
+            this.crypto.seal({
                 message: readKey.secret,
                 from: this.account.currentSealerSecret(),
                 to: this.account.currentSealerID(),
@@ -612,7 +606,7 @@ export class LocalNode {
                     tx: groupCoValue.nextTransactionID(),
                 },
             }),
-            "trusting"
+            "trusting",
         );
 
         group.set("readKey", readKey.id, "trusting");
@@ -623,9 +617,9 @@ export class LocalNode {
     /** @internal */
     testWithDifferentAccount(
         account: ControlledAccountOrAgent,
-        currentSessionID: SessionID
+        currentSessionID: SessionID,
     ): LocalNode {
-        const newNode = new LocalNode(account, currentSessionID);
+        const newNode = new LocalNode(account, currentSessionID, this.crypto);
 
         const coValuesToCopy = Object.entries(this.coValues);
 
@@ -650,7 +644,7 @@ export class LocalNode {
                 const newCoValue = new CoValueCore(
                     entry.coValue.header,
                     newNode,
-                    new Map(entry.coValue.sessionLogs)
+                    new Map(entry.coValue.sessionLogs),
                 );
 
                 newNode.coValues[coValueID as RawCoID] = {
@@ -666,7 +660,7 @@ export class LocalNode {
             // To make sure that when we edit the account, we're modifying the correct sessions
             const accountInNode = new RawControlledAccount(
                 newNode.expectCoValueLoaded(account.id),
-                account.agentSecret
+                account.agentSecret,
             );
             if (accountInNode.core.node !== newNode) {
                 throw new Error("Account's node is not the new node");
@@ -705,7 +699,7 @@ type CoValueState =
 /** @internal */
 export function newLoadingState(
     currentPeerIds: Set<PeerID>,
-    onProgress?: (progress: number) => void
+    onProgress?: (progress: number) => void,
 ): CoValueState {
     let resolve: (coValue: CoValueCore | "unavailable") => void;
 
@@ -725,7 +719,7 @@ export function newLoadingState(
                     resolve = r;
                 });
                 return [id, { type: "waiting", done, resolve: resolve! }];
-            })
+            }),
         ),
     };
 }

package/src/media.ts

@@ -1,8 +1,8 @@
-import { RawCoMap } from './coValues/coMap.js'
-import { RawBinaryCoStream } from './coValues/coStream.js'
+import { RawCoMap } from "./coValues/coMap.js";
+import { RawBinaryCoStream } from "./coValues/coStream.js";
 
 export type ImageDefinition = RawCoMap<{
     originalSize: [number, number];
     placeholderDataURL?: string;
     [res: `${number}x${number}`]: RawBinaryCoStream["id"];
-}>;
+}>;

package/src/permissions.ts

@@ -1,7 +1,7 @@
 import { CoID } from "./coValue.js";
 import { MapOpPayload } from "./coValues/coMap.js";
 import { JsonValue } from "./jsonValue.js";
-import { KeyID } from "./crypto.js";
+import { KeyID } from "./crypto/crypto.js";
 import { CoValueCore, Transaction } from "./coValueCore.js";
 import { accountOrAgentIDfromSessionID } from "./typeUtils/accountOrAgentIDfromSessionID.js";
 import { AgentID, RawCoID, SessionID, TransactionID } from "./ids.js";
@@ -25,7 +25,7 @@ export type Role =
     | "readerInvite";
 
 export function determineValidTransactions(
-    coValue: CoValueCore
+    coValue: CoValueCore,
 ): { txID: TransactionID; tx: Transaction }[] {
     if (coValue.header.ruleset.type === "group") {
         const allTransactionsSorted = [
@@ -73,7 +73,7 @@ export function determineValidTransactions(
                     continue;
                 } else {
                     console.warn(
-                        "Only admins can make private transactions in groups"
+                        "Only admins can make private transactions in groups",
                     );
                     continue;
                 }
@@ -92,8 +92,8 @@ export function determineValidTransactions(
                     JSON.stringify(tx.changes, (k, v) =>
                         k === "changes" || k === "encryptedChanges"
                             ? v.slice(0, 20) + "..."
-                            : v
-                    )
+                            : v,
+                    ),
                 );
                 continue;
             }
@@ -173,7 +173,7 @@ export function determineValidTransactions(
                 )
             ) {
                 console.warn(
-                    "Everyone can only be set to reader, writer or revoked"
+                    "Everyone can only be set to reader, writer or revoked",
                 );
                 continue;
             }
@@ -212,7 +212,7 @@ export function determineValidTransactions(
                     }
                 } else {
                     console.warn(
-                        "Group transaction must be made by current admin or invite"
+                        "Group transaction must be made by current admin or invite",
                     );
                     continue;
                 }
@@ -230,9 +230,9 @@ export function determineValidTransactions(
             coValue.node
                 .expectCoValueLoaded(
                     coValue.header.ruleset.group,
-                    "Determining valid transaction in owned object but its group wasn't loaded"
+                    "Determining valid transaction in owned object but its group wasn't loaded",
                 )
-                .getCurrentContent()
+                .getCurrentContent(),
         );
 
         if (groupContent.type !== "comap") {
@@ -264,7 +264,7 @@ export function determineValidTransactions(
                         txID: { sessionID: sessionID, txIndex },
                         tx,
                     }));
-            }
+            },
         );
     } else if (coValue.header.ruleset.type === "unsafeAllowAll") {
         return [...coValue.sessionLogs.entries()].flatMap(
@@ -273,28 +273,26 @@ export function determineValidTransactions(
                     txID: { sessionID: sessionID, txIndex },
                     tx,
                 }));
-            }
+            },
         );
     } else {
         throw new Error(
             "Unknown ruleset type " +
-                (coValue.header.ruleset as { type: string }).type
+                (coValue.header.ruleset as { type: string }).type,
         );
     }
 }
 
-export function isKeyForKeyField(
-    field: string
-): field is `${KeyID}_for_${KeyID}` {
-    return field.startsWith("key_") && field.includes("_for_key");
+export function isKeyForKeyField(co: string): co is `${KeyID}_for_${KeyID}` {
+    return co.startsWith("key_") && co.includes("_for_key");
 }
 
 export function isKeyForAccountField(
-    field: string
-): field is `${KeyID}_for_${AccountID | AgentID}` {
+    co: string,
+): co is `${KeyID}_for_${AccountID | AgentID}` {
     return (
-        (field.startsWith("key_") &&
-            (field.includes("_for_sealer") || field.includes("_for_co"))) ||
-        field.includes("_for_everyone")
+        (co.startsWith("key_") &&
+            (co.includes("_for_sealer") || co.includes("_for_co"))) ||
+        co.includes("_for_everyone")
     );
 }