@lifi/sdk 2.2.3 → 3.0.0-alpha.2

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

@@ -1,30 +1,27 @@
-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 { ChainId, LifiStep, Route, RouteOptions, Token } from '@lifi/types';
+import type { Hash, Hex, WalletClient } from 'viem';
+import type { StatusManager } from '../execution/StatusManager';
+import type { StepExecutor } from '../execution/StepExecutor';
+export type TransactionParameters = {
+    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;
 }
 export type UpdateRouteHook = (updatedRoute: Route) => void;
-export type TransactionRequestUpdateHook = (updatedTxRequest: TransactionRequest) => Promise<TransactionRequest>;
+export type TransactionRequestUpdateHook = (updatedTxRequest: TransactionParameters) => Promise<TransactionParameters>;
 export type Config = {
     apiUrl: string;
     rpcs: Record<ChainId, string[]>;
@@ -35,24 +32,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 +64,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 +95,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/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/utils/errors.js

@@ -9,25 +9,26 @@ var ErrorType;
     ErrorType["UnknownError"] = "UnknownError";
     ErrorType["SlippageError"] = "SlippageError";
 })(ErrorType || (ErrorType = {}));
-export 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 || (LifiErrorCode = {}));
+export 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 || (LiFiErrorCode = {}));
 export var EthersErrorType;
 (function (EthersErrorType) {
     EthersErrorType["ActionRejected"] = "ACTION_REJECTED";
@@ -72,11 +73,11 @@ export var MetaMaskProviderErrorCode;
     MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["disconnected"] = 4900] = "disconnected";
     MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["chainDisconnected"] = 4901] = "chainDisconnected";
 })(MetaMaskProviderErrorCode || (MetaMaskProviderErrorCode = {}));
-export class LifiError extends Error {
+export 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();
@@ -87,47 +88,47 @@ export class LifiError extends Error {
         }
     }
 }
-export class RPCError extends LifiError {
+export class RPCError extends LiFiError {
     constructor(code, message, htmlMessage, stack) {
         super(ErrorType.RPCError, code, message, htmlMessage, stack);
     }
 }
-export class ProviderError extends LifiError {
+export class ProviderError extends LiFiError {
     constructor(code, message, htmlMessage, stack) {
         super(ErrorType.ProviderError, code, message, htmlMessage, stack);
     }
 }
-export class ServerError extends LifiError {
+export class ServerError extends LiFiError {
     constructor(message, htmlMessage, stack) {
-        super(ErrorType.ServerError, LifiErrorCode.InternalError, message, htmlMessage, stack);
+        super(ErrorType.ServerError, LiFiErrorCode.InternalError, message, htmlMessage, stack);
     }
 }
-export class ValidationError extends LifiError {
+export class ValidationError extends LiFiError {
     constructor(message, htmlMessage, stack) {
-        super(ErrorType.ValidationError, LifiErrorCode.ValidationError, message, htmlMessage, stack);
+        super(ErrorType.ValidationError, LiFiErrorCode.ValidationError, message, htmlMessage, stack);
     }
 }
-export class TransactionError extends LifiError {
+export class TransactionError extends LiFiError {
     constructor(code, message, htmlMessage, stack) {
         super(ErrorType.TransactionError, code, message, htmlMessage, stack);
     }
 }
-export class SlippageError extends LifiError {
+export class SlippageError extends LiFiError {
     constructor(message, htmlMessage, stack) {
-        super(ErrorType.SlippageError, LifiErrorCode.SlippageError, message, htmlMessage, stack);
+        super(ErrorType.SlippageError, LiFiErrorCode.SlippageError, message, htmlMessage, stack);
     }
 }
-export class BalanceError extends LifiError {
+export class BalanceError extends LiFiError {
     constructor(message, htmlMessage, stack) {
-        super(ErrorType.ValidationError, LifiErrorCode.BalanceError, message, htmlMessage, stack);
+        super(ErrorType.ValidationError, LiFiErrorCode.BalanceError, message, htmlMessage, stack);
     }
 }
-export class NotFoundError extends LifiError {
+export class NotFoundError extends LiFiError {
     constructor(message, htmlMessage, stack) {
-        super(ErrorType.NotFoundError, LifiErrorCode.NotFound, message, htmlMessage, stack);
+        super(ErrorType.NotFoundError, LiFiErrorCode.NotFound, message, htmlMessage, stack);
     }
 }
-export class UnknownError extends LifiError {
+export class UnknownError extends LiFiError {
     constructor(code, message, htmlMessage, stack) {
         super(ErrorType.UnknownError, code, message, htmlMessage, stack);
     }

package/dist/utils/getMaxPriorityFeePerGas.d.ts

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

package/dist/utils/getMaxPriorityFeePerGas.js

@@ -0,0 +1,18 @@
+import { median } from './median';
+export 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 = median(maxPriorityFeePerGasList) ?? 0n;
+    const maxPriorityFeePerGasAvg = maxPriorityFeePerGasSum / BigInt(maxPriorityFeePerGasList.length);
+    return maxPriorityFeePerGasMedian > maxPriorityFeePerGasAvg
+        ? maxPriorityFeePerGasAvg
+        : maxPriorityFeePerGasMedian;
+};

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

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

package/dist/utils/median.d.ts

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

package/dist/utils/median.js

@@ -0,0 +1,11 @@
+export 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];
+};

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

@@ -1,8 +1,8 @@
 import { errorCodes as MetaMaskErrorCodes, getMessageFromCode, } from 'eth-rpc-errors';
+import { formatUnits } from 'viem';
 import { fetchTxErrorDetails } from '../helpers';
 import ChainsService from '../services/ChainsService';
-import { ErrorMessage, EthersErrorMessage, EthersErrorType, LifiError, LifiErrorCode, MetaMaskProviderErrorCode, NotFoundError, ProviderError, RPCError, ServerError, SlippageError, TransactionError, UnknownError, ValidationError, } from './errors';
-import { formatTokenAmountOnly } from './utils';
+import { ErrorMessage, EthersErrorMessage, EthersErrorType, LiFiError, LiFiErrorCode, MetaMaskProviderErrorCode, NotFoundError, ProviderError, RPCError, ServerError, SlippageError, TransactionError, UnknownError, ValidationError, } from './errors';
 /**
  * Available MetaMask error codes:
  *
@@ -40,7 +40,7 @@ export const getTransactionNotSentMessage = async (step, process) => {
     if (step) {
         const chainService = ChainsService.getInstance();
         const chain = await chainService.getChainById(step.action.fromChainId);
-        transactionNotSend += ` (${formatTokenAmountOnly(step.action.fromToken, step.action.fromAmount)} ${step.action.fromToken.symbol} on ${chain.name})`;
+        transactionNotSend += ` (${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.";
@@ -62,62 +62,65 @@ export const getTransactionFailedMessage = async (step, txLink) => {
         : baseString;
 };
 export const parseError = async (e, step, process) => {
-    if (e instanceof LifiError) {
+    if (e instanceof LiFiError) {
         return e;
     }
-    if (e.code) {
-        // MetaMask errors have a numeric error code
-        if (typeof e.code === 'number') {
-            if (Object.values(MetaMaskErrorCodes.rpc).includes(e.code)) {
-                // rpc errors
-                // underpriced errors are sent as internal errors, so we need to parse the message manually
-                if (e.code === MetaMaskErrorCodes.rpc.internal &&
-                    (e.message?.includes(EthersErrorMessage.Underpriced) ||
-                        e.message?.includes(EthersErrorMessage.LowReplacementFee))) {
-                    return new RPCError(LifiErrorCode.TransactionUnderpriced, ErrorMessage.TransactionUnderpriced, await getTransactionNotSentMessage(step, process), e.stack);
-                }
-                if (e.message?.includes(EthersErrorMessage.LowGas) ||
-                    e.message?.includes(EthersErrorMessage.OutOfGas)) {
-                    return new TransactionError(LifiErrorCode.GasLimitError, ErrorMessage.GasLimitLow, await getTransactionNotSentMessage(step, process), e.stack);
-                }
-                return new RPCError(e.code, getMessageFromCode(e.code), await getTransactionNotSentMessage(step, process), e.stack);
-            }
-            // provider errors
-            if (Object.values(MetaMaskErrorCodes.provider).includes(e.code)) {
-                return new ProviderError(e.code, getMessageFromCode(e.code), await getTransactionNotSentMessage(step, process), e.stack);
-            }
-        }
-    }
-    switch (e.code) {
+    const errorCode = e.code || e.cause?.code;
+    switch (errorCode) {
         case EthersErrorType.CallExecption:
             const defaultErrorMessage = await 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 fetchTxErrorDetails(e.transactionHash, step?.action.fromChainId);
                 const errorMessage = response?.error_message ?? e.reason;
                 const isAllowanceError = response?.error_message?.includes(EthersErrorMessage.ERC20Allowance) || e.reason?.includes(EthersErrorMessage.ERC20Allowance);
                 if (isAllowanceError) {
-                    return new TransactionError(LifiErrorCode.AllowanceRequired, e.reason, errorMessage, e.stack);
+                    return new TransactionError(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 ProviderError(LifiErrorCode.TransactionFailed, e.reason, defaultErrorMessage, e.stack);
+                return new ProviderError(LiFiErrorCode.TransactionFailed, e.reason, defaultErrorMessage, e.stack);
             }
         case EthersErrorType.InsufficientFunds:
-            return new TransactionError(LifiErrorCode.InsufficientFunds, e.message, await getTransactionNotSentMessage(step, process), e.stack);
+            return new TransactionError(LiFiErrorCode.InsufficientFunds, e.message, await getTransactionNotSentMessage(step, process), e.stack);
         case EthersErrorType.ActionRejected:
         case MetaMaskProviderErrorCode.userRejectedRequest:
-            return new TransactionError(LifiErrorCode.TransactionRejected, e.message, await getTransactionNotSentMessage(step, process), e.stack);
-        case LifiErrorCode.TransactionUnprepared:
-            return new TransactionError(LifiErrorCode.TransactionUnprepared, e.message, await getTransactionNotSentMessage(step, process), e.stack);
-        case LifiErrorCode.ValidationError:
-            return new TransactionError(LifiErrorCode.ValidationError, e.message, e.htmlMessage);
-        default:
-            return new UnknownError(LifiErrorCode.InternalError, e.message || ErrorMessage.UnknownError, undefined, e.stack);
+            return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, await getTransactionNotSentMessage(step, process), e.stack);
+        case LiFiErrorCode.TransactionUnprepared:
+            return new TransactionError(LiFiErrorCode.TransactionUnprepared, e.message, await getTransactionNotSentMessage(step, process), e.stack);
+        case LiFiErrorCode.ValidationError:
+            return new TransactionError(LiFiErrorCode.ValidationError, e.message, e.htmlMessage);
+        case LiFiErrorCode.TransactionCanceled:
+            return new TransactionError(LiFiErrorCode.TransactionCanceled, e.message, e.htmlMessage);
+        case LiFiErrorCode.ExchangeRateUpdateCanceled:
+            return new TransactionError(LiFiErrorCode.ExchangeRateUpdateCanceled, e.message, e.htmlMessage);
+        default: {
+            if (errorCode && typeof errorCode === 'number') {
+                if (Object.values(MetaMaskErrorCodes.rpc).includes(errorCode)) {
+                    // rpc errors
+                    // underpriced errors are sent as internal errors, so we need to parse the message manually
+                    if (errorCode === MetaMaskErrorCodes.rpc.internal &&
+                        (e.message?.includes(EthersErrorMessage.Underpriced) ||
+                            e.message?.includes(EthersErrorMessage.LowReplacementFee))) {
+                        return new RPCError(LiFiErrorCode.TransactionUnderpriced, ErrorMessage.TransactionUnderpriced, await getTransactionNotSentMessage(step, process), e.stack);
+                    }
+                    if (e.message?.includes(EthersErrorMessage.LowGas) ||
+                        e.message?.includes(EthersErrorMessage.OutOfGas)) {
+                        return new TransactionError(LiFiErrorCode.GasLimitError, ErrorMessage.GasLimitLow, await getTransactionNotSentMessage(step, process), e.stack);
+                    }
+                    return new RPCError(errorCode, getMessageFromCode(errorCode), await getTransactionNotSentMessage(step, process), e.stack);
+                }
+                // provider errors
+                if (Object.values(MetaMaskErrorCodes.provider).includes(errorCode)) {
+                    return new ProviderError(errorCode, getMessageFromCode(errorCode), await getTransactionNotSentMessage(step, process), e.stack);
+                }
+            }
+            return new UnknownError(LiFiErrorCode.InternalError, e.message || ErrorMessage.UnknownError, undefined, e.stack);
+        }
     }
 };
 export const parseBackendError = async (e) => {

package/dist/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;

package/dist/utils/utils.js

@@ -1,59 +1,9 @@
-import BigNumber from 'bignumber.js';
-import { constants } from 'ethers';
-import { getRpcProvider } from '../connectors';
-export const sleep = (mills) => {
+import { AddressZero, AlternativeAddressZero } from '../constants';
+export const wait = (ms) => {
     return new Promise((resolve) => {
-        setTimeout(resolve, mills);
+        setTimeout(resolve, ms);
     });
 };
-export const personalizeStep = async (signer, step) => {
-    if (step.action.toAddress && step.action.fromAddress) {
-        return step;
-    }
-    const address = await signer.getAddress();
-    const fromAddress = step.action.fromAddress || address;
-    const toAddress = step.action.toAddress || address;
-    return {
-        ...step,
-        action: {
-            ...step.action,
-            fromAddress,
-            toAddress,
-        },
-    };
-};
-export const splitListIntoChunks = (list, chunkSize) => list.reduce((resultList, item, index) => {
-    const chunkIndex = Math.floor(index / chunkSize);
-    if (!resultList[chunkIndex]) {
-        resultList[chunkIndex] = []; // start a new chunk
-    }
-    resultList[chunkIndex].push(item);
-    return resultList;
-}, []);
-export const formatTokenAmountOnly = (token, amount) => {
-    if (!amount) {
-        return '0.0';
-    }
-    let floated;
-    if (typeof amount === 'string') {
-        if (amount === '0') {
-            return '0.0';
-        }
-        floated = new BigNumber(amount).shiftedBy(-token.decimals);
-    }
-    else {
-        floated = amount;
-        if (floated.isZero()) {
-            return '0.0';
-        }
-    }
-    // show at least 4 decimal places and at least two non-zero digests
-    let decimalPlaces = 3;
-    while (floated.lt(1 / 10 ** decimalPlaces)) {
-        decimalPlaces++;
-    }
-    return floated.toFixed(decimalPlaces + 1, 1);
-};
 /**
  * Repeatedly calls a given asynchronous function until it resolves with a value
  * @param toRepeat The function that should be repeated
@@ -65,32 +15,20 @@ export const repeatUntilDone = async (toRepeat, timeout = 5000) => {
     while (!result) {
         result = await toRepeat();
         if (!result) {
-            await sleep(timeout);
+            await wait(timeout);
         }
     }
     return result;
 };
-/**
- * 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 const loadTransactionReceipt = async (chainId, txHash) => {
-    const rpc = await getRpcProvider(chainId);
-    const tx = await rpc.getTransaction(txHash);
-    return tx.wait();
-};
 export const isZeroAddress = (address) => {
-    if (address === constants.AddressZero ||
-        address === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee') {
+    if (address === AddressZero || address === AlternativeAddressZero) {
         return true;
     }
     return false;
 };
 export const isNativeTokenAddress = (address) => {
-    if (address === constants.AddressZero ||
-        address === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee' ||
+    if (address === AddressZero ||
+        address === AlternativeAddressZero ||
         // CELO native token
         address === '0x471ece3750da237f93b8e339c536989b8978a438') {
         return true;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "2.2.3";
+export declare const version = "3.0.0-alpha.2";

package/dist/version.js

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk';
-export const version = '2.2.3';
+export const version = '3.0.0-alpha.2';