@injectivelabs/exceptions 1.15.0 → 1.15.2

package/dist/esm/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/esm/exceptions/types/context.js

@@ -0,0 +1,20 @@
+export var HttpRequestMethod;
+(function (HttpRequestMethod) {
+    HttpRequestMethod["Get"] = "GET";
+    HttpRequestMethod["Post"] = "POST";
+    HttpRequestMethod["Options"] = "OPTIONS";
+})(HttpRequestMethod || (HttpRequestMethod = {}));
+export 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 || (ErrorType = {}));

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

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

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

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

package/dist/esm/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/esm/exceptions/types/modules.js

@@ -0,0 +1,63 @@
+export var ContractErrorModule;
+(function (ContractErrorModule) {
+    ContractErrorModule["Erc20Contract"] = "erc20-contract";
+    ContractErrorModule["Peggy"] = "peggy-contract";
+    ContractErrorModule["PeggyOld"] = "peggy-old-contract";
+})(ContractErrorModule || (ContractErrorModule = {}));
+export 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 || (ChainErrorModule = {}));
+export 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 || (IndexerErrorModule = {}));
+export 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 || (WalletErrorActionModule = {}));

package/dist/esm/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/esm/exceptions/utils/grpc.js

@@ -0,0 +1,3 @@
+import * as grpcPkg from '@injectivelabs/grpc-web';
+const grpc = grpcPkg.grpc ?? grpcPkg.default.grpc ?? grpcPkg;
+export { grpc, grpcPkg };

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

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

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

@@ -0,0 +1,20 @@
+export 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())));
+};

package/dist/esm/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/esm/exceptions/utils/maps.js

@@ -0,0 +1,125 @@
+import { chainErrorMessagesMap, chainModuleCodeErrorMessagesMap, } from '../messages.js';
+import { UnspecifiedErrorCode, } from '../types/index.js';
+export 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();
+};
+export const mapFailedTransactionMessageFromString = (message) => {
+    const parsedMessage = parseErrorMessage(message);
+    const messageInMapKey = Object.keys(chainErrorMessagesMap).find((key) => parsedMessage.toLowerCase().includes(key.toLowerCase()));
+    if (!messageInMapKey) {
+        return {
+            message: parsedMessage,
+            code: UnspecifiedErrorCode,
+            module: undefined,
+        };
+    }
+    return chainErrorMessagesMap[messageInMapKey];
+};
+export 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 = mapFailedTransactionMessageFromString(message);
+        return {
+            ...failedTxMap,
+            contextModule: failedTxMap.module || contextModule,
+            message: reason || failedTxMap.message,
+        };
+    }
+    const codespaceErrorMessages = chainModuleCodeErrorMessagesMap[contextModule];
+    if (!codespaceErrorMessages) {
+        return {
+            message: reason || message,
+            code: ABCICode,
+            contextModule,
+        };
+    }
+    return {
+        message: codespaceErrorMessages[ABCICode] || reason || message,
+        code: ABCICode,
+        contextModule,
+    };
+};
+export 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:', '');
+};

package/dist/esm/index.d.ts

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

package/dist/esm/index.js

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

package/dist/esm/package.json

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

package/dist/esm/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/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/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/esm/utils.js

@@ -0,0 +1,42 @@
+export const THROWN_EXCEPTIONS = [
+    'GrpcUnaryRequestException',
+    'HttpRequestException',
+    'Web3Exception',
+    'GeneralException',
+    'LedgerException',
+    'LedgerCosmosException',
+    'MetamaskException',
+    'TrezorException',
+    'CosmosWalletException',
+    'TransactionException',
+    'WalletException',
+    'TrustWalletException',
+    'OkxWalletException',
+    'BitGetException',
+];
+export const isThrownException = (exception) => {
+    if (THROWN_EXCEPTIONS.includes(exception.constructor.name)) {
+        return true;
+    }
+    if (THROWN_EXCEPTIONS.includes(exception.name)) {
+        return true;
+    }
+    if ('errorClass' in exception &&
+        THROWN_EXCEPTIONS.includes(exception.errorClass)) {
+        return true;
+    }
+    return false;
+};
+export 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,
+    };
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@injectivelabs/exceptions",
   "description": "List of exceptions that can be reused throughout Injective's projects.",
-  "version": "1.15.0",
+  "version": "1.15.2",
   "sideEffects": false,
   "license": "Apache-2.0",
   "type": "module",
@@ -61,5 +61,5 @@
   "devDependencies": {
     "shx": "^0.3.4"
   },
-  "gitHead": "acae5b41a4c8a0ac4f137cce434b9db81800a1c5"
+  "gitHead": "adf15fdda3172783b16fddba631c8054160fe772"
 }