cojson 0.7.33-hotfixes.5 → 0.7.34-neverthrow.0

package/src/coValueCore.ts

@@ -7,6 +7,7 @@ import {
     StreamingHash,
     KeyID,
     CryptoProvider,
+    SignerID,
 } from "./crypto/crypto.js";
 import { JsonObject, JsonValue } from "./jsonValue.js";
 import { base58 } from "@scure/base";
@@ -16,7 +17,7 @@ import {
     isKeyForKeyField,
 } from "./permissions.js";
 import { RawGroup } from "./coValues/group.js";
-import { LocalNode } from "./localNode.js";
+import { LocalNode, ResolveAccountAgentError } from "./localNode.js";
 import { CoValueKnownState, NewContentMessage } from "./sync.js";
 import { AgentID, RawCoID, SessionID, TransactionID } from "./ids.js";
 import { AccountID, ControlledAccountOrAgent } from "./coValues/account.js";
@@ -25,6 +26,7 @@ import { coreToCoValue } from "./coreToCoValue.js";
 import { expectGroup } from "./typeUtils/expectGroup.js";
 import { isAccountID } from "./typeUtils/isAccountID.js";
 import { accountOrAgentIDfromSessionID } from "./typeUtils/accountOrAgentIDfromSessionID.js";
+import { err, ok, Result, ResultAsync } from "neverthrow";
 
 /**
     In order to not block other concurrently syncing CoValues we introduce a maximum size of transactions,
@@ -103,7 +105,6 @@ export class CoValueCore {
     _decryptionCache: {
         [key: Encrypted<JsonValue[], JsonValue>]: JsonValue[] | undefined;
     } = {};
-    currentlyAsyncApplyingTxDone?: Promise<void>;
     _cachedKnownState?: CoValueKnownState;
     _cachedDependentOn?: RawCoID[];
     _cachedNewContentSinceEmpty?: NewContentMessage[] | undefined;
@@ -182,7 +183,9 @@ export class CoValueCore {
             this.header.meta?.type === "account"
                 ? (this.node.currentSessionID.replace(
                       this.node.account.id,
-                      this.node.account.currentAgentID(),
+                      this.node.account
+                          .currentAgentID()
+                          ._unsafeUnwrap({ withStackTrace: true }),
                   ) as SessionID)
                 : this.node.currentSessionID;
 
@@ -197,166 +200,163 @@ export class CoValueCore {
         newTransactions: Transaction[],
         givenExpectedNewHash: Hash | undefined,
         newSignature: Signature,
-    ): boolean {
-        const signerID = this.crypto.getAgentSignerID(
-            this.node.resolveAccountAgent(
+    ): Result<true, TryAddTransactionsError> {
+        return this.node
+            .resolveAccountAgent(
                 accountOrAgentIDfromSessionID(sessionID),
                 "Expected to know signer of transaction",
-            ),
-        );
+            )
+            .andThen((agent) => {
+                const signerID = this.crypto.getAgentSignerID(agent);
+
+                // const beforeHash = performance.now();
+                const { expectedNewHash, newStreamingHash } =
+                    this.expectedNewHashAfter(sessionID, newTransactions);
+                // const afterHash = performance.now();
+                // console.log(
+                //     "Hashing took",
+                //     afterHash - beforeHash
+                // );
+
+                if (
+                    givenExpectedNewHash &&
+                    givenExpectedNewHash !== expectedNewHash
+                ) {
+                    return err({
+                        type: "InvalidHash",
+                        id: this.id,
+                        expectedNewHash,
+                        givenExpectedNewHash,
+                    } satisfies InvalidHashError);
+                }
 
-        if (!signerID) {
-            console.warn(
-                "Unknown agent",
-                accountOrAgentIDfromSessionID(sessionID),
-            );
-            return false;
-        }
+                // const beforeVerify = performance.now();
+                if (
+                    !this.crypto.verify(newSignature, expectedNewHash, signerID)
+                ) {
+                    return err({
+                        type: "InvalidSignature",
+                        id: this.id,
+                        newSignature,
+                        sessionID,
+                        signerID,
+                    } satisfies InvalidSignatureError);
+                }
+                // const afterVerify = performance.now();
+                // console.log(
+                //     "Verify took",
+                //     afterVerify - beforeVerify
+                // );
+
+                this.doAddTransactions(
+                    sessionID,
+                    newTransactions,
+                    newSignature,
+                    expectedNewHash,
+                    newStreamingHash,
+                    "immediate",
+                );
 
-        // const beforeHash = performance.now();
-        const { expectedNewHash, newStreamingHash } = this.expectedNewHashAfter(
-            sessionID,
-            newTransactions,
-        );
-        // const afterHash = performance.now();
-        // console.log(
-        //     "Hashing took",
-        //     afterHash - beforeHash
-        // );
-
-        if (givenExpectedNewHash && givenExpectedNewHash !== expectedNewHash) {
-            console.warn("Invalid hash", {
-                expectedNewHash,
-                givenExpectedNewHash,
+                return ok(true as const);
             });
-            return false;
-        }
-
-        // const beforeVerify = performance.now();
-        if (!this.crypto.verify(newSignature, expectedNewHash, signerID)) {
-            console.warn(
-                "Invalid signature in",
-                this.id,
-                newSignature,
-                expectedNewHash,
-                signerID,
-            );
-            return false;
-        }
-        // const afterVerify = performance.now();
-        // console.log(
-        //     "Verify took",
-        //     afterVerify - beforeVerify
-        // );
-
-        this.doAddTransactions(
-            sessionID,
-            newTransactions,
-            newSignature,
-            expectedNewHash,
-            newStreamingHash,
-            "immediate",
-        );
-
-        return true;
     }
 
-    async tryAddTransactionsAsync(
+    tryAddTransactionsAsync(
         sessionID: SessionID,
         newTransactions: Transaction[],
         givenExpectedNewHash: Hash | undefined,
         newSignature: Signature,
-    ): Promise<boolean> {
-        if (this.currentlyAsyncApplyingTxDone) {
-            await this.currentlyAsyncApplyingTxDone;
-        }
-        let resolveDone!: () => void;
-
-        this.currentlyAsyncApplyingTxDone = new Promise((resolve) => {
-            resolveDone = resolve;
-        });
-
-        const signerID = this.crypto.getAgentSignerID(
-            await this.node.resolveAccountAgentAsync(
+    ): ResultAsync<true, TryAddTransactionsError> {
+        return this.node
+            .resolveAccountAgentAsync(
                 accountOrAgentIDfromSessionID(sessionID),
                 "Expected to know signer of transaction",
-            ),
-        );
-
-        if (!signerID) {
-            console.warn(
-                "Unknown agent",
-                accountOrAgentIDfromSessionID(sessionID),
-            );
-            resolveDone();
-            return false;
-        }
-
-        const nTxBefore =
-            this.sessionLogs.get(sessionID)?.transactions.length ?? 0;
-
-        // const beforeHash = performance.now();
-        const { expectedNewHash, newStreamingHash } =
-            await this.expectedNewHashAfterAsync(sessionID, newTransactions);
-        // const afterHash = performance.now();
-        // console.log(
-        //     "Hashing took",
-        //     afterHash - beforeHash
-        // );
-
-        const nTxAfter =
-            this.sessionLogs.get(sessionID)?.transactions.length ?? 0;
-
-        if (nTxAfter !== nTxBefore) {
-            const newTransactionLengthBefore = newTransactions.length;
-            newTransactions = newTransactions.slice(nTxAfter - nTxBefore);
-            console.warn("Transactions changed while async hashing", {
-                nTxBefore,
-                nTxAfter,
-                newTransactionLengthBefore,
-                remainingNewTransactions: newTransactions.length,
-            });
-        }
+            )
+            .andThen((agent) => {
+                const signerID = this.crypto.getAgentSignerID(agent);
+
+                const nTxBefore =
+                    this.sessionLogs.get(sessionID)?.transactions.length ?? 0;
+
+                // const beforeHash = performance.now();
+                return ResultAsync.fromSafePromise(
+                    this.expectedNewHashAfterAsync(sessionID, newTransactions),
+                ).andThen(({ expectedNewHash, newStreamingHash }) => {
+                    // const afterHash = performance.now();
+                    // console.log(
+                    //     "Hashing took",
+                    //     afterHash - beforeHash
+                    // );
+
+                    const nTxAfter =
+                        this.sessionLogs.get(sessionID)?.transactions.length ??
+                        0;
+
+                    if (nTxAfter !== nTxBefore) {
+                        const newTransactionLengthBefore =
+                            newTransactions.length;
+                        newTransactions = newTransactions.slice(
+                            nTxAfter - nTxBefore,
+                        );
+                        console.warn(
+                            "Transactions changed while async hashing",
+                            {
+                                nTxBefore,
+                                nTxAfter,
+                                newTransactionLengthBefore,
+                                remainingNewTransactions:
+                                    newTransactions.length,
+                            },
+                        );
+                    }
 
-        if (givenExpectedNewHash && givenExpectedNewHash !== expectedNewHash) {
-            console.warn("Invalid hash", {
-                expectedNewHash,
-                givenExpectedNewHash,
-            });
-            resolveDone();
-            return false;
-        }
+                    if (
+                        givenExpectedNewHash &&
+                        givenExpectedNewHash !== expectedNewHash
+                    ) {
+                        return err({
+                            type: "InvalidHash",
+                            id: this.id,
+                            expectedNewHash,
+                            givenExpectedNewHash,
+                        } satisfies InvalidHashError);
+                    }
 
-        performance.mark("verifyStart" + this.id);
-        if (!this.crypto.verify(newSignature, expectedNewHash, signerID)) {
-            console.warn(
-                "Invalid signature in",
-                this.id,
-                newSignature,
-                expectedNewHash,
-                signerID,
-            );
-            resolveDone();
-            return false;
-        }
-        performance.mark("verifyEnd" + this.id);
-        performance.measure(
-            "verify" + this.id,
-            "verifyStart" + this.id,
-            "verifyEnd" + this.id,
-        );
+                    performance.mark("verifyStart" + this.id);
+                    if (
+                        !this.crypto.verify(
+                            newSignature,
+                            expectedNewHash,
+                            signerID,
+                        )
+                    ) {
+                        return err({
+                            type: "InvalidSignature",
+                            id: this.id,
+                            newSignature,
+                            sessionID,
+                            signerID,
+                        } satisfies InvalidSignatureError);
+                    }
+                    performance.mark("verifyEnd" + this.id);
+                    performance.measure(
+                        "verify" + this.id,
+                        "verifyStart" + this.id,
+                        "verifyEnd" + this.id,
+                    );
 
-        this.doAddTransactions(
-            sessionID,
-            newTransactions,
-            newSignature,
-            expectedNewHash,
-            newStreamingHash,
-            "deferred",
-        );
+                    this.doAddTransactions(
+                        sessionID,
+                        newTransactions,
+                        newSignature,
+                        expectedNewHash,
+                        newStreamingHash,
+                        "deferred",
+                    );
 
-        resolveDone();
-        return true;
+                    return ok(true as const);
+                });
+            });
     }
 
     private doAddTransactions(
@@ -545,7 +545,9 @@ export class CoValueCore {
             this.header.meta?.type === "account"
                 ? (this.node.currentSessionID.replace(
                       this.node.account.id,
-                      this.node.account.currentAgentID(),
+                      this.node.account
+                          .currentAgentID()
+                          ._unsafeUnwrap({ withStackTrace: true }),
                   ) as SessionID)
                 : this.node.currentSessionID;
 
@@ -563,7 +565,7 @@ export class CoValueCore {
             [transaction],
             expectedNewHash,
             signature,
-        );
+        )._unsafeUnwrap({ withStackTrace: true });
 
         if (success) {
             void this.node.syncManager.syncCoValue(this);
@@ -709,7 +711,9 @@ export class CoValueCore {
             // Try to find key revelation for us
             const lookupAccountOrAgentID =
                 this.header.meta?.type === "account"
-                    ? this.node.account.currentAgentID()
+                    ? this.node.account
+                          .currentAgentID()
+                          ._unsafeUnwrap({ withStackTrace: true })
                     : this.node.account.id;
 
             const lastReadyKeyEdit = content.lastEditAt(
@@ -718,10 +722,9 @@ export class CoValueCore {
 
             if (lastReadyKeyEdit?.value) {
                 const revealer = lastReadyKeyEdit.by;
-                const revealerAgent = this.node.resolveAccountAgent(
-                    revealer,
-                    "Expected to know revealer",
-                );
+                const revealerAgent = this.node
+                    .resolveAccountAgent(revealer, "Expected to know revealer")
+                    ._unsafeUnwrap({ withStackTrace: true });
 
                 const secret = this.crypto.unseal(
                     lastReadyKeyEdit.value,
@@ -986,3 +989,23 @@ function getNextKnownSignatureIdx(
                 idx >= (sentStateForSessionID ?? knownStateForSessionID ?? -1),
         );
 }
+
+export type InvalidHashError = {
+    type: "InvalidHash";
+    id: RawCoID;
+    expectedNewHash: Hash;
+    givenExpectedNewHash: Hash;
+};
+
+export type InvalidSignatureError = {
+    type: "InvalidSignature";
+    id: RawCoID;
+    newSignature: Signature;
+    sessionID: SessionID;
+    signerID: SignerID;
+};
+
+export type TryAddTransactionsError =
+    | ResolveAccountAgentError
+    | InvalidHashError
+    | InvalidSignatureError;

package/src/coValues/account.ts

@@ -13,6 +13,7 @@ import { RawCoMap } from "./coMap.js";
 import { RawGroup, InviteSecret } from "./group.js";
 import { LocalNode } from "../index.js";
 import { JsonObject } from "../jsonValue.js";
+import { err, ok, Result } from "neverthrow";
 
 export function accountHeaderForInitialAgentSecret(
     agentSecret: AgentSecret,
@@ -30,28 +31,34 @@ export function accountHeaderForInitialAgentSecret(
     };
 }
 
+export type InvalidAccountAgentIDError = {
+    type: "InvalidAccountAgentID";
+    reason: string;
+};
+
 export class RawAccount<
     Meta extends AccountMeta = AccountMeta,
 > extends RawGroup<Meta> {
     _cachedCurrentAgentID: AgentID | undefined;
 
-    currentAgentID(): AgentID {
+    currentAgentID(): Result<AgentID, InvalidAccountAgentIDError> {
         if (this._cachedCurrentAgentID) {
-            return this._cachedCurrentAgentID;
+            return ok(this._cachedCurrentAgentID);
         }
         const agents = this.keys().filter((k): k is AgentID =>
             k.startsWith("sealer_"),
         );
 
         if (agents.length !== 1) {
-            throw new Error(
-                "Expected exactly one agent in account, got " + agents.length,
-            );
+            return err({
+                type: "InvalidAccountAgentID",
+                reason: "Account has " + agents.length + " agents",
+            });
         }
 
         this._cachedCurrentAgentID = agents[0];
 
-        return agents[0]!;
+        return ok(agents[0]!);
     }
 }
 
@@ -59,10 +66,10 @@ export interface ControlledAccountOrAgent {
     id: AccountID | AgentID;
     agentSecret: AgentSecret;
 
-    currentAgentID: () => AgentID;
-    currentSignerID: () => SignerID;
+    currentAgentID: () => Result<AgentID, InvalidAccountAgentIDError>;
+    currentSignerID: () => Result<SignerID, InvalidAccountAgentIDError>;
     currentSignerSecret: () => SignerSecret;
-    currentSealerID: () => SealerID;
+    currentSealerID: () => Result<SealerID, InvalidAccountAgentIDError>;
     currentSealerSecret: () => SealerSecret;
 }
 
@@ -96,25 +103,29 @@ export class RawControlledAccount<Meta extends AccountMeta = AccountMeta>
         return this.core.node.acceptInvite(groupOrOwnedValueID, inviteSecret);
     }
 
-    currentAgentID(): AgentID {
+    currentAgentID(): Result<AgentID, InvalidAccountAgentIDError> {
         if (this._cachedCurrentAgentID) {
-            return this._cachedCurrentAgentID;
+            return ok(this._cachedCurrentAgentID);
         }
         const agentID = this.crypto.getAgentID(this.agentSecret);
         this._cachedCurrentAgentID = agentID;
-        return agentID;
+        return ok(agentID);
     }
 
-    currentSignerID(): SignerID {
-        return this.crypto.getAgentSignerID(this.currentAgentID());
+    currentSignerID() {
+        return this.currentAgentID().map((id) =>
+            this.crypto.getAgentSignerID(id),
+        );
     }
 
     currentSignerSecret(): SignerSecret {
         return this.crypto.getAgentSignerSecret(this.agentSecret);
     }
 
-    currentSealerID(): SealerID {
-        return this.crypto.getAgentSealerID(this.currentAgentID());
+    currentSealerID() {
+        return this.currentAgentID().map((id) =>
+            this.crypto.getAgentSealerID(id),
+        );
     }
 
     currentSealerSecret(): SealerSecret {
@@ -133,20 +144,24 @@ export class ControlledAgent implements ControlledAccountOrAgent {
         return this.crypto.getAgentID(this.agentSecret);
     }
 
-    currentAgentID(): AgentID {
-        return this.crypto.getAgentID(this.agentSecret);
+    currentAgentID() {
+        return ok(this.crypto.getAgentID(this.agentSecret));
     }
 
-    currentSignerID(): SignerID {
-        return this.crypto.getAgentSignerID(this.currentAgentID());
+    currentSignerID() {
+        return this.currentAgentID().map((id) =>
+            this.crypto.getAgentSignerID(id),
+        );
     }
 
     currentSignerSecret(): SignerSecret {
         return this.crypto.getAgentSignerSecret(this.agentSecret);
     }
 
-    currentSealerID(): SealerID {
-        return this.crypto.getAgentSealerID(this.currentAgentID());
+    currentSealerID() {
+        return this.currentAgentID().map((id) =>
+            this.crypto.getAgentSealerID(id),
+        );
     }
 
     currentSealerSecret(): SealerSecret {

package/src/coValues/group.ts

@@ -120,7 +120,9 @@ export class RawGroup<
             const agent =
                 typeof account === "string"
                     ? account
-                    : account.currentAgentID();
+                    : account
+                          .currentAgentID()
+                          ._unsafeUnwrap({ withStackTrace: true });
             this.set(memberKey, role, "trusting");
 
             if (this.get(memberKey) !== role) {
@@ -175,7 +177,7 @@ export class RawGroup<
             const reader = this.core.node.resolveAccountAgent(
                 readerID,
                 "Expected to know currently permitted reader",
-            );
+            )._unsafeUnwrap({ withStackTrace: true });
 
             this.set(
                 `${newReadKey.id}_for_${readerID}`,