Rewrite error serialization

jest.config.js

@@ -41,10 +41,10 @@ module.exports = {
   // An object that configures minimum threshold enforcement for coverage results
   coverageThreshold: {
     global: {
-      branches: 90.09,
-      functions: 84.21,
-      lines: 95.32,
-      statements: 95.32,
+      branches: 94.31,
+      functions: 85,
+      lines: 96.85,
+      statements: 96.85,
     },
   },
 

package.json

@@ -36,7 +36,7 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@metamask/utils": "^3.2.0",
+    "@metamask/utils": "^5.0.0",
     "fast-safe-stringify": "^2.0.6"
   },
   "devDependencies": {

src/__fixtures__/errors.ts

@@ -5,7 +5,7 @@ export const dummyMessage = 'baz';
 
 export const invalidError0 = 0;
 export const invalidError1 = ['foo', 'bar', 3];
-export const invalidError2 = { code: 34 };
+export const invalidError2 = { code: 'foo' };
 export const invalidError3 = { code: 4001 };
 export const invalidError4 = {
   code: 4001,
@@ -15,7 +15,7 @@ export const invalidError4 = {
 export const invalidError5 = null;
 export const invalidError6 = undefined;
 export const invalidError7 = {
-  code: 34,
+  code: 'foo',
   message: dummyMessage,
   data: Object.assign({}, dummyData),
 };

src/classes.ts

@@ -1,12 +1,7 @@
 import safeStringify from 'fast-safe-stringify';
-import { Json } from '@metamask/utils';
+import { Json, JsonRpcError } from '@metamask/utils';
 
-export type SerializedEthereumRpcError = {
-  code: number;
-  message: string;
-  data?: Json;
-  stack?: string;
-};
+export { JsonRpcError };
 
 /**
  * Error subclass implementing JSON RPC 2.0 errors and Ethereum RPC errors
@@ -40,8 +35,8 @@ export class EthereumRpcError<T extends Json> extends Error {
    *
    * @returns A plain object with all public class properties.
    */
-  serialize(): SerializedEthereumRpcError {
-    const serialized: SerializedEthereumRpcError = {
+  serialize(): JsonRpcError {
+    const serialized: JsonRpcError = {
       code: this.code,
       message: this.message,
     };

src/utils.test.ts

@@ -13,9 +13,10 @@ import {
   validError3,
   validError4,
   dummyMessage,
+  dummyData,
 } from './__fixtures__';
 import { getMessageFromCode, serializeError } from './utils';
-import { errorCodes } from '.';
+import { errorCodes, ethErrors } from '.';
 
 const rpcCodes = errorCodes.rpc;
 
@@ -25,7 +26,7 @@ describe('serializeError', () => {
     expect(result).toStrictEqual({
       code: rpcCodes.internal,
       message: getMessageFromCode(rpcCodes.internal),
-      data: { originalError: invalidError0 },
+      data: { cause: invalidError0 },
     });
   });
 
@@ -34,7 +35,7 @@ describe('serializeError', () => {
     expect(result).toStrictEqual({
       code: rpcCodes.internal,
       message: getMessageFromCode(rpcCodes.internal),
-      data: { originalError: invalidError5 },
+      data: { cause: invalidError5 },
     });
   });
 
@@ -43,7 +44,7 @@ describe('serializeError', () => {
     expect(result).toStrictEqual({
       code: rpcCodes.internal,
       message: getMessageFromCode(rpcCodes.internal),
-      data: { originalError: invalidError6 },
+      data: { cause: null },
     });
   });
 
@@ -52,7 +53,7 @@ describe('serializeError', () => {
     expect(result).toStrictEqual({
       code: rpcCodes.internal,
       message: getMessageFromCode(rpcCodes.internal),
-      data: { originalError: invalidError1 },
+      data: { cause: invalidError1 },
     });
   });
 
@@ -61,34 +62,50 @@ describe('serializeError', () => {
     expect(result).toStrictEqual({
       code: rpcCodes.internal,
       message: getMessageFromCode(rpcCodes.internal),
-      data: { originalError: invalidError2 },
+      data: { cause: invalidError2 },
     });
   });
 
   it('handles invalid error: valid code, undefined message', () => {
     const result = serializeError(invalidError3);
     expect(result).toStrictEqual({
-      code: 4001,
-      message: getMessageFromCode(4001),
-      data: { originalError: Object.assign({}, invalidError3) },
+      code: errorCodes.rpc.internal,
+      message: getMessageFromCode(errorCodes.rpc.internal),
+      data: {
+        cause: {
+          code: 4001,
+        },
+      },
     });
   });
 
   it('handles invalid error: non-string message with data', () => {
     const result = serializeError(invalidError4);
     expect(result).toStrictEqual({
-      code: 4001,
-      message: getMessageFromCode(4001),
-      data: { originalError: Object.assign({}, invalidError4) },
+      code: rpcCodes.internal,
+      message: getMessageFromCode(rpcCodes.internal),
+      data: {
+        cause: {
+          code: invalidError4.code,
+          message: invalidError4.message,
+          data: Object.assign({}, dummyData),
+        },
+      },
     });
   });
 
   it('handles invalid error: invalid code with string message', () => {
     const result = serializeError(invalidError7);
     expect(result).toStrictEqual({
       code: rpcCodes.internal,
-      message: dummyMessage,
-      data: { originalError: Object.assign({}, invalidError7) },
+      message: getMessageFromCode(rpcCodes.internal),
+      data: {
+        cause: {
+          code: invalidError7.code,
+          message: invalidError7.message,
+          data: Object.assign({}, dummyData),
+        },
+      },
     });
   });
 
@@ -99,7 +116,7 @@ describe('serializeError', () => {
     expect(result).toStrictEqual({
       code: rpcCodes.methodNotFound,
       message: 'foo',
-      data: { originalError: Object.assign({}, invalidError2) },
+      data: { cause: Object.assign({}, invalidError2) },
     });
   });
 
@@ -145,10 +162,8 @@ describe('serializeError', () => {
     });
   });
 
-  it('handles valid error: message, data, and stack', () => {
-    const result = serializeError(
-      Object.assign({}, validError1, { stack: 'foo' }),
-    );
+  it('handles valid error: message and data', () => {
+    const result = serializeError(Object.assign({}, validError1));
     expect(result).toStrictEqual({
       code: 4001,
       message: validError1.message,
@@ -157,7 +172,7 @@ describe('serializeError', () => {
   });
 
   it('handles including stack: no stack present', () => {
-    const result = serializeError(validError1, { shouldIncludeStack: true });
+    const result = serializeError(validError1);
     expect(result).toStrictEqual({
       code: 4001,
       message: validError1.message,
@@ -168,7 +183,6 @@ describe('serializeError', () => {
   it('handles including stack: string stack present', () => {
     const result = serializeError(
       Object.assign({}, validError1, { stack: 'foo' }),
-      { shouldIncludeStack: true },
     );
     expect(result).toStrictEqual({
       code: 4001,
@@ -178,17 +192,102 @@ describe('serializeError', () => {
     });
   });
 
-  it('handles including stack: non-string stack present', () => {
+  it('handles removing stack', () => {
     const result = serializeError(
-      Object.assign({}, validError1, { stack: 2 }),
-      {
-        shouldIncludeStack: true,
-      },
+      Object.assign({}, validError1, { stack: 'foo' }),
+      { shouldIncludeStack: false },
     );
     expect(result).toStrictEqual({
       code: 4001,
       message: validError1.message,
       data: Object.assign({}, validError1.data),
     });
   });
+
+  it('handles regular Error()', () => {
+    const error = new Error('foo');
+    const result = serializeError(error);
+    expect(result).toStrictEqual({
+      code: errorCodes.rpc.internal,
+      message: getMessageFromCode(errorCodes.rpc.internal),
+      data: {
+        cause: {
+          message: error.message,
+          stack: error.stack,
+        },
+      },
+    });
+
+    expect(JSON.parse(JSON.stringify(result))).toStrictEqual({
+      code: errorCodes.rpc.internal,
+      message: getMessageFromCode(errorCodes.rpc.internal),
+      data: {
+        cause: {
+          message: error.message,
+          stack: error.stack,
+        },
+      },
+    });
+  });
+
+  it('handles EthereumRpcError', () => {
+    const error = ethErrors.rpc.invalidParams();
+    const result = serializeError(error);
+    expect(result).toStrictEqual({
+      code: error.code,
+      message: error.message,
+      stack: error.stack,
+    });
+
+    expect(JSON.parse(JSON.stringify(result))).toStrictEqual({
+      code: error.code,
+      message: error.message,
+      stack: error.stack,
+    });
+  });
+
+  it('removes non JSON-serializable props on cause', () => {
+    const error = new Error('foo');
+    // @ts-expect-error Intentionally using wrong type
+    error.message = () => undefined;
+    const result = serializeError(error);
+    expect(result).toStrictEqual({
+      code: errorCodes.rpc.internal,
+      message: getMessageFromCode(errorCodes.rpc.internal),
+      data: {
+        cause: {
+          stack: error.stack,
+        },
+      },
+    });
+  });
+
+  it('throws if fallback is invalid', () => {
+    expect(() =>
+      // @ts-expect-error Intentionally using wrong type
+      serializeError(new Error(), { fallbackError: new Error() }),
+    ).toThrow(
+      'Must provide fallback error with integer number code and string message.',
+    );
+  });
+
+  it('handles arrays passed as error', () => {
+    const error = ['foo', Symbol('bar'), { baz: 'qux', symbol: Symbol('') }];
+    const result = serializeError(error);
+    expect(result).toStrictEqual({
+      code: rpcCodes.internal,
+      message: getMessageFromCode(rpcCodes.internal),
+      data: {
+        cause: ['foo', null, { baz: 'qux' }],
+      },
+    });
+
+    expect(JSON.parse(JSON.stringify(result))).toStrictEqual({
+      code: rpcCodes.internal,
+      message: getMessageFromCode(rpcCodes.internal),
+      data: {
+        cause: ['foo', null, { baz: 'qux' }],
+      },
+    });
+  });
 });