@exodus/errors 2.1.0 → 2.2.0

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.2.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/errors@2.1.1...@exodus/errors@2.2.0) (2025-05-21)
+
+- refactor: pass through safe-strings (#12479)
+
+## [2.1.1](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/errors@2.1.0...@exodus/errors@2.1.1) (2025-05-08)
+
+### Bug Fixes
+
+- fix: remove `void` keyword (#12267)
+
 ## [2.1.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/errors@2.0.2...@exodus/errors@2.1.0) (2025-04-28)
 
 ### Features

package/lib/common-errors.d.ts

@@ -0,0 +1,40 @@
+declare const commonErrors: readonly [{
+    readonly pattern: RegExp;
+    readonly normalized: "Value is not a function";
+}, {
+    readonly pattern: RegExp;
+    readonly normalized: "Value is not a constructor";
+}, {
+    readonly pattern: RegExp;
+    readonly normalized: "Cannot convert null to object";
+}, {
+    readonly pattern: RegExp;
+    readonly normalized: "Cannot convert undefined to object";
+}, {
+    readonly pattern: RegExp;
+    readonly normalized: "Cannot read property/properties of null";
+}, {
+    readonly pattern: RegExp;
+    readonly normalized: "Cannot read property/properties of undefined";
+}, {
+    readonly pattern: RegExp;
+    readonly normalized: "Cannot set property/properties of null";
+}, {
+    readonly pattern: RegExp;
+    readonly normalized: "Cannot set property/properties of undefined";
+}, {
+    readonly pattern: RegExp;
+    readonly normalized: "Cannot access property of undefined";
+}, {
+    readonly pattern: RegExp;
+    readonly normalized: "Cannot access property of null";
+}, {
+    readonly pattern: RegExp;
+    readonly normalized: "Unexpected token";
+}, {
+    readonly pattern: RegExp;
+    readonly normalized: "Unexpected end of input";
+}];
+export type CommonErrorString = (typeof commonErrors)[number]['normalized'];
+export declare function toCommonErrorMessage(errorMessage: string): CommonErrorString | undefined;
+export {};

package/lib/common-errors.js

@@ -0,0 +1,59 @@
+const commonErrors = [
+    {
+        pattern: /.* is not a function/iu,
+        normalized: 'Value is not a function',
+    },
+    {
+        pattern: /.* is not a constructor/iu,
+        normalized: 'Value is not a constructor',
+    },
+    {
+        pattern: /cannot convert null to object/iu,
+        normalized: 'Cannot convert null to object',
+    },
+    {
+        pattern: /cannot convert undefined to object/iu,
+        normalized: 'Cannot convert undefined to object',
+    },
+    {
+        pattern: /cannot read (property|properties).* of null/iu,
+        normalized: 'Cannot read property/properties of null',
+    },
+    {
+        pattern: /cannot read (property|properties).* of undefined/iu,
+        normalized: 'Cannot read property/properties of undefined',
+    },
+    {
+        pattern: /cannot set (property|properties).* of null/iu,
+        normalized: 'Cannot set property/properties of null',
+    },
+    {
+        pattern: /cannot set (property|properties).* of undefined/iu,
+        normalized: 'Cannot set property/properties of undefined',
+    },
+    {
+        pattern: /undefined is not an object \(evaluating '.*'\)/iu,
+        normalized: 'Cannot access property of undefined',
+    },
+    {
+        pattern: /null is not an object \(evaluating '.*'\)/iu,
+        normalized: 'Cannot access property of null',
+    },
+    {
+        pattern: /unexpected (token|character)/iu,
+        normalized: 'Unexpected token',
+    },
+    {
+        pattern: /unexpected end of( JSON)? input/iu,
+        normalized: 'Unexpected end of input',
+    },
+];
+export function toCommonErrorMessage(errorMessage) {
+    if (!errorMessage)
+        return;
+    for (const { pattern, normalized } of commonErrors) {
+        if (pattern.test(errorMessage)) {
+            return normalized;
+        }
+    }
+}

package/lib/safe-error.d.ts

@@ -1,12 +1,18 @@
 import type { Frame } from './types.js';
+import type { CommonErrorString } from './common-errors.js';
 type ReadonlySetValues<S> = S extends ReadonlySet<infer T> ? T : never;
 declare const SAFE_NAMES_SET: ReadonlySet<"Error" | "AssertionError" | "TypeError" | "RangeError" | "UnknownError" | "SafeErrorFailedToParse" | "TimeoutError">;
-declare const SAFE_HINTS_SET: ReadonlySet<"broadcastTx" | "otherErr:broadcastTx" | "retry:broadcastTx" | "getNftArguments" | "ethCall" | "ethCall:executionReverted" | "failed to parse error">;
+type StaticAllowlistString = string & {
+    __branded_type: 'StaticAllowlistString';
+};
+type RuntimeSafeString = string & {
+    __branded_type: 'RuntimeSafeString';
+};
 export type SafeName = ReadonlySetValues<typeof SAFE_NAMES_SET>;
-export type SafeHint = ReadonlySetValues<typeof SAFE_HINTS_SET>;
 export type SafeCode = string & {
     __branded_type: 'SafeCodeOutcome';
 };
+export type SafeString = CommonErrorString | StaticAllowlistString | RuntimeSafeString;
 type UnknownError = Error & {
     hint?: unknown;
     code?: unknown;
@@ -35,7 +41,7 @@ export declare class SafeError {
     static from<T extends UnknownError>(err: T): SafeError;
     get name(): "Error" | "AssertionError" | "TypeError" | "RangeError" | "UnknownError" | "SafeErrorFailedToParse" | "TimeoutError";
     get code(): SafeCode | undefined;
-    get hint(): "broadcastTx" | "otherErr:broadcastTx" | "retry:broadcastTx" | "getNftArguments" | "ethCall" | "ethCall:executionReverted" | "failed to parse error" | undefined;
+    get hint(): SafeString | undefined;
     get stackFrames(): {
         function?: string | null;
         method?: string | null;
@@ -52,14 +58,14 @@ export declare class SafeError {
     toJSON(): {
         name: SafeName;
         code?: SafeCode;
-        hint?: SafeHint;
+        hint?: SafeString;
         stack?: string;
         timestamp: number;
     };
     constructor({ name, code, hint, stack, initSymbol, }: {
         name: SafeName;
         code?: SafeCode;
-        hint?: SafeHint;
+        hint?: SafeString;
         stack?: Frame[];
         initSymbol: typeof FACTORY_SYMBOL;
     });

package/lib/safe-error.js

@@ -1,6 +1,8 @@
+import { getAllowlist, isSafe } from '@exodus/safe-string';
 import assert from 'minimalistic-assert';
 import parseStackTraceNatively, { stackFramesToString } from './stack.js';
 import { omitUndefined } from './utils.js';
+import { toCommonErrorMessage } from './common-errors.js';
 function makeReadonlySet(values) {
     return new Set(values);
 }
@@ -32,24 +34,6 @@ const safeHints = {
         failedToParse: 'failed to parse error',
     },
 };
-const SAFE_HINTS_SET = makeReadonlySet(
-// @ts-expect-error doesn't like __proto__: null
-Object.values(safeHints).flatMap((safeHintCategory) => Object.values(safeHintCategory)));
-function getSafeHint(value) {
-    if (typeof value !== 'string') {
-        return undefined;
-    }
-    if (value === '') {
-        return undefined;
-    }
-    if (isSafeHint(value)) {
-        return value;
-    }
-    return [...SAFE_HINTS_SET].find((sh) => value.includes(sh));
-}
-function isSafeHint(value) {
-    return SAFE_HINTS_SET.has(value);
-}
 function isSafeName(value) {
     return SAFE_NAMES_SET.has(value);
 }
@@ -59,6 +43,11 @@ function isExodusErrorCode(code) {
 function isSafeCode(value) {
     return SAFE_CODES_SET.has(value) || isExodusErrorCode(value);
 }
+const staticAllowlist = getAllowlist();
+function getSafeString(str) {
+    if (isSafe(str))
+        return str;
+}
 const FACTORY_SYMBOL = Symbol('SafeError');
 export class SafeError {
     static hints = safeHints;
@@ -71,7 +60,12 @@ export class SafeError {
             safeName = isSafeName(name) ? name : 'UnknownError';
             const safeCodeCandidate = `${code}`;
             safeCode = isSafeCode(safeCodeCandidate) ? safeCodeCandidate : undefined;
-            safeHint = getSafeHint(hint) || getSafeHint(message);
+            const hintCandidates = [hint, message].filter((str) => typeof str === 'string');
+            safeHint =
+                // chicken sacrifice to TypeScript, otherwise would be hintCandidates.find((str) => isSafe(str))
+                hintCandidates.map((str) => getSafeString(str)).find(Boolean) ||
+                    staticAllowlist.find((safePrefix) => hintCandidates.some((str) => str.startsWith(safePrefix))) ||
+                    toCommonErrorMessage(message);
             const safeStack = parseStackTraceNatively(err);
             return new SafeError({
                 name: safeName,

package/lib/stack.js

@@ -25,7 +25,9 @@ export function captureStackTrace(err) {
         return err.stack;
     };
     try {
-        void err.stack; // trigger prepareStackTrace
+        // do NOT add "void", it will remove the whole line in a tragic transpilation accident
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        err.stack; // trigger prepareStackTrace
     }
     finally {
         Error.prepareStackTrace = originalPrepareStackTrace;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@exodus/errors",
   "type": "module",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Utilities for error handling in client code, such as sanitization",
   "author": "Exodus Movement, Inc.",
   "repository": {
@@ -34,15 +34,15 @@
     "test:hermes": "EXODUS_TEST_COVERAGE=0 run -T exodus-test --engine hermes:bundle --esbuild --jest src/__tests__/hermes/*.test.ts"
   },
   "dependencies": {
+    "@exodus/safe-string": "^1.0.0",
     "minimalistic-assert": "^1.0.1"
   },
   "devDependencies": {
     "@exodus/errors-fixture": "^1.0.0",
-    "@types/minimalistic-assert": "^1.0.1",
-    "hermes-engine-cli": "^0.12.0"
+    "@types/minimalistic-assert": "^1.0.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "06b62dd4394dc6aacbbb7c1bbb8ed7d66b8bea1a"
+  "gitHead": "30ebd4bfc064662078e5819e335a3d658f00bd1b"
 }