@lifi/sdk 2.0.0-beta.8 → 2.0.0

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

@@ -22,7 +22,28 @@ export declare enum LifiErrorCode {
     TransactionCanceled = 1010,
     SlippageError = 1011,
     TransactionRejected = 1012,
-    BalanceError = 1013
+    BalanceError = 1013,
+    AllowanceRequired = 1014,
+    InsufficientFunds = 1015
+}
+export declare enum EthersErrorType {
+    ActionRejected = "ACTION_REJECTED",
+    CallExecption = "CALL_EXCEPTION",
+    InsufficientFunds = "INSUFFICIENT_FUNDS"
+}
+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,31 @@ var LifiErrorCode;
     LifiErrorCode[LifiErrorCode["SlippageError"] = 1011] = "SlippageError";
     LifiErrorCode[LifiErrorCode["TransactionRejected"] = 1012] = "TransactionRejected";
     LifiErrorCode[LifiErrorCode["BalanceError"] = 1013] = "BalanceError";
-})(LifiErrorCode = exports.LifiErrorCode || (exports.LifiErrorCode = {}));
+    LifiErrorCode[LifiErrorCode["AllowanceRequired"] = 1014] = "AllowanceRequired";
+    LifiErrorCode[LifiErrorCode["InsufficientFunds"] = 1015] = "InsufficientFunds";
+})(LifiErrorCode || (exports.LifiErrorCode = LifiErrorCode = {}));
+var EthersErrorType;
+(function (EthersErrorType) {
+    EthersErrorType["ActionRejected"] = "ACTION_REJECTED";
+    EthersErrorType["CallExecption"] = "CALL_EXCEPTION";
+    EthersErrorType["InsufficientFunds"] = "INSUFFICIENT_FUNDS";
+})(EthersErrorType || (exports.EthersErrorType = 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 = 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 = ErrorMessage = {}));
 var MetaMaskRPCErrorCode;
 (function (MetaMaskRPCErrorCode) {
     MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["invalidInput"] = -32000] = "invalidInput";
@@ -42,7 +66,7 @@ var MetaMaskRPCErrorCode;
     MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["methodNotFound"] = -32601] = "methodNotFound";
     MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["invalidParams"] = -32602] = "invalidParams";
     MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["internal"] = -32603] = "internal";
-})(MetaMaskRPCErrorCode = exports.MetaMaskRPCErrorCode || (exports.MetaMaskRPCErrorCode = {}));
+})(MetaMaskRPCErrorCode || (exports.MetaMaskRPCErrorCode = MetaMaskRPCErrorCode = {}));
 var MetaMaskProviderErrorCode;
 (function (MetaMaskProviderErrorCode) {
     MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["userRejectedRequest"] = 4001] = "userRejectedRequest";
@@ -50,7 +74,7 @@ var MetaMaskProviderErrorCode;
     MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["unsupportedMethod"] = 4200] = "unsupportedMethod";
     MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["disconnected"] = 4900] = "disconnected";
     MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["chainDisconnected"] = 4901] = "chainDisconnected";
-})(MetaMaskProviderErrorCode = exports.MetaMaskProviderErrorCode || (exports.MetaMaskProviderErrorCode = {}));
+})(MetaMaskProviderErrorCode || (exports.MetaMaskProviderErrorCode = MetaMaskProviderErrorCode = {}));
 class LifiError extends Error {
     constructor(type, code, message, htmlMessage, stack) {
         super(message);

package/dist/cjs/utils/parseError.js

@@ -5,6 +5,7 @@ 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 helpers_1 = require("../helpers");
 const ChainsService_1 = __importDefault(require("../services/ChainsService"));
 const errors_1 = require("./errors");
 const utils_1 = require("./utils");
@@ -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,27 @@ 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.InsufficientFunds:
+            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:
@@ -106,7 +125,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 +144,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/preRestart.d.ts

@@ -1,2 +1,3 @@
+import { Signer } from 'ethers';
 import { Route } from '../types';
-export declare const handlePreRestart: (route: Route) => void;
+export declare const handlePreRestart: (route: Route, signer: Signer) => Promise<void>;

package/dist/cjs/utils/preRestart.js

@@ -2,24 +2,45 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handlePreRestart = void 0;
 const errors_1 = require("./errors");
-const handlePreRestart = (route) => {
+const handlePreRestart = async (route, signer) => {
     for (let index = 0; index < route.steps.length; index++) {
         const stepHasFailed = route.steps[index].execution?.status === 'FAILED';
         if (stepHasFailed) {
-            handleErrorType(route, index);
+            await handleErrorType(route, index, signer);
             deleteFailedProcesses(route, index);
             deleteTransactionData(route, index);
         }
     }
 };
 exports.handlePreRestart = handlePreRestart;
-const handleErrorType = (route, index) => {
+const handleErrorType = async (route, index, signer) => {
     const isGasLimitError = route.steps[index].execution?.process.some((p) => p.error?.code === errors_1.LifiErrorCode.GasLimitError);
     const isGasPriceError = route.steps[index].execution?.process.some((p) => p.error?.code === errors_1.LifiErrorCode.TransactionUnderpriced);
+    const { transactionRequest } = route.steps[index];
     if (isGasLimitError) {
+        if (transactionRequest) {
+            let gasLimit = transactionRequest.gasLimit;
+            try {
+                gasLimit = await signer.estimateGas(transactionRequest);
+            }
+            catch (error) { }
+            if (gasLimit) {
+                transactionRequest.gasLimit = `${(BigInt(gasLimit.toString()) * 125n) / 100n}`;
+            }
+        }
         route.steps[index].estimate.gasCosts?.forEach((gasCost) => (gasCost.limit = `${Math.round(Number(gasCost.limit) * 1.25)}`));
     }
     if (isGasPriceError) {
+        if (transactionRequest) {
+            let gasPrice = transactionRequest.gasPrice;
+            try {
+                gasPrice = await signer.getGasPrice();
+            }
+            catch (error) { }
+            if (gasPrice) {
+                transactionRequest.gasPrice = `${(BigInt(gasPrice.toString()) * 125n) / 100n}`;
+            }
+        }
         route.steps[index].estimate.gasCosts?.forEach((gasCost) => (gasCost.price = `${Math.round(Number(gasCost.price) * 1.25)}`));
     }
 };

package/dist/cjs/version.d.ts

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

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.8';
+exports.version = '2.0.0';

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>;

package/dist/connectors.js

@@ -1,7 +1,7 @@
-import { providers } from 'ethers';
-import { ChainId } from './types';
-import ConfigService from './services/ConfigService';
+import { FallbackProvider, StaticJsonRpcProvider, } from '@ethersproject/providers';
 import { getRandomNumber } from './helpers';
+import ConfigService from './services/ConfigService';
+import { ChainId } from './types';
 import { ServerError } from './utils/errors';
 // cached providers
 const chainProviders = {};
@@ -33,17 +33,15 @@ const getRandomProvider = (providerList) => {
 export const getRpcProvider = async (chainId, archive = false) => {
     if (archive && archiveRpcs[chainId]) {
         // return archive PRC, but don't cache it
-        return new providers.FallbackProvider([
-            new providers.StaticJsonRpcProvider(await getRpcUrl(chainId, archive), chainId),
+        return new FallbackProvider([
+            new StaticJsonRpcProvider(await getRpcUrl(chainId, archive), chainId),
         ]);
     }
-    if (!chainProviders[chainId]) {
+    if (!chainProviders[chainId]?.length) {
         chainProviders[chainId] = [];
         const urls = await getRpcUrls(chainId, archive);
         urls.forEach((url) => {
-            chainProviders[chainId].push(new providers.FallbackProvider([
-                new providers.StaticJsonRpcProvider(url, chainId),
-            ]));
+            chainProviders[chainId].push(new FallbackProvider([new StaticJsonRpcProvider(url, chainId)]));
         });
     }
     if (!chainProviders[chainId].length) {

package/dist/execution/RouteExecutionManager.d.ts

@@ -6,7 +6,7 @@ export declare class RouteExecutionManager {
     private executionDictionary;
     private executionPromiseDictionary;
     protected configService: ConfigService;
-    constructor(configUpdate?: ConfigUpdate);
+    constructor(configUpdate: ConfigUpdate);
     /**
      * Execute a route.
      * @param {Signer} signer - The signer required to send the transactions.

package/dist/execution/RouteExecutionManager.js

@@ -50,7 +50,7 @@ export class RouteExecutionManager {
                     return executionPromise ?? clonedRoute;
                 }
             }
-            handlePreRestart(clonedRoute);
+            await handlePreRestart(clonedRoute, signer);
             const executionPromise = this.executeSteps(signer, clonedRoute, settings);
             this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
             return executionPromise;

package/dist/execution/StatusManager.js

@@ -133,7 +133,7 @@ export class StatusManager {
                 throw new Error("Couldn't find a step to update.");
             }
             this.route.steps[stepIndex] = Object.assign(this.route.steps[stepIndex], step);
-            this.settings.updateCallback(this.route);
+            this.settings.updateRouteHook(this.route);
             this.internalUpdateRouteCallback(this.route);
             return this.route.steps[stepIndex];
         };

package/dist/execution/StepExecutionManager.js

@@ -75,6 +75,28 @@ export class StepExecutionManager {
                         if (!this.allowUserInteraction) {
                             return step.execution;
                         }
+                        if (settings.updateTransactionRequestHook) {
+                            const customConfig = await settings.updateTransactionRequestHook(transactionRequest);
+                            transactionRequest.gasLimit = customConfig.gasLimit;
+                            transactionRequest.gasPrice = customConfig.gasPrice;
+                            transactionRequest.maxPriorityFeePerGas =
+                                customConfig.maxPriorityFeePerGas;
+                            transactionRequest.maxFeePerGas = customConfig.maxFeePerGas;
+                        }
+                        else {
+                            try {
+                                const estimatedGasLimit = await signer.estimateGas(transactionRequest);
+                                if (estimatedGasLimit) {
+                                    transactionRequest.gasLimit = `${(BigInt(estimatedGasLimit.toString()) * 125n) / 100n}`;
+                                }
+                                // Fetch latest gasPrice from provider and use it
+                                const gasPrice = await signer.getGasPrice();
+                                if (gasPrice) {
+                                    transactionRequest.gasPrice = gasPrice;
+                                }
+                            }
+                            catch (error) { }
+                        }
                         // Submit the transaction
                         transaction = await signer.sendTransaction(transactionRequest);
                         // STEP 4: Wait for the transaction

package/dist/execution/StepExecutor.js

@@ -28,12 +28,20 @@ export class StepExecutor {
         };
         this.executeStep = async (signer, step) => {
             // Make sure that the chain is still correct
-            const updatedSigner = await switchChain(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
-            if (!updatedSigner) {
-                // Chain switch was not successful, stop execution here
-                return step;
+            // Find if it's bridging and the step is waiting for a transaction on the receiving chain
+            const recievingChainProcess = step.execution?.process.find((process) => process.type === 'RECEIVING_CHAIN');
+            // If the step is waiting for a transaction on the receiving chain, we do not switch the chain
+            // All changes are already done from the source chain
+            // Return the step
+            if (recievingChainProcess?.substatus !== 'WAIT_DESTINATION_TRANSACTION' ||
+                !recievingChainProcess) {
+                const updatedSigner = await switchChain(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
+                if (!updatedSigner) {
+                    // Chain switch was not successful, stop execution here
+                    return step;
+                }
+                signer = updatedSigner;
             }
-            signer = updatedSigner;
             const parameters = {
                 signer,
                 step,

package/dist/execution/stepComparison.d.ts

@@ -8,7 +8,7 @@ import { InternalExecutionSettings, LifiStep } from '../types';
  * @param statusManager
  * @param oldStep
  * @param newStep
- * @param acceptSlippageUpdateHook
+ * @param settings
  * @param allowUserInteraction
  */
 export declare const stepComparison: (statusManager: StatusManager, oldStep: LifiStep, newStep: LifiStep, settings: InternalExecutionSettings, allowUserInteraction: boolean) => Promise<LifiStep>;

package/dist/execution/stepComparison.js

@@ -8,7 +8,7 @@ import { checkStepSlippageThreshold } from './utils';
  * @param statusManager
  * @param oldStep
  * @param newStep
- * @param acceptSlippageUpdateHook
+ * @param settings
  * @param allowUserInteraction
  */
 export const stepComparison = async (statusManager, oldStep, newStep, settings, allowUserInteraction) => {
@@ -16,15 +16,12 @@ export const stepComparison = async (statusManager, oldStep, newStep, settings,
     if (checkStepSlippageThreshold(oldStep, newStep)) {
         return statusManager.updateStepInRoute(newStep);
     }
-    const acceptExchangeRateUpdateHook = settings.acceptExchangeRateUpdateHook ?? settings.acceptSlippageUpdateHook;
     let allowStepUpdate;
     if (allowUserInteraction) {
-        allowStepUpdate = await acceptExchangeRateUpdateHook({
+        allowStepUpdate = await settings.acceptExchangeRateUpdateHook({
             oldToAmount: oldStep.estimate.toAmount,
             newToAmount: newStep.estimate.toAmount,
             toToken: newStep.action.toToken,
-            oldSlippage: oldStep.action.slippage,
-            newSlippage: newStep.action.slippage,
         });
     }
     if (!allowStepUpdate) {

package/dist/helpers.d.ts

@@ -1,4 +1,5 @@
 import { LifiStep, Route, Token } from '@lifi/types';
+import { TenderlyResponse } from './types';
 /**
  * Predefined hook that decrypts calldata using EIP-1193 compliant wallet functions.
  * @param {string} walletAddress - The wallet address of the user that should decrypt the calldata.
@@ -24,3 +25,4 @@ export declare const checkPackageUpdates: (packageName?: string, packageVersion?
  * @throws {ValidationError} Throws a ValidationError if the step has missing values.
  */
 export declare const convertQuoteToRoute: (step: LifiStep) => Route;
+export declare const fetchTxErrorDetails: (txHash: string, chainId: number) => Promise<TenderlyResponse>;

package/dist/helpers.js

@@ -100,3 +100,7 @@ export const convertQuoteToRoute = (step) => {
     };
     return route;
 };
+export const fetchTxErrorDetails = async (txHash, chainId) => {
+    const response = await request(`https://api.tenderly.co/api/v1/public-contract/${chainId}/tx/${txHash}`);
+    return response;
+};

package/dist/services/ApiService.d.ts

@@ -9,7 +9,7 @@ declare const _default: {
     getRoutes: (requestConfig: RoutesRequest, options?: RequestOptions | undefined) => Promise<RoutesResponse>;
     getStatus: (requestConfig: GetStatusRequest, options?: RequestOptions | undefined) => Promise<StatusResponse>;
     getStepTransaction: (step: LifiStep, options?: RequestOptions | undefined) => Promise<LifiStep>;
-    getToken: (chain: ChainKey | ChainId, token: string, options?: RequestOptions | undefined) => Promise<Token>;
+    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>;

package/dist/services/ConfigService.d.ts

@@ -18,6 +18,6 @@ export default class ConfigService {
      * Use this if you need access to chain data (RPCs or multicalls)
      */
     getConfigAsync: () => Promise<Config>;
-    updateConfig: (configUpdate: ConfigUpdate) => Config;
+    updateConfig: (configUpdate: Partial<ConfigUpdate>) => Config;
     updateChains: (chains: Chain[]) => Config;
 }

package/dist/services/ConfigService.js

@@ -1,9 +1,8 @@
 import { ChainId, } from '../types';
 const DefaultExecutionSettings = {
     /* eslint-disable-next-line @typescript-eslint/no-empty-function */
-    updateCallback: () => { },
+    updateRouteHook: () => { },
     switchChainHook: () => Promise.resolve(undefined),
-    acceptSlippageUpdateHook: () => Promise.resolve(undefined),
     acceptExchangeRateUpdateHook: () => Promise.resolve(undefined),
     infiniteApproval: false,
     executeInBackground: false,

package/dist/typeguards.d.ts

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

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

@@ -1,3 +1,4 @@
+import { TransactionRequest } from '@ethersproject/abstract-provider';
 import { LifiStep, Route, RouteOptions, Token } from '@lifi/types';
 import BigNumber from 'bignumber.js';
 import { Signer } from 'ethers';
@@ -22,7 +23,8 @@ export interface ExecutionParams {
     statusManager: StatusManager;
     settings: InternalExecutionSettings;
 }
-export type CallbackFunction = (updatedRoute: Route) => void;
+export type UpdateRouteHook = (updatedRoute: Route) => void;
+export type TransactionRequestUpdateHook = (updatedTxRequest: TransactionRequest) => Promise<TransactionRequest>;
 export type Config = {
     apiUrl: string;
     rpcs: Record<ChainId, string[]>;
@@ -67,16 +69,13 @@ export interface RouteExecutionData {
 }
 export type ExecutionSettings = Partial<InternalExecutionSettings>;
 export interface InternalExecutionSettings {
-    updateCallback: CallbackFunction;
-    switchChainHook: SwitchChainHook;
-    acceptSlippageUpdateHook: AcceptSlippageUpdateHook;
     acceptExchangeRateUpdateHook: AcceptExchangeRateUpdateHook;
-    infiniteApproval: boolean;
+    switchChainHook: SwitchChainHook;
+    updateRouteHook: UpdateRouteHook;
+    updateTransactionRequestHook?: TransactionRequestUpdateHook;
     executeInBackground: boolean;
+    infiniteApproval: boolean;
 }
-export type EnforcedObjectProperties<T> = T & {
-    [P in keyof T]-?: T[P];
-};
 export type RouteExecutionDictionary = Partial<Record<string, RouteExecutionData>>;
 export type RouteExecutionPromiseDictionary = Partial<Record<string, Promise<Route>>>;
 export type RevokeTokenData = {
@@ -88,3 +87,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/utils/errors.d.ts

@@ -22,7 +22,28 @@ export declare enum LifiErrorCode {
     TransactionCanceled = 1010,
     SlippageError = 1011,
     TransactionRejected = 1012,
-    BalanceError = 1013
+    BalanceError = 1013,
+    AllowanceRequired = 1014,
+    InsufficientFunds = 1015
+}
+export declare enum EthersErrorType {
+    ActionRejected = "ACTION_REJECTED",
+    CallExecption = "CALL_EXCEPTION",
+    InsufficientFunds = "INSUFFICIENT_FUNDS"
+}
+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/utils/errors.js

@@ -25,7 +25,31 @@ export var LifiErrorCode;
     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 EthersErrorType;
+(function (EthersErrorType) {
+    EthersErrorType["ActionRejected"] = "ACTION_REJECTED";
+    EthersErrorType["CallExecption"] = "CALL_EXCEPTION";
+    EthersErrorType["InsufficientFunds"] = "INSUFFICIENT_FUNDS";
+})(EthersErrorType || (EthersErrorType = {}));
+export 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 || (EthersErrorMessage = {}));
+export 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 || (ErrorMessage = {}));
 export var MetaMaskRPCErrorCode;
 (function (MetaMaskRPCErrorCode) {
     MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["invalidInput"] = -32000] = "invalidInput";