@injectivelabs/exceptions 1.15.0 → 1.15.2

package/dist/cjs/exceptions/types/context.d.ts

@@ -0,0 +1,85 @@
+import { ErrorCode, ErrorContextCode } from './codes.js';
+export declare enum HttpRequestMethod {
+    Get = "GET",
+    Post = "POST",
+    Options = "OPTIONS"
+}
+export declare enum ErrorType {
+    Unspecified = "unspecified",
+    ChainError = "chain-error",
+    ExecutionError = "execution-error",
+    NotFoundError = "not-found-error",
+    ValidationError = "validation-error",
+    WalletError = "wallet-error",
+    WalletNotInstalledError = "wallet-not-installed-error",
+    GrpcUnaryRequest = "grpc-unary-request",
+    HttpRequest = "http-request",
+    Web3 = "web3",
+    Web3Gateway = "web3-gateway"
+}
+export interface ErrorContext {
+    code?: ErrorCode;
+    type?: ErrorType;
+    /**
+     * Additional context needed for the exception
+     */
+    context?: string;
+    /**
+     * Where is the exception thrown
+     */
+    contextModule?: string;
+    /**
+     * Needed when we get a code error from a Http/Grpc Request
+     * and we need to specify the error code for the particular message
+     * for example why the transaction has failed
+     * */
+    contextCode?: ErrorContextCode;
+}
+export interface Exception {
+    /**
+     * The type of the Error
+     */
+    type: ErrorType;
+    /**
+     * Error specific code (HttpStatus, GrpcStatus, etc)
+     */
+    code: ErrorCode;
+    /**
+     * The name of the error (the name of the instance of the Exception)
+     */
+    name: string;
+    /**
+     * Providing more context as to where the exception was thrown
+     * (ex: on-chain module, etc)
+     */
+    contextModule?: string;
+    /**
+     * Providing more context as to why the exception was thrown
+     * (ex: on-chain error code, etc)
+     */
+    contextCode?: ErrorContextCode;
+    /**
+     * Parsed message of the exception
+     */
+    message: string;
+    /**
+     * The original stack of the error
+     */
+    stack?: string;
+    /**
+     * The original message of the error
+     */
+    originalMessage: string;
+    parse?(): void;
+    parseError(error: Error): void;
+    parseContext(context?: ErrorContext): void;
+    setType(type: ErrorType): void;
+    setCode(code: ErrorCode): void;
+    setStack(stack: string): void;
+    setName(name: string): void;
+    setMessage(message: string): void;
+    setContextModule(contextModule: string): void;
+    toOriginalError(): Error;
+    toError(): Error;
+    toString(): string;
+}

package/dist/cjs/exceptions/types/context.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorType = exports.HttpRequestMethod = void 0;
+var HttpRequestMethod;
+(function (HttpRequestMethod) {
+    HttpRequestMethod["Get"] = "GET";
+    HttpRequestMethod["Post"] = "POST";
+    HttpRequestMethod["Options"] = "OPTIONS";
+})(HttpRequestMethod || (exports.HttpRequestMethod = HttpRequestMethod = {}));
+var ErrorType;
+(function (ErrorType) {
+    ErrorType["Unspecified"] = "unspecified";
+    ErrorType["ChainError"] = "chain-error";
+    ErrorType["ExecutionError"] = "execution-error";
+    ErrorType["NotFoundError"] = "not-found-error";
+    ErrorType["ValidationError"] = "validation-error";
+    ErrorType["WalletError"] = "wallet-error";
+    ErrorType["WalletNotInstalledError"] = "wallet-not-installed-error";
+    ErrorType["GrpcUnaryRequest"] = "grpc-unary-request";
+    ErrorType["HttpRequest"] = "http-request";
+    ErrorType["Web3"] = "web3";
+    ErrorType["Web3Gateway"] = "web3-gateway";
+})(ErrorType || (exports.ErrorType = ErrorType = {}));

package/dist/cjs/exceptions/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './modules.js';
+export * from './codes.js';
+export * from './context.js';

package/dist/cjs/exceptions/types/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./modules.js"), exports);
+__exportStar(require("./codes.js"), exports);
+__exportStar(require("./context.js"), exports);

package/dist/cjs/exceptions/types/modules.d.ts

@@ -0,0 +1,59 @@
+export declare enum ContractErrorModule {
+    Erc20Contract = "erc20-contract",
+    Peggy = "peggy-contract",
+    PeggyOld = "peggy-old-contract"
+}
+export declare enum ChainErrorModule {
+    Auction = "chain-auction",
+    Auth = "chain-auth",
+    Authz = "chain-authz",
+    Bank = "chain-bank",
+    Distribution = "chain-distribution",
+    Exchange = "chain-exchange",
+    Gov = "chain-gov",
+    Ibc = "chain-ibc",
+    InsuranceFund = "chain-insurance",
+    Mint = "chain-mint",
+    Oracle = "chain-oracle",
+    Peggy = "chain-peggy",
+    Staking = "chain-staking",
+    Wasm = "chain-wasm",
+    WasmX = "chain-wasmx",
+    Tendermint = "chain-tendermint",
+    Permissions = "chain-permissions"
+}
+export declare enum IndexerErrorModule {
+    Account = "indexer-account",
+    Auction = "indexer-auction",
+    Archiver = "indexer-archiver",
+    Derivatives = "indexer-derivatives",
+    Explorer = "indexer-explorer",
+    InsuranceFund = "indexer-insurance-fund",
+    Meta = "indexer-meta",
+    Mito = "indexer-mito",
+    Dmm = "dmm",
+    OLP = "olp",
+    Referral = "referral",
+    Oracle = "indexer-oracle",
+    Portfolio = "indexer-portfolio",
+    Spot = "indexer-spot",
+    Transaction = "indexer-transaction",
+    Trading = "indexer-trading",
+    ChronosDerivative = "indexer-chronos-derivative",
+    ChronosSpot = "indexer-chronos-spot",
+    ChronosMarkets = "indexer-chronos-markets",
+    Campaign = "indexer-campaign",
+    Web3Gw = "web3-gateway",
+    Abacus = "abacus"
+}
+export declare enum WalletErrorActionModule {
+    SignTransaction = "sign-transaction",
+    SignEthereumTransaction = "sign-ethereum-transaction",
+    SendTransaction = "send-transaction",
+    SendEthereumTransaction = "send-ethereum-transaction",
+    SignArbitrary = "sign-arbitrary",
+    GetAccounts = "get-accounts",
+    GetNetworkId = "get-network-id",
+    GetChainId = "get-chain-id",
+    GetEthereumTransactionReceipt = "get-ethereum-transaction-receipt"
+}

package/dist/cjs/exceptions/types/modules.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletErrorActionModule = exports.IndexerErrorModule = exports.ChainErrorModule = exports.ContractErrorModule = void 0;
+var ContractErrorModule;
+(function (ContractErrorModule) {
+    ContractErrorModule["Erc20Contract"] = "erc20-contract";
+    ContractErrorModule["Peggy"] = "peggy-contract";
+    ContractErrorModule["PeggyOld"] = "peggy-old-contract";
+})(ContractErrorModule || (exports.ContractErrorModule = ContractErrorModule = {}));
+var ChainErrorModule;
+(function (ChainErrorModule) {
+    ChainErrorModule["Auction"] = "chain-auction";
+    ChainErrorModule["Auth"] = "chain-auth";
+    ChainErrorModule["Authz"] = "chain-authz";
+    ChainErrorModule["Bank"] = "chain-bank";
+    ChainErrorModule["Distribution"] = "chain-distribution";
+    ChainErrorModule["Exchange"] = "chain-exchange";
+    ChainErrorModule["Gov"] = "chain-gov";
+    ChainErrorModule["Ibc"] = "chain-ibc";
+    ChainErrorModule["InsuranceFund"] = "chain-insurance";
+    ChainErrorModule["Mint"] = "chain-mint";
+    ChainErrorModule["Oracle"] = "chain-oracle";
+    ChainErrorModule["Peggy"] = "chain-peggy";
+    ChainErrorModule["Staking"] = "chain-staking";
+    ChainErrorModule["Wasm"] = "chain-wasm";
+    ChainErrorModule["WasmX"] = "chain-wasmx";
+    ChainErrorModule["Tendermint"] = "chain-tendermint";
+    ChainErrorModule["Permissions"] = "chain-permissions";
+})(ChainErrorModule || (exports.ChainErrorModule = ChainErrorModule = {}));
+var IndexerErrorModule;
+(function (IndexerErrorModule) {
+    IndexerErrorModule["Account"] = "indexer-account";
+    IndexerErrorModule["Auction"] = "indexer-auction";
+    IndexerErrorModule["Archiver"] = "indexer-archiver";
+    IndexerErrorModule["Derivatives"] = "indexer-derivatives";
+    IndexerErrorModule["Explorer"] = "indexer-explorer";
+    IndexerErrorModule["InsuranceFund"] = "indexer-insurance-fund";
+    IndexerErrorModule["Meta"] = "indexer-meta";
+    IndexerErrorModule["Mito"] = "indexer-mito";
+    IndexerErrorModule["Dmm"] = "dmm";
+    IndexerErrorModule["OLP"] = "olp";
+    IndexerErrorModule["Referral"] = "referral";
+    IndexerErrorModule["Oracle"] = "indexer-oracle";
+    IndexerErrorModule["Portfolio"] = "indexer-portfolio";
+    IndexerErrorModule["Spot"] = "indexer-spot";
+    IndexerErrorModule["Transaction"] = "indexer-transaction";
+    IndexerErrorModule["Trading"] = "indexer-trading";
+    IndexerErrorModule["ChronosDerivative"] = "indexer-chronos-derivative";
+    IndexerErrorModule["ChronosSpot"] = "indexer-chronos-spot";
+    IndexerErrorModule["ChronosMarkets"] = "indexer-chronos-markets";
+    IndexerErrorModule["Campaign"] = "indexer-campaign";
+    IndexerErrorModule["Web3Gw"] = "web3-gateway";
+    IndexerErrorModule["Abacus"] = "abacus";
+})(IndexerErrorModule || (exports.IndexerErrorModule = IndexerErrorModule = {}));
+var WalletErrorActionModule;
+(function (WalletErrorActionModule) {
+    WalletErrorActionModule["SignTransaction"] = "sign-transaction";
+    WalletErrorActionModule["SignEthereumTransaction"] = "sign-ethereum-transaction";
+    WalletErrorActionModule["SendTransaction"] = "send-transaction";
+    WalletErrorActionModule["SendEthereumTransaction"] = "send-ethereum-transaction";
+    WalletErrorActionModule["SignArbitrary"] = "sign-arbitrary";
+    WalletErrorActionModule["GetAccounts"] = "get-accounts";
+    WalletErrorActionModule["GetNetworkId"] = "get-network-id";
+    WalletErrorActionModule["GetChainId"] = "get-chain-id";
+    WalletErrorActionModule["GetEthereumTransactionReceipt"] = "get-ethereum-transaction-receipt";
+})(WalletErrorActionModule || (exports.WalletErrorActionModule = WalletErrorActionModule = {}));

package/dist/cjs/exceptions/utils/grpc.d.ts

@@ -0,0 +1,3 @@
+import * as grpcPkg from '@injectivelabs/grpc-web';
+declare const grpc: typeof grpcPkg.grpc;
+export { grpc, grpcPkg };

package/dist/cjs/exceptions/utils/grpc.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcPkg = exports.grpc = void 0;
+const grpcPkg = __importStar(require("@injectivelabs/grpc-web"));
+exports.grpcPkg = grpcPkg;
+const grpc = grpcPkg.grpc ?? grpcPkg.default.grpc ?? grpcPkg;
+exports.grpc = grpc;

package/dist/cjs/exceptions/utils/helpers.d.ts

@@ -0,0 +1 @@
+export declare const isCommonLockedError: (error: string) => boolean;

package/dist/cjs/exceptions/utils/helpers.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCommonLockedError = void 0;
+const isCommonLockedError = (error) => {
+    const commonMessages = [
+        'Ledger device: Incorrect length',
+        'Ledger device: INS_NOT_SUPPORTED',
+        'Ledger device: CLA_NOT_SUPPORTED',
+        'Unknown',
+        'Ledger device',
+        'CLA_NOT_SUPPORTED',
+        'CLA',
+        'Locked',
+        'Failed to open the device',
+        'Failed to open the device',
+        'Ledger Device is busy',
+        'Ledger device',
+        'UNKNOWN_ERROR',
+    ];
+    return (commonMessages.some((m) => m.includes(error)) ||
+        commonMessages.some((m) => error.toLowerCase().includes(m)) ||
+        commonMessages.some((m) => m.toLowerCase().includes(error.toLowerCase())));
+};
+exports.isCommonLockedError = isCommonLockedError;

package/dist/cjs/exceptions/utils/maps.d.ts

@@ -0,0 +1,13 @@
+import { ErrorContext, ErrorContextCode, TransactionChainErrorModule } from '../types/index.js';
+export declare const parseErrorMessage: (message: string) => string;
+export declare const mapFailedTransactionMessageFromString: (message: string) => {
+    message: string;
+    code: ErrorContextCode;
+    module?: TransactionChainErrorModule;
+};
+export declare const mapFailedTransactionMessage: (message: string, context?: ErrorContext) => {
+    message: string;
+    code: ErrorContextCode;
+    contextModule?: string;
+};
+export declare const mapMetamaskMessage: (message: string) => string;

package/dist/cjs/exceptions/utils/maps.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapMetamaskMessage = exports.mapFailedTransactionMessage = exports.mapFailedTransactionMessageFromString = exports.parseErrorMessage = void 0;
+const messages_js_1 = require("../messages.js");
+const index_js_1 = require("../types/index.js");
+const parseErrorMessage = (message) => {
+    const firstParse = message.split('message index: 0:');
+    if (firstParse.length === 1) {
+        const [firstParseString] = firstParse;
+        const secondParse = firstParseString.split(': invalid request');
+        const [secondParseString] = secondParse;
+        return secondParseString.trim().trimEnd();
+    }
+    const [, firstParseString] = firstParse;
+    const [actualMessage] = firstParseString.split(': invalid request');
+    return actualMessage.trim().trimEnd();
+};
+exports.parseErrorMessage = parseErrorMessage;
+const mapFailedTransactionMessageFromString = (message) => {
+    const parsedMessage = (0, exports.parseErrorMessage)(message);
+    const messageInMapKey = Object.keys(messages_js_1.chainErrorMessagesMap).find((key) => parsedMessage.toLowerCase().includes(key.toLowerCase()));
+    if (!messageInMapKey) {
+        return {
+            message: parsedMessage,
+            code: index_js_1.UnspecifiedErrorCode,
+            module: undefined,
+        };
+    }
+    return messages_js_1.chainErrorMessagesMap[messageInMapKey];
+};
+exports.mapFailedTransactionMessageFromString = mapFailedTransactionMessageFromString;
+const mapFailedTransactionMessage = (message, context) => {
+    const getWasmErrorFromMessage = (message) => {
+        if (!message.includes('execute wasm contract failed')) {
+            return;
+        }
+        const ReasonPattern = /(.*?)execute wasm contract failed(.*?)/g;
+        const reason = ReasonPattern.exec(message);
+        if (!reason) {
+            return;
+        }
+        if (reason.length < 2) {
+            return;
+        }
+        return reason[1].replace('failed to execute message; message index: 0: ', '');
+    };
+    const getABCICode = (message) => {
+        const ABCICodePattern = /{key:"ABCICode"[ \t]+value:"(.*?)"}/g;
+        const ABCICode = ABCICodePattern.exec(message);
+        if (!ABCICode || ABCICode.length < 2) {
+            return;
+        }
+        return Number(ABCICode[1]);
+    };
+    const getContextModule = (message) => {
+        const codespacePattern = /{key:"Codespace"[ \t]+value:"(.*?)"}/g;
+        const codespace = codespacePattern.exec(message);
+        if (!codespace || codespace.length < 2) {
+            return;
+        }
+        return codespace[1];
+    };
+    const getReason = (message) => {
+        const ReasonPattern = /\[reason:"(.*?)"/g;
+        const codespace = ReasonPattern.exec(message);
+        if (!codespace || codespace.length < 2) {
+            if (message.includes('execute wasm contract failed')) {
+                return getWasmErrorFromMessage(message);
+            }
+            return;
+        }
+        const reason = codespace[1];
+        if (reason === 'execute wasm contract failed') {
+            const SubReasonPattern = /(.*?)Generic error:(.*?): execute wasm/g;
+            const subReason = SubReasonPattern.exec(message);
+            if (!subReason) {
+                return reason;
+            }
+            return subReason[2] || reason;
+        }
+        return reason;
+    };
+    const ABCICode = context && context.code ? context.code : getABCICode(message);
+    const contextModule = context?.contextModule || getContextModule(message);
+    const reason = getReason(message);
+    if (!ABCICode || !contextModule) {
+        const failedTxMap = (0, exports.mapFailedTransactionMessageFromString)(message);
+        return {
+            ...failedTxMap,
+            contextModule: failedTxMap.module || contextModule,
+            message: reason || failedTxMap.message,
+        };
+    }
+    const codespaceErrorMessages = messages_js_1.chainModuleCodeErrorMessagesMap[contextModule];
+    if (!codespaceErrorMessages) {
+        return {
+            message: reason || message,
+            code: ABCICode,
+            contextModule,
+        };
+    }
+    return {
+        message: codespaceErrorMessages[ABCICode] || reason || message,
+        code: ABCICode,
+        contextModule,
+    };
+};
+exports.mapFailedTransactionMessage = mapFailedTransactionMessage;
+const mapMetamaskMessage = (message) => {
+    const parsedMessage = message.trim().toLowerCase();
+    if (parsedMessage.includes('User denied message signature'.toLowerCase())) {
+        return 'The request has been rejected';
+    }
+    if (parsedMessage.toLowerCase().includes('user denied'.toLowerCase())) {
+        return 'The request has been rejected';
+    }
+    if (parsedMessage.toLowerCase().includes('provided chain'.toLowerCase())) {
+        return 'Your Metamask selected network is incorrect';
+    }
+    if (parsedMessage
+        .toLowerCase()
+        .includes('missing or invalid parameters'.toLowerCase())) {
+        return 'Please make sure you are using Metamask';
+    }
+    if (parsedMessage
+        .toLowerCase()
+        .includes('Keyring Controller signTypedMessage'.toLowerCase())) {
+        return 'Please ensure your Ledger is connected, unlocked and your Ethereum app is open.';
+    }
+    return message.replaceAll('Keyring Controller signTypedMessage:', '');
+};
+exports.mapMetamaskMessage = mapMetamaskMessage;

package/dist/cjs/index.d.ts

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

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./exceptions/index.js"), exports);
+__exportStar(require("./utils.js"), exports);
+__exportStar(require("./types.js"), exports);

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/dist/cjs/types.d.ts

@@ -0,0 +1,2 @@
+import { Web3Exception, WalletException, TrezorException, BitGetException, LedgerException, GeneralException, MetamaskException, OkxWalletException, HttpRequestException, LedgerCosmosException, TrustWalletException, CosmosWalletException, TransactionException, GrpcUnaryRequestException } from './exceptions/exceptions/index.js';
+export type ThrownException = GrpcUnaryRequestException | HttpRequestException | Web3Exception | GeneralException | LedgerException | MetamaskException | TrustWalletException | OkxWalletException | TrezorException | CosmosWalletException | TransactionException | WalletException | LedgerCosmosException | BitGetException;

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from './exceptions/types/index.js';
+import { ThrownException } from './types.js';
+export declare const THROWN_EXCEPTIONS: string[];
+export declare const isThrownException: (exception: Error | Exception | ThrownException) => boolean;
+export declare const formatNotificationDescription: (description: string) => {
+    description: string;
+    tooltip: string;
+};

package/dist/cjs/utils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatNotificationDescription = exports.isThrownException = exports.THROWN_EXCEPTIONS = void 0;
+exports.THROWN_EXCEPTIONS = [
+    'GrpcUnaryRequestException',
+    'HttpRequestException',
+    'Web3Exception',
+    'GeneralException',
+    'LedgerException',
+    'LedgerCosmosException',
+    'MetamaskException',
+    'TrezorException',
+    'CosmosWalletException',
+    'TransactionException',
+    'WalletException',
+    'TrustWalletException',
+    'OkxWalletException',
+    'BitGetException',
+];
+const isThrownException = (exception) => {
+    if (exports.THROWN_EXCEPTIONS.includes(exception.constructor.name)) {
+        return true;
+    }
+    if (exports.THROWN_EXCEPTIONS.includes(exception.name)) {
+        return true;
+    }
+    if ('errorClass' in exception &&
+        exports.THROWN_EXCEPTIONS.includes(exception.errorClass)) {
+        return true;
+    }
+    return false;
+};
+exports.isThrownException = isThrownException;
+const formatNotificationDescription = (description) => {
+    const DESCRIPTION_CHARACTER_LIMIT = 50;
+    if (description.length <= DESCRIPTION_CHARACTER_LIMIT) {
+        return {
+            description,
+            tooltip: '',
+        };
+    }
+    return {
+        description: description.slice(0, DESCRIPTION_CHARACTER_LIMIT) + ' ...',
+        tooltip: description,
+    };
+};
+exports.formatNotificationDescription = formatNotificationDescription;

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

@@ -0,0 +1,76 @@
+import { Exception, ErrorType, ErrorContext, ErrorCode, ErrorContextCode } from './types/index.js';
+export declare abstract class ConcreteException extends Error implements Exception {
+    /**
+     * The type of the Error
+     */
+    type: ErrorType;
+    /**
+     * Error specific code (HttpStatus, GrpcStatus, etc)
+     */
+    code: ErrorCode;
+    /**
+     * The name of the error (the name of the instance of the Exception)
+     */
+    name: string;
+    /**
+     * The name of the error (the name of the instance of the Exception)
+     * Needed for reporting reasons, ex: bugsnag
+     */
+    errorClass: string;
+    /**
+     * Providing more context
+     * (ex: endpoint on http request)
+     */
+    context?: string;
+    /**
+     * Providing more context as to where the exception was thrown
+     * (ex: on-chain module, etc)
+     */
+    contextModule?: string;
+    /**
+     * Providing more context as to why the exception was thrown
+     * (ex: on-chain error code, etc)
+     */
+    contextCode?: ErrorContextCode;
+    /**
+     * Parsed message of the exception
+     */
+    message: string;
+    /**
+     * The original stack of the error
+     */
+    stack?: string;
+    /**
+     * The original message of the error
+     */
+    originalMessage: string;
+    constructor(error: Error, context?: ErrorContext);
+    parse(): void;
+    parseError(error: Error): void;
+    parseContext(errorContext?: ErrorContext): void;
+    setType(type: ErrorType): void;
+    setCode(code: ErrorCode): void;
+    setContext(context: string): void;
+    setOriginalMessage(message: string): void;
+    setStack(stack: string): void;
+    setName(name: string): void;
+    setMessage(message: string): void;
+    setContextModule(contextModule: string): void;
+    setContextCode(code: ErrorContextCode): void;
+    toOriginalError(): Error;
+    toError(): Error;
+    toCompactError(): Error;
+    toJson(): string;
+    toObject(): {
+        code: ErrorCode;
+        type: ErrorType;
+        errorClass: string;
+        message: string;
+        context: string | undefined;
+        contextCode: ErrorContextCode | undefined;
+        contextModule: string | undefined;
+        originalMessage: string;
+        stack: string[];
+    };
+    toString(): string;
+}