@exodus/errors 2.1.1 → 3.0.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.0.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/errors@2.1.1...@exodus/errors@3.0.0) (2025-05-16)
+
+### ⚠ BREAKING CHANGES
+
+- un-export hints whitelist, pass through safe-strings (#12479)
+
+- refactor!: un-export hints whitelist, 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

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;
@@ -14,28 +20,10 @@ type UnknownError = Error & {
 declare const FACTORY_SYMBOL: unique symbol;
 export declare class SafeError {
     #private;
-    static readonly hints: {
-        readonly __proto__: null;
-        readonly broadcastTx: {
-            readonly general: "broadcastTx";
-            readonly other: "otherErr:broadcastTx";
-            readonly retry: "retry:broadcastTx";
-        };
-        readonly getNftArguments: {
-            readonly general: "getNftArguments";
-        };
-        readonly ethCall: {
-            readonly general: "ethCall";
-            readonly executionReverted: "ethCall:executionReverted";
-        };
-        readonly safeError: {
-            readonly failedToParse: "failed to parse error";
-        };
-    };
     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 +40,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);
 }
@@ -14,42 +16,6 @@ const SAFE_NAMES_SET = makeReadonlySet([
     'SafeErrorFailedToParse',
     'TimeoutError',
 ]);
-const safeHints = {
-    __proto__: null,
-    broadcastTx: {
-        general: 'broadcastTx',
-        other: 'otherErr:broadcastTx',
-        retry: 'retry:broadcastTx',
-    },
-    getNftArguments: {
-        general: 'getNftArguments',
-    },
-    ethCall: {
-        general: 'ethCall',
-        executionReverted: 'ethCall:executionReverted',
-    },
-    safeError: {
-        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,9 +25,13 @@ 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;
     static from(err) {
         let safeName;
         let safeCode;
@@ -71,7 +41,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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@exodus/errors",
   "type": "module",
-  "version": "2.1.1",
+  "version": "3.0.0",
   "description": "Utilities for error handling in client code, such as sanitization",
   "author": "Exodus Movement, Inc.",
   "repository": {
@@ -30,10 +30,11 @@
     "lint": "run -T eslint .",
     "lint:fix": "yarn lint --fix",
     "test": "yarn run test:v8 && yarn run test:hermes",
-    "test:v8": "run -T exodus-test --esbuild --jest src/__tests__/v8/*.test.ts",
-    "test:hermes": "EXODUS_TEST_COVERAGE=0 run -T exodus-test --engine hermes:bundle --esbuild --jest src/__tests__/hermes/*.test.ts"
+    "test:v8": "run -T exodus-test --esbuild --jest src/__tests__/v8/*.test.ts src/__tests__/engine-agnostic/*.test.ts",
+    "test:hermes": "EXODUS_TEST_COVERAGE=0 run -T exodus-test --engine hermes:bundle --esbuild --jest src/__tests__/hermes/*.test.ts src/__tests__/engine-agnostic/*.test.ts"
   },
   "dependencies": {
+    "@exodus/safe-string": "^1.0.0",
     "minimalistic-assert": "^1.0.1"
   },
   "devDependencies": {
@@ -43,5 +44,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5d915aed4f43c8b9377e87c902347aac778391d2"
+  "gitHead": "aca2b6b0dbe54c8b2b14b14412c81d0237b8d5ee"
 }