@lifi/sdk 2.2.2 → 3.0.0-alpha.1

package/dist/cjs/types/internal.types.d.ts

@@ -1,24 +1,22 @@
-import { TransactionRequest } from '@ethersproject/abstract-provider';
-import { LifiStep, Route, RouteOptions, Token } from '@lifi/types';
-import BigNumber from 'bignumber.js';
-import { Signer } from 'ethers';
-import { ChainId } from '.';
-import { StatusManager } from '../execution/StatusManager';
-import { StepExecutor } from '../execution/StepExecutor';
-export interface TokenWithAmounts extends Token {
-    amount?: BigNumber;
-    amountRendered?: string;
-}
-export type ParsedReceipt = {
-    fromAmount?: string;
-    toAmount: string;
-    gasUsed: string;
-    gasPrice: string;
-    gasFee: string;
-    toTokenAddress?: string;
+import type { LifiStep, Route, RouteOptions, Token } from '@lifi/types';
+import type { Hash, Hex, WalletClient } from 'viem';
+import type { ChainId } from '.';
+import type { StatusManager } from '../execution/StatusManager';
+import type { StepExecutor } from '../execution/StepExecutor';
+export type TransactionRequest = {
+    chainId?: number;
+    to?: string;
+    from?: string;
+    nonce?: number;
+    data?: Hex;
+    value?: bigint;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
 };
 export interface ExecutionParams {
-    signer: Signer;
+    walletClient: WalletClient;
     step: LifiStep;
     statusManager: StatusManager;
     settings: InternalExecutionSettings;
@@ -35,24 +33,24 @@ export type Config = {
     userId?: string;
     integrator: string;
     widgetVersion?: string;
-    multisigConfig?: MultisigConfig;
+    multisig?: MultisigConfig;
 };
 export interface MultisigTxDetails {
     status: 'DONE' | 'FAILED' | 'PENDING' | 'CANCELLED';
-    txHash?: string;
+    txHash?: Hash;
 }
 export interface MultisigTransactionResponse {
     hash: string;
 }
 export interface BaseTransaction {
     to: string;
-    value: string;
+    value?: bigint;
     data: string;
 }
 export interface MultisigConfig {
-    isMultisigSigner?: boolean;
-    getMultisigTransactionDetails?: (txHash: string, fromChainId: number, updateIntermediateStatus?: () => void) => Promise<MultisigTxDetails>;
-    sendBatchTransaction?: (batchTransactions: BaseTransaction[]) => Promise<MultisigTransactionResponse>;
+    isMultisigWalletClient: boolean;
+    getMultisigTransactionDetails: (txHash: Hash, fromChainId: number, updateIntermediateStatus?: () => void) => Promise<MultisigTxDetails>;
+    sendBatchTransaction?: (batchTransactions: BaseTransaction[]) => Promise<Hash>;
     shouldBatchTransactions?: boolean;
 }
 export type ConfigUpdate = {
@@ -67,7 +65,7 @@ export type ConfigUpdate = {
     widgetVersion?: string;
     multisigConfig?: MultisigConfig;
 };
-export type SwitchChainHook = (requiredChainId: number) => Promise<Signer | undefined>;
+export type SwitchChainHook = (requiredChainId: number) => Promise<WalletClient | undefined>;
 export interface AcceptSlippageUpdateHookParams {
     toToken: Token;
     oldToAmount: string;
@@ -98,10 +96,6 @@ export interface InternalExecutionSettings {
 }
 export type RouteExecutionDictionary = Partial<Record<string, RouteExecutionData>>;
 export type RouteExecutionPromiseDictionary = Partial<Record<string, Promise<Route>>>;
-export type RevokeTokenData = {
-    token: Token;
-    approvalAddress: string;
-};
 export interface InteractionSettings {
     allowInteraction?: boolean;
     allowUpdates?: boolean;

package/dist/cjs/utils/errors.d.ts

@@ -8,7 +8,7 @@ declare enum ErrorType {
     UnknownError = "UnknownError",
     SlippageError = "SlippageError"
 }
-export declare enum LifiErrorCode {
+export declare enum LiFiErrorCode {
     InternalError = 1000,
     ValidationError = 1001,
     TransactionUnderpriced = 1002,
@@ -21,10 +21,11 @@ export declare enum LifiErrorCode {
     GasLimitError = 1009,
     TransactionCanceled = 1010,
     SlippageError = 1011,
-    TransactionRejected = 1012,
+    SignatureRejected = 1012,
     BalanceError = 1013,
     AllowanceRequired = 1014,
-    InsufficientFunds = 1015
+    InsufficientFunds = 1015,
+    ExchangeRateUpdateCanceled = 1016
 }
 export declare enum EthersErrorType {
     ActionRejected = "ACTION_REJECTED",
@@ -65,37 +66,37 @@ export declare enum MetaMaskProviderErrorCode {
     disconnected = 4900,
     chainDisconnected = 4901
 }
-export type ErrorCode = LifiErrorCode | MetaMaskRPCErrorCode | MetaMaskProviderErrorCode;
-export declare class LifiError extends Error {
+export type ErrorCode = LiFiErrorCode | MetaMaskRPCErrorCode | MetaMaskProviderErrorCode;
+export declare class LiFiError extends Error {
     code: ErrorCode;
     htmlMessage?: string;
     constructor(type: ErrorType, code: number, message: string, htmlMessage?: string, stack?: string);
 }
-export declare class RPCError extends LifiError {
+export declare class RPCError extends LiFiError {
     constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
 }
-export declare class ProviderError extends LifiError {
+export declare class ProviderError extends LiFiError {
     constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
 }
-export declare class ServerError extends LifiError {
+export declare class ServerError extends LiFiError {
     constructor(message: string, htmlMessage?: string, stack?: string);
 }
-export declare class ValidationError extends LifiError {
+export declare class ValidationError extends LiFiError {
     constructor(message: string, htmlMessage?: string, stack?: string);
 }
-export declare class TransactionError extends LifiError {
+export declare class TransactionError extends LiFiError {
     constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
 }
-export declare class SlippageError extends LifiError {
+export declare class SlippageError extends LiFiError {
     constructor(message: string, htmlMessage?: string, stack?: string);
 }
-export declare class BalanceError extends LifiError {
+export declare class BalanceError extends LiFiError {
     constructor(message: string, htmlMessage?: string, stack?: string);
 }
-export declare class NotFoundError extends LifiError {
+export declare class NotFoundError extends LiFiError {
     constructor(message: string, htmlMessage?: string, stack?: string);
 }
-export declare class UnknownError extends LifiError {
+export declare class UnknownError extends LiFiError {
     constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
 }
 export declare class HTTPError extends Error {

package/dist/cjs/utils/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HTTPError = exports.UnknownError = exports.NotFoundError = exports.BalanceError = exports.SlippageError = exports.TransactionError = exports.ValidationError = exports.ServerError = exports.ProviderError = exports.RPCError = exports.LifiError = exports.MetaMaskProviderErrorCode = exports.MetaMaskRPCErrorCode = exports.ErrorMessage = exports.EthersErrorMessage = exports.EthersErrorType = exports.LifiErrorCode = void 0;
+exports.HTTPError = exports.UnknownError = exports.NotFoundError = exports.BalanceError = exports.SlippageError = exports.TransactionError = exports.ValidationError = exports.ServerError = exports.ProviderError = exports.RPCError = exports.LiFiError = exports.MetaMaskProviderErrorCode = exports.MetaMaskRPCErrorCode = exports.ErrorMessage = exports.EthersErrorMessage = exports.EthersErrorType = exports.LiFiErrorCode = void 0;
 var ErrorType;
 (function (ErrorType) {
     ErrorType["RPCError"] = "RPCError";
@@ -12,25 +12,26 @@ var ErrorType;
     ErrorType["UnknownError"] = "UnknownError";
     ErrorType["SlippageError"] = "SlippageError";
 })(ErrorType || (ErrorType = {}));
-var LifiErrorCode;
-(function (LifiErrorCode) {
-    LifiErrorCode[LifiErrorCode["InternalError"] = 1000] = "InternalError";
-    LifiErrorCode[LifiErrorCode["ValidationError"] = 1001] = "ValidationError";
-    LifiErrorCode[LifiErrorCode["TransactionUnderpriced"] = 1002] = "TransactionUnderpriced";
-    LifiErrorCode[LifiErrorCode["TransactionFailed"] = 1003] = "TransactionFailed";
-    LifiErrorCode[LifiErrorCode["Timeout"] = 1004] = "Timeout";
-    LifiErrorCode[LifiErrorCode["ProviderUnavailable"] = 1005] = "ProviderUnavailable";
-    LifiErrorCode[LifiErrorCode["NotFound"] = 1006] = "NotFound";
-    LifiErrorCode[LifiErrorCode["ChainSwitchError"] = 1007] = "ChainSwitchError";
-    LifiErrorCode[LifiErrorCode["TransactionUnprepared"] = 1008] = "TransactionUnprepared";
-    LifiErrorCode[LifiErrorCode["GasLimitError"] = 1009] = "GasLimitError";
-    LifiErrorCode[LifiErrorCode["TransactionCanceled"] = 1010] = "TransactionCanceled";
-    LifiErrorCode[LifiErrorCode["SlippageError"] = 1011] = "SlippageError";
-    LifiErrorCode[LifiErrorCode["TransactionRejected"] = 1012] = "TransactionRejected";
-    LifiErrorCode[LifiErrorCode["BalanceError"] = 1013] = "BalanceError";
-    LifiErrorCode[LifiErrorCode["AllowanceRequired"] = 1014] = "AllowanceRequired";
-    LifiErrorCode[LifiErrorCode["InsufficientFunds"] = 1015] = "InsufficientFunds";
-})(LifiErrorCode || (exports.LifiErrorCode = LifiErrorCode = {}));
+var LiFiErrorCode;
+(function (LiFiErrorCode) {
+    LiFiErrorCode[LiFiErrorCode["InternalError"] = 1000] = "InternalError";
+    LiFiErrorCode[LiFiErrorCode["ValidationError"] = 1001] = "ValidationError";
+    LiFiErrorCode[LiFiErrorCode["TransactionUnderpriced"] = 1002] = "TransactionUnderpriced";
+    LiFiErrorCode[LiFiErrorCode["TransactionFailed"] = 1003] = "TransactionFailed";
+    LiFiErrorCode[LiFiErrorCode["Timeout"] = 1004] = "Timeout";
+    LiFiErrorCode[LiFiErrorCode["ProviderUnavailable"] = 1005] = "ProviderUnavailable";
+    LiFiErrorCode[LiFiErrorCode["NotFound"] = 1006] = "NotFound";
+    LiFiErrorCode[LiFiErrorCode["ChainSwitchError"] = 1007] = "ChainSwitchError";
+    LiFiErrorCode[LiFiErrorCode["TransactionUnprepared"] = 1008] = "TransactionUnprepared";
+    LiFiErrorCode[LiFiErrorCode["GasLimitError"] = 1009] = "GasLimitError";
+    LiFiErrorCode[LiFiErrorCode["TransactionCanceled"] = 1010] = "TransactionCanceled";
+    LiFiErrorCode[LiFiErrorCode["SlippageError"] = 1011] = "SlippageError";
+    LiFiErrorCode[LiFiErrorCode["SignatureRejected"] = 1012] = "SignatureRejected";
+    LiFiErrorCode[LiFiErrorCode["BalanceError"] = 1013] = "BalanceError";
+    LiFiErrorCode[LiFiErrorCode["AllowanceRequired"] = 1014] = "AllowanceRequired";
+    LiFiErrorCode[LiFiErrorCode["InsufficientFunds"] = 1015] = "InsufficientFunds";
+    LiFiErrorCode[LiFiErrorCode["ExchangeRateUpdateCanceled"] = 1016] = "ExchangeRateUpdateCanceled";
+})(LiFiErrorCode || (exports.LiFiErrorCode = LiFiErrorCode = {}));
 var EthersErrorType;
 (function (EthersErrorType) {
     EthersErrorType["ActionRejected"] = "ACTION_REJECTED";
@@ -75,11 +76,11 @@ var MetaMaskProviderErrorCode;
     MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["disconnected"] = 4900] = "disconnected";
     MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["chainDisconnected"] = 4901] = "chainDisconnected";
 })(MetaMaskProviderErrorCode || (exports.MetaMaskProviderErrorCode = MetaMaskProviderErrorCode = {}));
-class LifiError extends Error {
+class LiFiError extends Error {
     constructor(type, code, message, htmlMessage, stack) {
         super(message);
         // Set the prototype explicitly: https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
-        Object.setPrototypeOf(this, LifiError.prototype);
+        Object.setPrototypeOf(this, LiFiError.prototype);
         this.code = code;
         // the name property is used by toString(). It is a string and we can't use our custom ErrorTypes, that's why we have to cast
         this.name = type.toString();
@@ -90,56 +91,56 @@ class LifiError extends Error {
         }
     }
 }
-exports.LifiError = LifiError;
-class RPCError extends LifiError {
+exports.LiFiError = LiFiError;
+class RPCError extends LiFiError {
     constructor(code, message, htmlMessage, stack) {
         super(ErrorType.RPCError, code, message, htmlMessage, stack);
     }
 }
 exports.RPCError = RPCError;
-class ProviderError extends LifiError {
+class ProviderError extends LiFiError {
     constructor(code, message, htmlMessage, stack) {
         super(ErrorType.ProviderError, code, message, htmlMessage, stack);
     }
 }
 exports.ProviderError = ProviderError;
-class ServerError extends LifiError {
+class ServerError extends LiFiError {
     constructor(message, htmlMessage, stack) {
-        super(ErrorType.ServerError, LifiErrorCode.InternalError, message, htmlMessage, stack);
+        super(ErrorType.ServerError, LiFiErrorCode.InternalError, message, htmlMessage, stack);
     }
 }
 exports.ServerError = ServerError;
-class ValidationError extends LifiError {
+class ValidationError extends LiFiError {
     constructor(message, htmlMessage, stack) {
-        super(ErrorType.ValidationError, LifiErrorCode.ValidationError, message, htmlMessage, stack);
+        super(ErrorType.ValidationError, LiFiErrorCode.ValidationError, message, htmlMessage, stack);
     }
 }
 exports.ValidationError = ValidationError;
-class TransactionError extends LifiError {
+class TransactionError extends LiFiError {
     constructor(code, message, htmlMessage, stack) {
         super(ErrorType.TransactionError, code, message, htmlMessage, stack);
     }
 }
 exports.TransactionError = TransactionError;
-class SlippageError extends LifiError {
+class SlippageError extends LiFiError {
     constructor(message, htmlMessage, stack) {
-        super(ErrorType.SlippageError, LifiErrorCode.SlippageError, message, htmlMessage, stack);
+        super(ErrorType.SlippageError, LiFiErrorCode.SlippageError, message, htmlMessage, stack);
     }
 }
 exports.SlippageError = SlippageError;
-class BalanceError extends LifiError {
+class BalanceError extends LiFiError {
     constructor(message, htmlMessage, stack) {
-        super(ErrorType.ValidationError, LifiErrorCode.BalanceError, message, htmlMessage, stack);
+        super(ErrorType.ValidationError, LiFiErrorCode.BalanceError, message, htmlMessage, stack);
     }
 }
 exports.BalanceError = BalanceError;
-class NotFoundError extends LifiError {
+class NotFoundError extends LiFiError {
     constructor(message, htmlMessage, stack) {
-        super(ErrorType.NotFoundError, LifiErrorCode.NotFound, message, htmlMessage, stack);
+        super(ErrorType.NotFoundError, LiFiErrorCode.NotFound, message, htmlMessage, stack);
     }
 }
 exports.NotFoundError = NotFoundError;
-class UnknownError extends LifiError {
+class UnknownError extends LiFiError {
     constructor(code, message, htmlMessage, stack) {
         super(ErrorType.UnknownError, code, message, htmlMessage, stack);
     }

package/dist/cjs/utils/getMaxPriorityFeePerGas.d.ts

@@ -0,0 +1,2 @@
+import type { PublicClient } from 'viem';
+export declare const getMaxPriorityFeePerGas: (client: PublicClient) => Promise<bigint | undefined>;

package/dist/cjs/utils/getMaxPriorityFeePerGas.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxPriorityFeePerGas = void 0;
+const median_1 = require("./median");
+const getMaxPriorityFeePerGas = async (client) => {
+    const block = await client.getBlock({
+        includeTransactions: true,
+    });
+    const maxPriorityFeePerGasList = block.transactions
+        .filter((tx) => tx.maxPriorityFeePerGas)
+        .map((tx) => tx.maxPriorityFeePerGas);
+    if (!maxPriorityFeePerGasList.length) {
+        return;
+    }
+    const maxPriorityFeePerGasSum = maxPriorityFeePerGasList.reduce((acc, value) => (acc += value), 0n);
+    const maxPriorityFeePerGasMedian = (0, median_1.median)(maxPriorityFeePerGasList) ?? 0n;
+    const maxPriorityFeePerGasAvg = maxPriorityFeePerGasSum / BigInt(maxPriorityFeePerGasList.length);
+    return maxPriorityFeePerGasMedian > maxPriorityFeePerGasAvg
+        ? maxPriorityFeePerGasAvg
+        : maxPriorityFeePerGasMedian;
+};
+exports.getMaxPriorityFeePerGas = getMaxPriorityFeePerGas;

package/dist/cjs/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './errors';
+export * from './getMaxPriorityFeePerGas';
+export * from './median';
+export * from './parseError';
+export * from './utils';

package/dist/cjs/utils/index.js

@@ -0,0 +1,21 @@
+"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("./errors"), exports);
+__exportStar(require("./getMaxPriorityFeePerGas"), exports);
+__exportStar(require("./median"), exports);
+__exportStar(require("./parseError"), exports);
+__exportStar(require("./utils"), exports);

package/dist/cjs/utils/median.d.ts

@@ -0,0 +1 @@
+export declare const median: (arr: bigint[]) => bigint | undefined;

package/dist/cjs/utils/median.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.median = void 0;
+const median = (arr) => {
+    if (!arr.length) {
+        return;
+    }
+    const s = [...arr].sort((a, b) => (a > b ? 1 : a < b ? -1 : 0));
+    const mid = Math.floor(s.length / 2);
+    if (s.length % 2 === 0) {
+        return (s[mid - 1] + s[mid]) / 2n;
+    }
+    return s[mid];
+};
+exports.median = median;

package/dist/cjs/utils/parseError.d.ts

@@ -1,5 +1,5 @@
-import { LifiStep, Process } from '@lifi/types';
-import { LifiError } from './errors';
+import type { LifiStep, Process } from '@lifi/types';
+import { LiFiError } from './errors';
 /**
  * Available MetaMask error codes:
  *
@@ -33,5 +33,5 @@ import { LifiError } from './errors';
  */
 export declare const getTransactionNotSentMessage: (step?: LifiStep, process?: Process) => Promise<string>;
 export declare const getTransactionFailedMessage: (step: LifiStep, txLink?: string) => Promise<string>;
-export declare const parseError: (e: any, step?: LifiStep, process?: Process) => Promise<LifiError>;
-export declare const parseBackendError: (e: any) => Promise<LifiError>;
+export declare const parseError: (e: any, step?: LifiStep, process?: Process) => Promise<LiFiError>;
+export declare const parseBackendError: (e: any) => Promise<LiFiError>;

package/dist/cjs/utils/parseError.js

@@ -5,10 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseBackendError = exports.parseError = exports.getTransactionFailedMessage = exports.getTransactionNotSentMessage = void 0;
 const eth_rpc_errors_1 = require("eth-rpc-errors");
+const viem_1 = require("viem");
 const helpers_1 = require("../helpers");
 const ChainsService_1 = __importDefault(require("../services/ChainsService"));
 const errors_1 = require("./errors");
-const utils_1 = require("./utils");
 /**
  * Available MetaMask error codes:
  *
@@ -46,7 +46,7 @@ const getTransactionNotSentMessage = async (step, process) => {
     if (step) {
         const chainService = ChainsService_1.default.getInstance();
         const chain = await chainService.getChainById(step.action.fromChainId);
-        transactionNotSend += ` (${(0, utils_1.formatTokenAmountOnly)(step.action.fromToken, step.action.fromAmount)} ${step.action.fromToken.symbol} on ${chain.name})`;
+        transactionNotSend += ` (${(0, viem_1.formatUnits)(BigInt(step.action.fromAmount), step.action.fromToken.decimals)} ${step.action.fromToken.symbol} on ${chain.name})`;
     }
     transactionNotSend +=
         ", please retry.<br/>If it still doesn't work, it is safe to delete this transfer and start a new one.";
@@ -70,62 +70,65 @@ const getTransactionFailedMessage = async (step, txLink) => {
 };
 exports.getTransactionFailedMessage = getTransactionFailedMessage;
 const parseError = async (e, step, process) => {
-    if (e instanceof errors_1.LifiError) {
+    if (e instanceof errors_1.LiFiError) {
         return e;
     }
-    if (e.code) {
-        // MetaMask errors have a numeric error code
-        if (typeof e.code === 'number') {
-            if (Object.values(eth_rpc_errors_1.errorCodes.rpc).includes(e.code)) {
-                // rpc errors
-                // underpriced errors are sent as internal errors, so we need to parse the message manually
-                if (e.code === eth_rpc_errors_1.errorCodes.rpc.internal &&
-                    (e.message?.includes(errors_1.EthersErrorMessage.Underpriced) ||
-                        e.message?.includes(errors_1.EthersErrorMessage.LowReplacementFee))) {
-                    return new errors_1.RPCError(errors_1.LifiErrorCode.TransactionUnderpriced, errors_1.ErrorMessage.TransactionUnderpriced, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-                }
-                if (e.message?.includes(errors_1.EthersErrorMessage.LowGas) ||
-                    e.message?.includes(errors_1.EthersErrorMessage.OutOfGas)) {
-                    return new errors_1.TransactionError(errors_1.LifiErrorCode.GasLimitError, errors_1.ErrorMessage.GasLimitLow, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-                }
-                return new errors_1.RPCError(e.code, (0, eth_rpc_errors_1.getMessageFromCode)(e.code), await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-            }
-            // provider errors
-            if (Object.values(eth_rpc_errors_1.errorCodes.provider).includes(e.code)) {
-                return new errors_1.ProviderError(e.code, (0, eth_rpc_errors_1.getMessageFromCode)(e.code), await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-            }
-        }
-    }
-    switch (e.code) {
+    const errorCode = e.code || e.cause?.code;
+    switch (errorCode) {
         case errors_1.EthersErrorType.CallExecption:
             const defaultErrorMessage = await (0, exports.getTransactionNotSentMessage)(step, process);
             try {
                 if (!step?.action.fromChainId) {
-                    throw new Error('Signer is not defined.');
+                    throw new Error('fromChainId is not defined.');
                 }
                 const response = await (0, helpers_1.fetchTxErrorDetails)(e.transactionHash, step?.action.fromChainId);
                 const errorMessage = response?.error_message ?? e.reason;
                 const isAllowanceError = response?.error_message?.includes(errors_1.EthersErrorMessage.ERC20Allowance) || e.reason?.includes(errors_1.EthersErrorMessage.ERC20Allowance);
                 if (isAllowanceError) {
-                    return new errors_1.TransactionError(errors_1.LifiErrorCode.AllowanceRequired, e.reason, errorMessage, e.stack);
+                    return new errors_1.TransactionError(errors_1.LiFiErrorCode.AllowanceRequired, e.reason, errorMessage, e.stack);
                 }
                 // Error messages other than allowance error will be handled in catch block
                 throw new Error(e);
             }
             catch (error) {
-                return new errors_1.ProviderError(errors_1.LifiErrorCode.TransactionFailed, e.reason, defaultErrorMessage, e.stack);
+                return new errors_1.ProviderError(errors_1.LiFiErrorCode.TransactionFailed, e.reason, defaultErrorMessage, e.stack);
             }
         case errors_1.EthersErrorType.InsufficientFunds:
-            return new errors_1.TransactionError(errors_1.LifiErrorCode.InsufficientFunds, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+            return new errors_1.TransactionError(errors_1.LiFiErrorCode.InsufficientFunds, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
         case errors_1.EthersErrorType.ActionRejected:
         case errors_1.MetaMaskProviderErrorCode.userRejectedRequest:
-            return new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionRejected, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-        case errors_1.LifiErrorCode.TransactionUnprepared:
-            return new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-        case errors_1.LifiErrorCode.ValidationError:
-            return new errors_1.TransactionError(errors_1.LifiErrorCode.ValidationError, e.message, e.htmlMessage);
-        default:
-            return new errors_1.UnknownError(errors_1.LifiErrorCode.InternalError, e.message || errors_1.ErrorMessage.UnknownError, undefined, e.stack);
+            return new errors_1.TransactionError(errors_1.LiFiErrorCode.SignatureRejected, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+        case errors_1.LiFiErrorCode.TransactionUnprepared:
+            return new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionUnprepared, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+        case errors_1.LiFiErrorCode.ValidationError:
+            return new errors_1.TransactionError(errors_1.LiFiErrorCode.ValidationError, e.message, e.htmlMessage);
+        case errors_1.LiFiErrorCode.TransactionCanceled:
+            return new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionCanceled, e.message, e.htmlMessage);
+        case errors_1.LiFiErrorCode.ExchangeRateUpdateCanceled:
+            return new errors_1.TransactionError(errors_1.LiFiErrorCode.ExchangeRateUpdateCanceled, e.message, e.htmlMessage);
+        default: {
+            if (errorCode && typeof errorCode === 'number') {
+                if (Object.values(eth_rpc_errors_1.errorCodes.rpc).includes(errorCode)) {
+                    // rpc errors
+                    // underpriced errors are sent as internal errors, so we need to parse the message manually
+                    if (errorCode === eth_rpc_errors_1.errorCodes.rpc.internal &&
+                        (e.message?.includes(errors_1.EthersErrorMessage.Underpriced) ||
+                            e.message?.includes(errors_1.EthersErrorMessage.LowReplacementFee))) {
+                        return new errors_1.RPCError(errors_1.LiFiErrorCode.TransactionUnderpriced, errors_1.ErrorMessage.TransactionUnderpriced, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+                    }
+                    if (e.message?.includes(errors_1.EthersErrorMessage.LowGas) ||
+                        e.message?.includes(errors_1.EthersErrorMessage.OutOfGas)) {
+                        return new errors_1.TransactionError(errors_1.LiFiErrorCode.GasLimitError, errors_1.ErrorMessage.GasLimitLow, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+                    }
+                    return new errors_1.RPCError(errorCode, (0, eth_rpc_errors_1.getMessageFromCode)(errorCode), await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+                }
+                // provider errors
+                if (Object.values(eth_rpc_errors_1.errorCodes.provider).includes(errorCode)) {
+                    return new errors_1.ProviderError(errorCode, (0, eth_rpc_errors_1.getMessageFromCode)(errorCode), await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+                }
+            }
+            return new errors_1.UnknownError(errors_1.LiFiErrorCode.InternalError, e.message || errors_1.ErrorMessage.UnknownError, undefined, e.stack);
+        }
     }
 };
 exports.parseError = parseError;

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

@@ -1,12 +1,4 @@
-import { TransactionReceipt } from '@ethersproject/providers';
-import { LifiStep, Token } from '@lifi/types';
-import BigNumber from 'bignumber.js';
-import { Signer } from 'ethers';
-import { ChainId } from '../types';
-export declare const sleep: (mills: number) => Promise<undefined>;
-export declare const personalizeStep: (signer: Signer, step: LifiStep) => Promise<LifiStep>;
-export declare const splitListIntoChunks: <T>(list: T[], chunkSize: number) => T[][];
-export declare const formatTokenAmountOnly: (token: Token, amount: string | BigNumber | undefined) => string;
+export declare const wait: (ms: number) => Promise<undefined>;
 /**
  * Repeatedly calls a given asynchronous function until it resolves with a value
  * @param toRepeat The function that should be repeated
@@ -14,12 +6,5 @@ export declare const formatTokenAmountOnly: (token: Token, amount: string | BigN
  * @returns The result of the toRepeat function
  */
 export declare const repeatUntilDone: <T>(toRepeat: () => Promise<T | undefined>, timeout?: number) => Promise<T>;
-/**
- * Loads a transaction receipt using the rpc for the given chain id
- * @param chainId The chain id where the transaction should be loaded from
- * @param txHash The hash of the transaction
- * @returns TransactionReceipt
- */
-export declare const loadTransactionReceipt: (chainId: ChainId, txHash: string) => Promise<TransactionReceipt>;
 export declare const isZeroAddress: (address: string) => boolean;
 export declare const isNativeTokenAddress: (address: string) => boolean;