cojson 0.0.11 → 0.0.12

package/src/permissions.ts

@@ -1,36 +1,30 @@
-import { ContentType } from './contentType.js';
-import { CoMap, MapOpPayload } from './contentTypes/coMap.js';
-import { JsonValue } from './jsonValue.js';
+import { CoID, ContentType } from "./contentType.js";
+import { CoMap, MapOpPayload } from "./contentTypes/coMap.js";
+import { JsonObject, JsonValue } from "./jsonValue.js";
 import {
     Encrypted,
     KeyID,
     KeySecret,
-    RecipientID,
-    SealedSet,
-    SignatoryID,
     createdNowUnique,
     newRandomKeySecret,
     seal,
-    sealKeySecret,
-} from './crypto.js';
+    encryptKeySecret,
+    getAgentSealerID,
+    Sealed,
+} from "./crypto.js";
 import {
-    AgentCredential,
     CoValue,
     Transaction,
     TrustingTransaction,
-    agentIDfromSessionID,
-} from './coValue.js';
+    accountOrAgentIDfromSessionID,
+} from "./coValue.js";
 import { LocalNode } from "./node.js";
-import { AgentID, RawCoValueID, SessionID, TransactionID } from './ids.js';
+import { RawCoID, SessionID, TransactionID, isAgentID } from "./ids.js";
+import { AccountIDOrAgentID, GeneralizedControlledAccount, Profile } from "./account.js";
 
 export type PermissionsDef =
-    | { type: "team"; initialAdmin: AgentID; parentTeams?: RawCoValueID[] }
-    | { type: "ownedByTeam"; team: RawCoValueID }
-    | {
-          type: "agent";
-          initialSignatoryID: SignatoryID;
-          initialRecipientID: RecipientID;
-      }
+    | { type: "team"; initialAdmin: AccountIDOrAgentID }
+    | { type: "ownedByTeam"; team: RawCoID }
     | { type: "unsafeAllowAll" };
 
 export type Role = "reader" | "writer" | "admin" | "revoked";
@@ -68,7 +62,7 @@ export function determineValidTransactions(
             throw new Error("Team must have initialAdmin");
         }
 
-        const memberState: { [agent: AgentID]: Role } = {};
+        const memberState: { [agent: AccountIDOrAgentID]: Role } = {};
 
         const validTransactions: { txID: TransactionID; tx: Transaction }[] =
             [];
@@ -79,11 +73,12 @@ export function determineValidTransactions(
             tx,
         } of allTrustingTransactionsSorted) {
             // console.log("before", { memberState, validTransactions });
-            const transactor = agentIDfromSessionID(sessionID);
+            const transactor = accountOrAgentIDfromSessionID(sessionID);
 
             const change = tx.changes[0] as
-                | MapOpPayload<AgentID, Role>
-                | MapOpPayload<"readKey", JsonValue>;
+                | MapOpPayload<AccountIDOrAgentID, Role>
+                | MapOpPayload<"readKey", JsonValue>
+                | MapOpPayload<"profile", CoID<Profile>>;
             if (tx.changes.length !== 1) {
                 console.warn("Team transaction must have exactly one change");
                 continue;
@@ -100,6 +95,22 @@ export function determineValidTransactions(
                     continue;
                 }
 
+                validTransactions.push({ txID: { sessionID, txIndex }, tx });
+                continue;
+            } else if (change.key === 'profile') {
+                if (memberState[transactor] !== "admin") {
+                    console.warn("Only admins can set profile");
+                    continue;
+                }
+
+                validTransactions.push({ txID: { sessionID, txIndex }, tx });
+                continue;
+            } else if (isKeyForKeyField(change.key) || isKeyForAccountField(change.key)) {
+                if (memberState[transactor] !== "admin") {
+                    console.warn("Only admins can reveal keys");
+                    continue;
+                }
+
                 // TODO: check validity of agents who the key is revealed to?
 
                 validTransactions.push({ txID: { sessionID, txIndex }, tx });
@@ -152,11 +163,12 @@ export function determineValidTransactions(
 
         return validTransactions;
     } else if (coValue.header.ruleset.type === "ownedByTeam") {
-        const teamContent =
-            coValue.node.expectCoValueLoaded(
+        const teamContent = coValue.node
+            .expectCoValueLoaded(
                 coValue.header.ruleset.team,
                 "Determining valid transaction in owned object but its team wasn't loaded"
-            ).getCurrentContent();
+            )
+            .getCurrentContent();
 
         if (teamContent.type !== "comap") {
             throw new Error("Team must be a map");
@@ -164,7 +176,9 @@ export function determineValidTransactions(
 
         return Object.entries(coValue.sessions).flatMap(
             ([sessionID, sessionLog]) => {
-                const transactor = agentIDfromSessionID(sessionID as SessionID);
+                const transactor = accountOrAgentIDfromSessionID(
+                    sessionID as SessionID
+                );
                 return sessionLog.transactions
                     .filter((tx) => {
                         const transactorRoleAtTxTime = teamContent.getAtTime(
@@ -192,80 +206,77 @@ export function determineValidTransactions(
                 }));
             }
         );
-    } else if (coValue.header.ruleset.type === "agent") {
-        // TODO
-        return [];
     } else {
-        throw new Error("Unknown ruleset type " + (coValue.header.ruleset as any).type);
+        throw new Error(
+            "Unknown ruleset type " + (coValue.header.ruleset as any).type
+        );
     }
 }
 
-export type TeamContent = { [key: AgentID]: Role } & {
-    readKey: {
-        keyID: KeyID;
-        revelation: SealedSet<KeySecret>;
-        previousKeys?: {
-            [key: KeyID]: Encrypted<
-                KeySecret,
-                { sealed: KeyID; sealing: KeyID }
-            >;
-        };
-    };
+export type TeamContent = {
+    profile: CoID<Profile> | null;
+    [key: AccountIDOrAgentID]: Role;
+    readKey: KeyID;
+    [revelationFor: `${KeyID}_for_${AccountIDOrAgentID}`]: Sealed<KeySecret>;
+    [oldKeyForNewKey: `${KeyID}_for_${KeyID}`]: Encrypted<
+        KeySecret,
+        { encryptedID: KeyID; encryptingID: KeyID }
+    >;
 };
 
-export function expectTeamContent(content: ContentType): CoMap<TeamContent, {}> {
+export function expectTeamContent(
+    content: ContentType
+): CoMap<TeamContent, JsonObject | null> {
     if (content.type !== "comap") {
         throw new Error("Expected map");
     }
 
-    return content as CoMap<TeamContent, {}>;
+    return content as CoMap<TeamContent, JsonObject | null>;
 }
 
 export class Team {
-    teamMap: CoMap<TeamContent, {}>;
+    teamMap: CoMap<TeamContent, JsonObject | null>;
     node: LocalNode;
 
-    constructor(teamMap: CoMap<TeamContent, {}>, node: LocalNode) {
+    constructor(teamMap: CoMap<TeamContent, JsonObject | null>, node: LocalNode) {
         this.teamMap = teamMap;
         this.node = node;
     }
 
-    get id(): RawCoValueID {
+    get id(): CoID<CoMap<TeamContent, JsonObject | null>> {
         return this.teamMap.id;
     }
 
-    addMember(agentID: AgentID, role: Role) {
+    addMember(accountID: AccountIDOrAgentID, role: Role) {
         this.teamMap = this.teamMap.edit((map) => {
-            const agent = this.node.expectAgentLoaded(agentID, "Expected to know agent to add them to team");
-
-            if (!agent) {
-                throw new Error("Unknown agent " + agentID);
-            }
-
-            map.set(agentID, role, "trusting");
-            if (map.get(agentID) !== role) {
-                throw new Error("Failed to set role");
-            }
-
             const currentReadKey = this.teamMap.coValue.getCurrentReadKey();
 
             if (!currentReadKey.secret) {
                 throw new Error("Can't add member without read key secret");
             }
 
-            const revelation = seal(
-                currentReadKey.secret,
-                this.teamMap.coValue.node.agentCredential.recipientSecret,
-                new Set([agent.recipientID]),
-                {
-                    in: this.teamMap.coValue.id,
-                    tx: this.teamMap.coValue.nextTransactionID(),
-                }
+            const agent = this.node.resolveAccountAgent(
+                accountID,
+                "Expected to know agent to add them to team"
             );
 
+            map.set(accountID, role, "trusting");
+
+            if (map.get(accountID) !== role) {
+                throw new Error("Failed to set role");
+            }
+
             map.set(
-                "readKey",
-                { keyID: currentReadKey.id, revelation },
+                `${currentReadKey.id}_for_${accountID}`,
+                seal(
+                    currentReadKey.secret,
+                    this.teamMap.coValue.node.account.currentSealerSecret(),
+                    getAgentSealerID(agent),
+                    {
+                        in: this.teamMap.coValue.id,
+                        tx: this.teamMap.coValue.nextTransactionID(),
+                    }
+                ),
                 "trusting"
             );
         });
@@ -273,7 +284,7 @@ export class Team {
 
     rotateReadKey() {
         const currentlyPermittedReaders = this.teamMap.keys().filter((key) => {
-            if (key.startsWith("co_agent")) {
+            if (key.startsWith("co_") || isAgentID(key)) {
                 const role = this.teamMap.get(key);
                 return (
                     role === "admin" || role === "writer" || role === "reader"
@@ -281,12 +292,14 @@ export class Team {
             } else {
                 return false;
             }
-        }) as AgentID[];
+        }) as AccountIDOrAgentID[];
 
         const maybeCurrentReadKey = this.teamMap.coValue.getCurrentReadKey();
 
         if (!maybeCurrentReadKey.secret) {
-            throw new Error("Can't rotate read key secret we don't have access to");
+            throw new Error(
+                "Can't rotate read key secret we don't have access to"
+            );
         }
 
         const currentReadKey = {
@@ -296,54 +309,51 @@ export class Team {
 
         const newReadKey = newRandomKeySecret();
 
-        const newReadKeyRevelation = seal(
-            newReadKey.secret,
-            this.teamMap.coValue.node.agentCredential.recipientSecret,
-            new Set(
-                currentlyPermittedReaders.map(
-                    (reader) => {
-                        const readerAgent = this.node.expectAgentLoaded(reader, "Expected to know currently permitted reader");
-                        if (!readerAgent) {
-                            throw new Error("Unknown agent " + reader);
+        this.teamMap = this.teamMap.edit((map) => {
+            for (const readerID of currentlyPermittedReaders) {
+                const reader = this.node.resolveAccountAgent(
+                    readerID,
+                    "Expected to know currently permitted reader"
+                );
+
+                map.set(
+                    `${newReadKey.id}_for_${readerID}`,
+                    seal(
+                        newReadKey.secret,
+                        this.teamMap.coValue.node.account.currentSealerSecret(),
+                        getAgentSealerID(reader),
+                        {
+                            in: this.teamMap.coValue.id,
+                            tx: this.teamMap.coValue.nextTransactionID(),
                         }
-                        return readerAgent.recipientID
-                    }
-                )
-            ),
-            {
-                in: this.teamMap.coValue.id,
-                tx: this.teamMap.coValue.nextTransactionID(),
+                    ),
+                    "trusting"
+                );
             }
-        );
 
-        this.teamMap = this.teamMap.edit((map) => {
             map.set(
-                "readKey",
-                {
-                    keyID: newReadKey.id,
-                    revelation: newReadKeyRevelation,
-                    previousKeys: {
-                        [currentReadKey.id]: sealKeySecret({
-                            sealing: newReadKey,
-                            toSeal: currentReadKey,
-                        }).encrypted,
-                    },
-                },
+                `${currentReadKey.id}_for_${newReadKey.id}`,
+                encryptKeySecret({
+                    encrypting: newReadKey,
+                    toEncrypt: currentReadKey,
+                }).encrypted,
                 "trusting"
             );
+
+            map.set("readKey", newReadKey.id, "trusting");
         });
     }
 
-    removeMember(agentID: AgentID) {
+    removeMember(accountID: AccountIDOrAgentID) {
         this.teamMap = this.teamMap.edit((map) => {
-            map.set(agentID, "revoked", "trusting");
+            map.set(accountID, "revoked", "trusting");
         });
 
         this.rotateReadKey();
     }
 
-    createMap<M extends { [key: string]: JsonValue }, Meta extends JsonValue>(
-        meta?: M
+    createMap<M extends { [key: string]: JsonValue }, Meta extends JsonObject | null>(
+        meta?: Meta
     ): CoMap<M, Meta> {
         return this.node
             .createCoValue({
@@ -354,22 +364,29 @@ export class Team {
                 },
                 meta: meta || null,
                 ...createdNowUnique(),
-                publicNickname: "map",
             })
             .getCurrentContent() as CoMap<M, Meta>;
     }
 
-    testWithDifferentCredentials(
-        credential: AgentCredential,
+    testWithDifferentAccount(
+        account: GeneralizedControlledAccount,
         sessionId: SessionID
     ): Team {
         return new Team(
             expectTeamContent(
                 this.teamMap.coValue
-                    .testWithDifferentCredentials(credential, sessionId)
+                    .testWithDifferentAccount(account, sessionId)
                     .getCurrentContent()
             ),
             this.node
         );
     }
 }
+
+export function isKeyForKeyField(field: string): field is `${KeyID}_for_${KeyID}` {
+    return field.startsWith("key_") && field.includes("_for_key");
+}
+
+export function isKeyForAccountField(field: string): field is `${KeyID}_for_${AccountIDOrAgentID}` {
+    return field.startsWith("key_") && (field.includes("_for_sealer") || field.includes("_for_co"));
+}