@lifi/sdk 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/cjs/request.d.ts

@@ -0,0 +1,9 @@
+export declare const requestSettings: {
+    retries: number;
+};
+interface ExtendedRequestInit extends RequestInit {
+    retries?: number;
+    skipTrackingHeaders?: boolean;
+}
+export declare const request: <T = Response>(url: RequestInfo | URL, options?: ExtendedRequestInit) => Promise<T>;
+export {};

package/dist/cjs/request.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.request = exports.requestSettings = void 0;
+const ConfigService_1 = __importDefault(require("./services/ConfigService"));
+const errors_1 = require("./utils/errors");
+const utils_1 = require("./utils/utils");
+const version_1 = require("./version");
+exports.requestSettings = {
+    retries: 1,
+};
+const request = async (url, options = {
+    retries: exports.requestSettings.retries,
+}) => {
+    const { userId, integrator, widgetVersion } = ConfigService_1.default.getInstance().getConfig();
+    options.retries = options.retries ?? exports.requestSettings.retries;
+    try {
+        if (!options.skipTrackingHeaders) {
+            if (userId) {
+                options.headers = {
+                    ...options?.headers,
+                    'X-LIFI-UserId': userId,
+                };
+            }
+            if (widgetVersion) {
+                options.headers = {
+                    ...options?.headers,
+                    'X-LIFI-Widget': widgetVersion,
+                };
+            }
+            if (version_1.version) {
+                options.headers = {
+                    ...options?.headers,
+                    'X-LIFI-SDK': version_1.version,
+                };
+            }
+            // integrator is mandatory during SDK initialization
+            options.headers = {
+                ...options?.headers,
+                'X-LIFI-Integrator': integrator,
+            };
+        }
+        const response = await fetch(url, options);
+        if (!response.ok) {
+            throw new errors_1.HTTPError(response);
+        }
+        const data = await response.json();
+        return data;
+    }
+    catch (error) {
+        if (options.retries > 0 && error?.status === 500) {
+            await (0, utils_1.sleep)(500);
+            return (0, exports.request)(url, { ...options, retries: options.retries - 1 });
+        }
+        throw error;
+    }
+};
+exports.request = request;

package/dist/cjs/services/ApiService.d.ts

@@ -1,16 +1,17 @@
-import { ContractCallQuoteRequest, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
-import { ChainId, ChainKey, ExtendedChain, PossibilitiesRequest, PossibilitiesResponse, RoutesRequest, RoutesResponse, StatusResponse, Step, Token, ToolsRequest, ToolsResponse } from '../types';
+import { ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
+import { ChainId, ChainKey, ExtendedChain, PossibilitiesRequest, PossibilitiesResponse, RoutesRequest, RoutesResponse, StatusResponse, Token, ToolsRequest, ToolsResponse } from '../types';
 declare const _default: {
     getChains: (options?: RequestOptions | undefined) => Promise<ExtendedChain[]>;
-    getContractCallQuote: (requestConfig: ContractCallQuoteRequest, options?: RequestOptions | undefined) => Promise<Step>;
+    getContractCallQuote: (requestConfig: ContractCallQuoteRequest, options?: RequestOptions | undefined) => Promise<LifiStep>;
     getGasRecommendation: ({ chainId, fromChain, fromToken }: GasRecommendationRequest, options?: RequestOptions | undefined) => Promise<GasRecommendationResponse>;
     getPossibilities: (requestConfig?: PossibilitiesRequest | undefined, options?: RequestOptions | undefined) => Promise<PossibilitiesResponse>;
-    getQuote: (requestConfig: QuoteRequest, options?: RequestOptions | undefined) => Promise<Step>;
+    getQuote: (requestConfig: QuoteRequest, options?: RequestOptions | undefined) => Promise<LifiStep>;
     getRoutes: (requestConfig: RoutesRequest, options?: RequestOptions | undefined) => Promise<RoutesResponse>;
-    getStatus: ({ bridge, fromChain, toChain, txHash }: GetStatusRequest, options?: RequestOptions | undefined) => Promise<StatusResponse>;
-    getStepTransaction: (step: Step, options?: RequestOptions | undefined) => Promise<Step>;
-    getToken: (chain: ChainKey | ChainId, token: string, options?: RequestOptions | undefined) => Promise<Token>;
+    getStatus: (requestConfig: GetStatusRequest, options?: RequestOptions | undefined) => Promise<StatusResponse>;
+    getStepTransaction: (step: LifiStep, options?: RequestOptions | undefined) => Promise<LifiStep>;
+    getToken: (chain: ChainId | ChainKey, token: string, options?: RequestOptions | undefined) => Promise<Token>;
     getTokens: (requestConfig?: TokensRequest | undefined, options?: RequestOptions | undefined) => Promise<TokensResponse>;
     getTools: (requestConfig?: ToolsRequest | undefined, options?: RequestOptions | undefined) => Promise<ToolsResponse>;
+    getAvailableConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;
 };
 export default _default;

package/dist/cjs/services/ApiService.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const helpers_1 = require("../helpers");
+const request_1 = require("../request");
 const typeguards_1 = require("../typeguards");
 const errors_1 = require("../utils/errors");
 const parseError_1 = require("../utils/parseError");
@@ -24,7 +24,7 @@ const getPossibilities = async (requestConfig, options) => {
     }
     // send request
     try {
-        const response = await (0, helpers_1.request)(`${config.apiUrl}/advanced/possibilities`, {
+        const response = await (0, request_1.request)(`${config.apiUrl}/advanced/possibilities`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -47,7 +47,7 @@ const getToken = async (chain, token, options) => {
     }
     const config = ConfigService_1.default.getInstance().getConfig();
     try {
-        const response = await (0, helpers_1.request)(`${config.apiUrl}/token?${new URLSearchParams({
+        const response = await (0, request_1.request)(`${config.apiUrl}/token?${new URLSearchParams({
             chain,
             token,
         })}`, {
@@ -100,7 +100,7 @@ const getQuote = async (requestConfig, options) => {
     Object.keys(requestConfig).forEach((key) => !requestConfig[key] &&
         delete requestConfig[key]);
     try {
-        const response = await (0, helpers_1.request)(`${config.apiUrl}/quote?${new URLSearchParams(requestConfig)}`, {
+        const response = await (0, request_1.request)(`${config.apiUrl}/quote?${new URLSearchParams(requestConfig)}`, {
             signal: options?.signal,
         });
         return response;
@@ -152,7 +152,7 @@ const getContractCallQuote = async (requestConfig, options) => {
             config.defaultRouteOptions.exchanges?.prefer;
     // send request
     try {
-        const response = await (0, helpers_1.request)(`${config.apiUrl}/quote/contractCall`, {
+        const response = await (0, request_1.request)(`${config.apiUrl}/quote/contractCall`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -166,27 +166,14 @@ const getContractCallQuote = async (requestConfig, options) => {
         throw await (0, parseError_1.parseBackendError)(e);
     }
 };
-const getStatus = async ({ bridge, fromChain, toChain, txHash }, options) => {
-    if (fromChain !== toChain && !bridge) {
-        throw new errors_1.ValidationError('Parameter "bridge" is required for cross chain transfers.');
-    }
-    if (!fromChain) {
-        throw new errors_1.ValidationError('Required parameter "fromChain" is missing.');
-    }
-    if (!toChain) {
-        throw new errors_1.ValidationError('Required parameter "toChain" is missing.');
-    }
-    if (!txHash) {
+const getStatus = async (requestConfig, options) => {
+    if (!requestConfig.txHash) {
         throw new errors_1.ValidationError('Required parameter "txHash" is missing.');
     }
     const config = ConfigService_1.default.getInstance().getConfig();
+    const queryParams = new URLSearchParams(requestConfig);
     try {
-        const response = await (0, helpers_1.request)(`${config.apiUrl}/status?${new URLSearchParams({
-            bridge,
-            fromChain,
-            toChain,
-            txHash,
-        })}`, {
+        const response = await (0, request_1.request)(`${config.apiUrl}/status?${queryParams}`, {
             signal: options?.signal,
         });
         return response;
@@ -198,7 +185,7 @@ const getStatus = async ({ bridge, fromChain, toChain, txHash }, options) => {
 const getChains = async (options) => {
     const config = ConfigService_1.default.getInstance().getConfig();
     try {
-        const response = await (0, helpers_1.request)(`${config.apiUrl}/chains`, {
+        const response = await (0, request_1.request)(`${config.apiUrl}/chains`, {
             signal: options?.signal,
         });
         return response.chains;
@@ -219,7 +206,7 @@ const getRoutes = async (requestConfig, options) => {
     };
     // send request
     try {
-        const response = await (0, helpers_1.request)(`${config.apiUrl}/advanced/routes`, {
+        const response = await (0, request_1.request)(`${config.apiUrl}/advanced/routes`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -241,7 +228,7 @@ const getStepTransaction = async (step, options) => {
     }
     const config = ConfigService_1.default.getInstance().getConfig();
     try {
-        const response = await (0, helpers_1.request)(`${config.apiUrl}/advanced/stepTransaction`, {
+        const response = await (0, request_1.request)(`${config.apiUrl}/advanced/stepTransaction`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -261,7 +248,7 @@ const getTools = async (requestConfig, options) => {
         Object.keys(requestConfig).forEach((key) => !requestConfig[key] &&
             delete requestConfig[key]);
     }
-    const response = await (0, helpers_1.request)(`${config.apiUrl}/tools?${new URLSearchParams(requestConfig)}`, {
+    const response = await (0, request_1.request)(`${config.apiUrl}/tools?${new URLSearchParams(requestConfig)}`, {
         signal: options?.signal,
     });
     return response;
@@ -272,7 +259,7 @@ const getTokens = async (requestConfig, options) => {
         Object.keys(requestConfig).forEach((key) => !requestConfig[key] &&
             delete requestConfig[key]);
     }
-    const response = await (0, helpers_1.request)(`${config.apiUrl}/tokens?${new URLSearchParams(requestConfig)}`, {
+    const response = await (0, request_1.request)(`${config.apiUrl}/tokens?${new URLSearchParams(requestConfig)}`, {
         signal: options?.signal,
     });
     return response;
@@ -282,11 +269,15 @@ const getGasRecommendation = async ({ chainId, fromChain, fromToken }, options)
     if (!chainId) {
         throw new errors_1.ValidationError('Required parameter "chainId" is missing.');
     }
+    const url = new URL(`${config.apiUrl}/gas/suggestion/${chainId}`);
+    if (fromChain) {
+        url.searchParams.append('fromChain', fromChain);
+    }
+    if (fromToken) {
+        url.searchParams.append('fromToken', fromToken);
+    }
     try {
-        const response = await (0, helpers_1.request)(`${config.apiUrl}/gas/suggestion/${chainId}?${new URLSearchParams({
-            fromChain,
-            fromToken,
-        })}`, {
+        const response = await (0, request_1.request)(url, {
             signal: options?.signal,
         });
         return response;
@@ -295,6 +286,35 @@ const getGasRecommendation = async ({ chainId, fromChain, fromToken }, options)
         throw await (0, parseError_1.parseBackendError)(e);
     }
 };
+const getAvailableConnections = async (connectionRequest) => {
+    const config = ConfigService_1.default.getInstance().getConfig();
+    const url = new URL(`${config.apiUrl}/connections`);
+    const { fromChain, fromToken, toChain, toToken, allowBridges } = connectionRequest;
+    if (fromChain) {
+        url.searchParams.append('fromChain', fromChain);
+    }
+    if (fromToken) {
+        url.searchParams.append('fromToken', fromToken);
+    }
+    if (toChain) {
+        url.searchParams.append('fromToken', toChain);
+    }
+    if (toToken) {
+        url.searchParams.append('fromToken', toToken);
+    }
+    if (allowBridges?.length) {
+        allowBridges.forEach((bridge) => {
+            url.searchParams.append('allowBridges', bridge);
+        });
+    }
+    try {
+        const response = await (0, request_1.request)(url);
+        return response;
+    }
+    catch (e) {
+        throw await (0, parseError_1.parseBackendError)(e);
+    }
+};
 exports.default = {
     getChains,
     getContractCallQuote,
@@ -307,4 +327,5 @@ exports.default = {
     getToken,
     getTokens,
     getTools,
+    getAvailableConnections,
 };

package/dist/cjs/services/ConfigService.js

@@ -5,7 +5,6 @@ const DefaultExecutionSettings = {
     /* eslint-disable-next-line @typescript-eslint/no-empty-function */
     updateCallback: () => { },
     switchChainHook: () => Promise.resolve(undefined),
-    acceptSlippageUpdateHook: () => Promise.resolve(undefined),
     acceptExchangeRateUpdateHook: () => Promise.resolve(undefined),
     infiniteApproval: false,
     executeInBackground: false,
@@ -39,6 +38,10 @@ class ConfigService {
             this.config.defaultExecutionSettings = Object.assign(this.config.defaultExecutionSettings, configUpdate.defaultExecutionSettings);
             // OPTIONS
             this.config.defaultRouteOptions = Object.assign(this.config.defaultRouteOptions, configUpdate.defaultRouteOptions);
+            this.config.userId = configUpdate.userId || this.config.userId;
+            this.config.integrator = configUpdate.integrator || this.config.integrator;
+            this.config.widgetVersion =
+                configUpdate.widgetVersion || this.config.widgetVersion;
             return this.config;
         };
         this.updateChains = (chains) => {
@@ -78,7 +81,6 @@ class ConfigService {
         return this.instance;
     }
 }
-exports.default = ConfigService;
 ConfigService.getDefaultConfig = () => {
     return {
         apiUrl: 'https://li.quest/v1',
@@ -88,5 +90,7 @@ ConfigService.getDefaultConfig = () => {
         defaultRouteOptions: {
             integrator: 'lifi-sdk',
         },
+        integrator: 'lifi-sdk',
     };
 };
+exports.default = ConfigService;

package/dist/cjs/typeguards.d.ts

@@ -1,4 +1,4 @@
-import { RoutesRequest, Step, Token } from './types';
+import { LifiStep, RoutesRequest, Token } from './types';
 export declare const isRoutesRequest: (routesRequest: RoutesRequest) => routesRequest is RoutesRequest;
-export declare const isStep: (step: Step) => step is Step;
+export declare const isStep: (step: LifiStep) => step is LifiStep;
 export declare const isToken: (token: Token) => token is Token;

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

@@ -1,4 +1,5 @@
-import { Route, RouteOptions, Step, Token } from '@lifi/types';
+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 '.';
@@ -18,11 +19,12 @@ export type ParsedReceipt = {
 };
 export interface ExecutionParams {
     signer: Signer;
-    step: Step;
+    step: LifiStep;
     statusManager: StatusManager;
     settings: InternalExecutionSettings;
 }
 export type CallbackFunction = (updatedRoute: Route) => void;
+export type TxRequestCallbackFunction = (updatedTxRequest: TransactionRequest) => Promise<TransactionRequest>;
 export type Config = {
     apiUrl: string;
     rpcs: Record<ChainId, string[]>;
@@ -30,6 +32,9 @@ export type Config = {
     defaultExecutionSettings: InternalExecutionSettings;
     defaultRouteOptions: RouteOptions;
     disableVersionCheck?: boolean;
+    userId?: string;
+    integrator: string;
+    widgetVersion?: string;
 };
 export type ConfigUpdate = {
     apiUrl?: string;
@@ -38,6 +43,9 @@ export type ConfigUpdate = {
     defaultExecutionSettings?: ExecutionSettings;
     defaultRouteOptions?: RouteOptions;
     disableVersionCheck?: boolean;
+    userId?: string;
+    integrator: string;
+    widgetVersion?: string;
 };
 export type SwitchChainHook = (requiredChainId: number) => Promise<Signer | undefined>;
 export interface AcceptSlippageUpdateHookParams {
@@ -54,7 +62,7 @@ export interface ExchangeRateUpdateParams {
     newToAmount: string;
 }
 export type AcceptExchangeRateUpdateHook = (params: ExchangeRateUpdateParams) => Promise<boolean | undefined>;
-export interface ExecutionData {
+export interface RouteExecutionData {
     route: Route;
     executors: StepExecutor[];
     settings: InternalExecutionSettings;
@@ -63,20 +71,16 @@ export type ExecutionSettings = Partial<InternalExecutionSettings>;
 export interface InternalExecutionSettings {
     updateCallback: CallbackFunction;
     switchChainHook: SwitchChainHook;
-    acceptSlippageUpdateHook: AcceptSlippageUpdateHook;
     acceptExchangeRateUpdateHook: AcceptExchangeRateUpdateHook;
     infiniteApproval: boolean;
     executeInBackground: boolean;
+    updateTransactionRequest?: TxRequestCallbackFunction;
 }
 export type EnforcedObjectProperties<T> = T & {
     [P in keyof T]-?: T[P];
 };
-export interface ActiveRouteDictionary {
-    [k: string]: {
-        executionData: ExecutionData;
-        executionPromise: Promise<Route>;
-    };
-}
+export type RouteExecutionDictionary = Partial<Record<string, RouteExecutionData>>;
+export type RouteExecutionPromiseDictionary = Partial<Record<string, Promise<Route>>>;
 export type RevokeTokenData = {
     token: Token;
     approvalAddress: string;
@@ -86,3 +90,43 @@ export interface InteractionSettings {
     allowUpdates?: boolean;
     stopExecution?: boolean;
 }
+export interface TenderlyResponse {
+    hash: string;
+    block_hash: string;
+    block_number: number;
+    from: string;
+    gas: number;
+    gas_price: number;
+    gas_fee_cap: number;
+    gas_tip_cap: number;
+    cumulative_gas_used: number;
+    gas_used: number;
+    effective_gas_price: number;
+    input: string;
+    nonce: number;
+    to: string;
+    index: number;
+    value: string;
+    access_list: any;
+    status: boolean;
+    addresses: string[];
+    contract_ids: string[];
+    network_id: string;
+    timestamp: string;
+    function_selector: string;
+    l1_block_number: number;
+    l1_timestamp: number;
+    deposit_tx: boolean;
+    system_tx: boolean;
+    mint: number;
+    sig: Signature;
+    error_message: string;
+    method: string;
+    decoded_input: any;
+    call_trace: any;
+}
+export interface Signature {
+    v: string;
+    r: string;
+    s: string;
+}

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

@@ -22,7 +22,26 @@ export declare enum LifiErrorCode {
     TransactionCanceled = 1010,
     SlippageError = 1011,
     TransactionRejected = 1012,
-    BalanceError = 1013
+    BalanceError = 1013,
+    AllowanceRequired = 1014
+}
+export declare enum EthersErrorType {
+    CallExecption = "CALL_EXCEPTION",
+    ActionRejected = "ACTION_REJECTED"
+}
+export declare enum EthersErrorMessage {
+    ERC20Allowance = "ERC20: transfer amount exceeds allowance",
+    LowGas = "intrinsic gas too low",
+    OutOfGas = "out of gas",
+    Underpriced = "underpriced",
+    LowReplacementFee = "replacement fee too low"
+}
+export declare enum ErrorMessage {
+    UnknownError = "Unknown error occurred.",
+    SlippageError = "The slippage is larger than the defined threshold. Please request a new route to get a fresh quote.",
+    GasLimitLow = "Gas limit is too low.",
+    TransactionUnderpriced = "Transaction is underpriced.",
+    Default = "Something went wrong."
 }
 export declare enum MetaMaskRPCErrorCode {
     invalidInput = -32000,

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.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";
@@ -28,7 +28,29 @@ var LifiErrorCode;
     LifiErrorCode[LifiErrorCode["SlippageError"] = 1011] = "SlippageError";
     LifiErrorCode[LifiErrorCode["TransactionRejected"] = 1012] = "TransactionRejected";
     LifiErrorCode[LifiErrorCode["BalanceError"] = 1013] = "BalanceError";
+    LifiErrorCode[LifiErrorCode["AllowanceRequired"] = 1014] = "AllowanceRequired";
 })(LifiErrorCode = exports.LifiErrorCode || (exports.LifiErrorCode = {}));
+var EthersErrorType;
+(function (EthersErrorType) {
+    EthersErrorType["CallExecption"] = "CALL_EXCEPTION";
+    EthersErrorType["ActionRejected"] = "ACTION_REJECTED";
+})(EthersErrorType = exports.EthersErrorType || (exports.EthersErrorType = {}));
+var EthersErrorMessage;
+(function (EthersErrorMessage) {
+    EthersErrorMessage["ERC20Allowance"] = "ERC20: transfer amount exceeds allowance";
+    EthersErrorMessage["LowGas"] = "intrinsic gas too low";
+    EthersErrorMessage["OutOfGas"] = "out of gas";
+    EthersErrorMessage["Underpriced"] = "underpriced";
+    EthersErrorMessage["LowReplacementFee"] = "replacement fee too low";
+})(EthersErrorMessage = exports.EthersErrorMessage || (exports.EthersErrorMessage = {}));
+var ErrorMessage;
+(function (ErrorMessage) {
+    ErrorMessage["UnknownError"] = "Unknown error occurred.";
+    ErrorMessage["SlippageError"] = "The slippage is larger than the defined threshold. Please request a new route to get a fresh quote.";
+    ErrorMessage["GasLimitLow"] = "Gas limit is too low.";
+    ErrorMessage["TransactionUnderpriced"] = "Transaction is underpriced.";
+    ErrorMessage["Default"] = "Something went wrong.";
+})(ErrorMessage = exports.ErrorMessage || (exports.ErrorMessage = {}));
 var MetaMaskRPCErrorCode;
 (function (MetaMaskRPCErrorCode) {
     MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["invalidInput"] = -32000] = "invalidInput";

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

@@ -1,4 +1,4 @@
-import { Process, Step } from '@lifi/types';
+import { LifiStep, Process } from '@lifi/types';
 import { LifiError } from './errors';
 /**
  * Available MetaMask error codes:
@@ -31,7 +31,7 @@ import { LifiError } from './errors';
  * https://eips.ethereum.org/EIPS/eip-1474#error-codes
  * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
  */
-export declare const getTransactionNotSentMessage: (step?: Step, process?: Process) => Promise<string>;
-export declare const getTransactionFailedMessage: (step: Step, txLink?: string) => Promise<string>;
-export declare const parseError: (e: any, step?: Step, process?: Process) => Promise<LifiError>;
+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>;

package/dist/cjs/utils/parseError.js

@@ -8,6 +8,7 @@ const eth_rpc_errors_1 = require("eth-rpc-errors");
 const ChainsService_1 = __importDefault(require("../services/ChainsService"));
 const errors_1 = require("./errors");
 const utils_1 = require("./utils");
+const helpers_1 = require("../helpers");
 /**
  * Available MetaMask error codes:
  *
@@ -79,13 +80,13 @@ const parseError = async (e, step, process) => {
                 // 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('underpriced') ||
-                        e.message?.includes('replacement fee too low'))) {
-                    return new errors_1.RPCError(errors_1.LifiErrorCode.TransactionUnderpriced, 'Transaction is underpriced.', await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+                    (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('intrinsic gas too low') ||
-                    e.message?.includes('out of gas')) {
-                    return new errors_1.TransactionError(errors_1.LifiErrorCode.GasLimitError, 'Gas limit is too low.', 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);
             }
@@ -96,9 +97,25 @@ const parseError = async (e, step, process) => {
         }
     }
     switch (e.code) {
-        case 'CALL_EXCEPTION':
-            return new errors_1.ProviderError(errors_1.LifiErrorCode.TransactionFailed, e.reason, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-        case 'ACTION_REJECTED':
+        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.');
+                }
+                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);
+                }
+                // 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);
+            }
+        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:
@@ -106,7 +123,7 @@ const parseError = async (e, step, process) => {
         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 || 'Unknown error occurred.', undefined, e.stack);
+            return new errors_1.UnknownError(errors_1.LifiErrorCode.InternalError, e.message || errors_1.ErrorMessage.UnknownError, undefined, e.stack);
     }
 };
 exports.parseError = parseError;
@@ -125,11 +142,11 @@ const parseBackendError = async (e) => {
         return new errors_1.NotFoundError(data?.message || e.response?.statusText, undefined, e.stack);
     }
     if (e.response?.status === 409) {
-        return new errors_1.SlippageError(data?.message || e.response?.statusText, 'The slippage is larger than the defined threshold. Please request a new route to get a fresh quote.', e.stack);
+        return new errors_1.SlippageError(data?.message || e.response?.statusText, errors_1.ErrorMessage.SlippageError, e.stack);
     }
     if (e.response?.status === 500) {
         return new errors_1.ServerError(data?.message || e.response?.statusText, undefined, e.stack);
     }
-    return new errors_1.ServerError('Something went wrong.', undefined, e.stack);
+    return new errors_1.ServerError(errors_1.ErrorMessage.Default, undefined, e.stack);
 };
 exports.parseBackendError = parseBackendError;

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

@@ -1,10 +1,10 @@
 import { TransactionReceipt } from '@ethersproject/providers';
-import { Token } from '@lifi/types';
+import { LifiStep, Token } from '@lifi/types';
 import BigNumber from 'bignumber.js';
 import { Signer } from 'ethers';
-import { ChainId, Step } from '../types';
+import { ChainId } from '../types';
 export declare const sleep: (mills: number) => Promise<undefined>;
-export declare const personalizeStep: (signer: Signer, step: Step) => Promise<Step>;
+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;
 /**

package/dist/cjs/version.d.ts

@@ -1,2 +1,2 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "2.0.0-beta.1";
+export declare const version = "2.0.0-beta.11";

package/dist/cjs/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = exports.name = void 0;
 exports.name = '@lifi/sdk';
-exports.version = '2.0.0-beta.1';
+exports.version = '2.0.0-beta.11';

package/dist/connectors.d.ts

@@ -1,5 +1,5 @@
-import { ChainId } from './types';
 import { FallbackProvider } from '@ethersproject/providers';
+import { ChainId } from './types';
 export declare const getRpcUrl: (chainId: ChainId, archive?: boolean) => Promise<string>;
 export declare const getRpcUrls: (chainId: ChainId, archive?: boolean) => Promise<string[]>;
 export declare const getRpcProvider: (chainId: number, archive?: boolean) => Promise<FallbackProvider>;