@onekeyfe/cross-inpage-provider-errors 0.0.2

package/dist/classes.js

@@ -0,0 +1,70 @@
+import safeStringify from 'fast-safe-stringify';
+/**
+ * Error subclass implementing JSON RPC 2.0 errors and Web3 RPC errors
+ * per EIP-1474.
+ * Permits any integer error code.
+ */
+export class Web3RpcError extends Error {
+    constructor(code, message, data) {
+        if (!Number.isInteger(code)) {
+            throw new Error('"code" must be an integer.');
+        }
+        if (!message || typeof message !== 'string') {
+            throw new Error('"message" must be a nonempty string.');
+        }
+        super(message);
+        this.code = code;
+        if (data !== undefined) {
+            this.data = data;
+        }
+    }
+    /**
+     * Returns a plain object with all public class properties.
+     */
+    serialize() {
+        const serialized = {
+            code: this.code,
+            message: this.message,
+        };
+        if (this.data !== undefined) {
+            serialized.data = this.data;
+        }
+        if (this.stack) {
+            serialized.stack = this.stack;
+        }
+        return serialized;
+    }
+    /**
+     * Return a string representation of the serialized error, omitting
+     * any circular references.
+     */
+    toString() {
+        return safeStringify(this.serialize(), stringifyReplacer, 2);
+    }
+}
+/**
+ * Error subclass implementing Web3 Provider errors per EIP-1193.
+ * Permits integer error codes in the [ 1000 <= 4999 ] range.
+ */
+export class Web3ProviderError extends Web3RpcError {
+    /**
+     * Create an Web3 Provider JSON-RPC error.
+     * `code` must be an integer in the 1000 <= 4999 range.
+     */
+    constructor(code, message, data) {
+        if (!isValidWeb3ProviderCode(code)) {
+            throw new Error('"code" must be an integer such that: 1000 <= code <= 4999');
+        }
+        super(code, message, data);
+    }
+}
+// Internal
+function isValidWeb3ProviderCode(code) {
+    return Number.isInteger(code) && code >= 1000 && code <= 4999;
+}
+function stringifyReplacer(_, value) {
+    if (value === '[Circular]') {
+        return undefined;
+    }
+    return value;
+}

package/dist/error-constants.d.ts

@@ -0,0 +1,95 @@
+interface ErrorCodes {
+    readonly rpc: {
+        readonly invalidInput: -32000;
+        readonly resourceNotFound: -32001;
+        readonly resourceUnavailable: -32002;
+        readonly transactionRejected: -32003;
+        readonly methodNotSupported: -32004;
+        readonly limitExceeded: -32005;
+        readonly parse: -32700;
+        readonly invalidRequest: -32600;
+        readonly methodNotFound: -32601;
+        readonly invalidParams: -32602;
+        readonly internal: -32603;
+    };
+    readonly provider: {
+        readonly userRejectedRequest: 4001;
+        readonly unauthorized: 4100;
+        readonly unsupportedMethod: 4200;
+        readonly disconnected: 4900;
+        readonly chainDisconnected: 4901;
+        readonly requestTimeout: 4500;
+    };
+}
+export declare const errorCodes: ErrorCodes;
+export declare const errorValues: {
+    '-32700': {
+        standard: string;
+        message: string;
+    };
+    '-32600': {
+        standard: string;
+        message: string;
+    };
+    '-32601': {
+        standard: string;
+        message: string;
+    };
+    '-32602': {
+        standard: string;
+        message: string;
+    };
+    '-32603': {
+        standard: string;
+        message: string;
+    };
+    '-32000': {
+        standard: string;
+        message: string;
+    };
+    '-32001': {
+        standard: string;
+        message: string;
+    };
+    '-32002': {
+        standard: string;
+        message: string;
+    };
+    '-32003': {
+        standard: string;
+        message: string;
+    };
+    '-32004': {
+        standard: string;
+        message: string;
+    };
+    '-32005': {
+        standard: string;
+        message: string;
+    };
+    '4001': {
+        standard: string;
+        message: string;
+    };
+    '4100': {
+        standard: string;
+        message: string;
+    };
+    '4200': {
+        standard: string;
+        message: string;
+    };
+    '4900': {
+        standard: string;
+        message: string;
+    };
+    '4901': {
+        standard: string;
+        message: string;
+    };
+    '4500': {
+        standard: string;
+        message: string;
+    };
+};
+export {};

package/dist/error-constants.js

@@ -0,0 +1,95 @@
+export const errorCodes = {
+    rpc: {
+        invalidInput: -32000,
+        resourceNotFound: -32001,
+        resourceUnavailable: -32002,
+        transactionRejected: -32003,
+        methodNotSupported: -32004,
+        limitExceeded: -32005,
+        parse: -32700,
+        invalidRequest: -32600,
+        methodNotFound: -32601,
+        invalidParams: -32602,
+        internal: -32603,
+    },
+    provider: {
+        userRejectedRequest: 4001,
+        unauthorized: 4100,
+        unsupportedMethod: 4200,
+        disconnected: 4900,
+        chainDisconnected: 4901,
+        requestTimeout: 4500,
+    },
+};
+export const errorValues = {
+    '-32700': {
+        standard: 'JSON RPC 2.0',
+        message: 'Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.',
+    },
+    '-32600': {
+        standard: 'JSON RPC 2.0',
+        message: 'The JSON sent is not a valid Request object.',
+    },
+    '-32601': {
+        standard: 'JSON RPC 2.0',
+        message: 'The method does not exist / is not available.',
+    },
+    '-32602': {
+        standard: 'JSON RPC 2.0',
+        message: 'Invalid method parameter(s).',
+    },
+    '-32603': {
+        standard: 'JSON RPC 2.0',
+        message: 'Internal JSON-RPC error.',
+    },
+    '-32000': {
+        standard: 'EIP-1474',
+        message: 'Invalid input.',
+    },
+    '-32001': {
+        standard: 'EIP-1474',
+        message: 'Resource not found.',
+    },
+    '-32002': {
+        standard: 'EIP-1474',
+        message: 'Resource unavailable.',
+    },
+    '-32003': {
+        standard: 'EIP-1474',
+        message: 'Transaction rejected.',
+    },
+    '-32004': {
+        standard: 'EIP-1474',
+        message: 'Method not supported.',
+    },
+    '-32005': {
+        standard: 'EIP-1474',
+        message: 'Request limit exceeded.',
+    },
+    '4001': {
+        standard: 'EIP-1193',
+        message: 'User rejected the request.',
+    },
+    '4100': {
+        standard: 'EIP-1193',
+        message: 'The requested account and/or method has not been authorized by the user.',
+    },
+    '4200': {
+        standard: 'EIP-1193',
+        message: 'The requested method is not supported by this Web3 provider.',
+    },
+    '4900': {
+        standard: 'EIP-1193',
+        message: 'The provider is disconnected from all chains.',
+    },
+    '4901': {
+        standard: 'EIP-1193',
+        message: 'The provider is disconnected from the specified chain.',
+    },
+    '4500': {
+        standard: '',
+        message: 'The request by this Web3 provider is timeout.',
+    },
+};
+// https://eips.ethereum.org/EIPS/eip-1474#error-codes
+// https://eips.ethereum.org/EIPS/eip-1193#provider-errors

package/dist/errors.d.ts

@@ -0,0 +1,92 @@
+import { Web3RpcError, Web3ProviderError } from './classes';
+interface Web3ErrorOptions<T> {
+    message?: string;
+    data?: T;
+}
+interface ServerErrorOptions<T> extends Web3ErrorOptions<T> {
+    code: number;
+}
+declare type CustomErrorArg<T> = ServerErrorOptions<T>;
+declare type Web3ErrorsArg<T> = Web3ErrorOptions<T> | string;
+export declare const web3Errors: {
+    rpc: {
+        /**
+         * Get a JSON RPC 2.0 Parse (-32700) error.
+         */
+        parse: <T>(arg?: Web3ErrorsArg<T> | undefined) => Web3RpcError<T>;
+        /**
+         * Get a JSON RPC 2.0 Invalid Request (-32600) error.
+         */
+        invalidRequest: <T_1>(arg?: Web3ErrorsArg<T_1> | undefined) => Web3RpcError<T_1>;
+        /**
+         * Get a JSON RPC 2.0 Invalid Params (-32602) error.
+         */
+        invalidParams: <T_2>(arg?: Web3ErrorsArg<T_2> | undefined) => Web3RpcError<T_2>;
+        /**
+         * Get a JSON RPC 2.0 Method Not Found (-32601) error.
+         */
+        methodNotFound: <T_3>(arg?: Web3ErrorsArg<T_3> | undefined) => Web3RpcError<T_3>;
+        /**
+         * Get a JSON RPC 2.0 Internal (-32603) error.
+         */
+        internal: <T_4>(arg?: Web3ErrorsArg<T_4> | undefined) => Web3RpcError<T_4>;
+        /**
+         * Get a JSON RPC 2.0 Server error.
+         * Permits integer error codes in the [ -32099 <= -32005 ] range.
+         * Codes -32000 through -32004 are reserved by EIP-1474.
+         */
+        server: <T_5>(opts: ServerErrorOptions<T_5>) => Web3RpcError<T_5>;
+        /**
+         * Get an Web3 JSON RPC Invalid Input (-32000) error.
+         */
+        invalidInput: <T_6>(arg?: Web3ErrorsArg<T_6> | undefined) => Web3RpcError<T_6>;
+        /**
+         * Get an Web3 JSON RPC Resource Not Found (-32001) error.
+         */
+        resourceNotFound: <T_7>(arg?: Web3ErrorsArg<T_7> | undefined) => Web3RpcError<T_7>;
+        /**
+         * Get an Web3 JSON RPC Resource Unavailable (-32002) error.
+         */
+        resourceUnavailable: <T_8>(arg?: Web3ErrorsArg<T_8> | undefined) => Web3RpcError<T_8>;
+        /**
+         * Get an Web3 JSON RPC Transaction Rejected (-32003) error.
+         */
+        transactionRejected: <T_9>(arg?: Web3ErrorsArg<T_9> | undefined) => Web3RpcError<T_9>;
+        /**
+         * Get an Web3 JSON RPC Method Not Supported (-32004) error.
+         */
+        methodNotSupported: <T_10>(arg?: Web3ErrorsArg<T_10> | undefined) => Web3RpcError<T_10>;
+        /**
+         * Get an Web3 JSON RPC Limit Exceeded (-32005) error.
+         */
+        limitExceeded: <T_11>(arg?: Web3ErrorsArg<T_11> | undefined) => Web3RpcError<T_11>;
+    };
+    provider: {
+        /**
+         * Get an Web3 Provider User Rejected Request (4001) error.
+         */
+        userRejectedRequest: <T_12>(arg?: Web3ErrorsArg<T_12> | undefined) => Web3ProviderError<T_12>;
+        /**
+         * Get an Web3 Provider Unauthorized (4100) error.
+         */
+        unauthorized: <T_13>(arg?: Web3ErrorsArg<T_13> | undefined) => Web3ProviderError<T_13>;
+        /**
+         * Get an Web3 Provider Unsupported Method (4200) error.
+         */
+        unsupportedMethod: <T_14>(arg?: Web3ErrorsArg<T_14> | undefined) => Web3ProviderError<T_14>;
+        /**
+         * Get an Web3 Provider Not Connected (4900) error.
+         */
+        disconnected: <T_15>(arg?: Web3ErrorsArg<T_15> | undefined) => Web3ProviderError<T_15>;
+        /**
+         * Get an Web3 Provider Chain Not Connected (4901) error.
+         */
+        chainDisconnected: <T_16>(arg?: Web3ErrorsArg<T_16> | undefined) => Web3ProviderError<T_16>;
+        requestTimeout: <T_17>(arg?: Web3ErrorsArg<T_17> | undefined) => Web3ProviderError<T_17>;
+        /**
+         * Get a custom Web3 Provider error.
+         */
+        custom: <T_18>(opts: CustomErrorArg<T_18>) => Web3ProviderError<T_18>;
+    };
+};
+export {};

package/dist/errors.js

@@ -0,0 +1,138 @@
+import { Web3RpcError, Web3ProviderError } from './classes';
+import { getMessageFromCode } from './utils';
+import { errorCodes } from './error-constants';
+export const web3Errors = {
+    rpc: {
+        /**
+         * Get a JSON RPC 2.0 Parse (-32700) error.
+         */
+        parse: (arg) => getWeb3JsonRpcError(errorCodes.rpc.parse, arg),
+        /**
+         * Get a JSON RPC 2.0 Invalid Request (-32600) error.
+         */
+        invalidRequest: (arg) => getWeb3JsonRpcError(errorCodes.rpc.invalidRequest, arg),
+        /**
+         * Get a JSON RPC 2.0 Invalid Params (-32602) error.
+         */
+        invalidParams: (arg) => getWeb3JsonRpcError(errorCodes.rpc.invalidParams, arg),
+        /**
+         * Get a JSON RPC 2.0 Method Not Found (-32601) error.
+         */
+        methodNotFound: (arg) => getWeb3JsonRpcError(errorCodes.rpc.methodNotFound, arg),
+        /**
+         * Get a JSON RPC 2.0 Internal (-32603) error.
+         */
+        internal: (arg) => getWeb3JsonRpcError(errorCodes.rpc.internal, arg),
+        /**
+         * Get a JSON RPC 2.0 Server error.
+         * Permits integer error codes in the [ -32099 <= -32005 ] range.
+         * Codes -32000 through -32004 are reserved by EIP-1474.
+         */
+        server: (opts) => {
+            if (!opts || typeof opts !== 'object' || Array.isArray(opts)) {
+                throw new Error('Web3 RPC Server errors must provide single object argument.');
+            }
+            const { code } = opts;
+            if (!Number.isInteger(code) || code > -32005 || code < -32099) {
+                throw new Error('"code" must be an integer such that: -32099 <= code <= -32005');
+            }
+            return getWeb3JsonRpcError(code, opts);
+        },
+        /**
+         * Get an Web3 JSON RPC Invalid Input (-32000) error.
+         */
+        invalidInput: (arg) => getWeb3JsonRpcError(errorCodes.rpc.invalidInput, arg),
+        /**
+         * Get an Web3 JSON RPC Resource Not Found (-32001) error.
+         */
+        resourceNotFound: (arg) => getWeb3JsonRpcError(errorCodes.rpc.resourceNotFound, arg),
+        /**
+         * Get an Web3 JSON RPC Resource Unavailable (-32002) error.
+         */
+        resourceUnavailable: (arg) => getWeb3JsonRpcError(errorCodes.rpc.resourceUnavailable, arg),
+        /**
+         * Get an Web3 JSON RPC Transaction Rejected (-32003) error.
+         */
+        transactionRejected: (arg) => getWeb3JsonRpcError(errorCodes.rpc.transactionRejected, arg),
+        /**
+         * Get an Web3 JSON RPC Method Not Supported (-32004) error.
+         */
+        methodNotSupported: (arg) => getWeb3JsonRpcError(errorCodes.rpc.methodNotSupported, arg),
+        /**
+         * Get an Web3 JSON RPC Limit Exceeded (-32005) error.
+         */
+        limitExceeded: (arg) => getWeb3JsonRpcError(errorCodes.rpc.limitExceeded, arg),
+    },
+    provider: {
+        /**
+         * Get an Web3 Provider User Rejected Request (4001) error.
+         */
+        userRejectedRequest: (arg) => {
+            return getWeb3ProviderError(errorCodes.provider.userRejectedRequest, arg);
+        },
+        /**
+         * Get an Web3 Provider Unauthorized (4100) error.
+         */
+        unauthorized: (arg) => {
+            return getWeb3ProviderError(errorCodes.provider.unauthorized, arg);
+        },
+        /**
+         * Get an Web3 Provider Unsupported Method (4200) error.
+         */
+        unsupportedMethod: (arg) => {
+            return getWeb3ProviderError(errorCodes.provider.unsupportedMethod, arg);
+        },
+        /**
+         * Get an Web3 Provider Not Connected (4900) error.
+         */
+        disconnected: (arg) => {
+            return getWeb3ProviderError(errorCodes.provider.disconnected, arg);
+        },
+        /**
+         * Get an Web3 Provider Chain Not Connected (4901) error.
+         */
+        chainDisconnected: (arg) => {
+            return getWeb3ProviderError(errorCodes.provider.chainDisconnected, arg);
+        },
+        requestTimeout: (arg) => {
+            return getWeb3ProviderError(errorCodes.provider.requestTimeout, arg);
+        },
+        /**
+         * Get a custom Web3 Provider error.
+         */
+        custom: (opts) => {
+            if (!opts || typeof opts !== 'object' || Array.isArray(opts)) {
+                throw new Error('Web3 Provider custom errors must provide single object argument.');
+            }
+            const { code, message, data } = opts;
+            if (!message || typeof message !== 'string') {
+                throw new Error('"message" must be a nonempty string');
+            }
+            return new Web3ProviderError(code, message, data);
+        },
+    },
+};
+// Internal
+function getWeb3JsonRpcError(code, arg) {
+    const [message, data] = parseOpts(arg);
+    return new Web3RpcError(code, message || getMessageFromCode(code), data);
+}
+function getWeb3ProviderError(code, arg) {
+    const [message, data] = parseOpts(arg);
+    return new Web3ProviderError(code, message || getMessageFromCode(code), data);
+}
+function parseOpts(arg) {
+    if (arg) {
+        if (typeof arg === 'string') {
+            return [arg];
+        }
+        else if (typeof arg === 'object' && !Array.isArray(arg)) {
+            const { message, data } = arg;
+            if (message && typeof message !== 'string') {
+                throw new Error('Must specify string message.');
+            }
+            return [message || undefined, data];
+        }
+    }
+    return [];
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { Web3RpcError, Web3ProviderError } from './classes';
+import { serializeError, getMessageFromCode } from './utils';
+import { web3Errors } from './errors';
+import { errorCodes } from './error-constants';
+export { errorCodes, web3Errors, Web3RpcError, Web3ProviderError, serializeError, getMessageFromCode, };

package/dist/index.js

@@ -0,0 +1,5 @@
+import { Web3RpcError, Web3ProviderError } from './classes';
+import { serializeError, getMessageFromCode, } from './utils';
+import { web3Errors } from './errors';
+import { errorCodes } from './error-constants';
+export { errorCodes, web3Errors, Web3RpcError, Web3ProviderError, serializeError, getMessageFromCode, };

package/dist/utils.d.ts

@@ -0,0 +1,22 @@
+import { SerializedWeb3RpcError } from './classes';
+export declare const JSON_RPC_SERVER_ERROR_MESSAGE = "Unspecified server error.";
+/**
+ * Gets the message for a given code, or a fallback message if the code has
+ * no corresponding message.
+ */
+export declare function getMessageFromCode(code: number, fallbackMessage?: string): string;
+/**
+ * Returns whether the given code is valid.
+ * A code is only valid if it has a message.
+ */
+export declare function isValidCode(code: number): boolean;
+/**
+ * Serializes the given error to an Web3 JSON RPC-compatible error object.
+ * Merely copies the given error's values if it is already compatible.
+ * If the given error is not fully compatible, it will be preserved on the
+ * returned object's data.originalError property.
+ */
+export declare function serializeError(error: unknown, { fallbackError, shouldIncludeStack, }?: {
+    fallbackError?: SerializedWeb3RpcError | undefined;
+    shouldIncludeStack?: boolean | undefined;
+}): SerializedWeb3RpcError;

package/dist/utils.js

@@ -0,0 +1,104 @@
+import { errorCodes, errorValues } from './error-constants';
+import { Web3RpcError } from './classes';
+const FALLBACK_ERROR_CODE = errorCodes.rpc.internal;
+const FALLBACK_MESSAGE = 'Unspecified error message. This is a bug, please report it.';
+const FALLBACK_ERROR = {
+    code: FALLBACK_ERROR_CODE,
+    message: getMessageFromCode(FALLBACK_ERROR_CODE),
+};
+export const JSON_RPC_SERVER_ERROR_MESSAGE = 'Unspecified server error.';
+/**
+ * Gets the message for a given code, or a fallback message if the code has
+ * no corresponding message.
+ */
+export function getMessageFromCode(code, fallbackMessage = FALLBACK_MESSAGE) {
+    if (Number.isInteger(code)) {
+        const codeString = code.toString();
+        if (hasKey(errorValues, codeString)) {
+            return errorValues[codeString].message;
+        }
+        if (isJsonRpcServerError(code)) {
+            return JSON_RPC_SERVER_ERROR_MESSAGE;
+        }
+    }
+    return fallbackMessage;
+}
+/**
+ * Returns whether the given code is valid.
+ * A code is only valid if it has a message.
+ */
+export function isValidCode(code) {
+    if (!Number.isInteger(code)) {
+        return false;
+    }
+    const codeString = code.toString();
+    if (errorValues[codeString]) {
+        return true;
+    }
+    if (isJsonRpcServerError(code)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Serializes the given error to an Web3 JSON RPC-compatible error object.
+ * Merely copies the given error's values if it is already compatible.
+ * If the given error is not fully compatible, it will be preserved on the
+ * returned object's data.originalError property.
+ */
+export function serializeError(error, { fallbackError = FALLBACK_ERROR, shouldIncludeStack = false, } = {}) {
+    var _a, _b;
+    if (!fallbackError ||
+        !Number.isInteger(fallbackError.code) ||
+        typeof fallbackError.message !== 'string') {
+        throw new Error('Must provide fallback error with integer number code and string message.');
+    }
+    if (error instanceof Web3RpcError) {
+        return error.serialize();
+    }
+    const serialized = {};
+    if (error &&
+        typeof error === 'object' &&
+        !Array.isArray(error) &&
+        hasKey(error, 'code') &&
+        isValidCode(error.code)) {
+        const _error = error;
+        serialized.code = _error.code;
+        if (_error.message && typeof _error.message === 'string') {
+            serialized.message = _error.message;
+            if (hasKey(_error, 'data')) {
+                serialized.data = _error.data;
+            }
+        }
+        else {
+            serialized.message = getMessageFromCode(serialized.code);
+            serialized.data = { originalError: assignOriginalError(error) };
+        }
+    }
+    else {
+        serialized.code = fallbackError.code;
+        const message = (_a = error) === null || _a === void 0 ? void 0 : _a.message;
+        serialized.message = (message && typeof message === 'string'
+            ? message
+            : fallbackError.message);
+        serialized.data = { originalError: assignOriginalError(error) };
+    }
+    const stack = (_b = error) === null || _b === void 0 ? void 0 : _b.stack;
+    if (shouldIncludeStack && error && stack && typeof stack === 'string') {
+        serialized.stack = stack;
+    }
+    return serialized;
+}
+// Internal
+function isJsonRpcServerError(code) {
+    return code >= -32099 && code <= -32000;
+}
+function assignOriginalError(error) {
+    if (error && typeof error === 'object' && !Array.isArray(error)) {
+        return Object.assign({}, error);
+    }
+    return error;
+}
+function hasKey(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@onekeyfe/cross-inpage-provider-errors",
+  "version": "0.0.2",
+  "keywords": [
+    "cross-inpage-provider"
+  ],
+  "author": "dev-fe@onekey.so",
+  "repository": "https://github.com/OneKeyHQ/cross-inpage-provider",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "files": [
+    "dist/*"
+  ],
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.js",
+    "require": "./dist/cjs/index.js"
+  },
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "main": "./dist/cjs/index.js",
+  "scripts": {
+    "prebuild": "rm -rf dist",
+    "build": "tsc && tsc --project tsconfig.cjs.json",
+    "start": "tsc --watch"
+  },
+  "dependencies": {
+    "fast-safe-stringify": "^2.1.1"
+  },
+  "gitHead": "97aa3c911466f5c3a46b005a69d5b3edd1d8fd7c"
+}