@injectivelabs/exceptions 1.15.0 → 1.15.2

package/dist/esm/exceptions/base.js

@@ -0,0 +1,171 @@
+/* eslint-disable class-methods-use-this */
+import { ErrorType, UnspecifiedErrorCode, } from './types/index.js';
+/**
+ * we have to define it here as
+ * well as in @injectivelabs/utils as that package is
+ * importing the exceptions package
+ * */
+const toPascalCase = (str) => {
+    return `${str}`
+        .toLowerCase()
+        .replace(new RegExp(/[-_]+/, 'g'), ' ')
+        .replace(new RegExp(/[^\w\s]/, 'g'), '')
+        .replace(new RegExp(/\s+(.)(\w*)/, 'g'), (_$1, $2, $3) => `${$2.toUpperCase() + $3}`)
+        .replace(new RegExp(/\w/), (s) => s.toUpperCase());
+};
+export class ConcreteException extends Error {
+    /**
+     * The type of the Error
+     */
+    type = ErrorType.Unspecified;
+    /**
+     * Error specific code (HttpStatus, GrpcStatus, etc)
+     */
+    code = UnspecifiedErrorCode;
+    /**
+     * The name of the error (the name of the instance of the Exception)
+     */
+    name;
+    /**
+     * The name of the error (the name of the instance of the Exception)
+     * Needed for reporting reasons, ex: bugsnag
+     */
+    errorClass;
+    /**
+     * Providing more context
+     * (ex: endpoint on http request)
+     */
+    context;
+    /**
+     * Providing more context as to where the exception was thrown
+     * (ex: on-chain module, etc)
+     */
+    contextModule;
+    /**
+     * Providing more context as to why the exception was thrown
+     * (ex: on-chain error code, etc)
+     */
+    contextCode;
+    /**
+     * Parsed message of the exception
+     */
+    message = '';
+    /**
+     * The original stack of the error
+     */
+    stack = '';
+    /**
+     * The original message of the error
+     */
+    originalMessage = '';
+    constructor(error, context) {
+        super(error.message);
+        this.parseError(error);
+        this.parseContext(context);
+        this.parse();
+    }
+    parse() {
+        //
+    }
+    parseError(error) {
+        this.setStack(error.stack || '');
+        this.setMessage(error.message);
+        this.originalMessage = error.message;
+    }
+    parseContext(errorContext) {
+        const { contextModule, type, code, context } = errorContext || {
+            contextModule: 'Unknown',
+            context: 'Unknown',
+            code: UnspecifiedErrorCode,
+            type: ErrorType.Unspecified,
+        };
+        this.context = context;
+        this.contextModule = contextModule;
+        this.type = type || ErrorType.Unspecified;
+        this.code = code || UnspecifiedErrorCode;
+    }
+    setType(type) {
+        this.type = type;
+    }
+    setCode(code) {
+        this.code = code;
+    }
+    setContext(context) {
+        this.context = context;
+    }
+    setOriginalMessage(message) {
+        this.originalMessage = message;
+    }
+    setStack(stack) {
+        try {
+            this.stack = stack;
+        }
+        catch (e) {
+            // throw nothing here
+        }
+    }
+    setName(name) {
+        this.name = name;
+        this.errorClass = name;
+        super.name = name;
+    }
+    setMessage(message) {
+        this.message = message;
+        super.message = message;
+    }
+    setContextModule(contextModule) {
+        this.contextModule = contextModule;
+    }
+    setContextCode(code) {
+        this.contextCode = code;
+    }
+    toOriginalError() {
+        const error = new Error(this.originalMessage);
+        error.stack = this.stack;
+        error.name = this.name || '';
+        return error;
+    }
+    toError() {
+        const error = new Error(this.message);
+        error.stack = this.stack;
+        error.name = this.name || '';
+        return error;
+    }
+    toCompactError() {
+        const name = this.name || toPascalCase(this.type);
+        const error = new Error(`${this.message} | ${JSON.stringify({
+            type: this.type,
+            code: this.code,
+            errorClass: name,
+            message: this.message,
+            context: this.context,
+            contextCode: this.contextCode,
+            contextModule: this.contextModule,
+            originalMessage: this.originalMessage,
+            stack: (this.stack || '').split('\n').map((line) => line.trim()),
+        })}`);
+        error.stack = this.stack;
+        error.name = this.name || toPascalCase(this.type);
+        return error;
+    }
+    toJson() {
+        return JSON.stringify({ error: this.message, stack: this.stack });
+    }
+    toObject() {
+        const name = this.name || toPascalCase(this.type);
+        return {
+            code: this.code,
+            type: this.type,
+            errorClass: name,
+            message: this.message,
+            context: this.context,
+            contextCode: this.contextCode,
+            contextModule: this.contextModule,
+            originalMessage: this.originalMessage,
+            stack: (this.stack || '').split('\n').map((line) => line.trim()),
+        };
+    }
+    toString() {
+        return this.message;
+    }
+}

package/dist/esm/exceptions/exceptions/BitGetException.d.ts

@@ -0,0 +1,7 @@
+import { ConcreteException } from '../base.js';
+import { ErrorContext } from '../types/index.js';
+export declare class BitGetException extends ConcreteException {
+    static errorClass: string;
+    constructor(error: Error, context?: ErrorContext);
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/BitGetException.js

@@ -0,0 +1,19 @@
+import { ConcreteException } from '../base.js';
+import { ErrorType } from '../types/index.js';
+import { mapMetamaskMessage } from '../utils/maps.js';
+const removeBitGetFromErrorString = (message) => message
+    .replaceAll('BitGet', '')
+    .replaceAll('Bitget:', '')
+    .replaceAll('Bitkeep:', '');
+export class BitGetException extends ConcreteException {
+    static errorClass = 'BitGetException';
+    constructor(error, context) {
+        super(error, context);
+        this.type = ErrorType.WalletError;
+    }
+    parse() {
+        const { message } = this;
+        this.setName(BitGetException.errorClass);
+        this.setMessage(mapMetamaskMessage(removeBitGetFromErrorString(message)));
+    }
+}

package/dist/esm/exceptions/exceptions/CosmosWalletException.d.ts

@@ -0,0 +1,7 @@
+import { ConcreteException } from '../base.js';
+import { ErrorContext } from '../types/index.js';
+export declare class CosmosWalletException extends ConcreteException {
+    static errorClass: string;
+    constructor(error: Error, context?: ErrorContext);
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/CosmosWalletException.js

@@ -0,0 +1,12 @@
+import { ConcreteException } from '../base.js';
+import { ErrorType } from '../types/index.js';
+export class CosmosWalletException extends ConcreteException {
+    static errorClass = 'CosmosWalletException';
+    constructor(error, context) {
+        super(error, context);
+        this.type = ErrorType.WalletError;
+    }
+    parse() {
+        this.setName(CosmosWalletException.errorClass);
+    }
+}

package/dist/esm/exceptions/exceptions/GeneralException.d.ts

@@ -0,0 +1,5 @@
+import { ConcreteException } from '../base.js';
+export declare class GeneralException extends ConcreteException {
+    static errorClass: string;
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/GeneralException.js

@@ -0,0 +1,7 @@
+import { ConcreteException } from '../base.js';
+export class GeneralException extends ConcreteException {
+    static errorClass = 'GeneralException';
+    parse() {
+        this.setName(GeneralException.errorClass);
+    }
+}

package/dist/esm/exceptions/exceptions/GrpcUnaryRequestException.d.ts

@@ -0,0 +1,7 @@
+import { ConcreteException } from '../base.js';
+import { ErrorContext } from '../types/index.js';
+export declare class GrpcUnaryRequestException extends ConcreteException {
+    static errorClass: string;
+    constructor(error: Error, context?: ErrorContext);
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/GrpcUnaryRequestException.js

@@ -0,0 +1,17 @@
+import { ConcreteException } from '../base.js';
+import { ErrorType, GRPC_REQUEST_FAILED } from '../types/index.js';
+export class GrpcUnaryRequestException extends ConcreteException {
+    static errorClass = 'GrpcUnaryRequestException';
+    constructor(error, context) {
+        super(error, context);
+        this.type = ErrorType.GrpcUnaryRequest;
+    }
+    parse() {
+        const { message } = this;
+        if (message.toLowerCase().includes('response closed without headers')) {
+            this.setMessage('The request has failed. The server has closed the connection without sending any headers.');
+            this.setContextCode(GRPC_REQUEST_FAILED);
+        }
+        this.setName(GrpcUnaryRequestException.errorClass);
+    }
+}

package/dist/esm/exceptions/exceptions/HttpRequestException.d.ts

@@ -0,0 +1,10 @@
+import { ConcreteException } from '../base.js';
+import { ErrorContext, HttpRequestMethod } from '../types/index.js';
+export declare class HttpRequestException extends ConcreteException {
+    static errorClass: string;
+    method: HttpRequestMethod;
+    constructor(error: Error, context?: ErrorContext & {
+        method?: HttpRequestMethod;
+    });
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/HttpRequestException.js

@@ -0,0 +1,17 @@
+import { ConcreteException } from '../base.js';
+import { ErrorType, HttpRequestMethod } from '../types/index.js';
+export class HttpRequestException extends ConcreteException {
+    static errorClass = 'HttpRequestException';
+    method = HttpRequestMethod.Get;
+    constructor(error, context) {
+        super(error, context);
+        this.type = ErrorType.HttpRequest;
+        this.method = context
+            ? context.method || HttpRequestMethod.Get
+            : HttpRequestMethod.Get;
+        this.context = context?.context || 'Unknown';
+    }
+    parse() {
+        this.setName(HttpRequestException.errorClass);
+    }
+}

package/dist/esm/exceptions/exceptions/LedgerCosmosException.d.ts

@@ -0,0 +1,7 @@
+import { ConcreteException } from '../base.js';
+import { ErrorContext } from '../types/index.js';
+export declare class LedgerCosmosException extends ConcreteException {
+    static errorClass: string;
+    constructor(error: Error, context?: ErrorContext);
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/LedgerCosmosException.js

@@ -0,0 +1,36 @@
+import { ConcreteException } from '../base.js';
+import { ErrorType } from '../types/index.js';
+import { isCommonLockedError } from '../utils/helpers.js';
+export class LedgerCosmosException extends ConcreteException {
+    static errorClass = 'LedgerCosmosException';
+    constructor(error, context) {
+        super(error, context);
+        this.type = ErrorType.WalletError;
+    }
+    parse() {
+        const { message } = this;
+        if (isCommonLockedError(message)) {
+            this.setMessage('Please ensure your Ledger is connected, unlocked and your Cosmos app is open.');
+        }
+        if (message.includes('No device selected.')) {
+            this.setMessage('Please make sure your Ledger device is connected, unlocked and your Cosmos app is open');
+        }
+        if (message.includes('Unable to set device configuration.')) {
+            this.setMessage('Please restart your Ledger device and try connecting again');
+        }
+        if (message.includes('Cannot read properties of undefined')) {
+            this.setMessage('Please make sure your Ledger device is connected');
+        }
+        if (message.toLowerCase().includes('locked')) {
+            this.setMessage('Please make sure your Ledger device is connected, unlocked and your Cosmos app is open');
+        }
+        if (message.includes('Condition of use not satisfied') ||
+            message.includes('0x6985')) {
+            this.setMessage('The request has been rejected');
+        }
+        if (message.includes('U2F browser support is needed for Ledger.')) {
+            this.setMessage('Please use the latest Chrome/Firefox browser versions to connect with your Ledger device');
+        }
+        this.setName(LedgerCosmosException.errorClass);
+    }
+}

package/dist/esm/exceptions/exceptions/LedgerException.d.ts

@@ -0,0 +1,7 @@
+import { ConcreteException } from '../base.js';
+import { ErrorContext } from '../types/index.js';
+export declare class LedgerException extends ConcreteException {
+    static errorClass: string;
+    constructor(error: Error, context?: ErrorContext);
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/LedgerException.js

@@ -0,0 +1,36 @@
+import { ConcreteException } from '../base.js';
+import { ErrorType } from '../types/index.js';
+import { isCommonLockedError } from '../utils/helpers.js';
+export class LedgerException extends ConcreteException {
+    static errorClass = 'LedgerException';
+    constructor(error, context) {
+        super(error, context);
+        this.type = ErrorType.WalletError;
+    }
+    parse() {
+        const { message } = this;
+        if (isCommonLockedError(message)) {
+            this.setMessage('Please ensure your Ledger is connected, unlocked and your Ethereum app is open.');
+        }
+        if (message.includes('No device selected.')) {
+            this.setMessage('Please make sure your Ledger device is connected, unlocked and your Ethereum app is open');
+        }
+        if (message.includes('Unable to set device configuration.')) {
+            this.setMessage('Please restart your Ledger device and try connecting again');
+        }
+        if (message.includes('Cannot read properties of undefined')) {
+            this.setMessage('Please make sure your Ledger device is connected');
+        }
+        if (message.toLowerCase().includes('locked')) {
+            this.setMessage('Please make sure your Ledger device is connected, unlocked and your Ethereum app is open');
+        }
+        if (message.includes('Condition of use not satisfied') ||
+            message.includes('0x6985')) {
+            this.setMessage('The request has been rejected');
+        }
+        if (message.includes('U2F browser support is needed for Ledger.')) {
+            this.setMessage('Please use the latest Chrome/Firefox browser versions to connect with your Ledger device');
+        }
+        this.setName(LedgerException.errorClass);
+    }
+}

package/dist/esm/exceptions/exceptions/MetamaskException.d.ts

@@ -0,0 +1,7 @@
+import { ConcreteException } from '../base.js';
+import { ErrorContext } from '../types/index.js';
+export declare class MetamaskException extends ConcreteException {
+    static errorClass: string;
+    constructor(error: Error, context?: ErrorContext);
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/MetamaskException.js

@@ -0,0 +1,19 @@
+import { ConcreteException } from '../base.js';
+import { ErrorType } from '../types/index.js';
+import { mapMetamaskMessage } from '../utils/maps.js';
+const removeMetamaskFromErrorString = (message) => message
+    .replaceAll('Metamask', '')
+    .replaceAll('MetaMask', '')
+    .replaceAll('Metamask:', '');
+export class MetamaskException extends ConcreteException {
+    static errorClass = 'MetamaskException';
+    constructor(error, context) {
+        super(error, context);
+        this.type = ErrorType.WalletError;
+    }
+    parse() {
+        const { message } = this;
+        this.setMessage(mapMetamaskMessage(removeMetamaskFromErrorString(message)));
+        this.setName(MetamaskException.errorClass);
+    }
+}

package/dist/esm/exceptions/exceptions/OkxWalletException.d.ts

@@ -0,0 +1,7 @@
+import { ConcreteException } from '../base.js';
+import { ErrorContext } from '../types/index.js';
+export declare class OkxWalletException extends ConcreteException {
+    static errorClass: string;
+    constructor(error: Error, context?: ErrorContext);
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/OkxWalletException.js

@@ -0,0 +1,19 @@
+import { ConcreteException } from '../base.js';
+import { ErrorType } from '../types/index.js';
+import { mapMetamaskMessage } from '../utils/maps.js';
+const removeOkxWalletFromErrorString = (message) => message
+    .replaceAll('OkxWallet', '')
+    .replaceAll('Okx', '')
+    .replaceAll('OkxWallet:', '');
+export class OkxWalletException extends ConcreteException {
+    static errorClass = 'OkxWalletException';
+    constructor(error, context) {
+        super(error, context);
+        this.type = ErrorType.WalletError;
+    }
+    parse() {
+        const { message } = this;
+        this.setMessage(mapMetamaskMessage(removeOkxWalletFromErrorString(message)));
+        this.setName(OkxWalletException.errorClass);
+    }
+}

package/dist/esm/exceptions/exceptions/TransactionException.d.ts

@@ -0,0 +1,7 @@
+import { ConcreteException } from '../base.js';
+import { ErrorContext } from '../types/index.js';
+export declare class TransactionException extends ConcreteException {
+    static errorClass: string;
+    constructor(error: Error, context?: ErrorContext);
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/TransactionException.js

@@ -0,0 +1,22 @@
+import { ConcreteException } from '../base.js';
+import { ErrorType } from '../types/index.js';
+import { mapFailedTransactionMessage, parseErrorMessage } from '../utils/maps.js';
+export class TransactionException extends ConcreteException {
+    static errorClass = 'TransactionException';
+    constructor(error, context) {
+        super(error, context);
+        this.type = ErrorType.ChainError;
+    }
+    parse() {
+        const { message, context, contextModule, contextCode } = this;
+        const { code, message: parsedMessage, contextModule: parsedContextModule, } = mapFailedTransactionMessage(message, { contextCode, contextModule });
+        this.setContext(context || 'Unknown');
+        this.setMessage(parsedMessage);
+        this.setContextCode(code);
+        this.setOriginalMessage(parseErrorMessage(message));
+        if (parsedContextModule) {
+            this.setContextModule(parsedContextModule);
+        }
+        this.setName(TransactionException.errorClass);
+    }
+}

package/dist/esm/exceptions/exceptions/TrezorException.d.ts

@@ -0,0 +1,7 @@
+import { ConcreteException } from '../base.js';
+import { ErrorContext } from '../types/index.js';
+export declare class TrezorException extends ConcreteException {
+    static errorClass: string;
+    constructor(error: Error, context?: ErrorContext);
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/TrezorException.js

@@ -0,0 +1,12 @@
+import { ConcreteException } from '../base.js';
+import { ErrorType } from '../types/index.js';
+export class TrezorException extends ConcreteException {
+    static errorClass = 'TrezorException';
+    constructor(error, context) {
+        super(error, context);
+        this.type = ErrorType.WalletError;
+    }
+    parse() {
+        this.setName(TrezorException.errorClass);
+    }
+}

package/dist/esm/exceptions/exceptions/TrustWalletException.d.ts

@@ -0,0 +1,7 @@
+import { ConcreteException } from '../base.js';
+import { ErrorContext } from '../types/index.js';
+export declare class TrustWalletException extends ConcreteException {
+    static errorClass: string;
+    constructor(error: Error, context?: ErrorContext);
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/TrustWalletException.js

@@ -0,0 +1,21 @@
+import { ConcreteException } from '../base.js';
+import { ErrorType } from '../types/index.js';
+import { mapMetamaskMessage } from '../utils/maps.js';
+const removeTrustWalletFromErrorString = (message) => message
+    .replaceAll('TrustWallet', '')
+    .replaceAll('Trust Wallet', '')
+    .replaceAll('Trustwallet', '')
+    .replaceAll('TrustWallet:', '')
+    .replaceAll('Trust Wallet:', '');
+export class TrustWalletException extends ConcreteException {
+    static errorClass = 'TrustWalletException';
+    constructor(error, context) {
+        super(error, context);
+        this.type = ErrorType.WalletError;
+    }
+    parse() {
+        const { message } = this;
+        this.setMessage(mapMetamaskMessage(removeTrustWalletFromErrorString(message)));
+        this.setName(TrustWalletException.errorClass);
+    }
+}

package/dist/esm/exceptions/exceptions/WalletException.d.ts

@@ -0,0 +1,5 @@
+import { ConcreteException } from '../base.js';
+export declare class WalletException extends ConcreteException {
+    static errorClass: string;
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/WalletException.js

@@ -0,0 +1,7 @@
+import { ConcreteException } from '../base.js';
+export class WalletException extends ConcreteException {
+    static errorClass = 'WalletException';
+    parse() {
+        this.setName(WalletException.errorClass);
+    }
+}

package/dist/esm/exceptions/exceptions/Web3Exception.d.ts

@@ -0,0 +1,7 @@
+import { ConcreteException } from '../base.js';
+import { ErrorContext } from '../types/index.js';
+export declare class Web3Exception extends ConcreteException {
+    static errorClass: string;
+    constructor(error: Error, context?: ErrorContext);
+    parse(): void;
+}

package/dist/esm/exceptions/exceptions/Web3Exception.js

@@ -0,0 +1,12 @@
+import { ConcreteException } from '../base.js';
+import { ErrorType } from '../types/index.js';
+export class Web3Exception extends ConcreteException {
+    static errorClass = 'Web3Exception';
+    constructor(error, context) {
+        super(error, context);
+        this.type = ErrorType.Web3;
+    }
+    parse() {
+        this.setName(Web3Exception.errorClass);
+    }
+}

package/dist/esm/exceptions/exceptions/index.d.ts

@@ -0,0 +1,15 @@
+import { GrpcUnaryRequestException } from './GrpcUnaryRequestException.js';
+import { HttpRequestException } from './HttpRequestException.js';
+import { Web3Exception } from './Web3Exception.js';
+import { GeneralException } from './GeneralException.js';
+import { LedgerException } from './LedgerException.js';
+import { LedgerCosmosException } from './LedgerCosmosException.js';
+import { MetamaskException } from './MetamaskException.js';
+import { TrustWalletException } from './TrustWalletException.js';
+import { OkxWalletException } from './OkxWalletException.js';
+import { TrezorException } from './TrezorException.js';
+import { CosmosWalletException } from './CosmosWalletException.js';
+import { TransactionException } from './TransactionException.js';
+import { WalletException } from './WalletException.js';
+import { BitGetException } from './BitGetException.js';
+export { Web3Exception, LedgerException, TrezorException, WalletException, GeneralException, BitGetException, MetamaskException, TransactionException, TrustWalletException, OkxWalletException, HttpRequestException, LedgerCosmosException, CosmosWalletException, GrpcUnaryRequestException, };

package/dist/esm/exceptions/exceptions/index.js

@@ -0,0 +1,15 @@
+import { GrpcUnaryRequestException } from './GrpcUnaryRequestException.js';
+import { HttpRequestException } from './HttpRequestException.js';
+import { Web3Exception } from './Web3Exception.js';
+import { GeneralException } from './GeneralException.js';
+import { LedgerException } from './LedgerException.js';
+import { LedgerCosmosException } from './LedgerCosmosException.js';
+import { MetamaskException } from './MetamaskException.js';
+import { TrustWalletException } from './TrustWalletException.js';
+import { OkxWalletException } from './OkxWalletException.js';
+import { TrezorException } from './TrezorException.js';
+import { CosmosWalletException } from './CosmosWalletException.js';
+import { TransactionException } from './TransactionException.js';
+import { WalletException } from './WalletException.js';
+import { BitGetException } from './BitGetException.js';
+export { Web3Exception, LedgerException, TrezorException, WalletException, GeneralException, BitGetException, MetamaskException, TransactionException, TrustWalletException, OkxWalletException, HttpRequestException, LedgerCosmosException, CosmosWalletException, GrpcUnaryRequestException, };

package/dist/esm/exceptions/index.d.ts

@@ -0,0 +1,2 @@
+export * from './exceptions/index.js';
+export * from './types/index.js';

package/dist/esm/exceptions/index.js

@@ -0,0 +1,2 @@
+export * from './exceptions/index.js';
+export * from './types/index.js';

package/dist/esm/exceptions/messages.d.ts

@@ -0,0 +1,12 @@
+import { ErrorContextCode, TransactionChainErrorModule } from './types/index.js';
+export declare const chainModuleCodeErrorMessagesMap: Record<string, Record<number, string>>;
+/**
+ * **Legacy** but needed for error messages from broadcasting transactions
+ * where we don't control the response and only have the message
+ * i.e Keplr, Leap, etc
+ */
+export declare const chainErrorMessagesMap: Record<string, {
+    message: string;
+    code: ErrorContextCode;
+    module: TransactionChainErrorModule;
+}>;