Rename exports to be more generic

Author: Mrtenz

README.md

@@ -17,48 +17,48 @@ or
 ## Usage
 
 ```js
-import { ethErrors } from '@metamask/rpc-errors';
+import { rpcErrors, providerErrors } from '@metamask/rpc-errors';
 
-throw ethErrors.provider.unauthorized();
+throw rpcErrors.invalidRequest();
 // or
-throw ethErrors.provider.unauthorized('my custom message');
+throw providerErrors.unauthorized('my custom message');
 ```
 
 ## Supported Errors
 
+- Generic JSON RPC 2.0 errors
+  - Per [JSON RPC 2.0 spec](https://www.jsonrpc.org/specification#error_object)
 - Ethereum JSON RPC
   - Per [EIP-1474](https://eips.ethereum.org/EIPS/eip-1474#error-codes)
-    - This includes all
-      [JSON RPC 2.0 errors](https://www.jsonrpc.org/specification#error_object)
 - Ethereum Provider errors
   - Per [EIP-1193](https://eips.ethereum.org/EIPS/eip-1193#provider-errors)
     - Does **not** yet support [`CloseEvent` errors or status codes](https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes).
 
 ## API
 
 ```js
-import { ethErrors } from '@metamask/rpc-errors';
+import { rpcErrors, providerErrors } from '@metamask/rpc-errors';
 
-// Ethereum RPC errors are namespaced under "ethErrors.rpc"
-response.error = ethErrors.rpc.methodNotFound({
+// JSON-RPC errors are namespaced under "rpcErrors"
+response.error = rpcErrors.methodNotFound({
   message: optionalCustomMessage,
   data: optionalData,
 });
 
-// Provider errors namespaced under ethErrors.provider
-response.error = ethErrors.provider.unauthorized({
+// Provider errors namespaced under providerErrors
+response.error = providerErrors.unauthorized({
   message: optionalCustomMessage,
   data: optionalData,
 });
 
 // each error getter takes a single "opts" argument
 // for most errors, this can be replaced with a single string, which becomes
 // the error message
-response.error = ethErrors.provider.unauthorized(customMessage);
+response.error = providerErrors.unauthorized(customMessage);
 
 // if an error getter accepts a single string, all arguments can be omitted
-response.error = ethErrors.provider.unauthorized();
-response.error = ethErrors.provider.unauthorized({});
+response.error = providerErrors.unauthorized();
+response.error = providerErrors.unauthorized({});
 
 // omitting the message will produce an error with a default message per
 // the relevant spec
@@ -67,13 +67,13 @@ response.error = ethErrors.provider.unauthorized({});
 // "data" property
 
 // the JSON RPC 2.0 server error requires a valid code
-response.error = ethErrors.rpc.server({
+response.error = rpcErrors.server({
   code: -32031,
 });
 
 // custom Ethereum Provider errors require a valid code and message
 // valid codes are integers i such that: 1000 <= i <= 4999
-response.error = ethErrors.provider.custom({
+response.error = providerErrors.custom({
   code: 1001,
   message: 'foo',
 });
@@ -109,7 +109,7 @@ response.error = serializeError(maybeAnError, fallbackError)
 /**
  * Classes
  */
-import { EthereumRpcError, EthereumProviderError } from '@metamask/rpc-errors';
+import { JsonRpcError, EthereumProviderError } from '@metamask/rpc-errors';
 
 /**
  * getMessageFromCode and errorCodes
@@ -126,11 +126,11 @@ const message2 = getMessageFromCode(someCode, myFallback);
 const message3 = getMessageFromCode(someCode, null);
 
 // {
-//   rpc: { [errorName]: code, ... },
-//   provider: { [errorName]: code, ... },
+//   rpcErrors: { [errorName]: code, ... },
+//   providerErrors: { [errorName]: code, ... },
 // }
-const code1 = errorCodes.rpc.parse;
-const code2 = errorCodes.provider.userRejectedRequest;
+const code1 = rpcErrors.parse;
+const code2 = providerErrors.userRejectedRequest;
 
 // all codes in errorCodes have default messages
 const message4 = getMessageFromCode(code1);

package.json

@@ -8,13 +8,13 @@
     "errors",
     "utility"
   ],
-  "homepage": "https://github.com/MetaMask/eth-rpc-errors#readme",
+  "homepage": "https://github.com/MetaMask/rpc-errors#readme",
   "bugs": {
-    "url": "https://github.com/MetaMask/eth-rpc-errors/issues"
+    "url": "https://github.com/MetaMask/rpc-errors/issues"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/MetaMask/eth-rpc-errors.git"
+    "url": "https://github.com/MetaMask/rpc-errors.git"
   },
   "license": "MIT",
   "author": "Erik Marks <[email protected]>",

src/__fixtures__/errors.ts

@@ -1,4 +1,4 @@
-import { ethErrors } from '..';
+import { rpcErrors } from '..';
 
 export const dummyData = { foo: 'bar' };
 export const dummyMessage = 'baz';
@@ -26,11 +26,11 @@ export const validError1 = {
   message: dummyMessage,
   data: Object.assign({}, dummyData),
 };
-export const validError2 = ethErrors.rpc.parse();
+export const validError2 = rpcErrors.parse();
 delete validError2.stack;
-export const validError3 = ethErrors.rpc.parse(dummyMessage);
+export const validError3 = rpcErrors.parse(dummyMessage);
 delete validError3.stack;
-export const validError4 = ethErrors.rpc.parse({
+export const validError4 = rpcErrors.parse({
   message: dummyMessage,
   data: Object.assign({}, dummyData),
 });

src/classes.ts

@@ -1,15 +1,15 @@
 import safeStringify from 'fast-safe-stringify';
-import { Json, JsonRpcError } from '@metamask/utils';
+import { Json, JsonRpcError as SerializedJsonRpcError } from '@metamask/utils';
 
-export { JsonRpcError };
+export { SerializedJsonRpcError };
 
 /**
  * Error subclass implementing JSON RPC 2.0 errors and Ethereum RPC errors
  * per EIP-1474.
  *
  * Permits any integer error code.
  */
-export class EthereumRpcError<T extends Json> extends Error {
+export class JsonRpcError<T extends Json> extends Error {
   public code: number;
 
   public data?: T;
@@ -20,7 +20,7 @@ export class EthereumRpcError<T extends Json> extends Error {
     }
 
     if (!message || typeof message !== 'string') {
-      throw new Error('"message" must be a nonempty string.');
+      throw new Error('"message" must be a non-empty string.');
     }
 
     super(message);
@@ -35,8 +35,8 @@ export class EthereumRpcError<T extends Json> extends Error {
    *
    * @returns A plain object with all public class properties.
    */
-  serialize(): JsonRpcError {
-    const serialized: JsonRpcError = {
+  serialize(): SerializedJsonRpcError {
+    const serialized: SerializedJsonRpcError = {
       code: this.code,
       message: this.message,
     };
@@ -65,7 +65,7 @@ export class EthereumRpcError<T extends Json> extends Error {
  * Error subclass implementing Ethereum Provider errors per EIP-1193.
  * Permits integer error codes in the [ 1000 <= 4999 ] range.
  */
-export class EthereumProviderError<T extends Json> extends EthereumRpcError<T> {
+export class EthereumProviderError<T extends Json> extends JsonRpcError<T> {
   /**
    * Create an Ethereum Provider JSON-RPC error.
    *

src/errors.test.ts

@@ -5,19 +5,20 @@ import {
   SERVER_ERROR_CODE,
   CUSTOM_ERROR_CODE,
 } from './__fixtures__';
-import { ethErrors, errorCodes } from '.';
+import { providerErrors } from './errors';
+import { rpcErrors, errorCodes } from '.';
 
-describe('ethErrors.rpc.invalidInput', () => {
+describe('rpcErrors.invalidInput', () => {
   it('accepts a single string argument where appropriate', () => {
-    const err = ethErrors.rpc.invalidInput(CUSTOM_ERROR_MESSAGE);
+    const err = rpcErrors.invalidInput(CUSTOM_ERROR_MESSAGE);
     expect(err.code).toBe(errorCodes.rpc.invalidInput);
     expect(err.message).toBe(CUSTOM_ERROR_MESSAGE);
   });
 });
 
-describe('ethErrors.provider.unauthorized', () => {
+describe('providerErrors.unauthorized', () => {
   it('accepts a single string argument where appropriate', () => {
-    const err = ethErrors.provider.unauthorized(CUSTOM_ERROR_MESSAGE);
+    const err = providerErrors.unauthorized(CUSTOM_ERROR_MESSAGE);
     expect(err.code).toBe(errorCodes.provider.unauthorized);
     expect(err.message).toBe(CUSTOM_ERROR_MESSAGE);
   });
@@ -27,7 +28,7 @@ describe('custom provider error options', () => {
   it('throws if the value is not an options object', () => {
     expect(() => {
       // @ts-expect-error Invalid input
-      ethErrors.provider.custom('bar');
+      providerErrors.custom('bar');
     }).toThrow(
       'Ethereum Provider custom errors must provide single object argument.',
     );
@@ -36,11 +37,11 @@ describe('custom provider error options', () => {
   it('throws if the value is invalid', () => {
     expect(() => {
       // @ts-expect-error Invalid input
-      ethErrors.provider.custom({ code: 4009, message: 2 });
+      providerErrors.custom({ code: 4009, message: 2 });
     }).toThrow('"message" must be a nonempty string');
 
     expect(() => {
-      ethErrors.provider.custom({ code: 4009, message: '' });
+      providerErrors.custom({ code: 4009, message: '' });
     }).toThrow('"message" must be a nonempty string');
   });
 });
@@ -49,24 +50,24 @@ describe('ethError.rpc.server', () => {
   it('throws on invalid input', () => {
     expect(() => {
       // @ts-expect-error Invalid input
-      ethErrors.rpc.server('bar');
+      rpcErrors.server('bar');
     }).toThrow(
       'Ethereum RPC Server errors must provide single object argument.',
     );
 
     expect(() => {
       // @ts-expect-error Invalid input
-      ethErrors.rpc.server({ code: 'bar' });
+      rpcErrors.server({ code: 'bar' });
     }).toThrow('"code" must be an integer such that: -32099 <= code <= -32005');
 
     expect(() => {
-      ethErrors.rpc.server({ code: 1 });
+      rpcErrors.server({ code: 1 });
     }).toThrow('"code" must be an integer such that: -32099 <= code <= -32005');
   });
 });
 
-describe('ethError.rpc', () => {
-  it.each(Object.entries(ethErrors.rpc).filter(([key]) => key !== 'server'))(
+describe('rpcErrors', () => {
+  it.each(Object.entries(rpcErrors).filter(([key]) => key !== 'server'))(
     '%s returns appropriate value',
     (key, value) => {
       const createError = value as any;
@@ -86,7 +87,7 @@ describe('ethError.rpc', () => {
   );
 
   it('server returns appropriate value', () => {
-    const error = ethErrors.rpc.server({
+    const error = rpcErrors.server({
       code: SERVER_ERROR_CODE,
       data: Object.assign({}, dummyData),
     });
@@ -96,24 +97,25 @@ describe('ethError.rpc', () => {
   });
 });
 
-describe('ethError.provider', () => {
-  it.each(
-    Object.entries(ethErrors.provider).filter(([key]) => key !== 'custom'),
-  )('%s returns appropriate value', (key, value) => {
-    const createError = value as any;
-    const error = createError({
-      message: null,
-      data: Object.assign({}, dummyData),
-    });
-    // @ts-expect-error TypeScript does not like indexing into this with the key
-    const providerCode = errorCodes.provider[key];
-    expect(error.code >= 1000 && error.code < 5000).toBe(true);
-    expect(error.code).toBe(providerCode);
-    expect(error.message).toBe(getMessageFromCode(providerCode));
-  });
+describe('providerErrors', () => {
+  it.each(Object.entries(providerErrors).filter(([key]) => key !== 'custom'))(
+    '%s returns appropriate value',
+    (key, value) => {
+      const createError = value as any;
+      const error = createError({
+        message: null,
+        data: Object.assign({}, dummyData),
+      });
+      // @ts-expect-error TypeScript does not like indexing into this with the key
+      const providerCode = errorCodes.provider[key];
+      expect(error.code >= 1000 && error.code < 5000).toBe(true);
+      expect(error.code).toBe(providerCode);
+      expect(error.message).toBe(getMessageFromCode(providerCode));
+    },
+  );
 
   it('custom returns appropriate value', () => {
-    const error = ethErrors.provider.custom({
+    const error = providerErrors.custom({
       code: CUSTOM_ERROR_CODE,
       message: CUSTOM_ERROR_MESSAGE,
       data: Object.assign({}, dummyData),