@lifi/sdk 1.6.4 → 1.7.0

package/dist/cjs/allowance/tokenApproval.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revokeTokenApproval = exports.approveToken = exports.bulkGetTokenApproval = exports.getTokenApproval = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ethers_1 = require("ethers");
+const helpers_1 = require("../helpers");
+const utils_1 = require("../utils/utils");
+const utils_2 = require("./utils");
+const getTokenApproval = (signer, token, approvalAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    // native token don't need approval
+    if ((0, utils_1.isNativeTokenAddress)(token.address)) {
+        return;
+    }
+    const approved = yield (0, utils_2.getApproved)(signer, token.address, approvalAddress);
+    return approved.toString();
+});
+exports.getTokenApproval = getTokenApproval;
+const bulkGetTokenApproval = (signer, tokenData) => __awaiter(void 0, void 0, void 0, function* () {
+    // filter out native tokens
+    const filteredTokenData = tokenData.filter(({ token }) => !(0, utils_1.isNativeTokenAddress)(token.address));
+    // group by chain
+    const tokenDataByChain = (0, utils_2.groupByChain)(filteredTokenData);
+    const approvalPromises = Object.keys(tokenDataByChain).map((chainId) => __awaiter(void 0, void 0, void 0, function* () {
+        const parsedChainId = Number.parseInt(chainId);
+        // get allowances for current chain and token list
+        return (0, utils_2.getAllowanceViaMulticall)(signer, parsedChainId, tokenDataByChain[parsedChainId]);
+    }));
+    const approvalsByChain = yield Promise.all(approvalPromises);
+    const approvals = approvalsByChain.flat();
+    return tokenData.map(({ token }) => {
+        // native token don't need approval
+        if ((0, utils_1.isNativeTokenAddress)(token.address)) {
+            return { token, approval: undefined };
+        }
+        const approved = approvals.find((approval) => (0, helpers_1.isSameToken)(approval.token, token));
+        return { token, approval: approved === null || approved === void 0 ? void 0 : approved.approvedAmount.toString() };
+    });
+});
+exports.bulkGetTokenApproval = bulkGetTokenApproval;
+const approveToken = ({ signer, token, approvalAddress, amount, infiniteApproval = false, }) => __awaiter(void 0, void 0, void 0, function* () {
+    // native token don't need approval
+    if ((0, utils_1.isNativeTokenAddress)(token.address)) {
+        return;
+    }
+    const approvedAmount = yield (0, utils_2.getApproved)(signer, token.address, approvalAddress);
+    if (new bignumber_js_1.default(amount).gt(approvedAmount)) {
+        const approvalAmount = infiniteApproval
+            ? ethers_1.constants.MaxUint256.toString()
+            : amount;
+        const approveTx = yield (0, utils_2.setApproval)(signer, token.address, approvalAddress, approvalAmount);
+        yield approveTx.wait();
+    }
+});
+exports.approveToken = approveToken;
+const revokeTokenApproval = ({ signer, token, approvalAddress, }) => __awaiter(void 0, void 0, void 0, function* () {
+    // native token don't need approval
+    if ((0, utils_1.isNativeTokenAddress)(token.address)) {
+        return;
+    }
+    const approvedAmount = yield (0, utils_2.getApproved)(signer, token.address, approvalAddress);
+    if (!approvedAmount.isZero()) {
+        const approveTx = yield (0, utils_2.setApproval)(signer, token.address, approvalAddress, '0');
+        yield approveTx.wait();
+    }
+});
+exports.revokeTokenApproval = revokeTokenApproval;

package/dist/cjs/balance/checkBalance.d.ts

@@ -0,0 +1,3 @@
+import { ethers } from 'ethers';
+import { Step } from '..';
+export declare const checkBalance: (signer: ethers.Signer, step: Step, depth?: number) => Promise<void>;

package/dist/cjs/{execution/balanceCheck.execute.js → balance/checkBalance.js}

@@ -12,17 +12,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.balanceCheck = void 0;
+exports.checkBalance = void 0;
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const balances_1 = __importDefault(require("../balances"));
 const errors_1 = require("../utils/errors");
-const balanceCheck = (signer, step) => __awaiter(void 0, void 0, void 0, function* () {
-    const tokenAmount = yield balances_1.default.getTokenBalance(yield signer.getAddress(), step.action.fromToken);
+const getTokenBalance_1 = require("./getTokenBalance");
+const checkBalance = (signer, step, depth = 0) => __awaiter(void 0, void 0, void 0, function* () {
+    const tokenAmount = yield (0, getTokenBalance_1.getTokenBalance)(yield signer.getAddress(), step.action.fromToken);
     if (tokenAmount) {
         const currentBalance = new bignumber_js_1.default(tokenAmount.amount).shiftedBy(tokenAmount.decimals);
         const neededBalance = new bignumber_js_1.default(step.action.fromAmount);
         if (currentBalance.lt(neededBalance)) {
-            if (neededBalance.multipliedBy(1 - step.action.slippage).lte(currentBalance)) {
+            if (depth <= 3) {
+                yield new Promise((resolve) => {
+                    setTimeout(resolve, 200);
+                });
+                yield (0, exports.checkBalance)(signer, step, depth + 1);
+            }
+            else if (neededBalance.multipliedBy(1 - step.action.slippage).lte(currentBalance)) {
                 // adjust amount in slippage limits
                 step.action.fromAmount = currentBalance.toFixed(0);
             }
@@ -40,9 +46,9 @@ const balanceCheck = (signer, step) => __awaiter(void 0, void 0, void 0, functio
                         `If the problem consists, please delete this transfer and ` +
                             `start a new one with a maximum of ${current} ${tokenAmount.symbol}.`;
                 }
-                throw new errors_1.ValidationError('The balance is too low.', errorMessage);
+                throw new errors_1.BalanceError('The balance is too low.', errorMessage);
             }
         }
     }
 });
-exports.balanceCheck = balanceCheck;
+exports.checkBalance = checkBalance;

package/dist/cjs/balance/getTokenBalance.d.ts

@@ -0,0 +1,8 @@
+import { Token, TokenAmount } from '@lifi/types';
+export declare const getTokenBalance: (walletAddress: string, token: Token) => Promise<TokenAmount | null>;
+export declare const getTokenBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
+export declare const getTokenBalancesForChains: (walletAddress: string, tokensByChain: {
+    [chainId: number]: Token[];
+}) => Promise<{
+    [chainId: number]: TokenAmount[];
+}>;

package/dist/cjs/{balances/index.js → balance/getTokenBalance.js}

@@ -12,11 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenBalancesForChains = exports.getTokenBalances = exports.getTokenBalance = void 0;
 const utils_1 = __importDefault(require("./utils"));
 const getTokenBalance = (walletAddress, token) => __awaiter(void 0, void 0, void 0, function* () {
-    const tokenAmounts = yield getTokenBalances(walletAddress, [token]);
+    const tokenAmounts = yield (0, exports.getTokenBalances)(walletAddress, [token]);
     return tokenAmounts.length ? tokenAmounts[0] : null;
 });
+exports.getTokenBalance = getTokenBalance;
 const getTokenBalances = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0, function* () {
     // split by chain
     const tokensByChain = {};
@@ -26,9 +28,10 @@ const getTokenBalances = (walletAddress, tokens) => __awaiter(void 0, void 0, vo
         }
         tokensByChain[token.chainId].push(token);
     });
-    const tokenAmountsByChain = yield getTokenBalancesForChains(walletAddress, tokensByChain);
+    const tokenAmountsByChain = yield (0, exports.getTokenBalancesForChains)(walletAddress, tokensByChain);
     return Object.values(tokenAmountsByChain).flat();
 });
+exports.getTokenBalances = getTokenBalances;
 const getTokenBalancesForChains = (walletAddress, tokensByChain) => __awaiter(void 0, void 0, void 0, function* () {
     const tokenAmountsByChain = {};
     const promises = Object.keys(tokensByChain).map((chainIdStr) => __awaiter(void 0, void 0, void 0, function* () {
@@ -39,8 +42,4 @@ const getTokenBalancesForChains = (walletAddress, tokensByChain) => __awaiter(vo
     yield Promise.allSettled(promises);
     return tokenAmountsByChain;
 });
-exports.default = {
-    getTokenBalance,
-    getTokenBalances,
-    getTokenBalancesForChains,
-};
+exports.getTokenBalancesForChains = getTokenBalancesForChains;

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

@@ -0,0 +1,2 @@
+export * from './checkBalance';
+export * from './getTokenBalance';

package/dist/cjs/balance/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./checkBalance"), exports);
+__exportStar(require("./getTokenBalance"), exports);

package/dist/cjs/{balances → balance}/utils.js

@@ -45,7 +45,7 @@ const getBalances = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0,
     tokens.forEach((token) => {
         if (token.chainId !== chainId) {
             // eslint-disable-next-line no-console
-            console.warn(`Requested tokens have to be on same chain.`);
+            console.warn(`Requested tokens have to be on the same chain.`);
             return [];
         }
     });

package/dist/cjs/execution/{exchanges/swap.execute.d.ts → ExecutionManager.d.ts}

@@ -1,7 +1,7 @@
 import { Execution } from '@lifi/types';
-import { ExecuteSwapParams } from '../../types';
-export declare class SwapExecutionManager {
+import { ExecutionParams } from '../types';
+export declare class ExecutionManager {
     allowUserInteraction: boolean;
     allowInteraction: (value: boolean) => void;
-    execute: ({ signer, step, statusManager, settings, }: ExecuteSwapParams) => Promise<Execution>;
+    execute: ({ signer, step, statusManager, settings, }: ExecutionParams) => Promise<Execution>;
 }

package/dist/cjs/execution/{bridges/bridge.execute.js → ExecutionManager.js}

@@ -12,19 +12,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BridgeExecutionManager = void 0;
-const ApiService_1 = __importDefault(require("../../services/ApiService"));
-const ChainsService_1 = __importDefault(require("../../services/ChainsService"));
-const errors_1 = require("../../utils/errors");
-const getProvider_1 = require("../../utils/getProvider");
-const parseError_1 = require("../../utils/parseError");
-const utils_1 = require("../../utils/utils");
-const allowance_execute_1 = require("../allowance.execute");
-const balanceCheck_execute_1 = require("../balanceCheck.execute");
-const stepComparison_1 = require("../stepComparison");
-const switchChain_1 = require("../switchChain");
-const utils_2 = require("../utils");
-class BridgeExecutionManager {
+exports.ExecutionManager = void 0;
+const allowance_1 = require("../allowance");
+const balance_1 = require("../balance");
+const ApiService_1 = __importDefault(require("../services/ApiService"));
+const ChainsService_1 = __importDefault(require("../services/ChainsService"));
+const errors_1 = require("../utils/errors");
+const getProvider_1 = require("../utils/getProvider");
+const parseError_1 = require("../utils/parseError");
+const utils_1 = require("../utils/utils");
+const stepComparison_1 = require("./stepComparison");
+const switchChain_1 = require("./switchChain");
+const utils_2 = require("./utils");
+class ExecutionManager {
     constructor() {
         this.allowUserInteraction = true;
         this.allowInteraction = (value) => {
@@ -36,19 +36,21 @@ class BridgeExecutionManager {
             const chainsService = ChainsService_1.default.getInstance();
             const fromChain = yield chainsService.getChainById(step.action.fromChainId);
             const toChain = yield chainsService.getChainById(step.action.toChainId);
+            const isBridgeExecution = fromChain.id !== toChain.id;
+            const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP';
             // STEP 1: Check allowance
-            const oldCrossProcess = step.execution.process.find((p) => p.type === 'CROSS_CHAIN');
+            const existingProcess = step.execution.process.find((p) => p.type === currentProcessType);
             // Check token approval only if fromToken is not the native token => no approval needed in that case
-            if (!(oldCrossProcess === null || oldCrossProcess === void 0 ? void 0 : oldCrossProcess.txHash) &&
+            if (!(existingProcess === null || existingProcess === void 0 ? void 0 : existingProcess.txHash) &&
                 !(0, utils_1.isZeroAddress)(step.action.fromToken.address)) {
-                yield (0, allowance_execute_1.checkAllowance)(signer, step, statusManager, settings, fromChain, this.allowUserInteraction);
+                yield (0, allowance_1.checkAllowance)(signer, step, statusManager, settings, fromChain, this.allowUserInteraction);
             }
             // STEP 2: Get transaction
-            let crossChainProcess = statusManager.findOrCreateProcess(step, 'CROSS_CHAIN');
-            if (crossChainProcess.status !== 'DONE') {
+            let process = statusManager.findOrCreateProcess(step, currentProcessType);
+            if (process.status !== 'DONE') {
                 try {
                     let transaction;
-                    if (crossChainProcess.txHash) {
+                    if (process.txHash) {
                         // Make sure that the chain is still correct
                         const updatedSigner = yield (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
                         if (!updatedSigner) {
@@ -57,17 +59,18 @@ class BridgeExecutionManager {
                         }
                         signer = updatedSigner;
                         // Load exiting transaction
-                        transaction = yield (0, getProvider_1.getProvider)(signer).getTransaction(crossChainProcess.txHash);
+                        transaction = yield (0, getProvider_1.getProvider)(signer).getTransaction(process.txHash);
                     }
                     else {
-                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'STARTED');
+                        process = statusManager.updateProcess(step, process.type, 'STARTED');
                         // Check balance
-                        yield (0, balanceCheck_execute_1.balanceCheck)(signer, step);
+                        yield (0, balance_1.checkBalance)(signer, step);
                         // Create new transaction
                         if (!step.transactionRequest) {
                             const personalizedStep = yield (0, utils_1.personalizeStep)(signer, step);
                             const updatedStep = yield ApiService_1.default.getStepTransaction(personalizedStep);
-                            step = Object.assign(Object.assign({}, (yield (0, stepComparison_1.stepComparison)(statusManager, personalizedStep, updatedStep, settings.acceptSlippageUpdateHook, this.allowUserInteraction))), { execution: step.execution });
+                            const comparedStep = yield (0, stepComparison_1.stepComparison)(statusManager, personalizedStep, updatedStep, settings, this.allowUserInteraction);
+                            step = Object.assign(Object.assign({}, comparedStep), { execution: step.execution });
                         }
                         const { transactionRequest } = step;
                         if (!transactionRequest) {
@@ -81,14 +84,14 @@ class BridgeExecutionManager {
                             return step.execution;
                         }
                         signer = updatedSigner;
-                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'ACTION_REQUIRED');
+                        process = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED');
                         if (!this.allowUserInteraction) {
                             return step.execution;
                         }
                         // Submit the transaction
                         transaction = yield signer.sendTransaction(transactionRequest);
                         // STEP 4: Wait for the transaction
-                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'PENDING', {
+                        process = statusManager.updateProcess(step, process.type, 'PENDING', {
                             txHash: transaction.hash,
                             txLink: fromChain.metamask.blockExplorerUrls[0] +
                                 'tx/' +
@@ -96,11 +99,17 @@ class BridgeExecutionManager {
                         });
                     }
                     yield transaction.wait();
-                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'DONE');
+                    process = statusManager.updateProcess(step, process.type, 'PENDING', {
+                        txHash: transaction.hash,
+                        txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + transaction.hash,
+                    });
+                    if (isBridgeExecution) {
+                        process = statusManager.updateProcess(step, process.type, 'DONE');
+                    }
                 }
                 catch (e) {
                     if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
-                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'DONE', {
+                        process = statusManager.updateProcess(step, process.type, 'DONE', {
                             txHash: e.replacement.hash,
                             txLink: fromChain.metamask.blockExplorerUrls[0] +
                                 'tx/' +
@@ -108,8 +117,8 @@ class BridgeExecutionManager {
                         });
                     }
                     else {
-                        const error = yield (0, parseError_1.parseError)(e, step, crossChainProcess);
-                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'FAILED', {
+                        const error = yield (0, parseError_1.parseError)(e, step, process);
+                        process = statusManager.updateProcess(step, process.type, 'FAILED', {
                             error: {
                                 message: error.message,
                                 htmlMessage: error.htmlMessage,
@@ -122,14 +131,17 @@ class BridgeExecutionManager {
                 }
             }
             // STEP 5: Wait for the receiving chain
-            let receivingChainProcess = statusManager.findOrCreateProcess(step, 'RECEIVING_CHAIN', 'PENDING');
+            const processTxHash = process.txHash;
+            if (isBridgeExecution) {
+                process = statusManager.findOrCreateProcess(step, 'RECEIVING_CHAIN', 'PENDING');
+            }
             let statusResponse;
             try {
-                if (!crossChainProcess.txHash) {
+                if (!processTxHash) {
                     throw new Error('Transaction hash is undefined.');
                 }
-                statusResponse = yield (0, utils_2.waitForReceivingTransaction)(crossChainProcess.txHash, statusManager, receivingChainProcess.type, step);
-                receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'DONE', {
+                statusResponse = yield (0, utils_2.waitForReceivingTransaction)(processTxHash, statusManager, process.type, step);
+                process = statusManager.updateProcess(step, process.type, 'DONE', {
                     substatus: statusResponse.substatus,
                     substatusMessage: statusResponse.substatusMessage ||
                         (0, utils_2.getSubstatusMessage)(statusResponse.status, statusResponse.substatus),
@@ -142,16 +154,19 @@ class BridgeExecutionManager {
                     fromAmount: statusResponse.sending.amount,
                     toAmount: (_c = statusResponse.receiving) === null || _c === void 0 ? void 0 : _c.amount,
                     toToken: (_d = statusResponse.receiving) === null || _d === void 0 ? void 0 : _d.token,
-                    gasUsed: statusResponse.sending.gasUsed,
+                    gasAmount: statusResponse.sending.gasAmount,
+                    gasAmountUSD: statusResponse.sending.gasAmountUSD,
                     gasPrice: statusResponse.sending.gasPrice,
+                    gasToken: statusResponse.sending.gasToken,
+                    gasUsed: statusResponse.sending.gasUsed,
                 });
             }
             catch (e) {
-                receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'FAILED', {
+                process = statusManager.updateProcess(step, process.type, 'FAILED', {
                     error: {
                         code: errors_1.LifiErrorCode.TransactionFailed,
                         message: 'Failed while waiting for receiving chain.',
-                        htmlMessage: (0, parseError_1.getTransactionFailedMessage)(step, crossChainProcess.txLink),
+                        htmlMessage: (0, parseError_1.getTransactionFailedMessage)(step, process.txLink),
                     },
                 });
                 statusManager.updateExecution(step, 'FAILED');
@@ -163,4 +178,4 @@ class BridgeExecutionManager {
         });
     }
 }
-exports.BridgeExecutionManager = BridgeExecutionManager;
+exports.ExecutionManager = ExecutionManager;

package/dist/cjs/execution/StatusManager.d.ts

@@ -3,11 +3,14 @@ interface Receipt {
     fromAmount?: string;
     toAmount?: string;
     toToken?: Token;
-    gasUsed?: string;
     gasPrice?: string;
+    gasUsed?: string;
+    gasToken?: Token;
+    gasAmount?: string;
+    gasAmountUSD?: string;
 }
-declare type InternalUpdateRouteCallback = (route: Route) => void;
-declare type OptionalParameters = Partial<Pick<Process, 'doneAt' | 'failedAt' | 'txHash' | 'txLink' | 'error' | 'substatus' | 'substatusMessage'>>;
+type InternalUpdateRouteCallback = (route: Route) => void;
+type OptionalParameters = Partial<Pick<Process, 'doneAt' | 'failedAt' | 'txHash' | 'txLink' | 'error' | 'substatus' | 'substatusMessage'>>;
 /**
  * Manages status updates of a route and provides various functions for tracking processes
  * @param  {Route} route  The route this StatusManger belongs to.

package/dist/cjs/execution/StatusManager.js

@@ -160,9 +160,7 @@ class StatusManager {
         }
         step.execution.status = status;
         if (receipt) {
-            step.execution.fromAmount = receipt.fromAmount;
-            step.execution.toAmount = receipt.toAmount;
-            step.execution.toToken = receipt.toToken;
+            step.execution = Object.assign(Object.assign({}, step.execution), receipt);
         }
         this.updateStepInRoute(step);
         return step;

package/dist/cjs/execution/StepExecutor.d.ts

@@ -1,17 +1,15 @@
 import { Signer } from 'ethers';
 import { InteractionSettings, InternalExecutionSettings, Step } from '../types';
+import { ExecutionManager } from './ExecutionManager';
 import { StatusManager } from './StatusManager';
 export declare class StepExecutor {
-    settings: InternalExecutionSettings;
+    executionManager: ExecutionManager;
     statusManager: StatusManager;
-    private swapExecutionManager;
-    private bridgeExecutionManager;
+    settings: InternalExecutionSettings;
     allowUserInteraction: boolean;
     executionStopped: boolean;
     constructor(statusManager: StatusManager, settings: InternalExecutionSettings);
     setInteraction: (settings?: InteractionSettings) => void;
     checkChain: () => never;
     executeStep: (signer: Signer, step: Step) => Promise<Step>;
-    private executeSwap;
-    private executeCross;
 }

package/dist/cjs/execution/StepExecutor.js

@@ -10,8 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StepExecutor = void 0;
-const bridge_execute_1 = require("./bridges/bridge.execute");
-const swap_execute_1 = require("./exchanges/swap.execute");
+const ExecutionManager_1 = require("./ExecutionManager");
 const switchChain_1 = require("./switchChain");
 // Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
 const defaultInteractionSettings = {
@@ -21,15 +20,12 @@ const defaultInteractionSettings = {
 };
 class StepExecutor {
     constructor(statusManager, settings) {
-        this.swapExecutionManager = new swap_execute_1.SwapExecutionManager();
-        this.bridgeExecutionManager = new bridge_execute_1.BridgeExecutionManager();
         this.allowUserInteraction = true;
         this.executionStopped = false;
         this.setInteraction = (settings) => {
             const interactionSettings = Object.assign(Object.assign({}, defaultInteractionSettings), settings);
             this.allowUserInteraction = interactionSettings.allowInteraction;
-            this.swapExecutionManager.allowInteraction(interactionSettings.allowInteraction);
-            this.bridgeExecutionManager.allowInteraction(interactionSettings.allowInteraction);
+            this.executionManager.allowInteraction(interactionSettings.allowInteraction);
             this.statusManager.allowUpdates(interactionSettings.allowUpdates);
             this.executionStopped = interactionSettings.stopExecution;
         };
@@ -47,37 +43,16 @@ class StepExecutor {
                 return step;
             }
             signer = updatedSigner;
-            switch (step.type) {
-                case 'lifi':
-                case 'cross':
-                    yield this.executeCross(signer, step);
-                    break;
-                case 'swap':
-                    yield this.executeSwap(signer, step);
-                    break;
-                default:
-                    throw new Error('Unsupported step type.');
-            }
-            return step;
-        });
-        this.executeSwap = (signer, step) => {
-            const swapParams = {
-                signer,
-                step,
-                settings: this.settings,
-                statusManager: this.statusManager,
-            };
-            return this.swapExecutionManager.execute(swapParams);
-        };
-        this.executeCross = (signer, step) => {
-            const crossParams = {
+            const parameters = {
                 signer,
                 step,
                 settings: this.settings,
                 statusManager: this.statusManager,
             };
-            return this.bridgeExecutionManager.execute(crossParams);
-        };
+            yield this.executionManager.execute(parameters);
+            return step;
+        });
+        this.executionManager = new ExecutionManager_1.ExecutionManager();
         this.statusManager = statusManager;
         this.settings = settings;
     }

package/dist/cjs/execution/stepComparison.d.ts

@@ -1,9 +1,9 @@
 import { StatusManager } from '.';
-import { AcceptSlippageUpdateHook, Step } from '../types';
+import { InternalExecutionSettings, Step } from '../types';
 /**
- * This method checks whether the new and updated Step meets the required slippage conditions.
+ * This method checks whether the new and updated Step meets the required exchange rate conditions.
  * If yes it returns the updated Step.
- * If no and if user interaction is allowed it triggers the acceptSlippageUpdateHook. If no user interaction is allowed it aborts.
+ * If no and if user interaction is allowed it triggers the acceptExchangeRateUpdateHook. If no user interaction is allowed it aborts.
  *
  * @param statusManager
  * @param oldStep
@@ -11,4 +11,4 @@ import { AcceptSlippageUpdateHook, Step } from '../types';
  * @param acceptSlippageUpdateHook
  * @param allowUserInteraction
  */
-export declare const stepComparison: (statusManager: StatusManager, oldStep: Step, newStep: Step, acceptSlippageUpdateHook: AcceptSlippageUpdateHook, allowUserInteraction: boolean) => Promise<Step>;
+export declare const stepComparison: (statusManager: StatusManager, oldStep: Step, newStep: Step, settings: InternalExecutionSettings, allowUserInteraction: boolean) => Promise<Step>;

package/dist/cjs/execution/stepComparison.js

@@ -11,12 +11,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stepComparison = void 0;
 const errors_1 = require("../utils/errors");
-const parseError_1 = require("../utils/parseError");
 const utils_1 = require("./utils");
 /**
- * This method checks whether the new and updated Step meets the required slippage conditions.
+ * This method checks whether the new and updated Step meets the required exchange rate conditions.
  * If yes it returns the updated Step.
- * If no and if user interaction is allowed it triggers the acceptSlippageUpdateHook. If no user interaction is allowed it aborts.
+ * If no and if user interaction is allowed it triggers the acceptExchangeRateUpdateHook. If no user interaction is allowed it aborts.
  *
  * @param statusManager
  * @param oldStep
@@ -24,13 +23,16 @@ const utils_1 = require("./utils");
  * @param acceptSlippageUpdateHook
  * @param allowUserInteraction
  */
-const stepComparison = (statusManager, oldStep, newStep, acceptSlippageUpdateHook, allowUserInteraction) => __awaiter(void 0, void 0, void 0, function* () {
-    if ((0, utils_1.updatedStepMeetsSlippageConditions)(oldStep, newStep)) {
+const stepComparison = (statusManager, oldStep, newStep, settings, allowUserInteraction) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    // Check if changed exchange rate is in the range of slippage threshold
+    if ((0, utils_1.checkStepSlippageThreshold)(oldStep, newStep)) {
         return statusManager.updateStepInRoute(newStep);
     }
+    const acceptExchangeRateUpdateHook = (_a = settings.acceptExchangeRateUpdateHook) !== null && _a !== void 0 ? _a : settings.acceptSlippageUpdateHook;
     let allowStepUpdate;
     if (allowUserInteraction) {
-        allowStepUpdate = yield acceptSlippageUpdateHook({
+        allowStepUpdate = yield acceptExchangeRateUpdateHook({
             oldToAmount: oldStep.estimate.toAmount,
             newToAmount: newStep.estimate.toAmount,
             toToken: newStep.action.toToken,
@@ -39,7 +41,9 @@ const stepComparison = (statusManager, oldStep, newStep, acceptSlippageUpdateHoo
         });
     }
     if (!allowStepUpdate) {
-        throw new errors_1.TransactionError(errors_1.LifiErrorCode.SlippageNotMet, 'Slippage conditions not met!', (0, parseError_1.getSlippageNotMetMessage)(oldStep));
+        // The user declined the new exchange rate, so we are not going to proceed
+        throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionCanceled, 'Exchange rate has changed!', `Transaction was not sent, your funds are still in your wallet.
+      The exchange rate has changed and the previous estimation can not be fulfilled due to value loss.`);
     }
     return statusManager.updateStepInRoute(newStep);
 });

package/dist/cjs/execution/switchChain.js

@@ -45,7 +45,7 @@ const switchChain = (signer, statusManager, step, switchChainHook, allowUserInte
         return updatedSigner;
     }
     catch (error) {
-        switchProcess = statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
+        statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
             error: {
                 message: error.message,
                 code: errors_1.LifiErrorCode.ChainSwitchError,

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

@@ -3,4 +3,4 @@ import { StatusManager } from '..';
 export declare function waitForReceivingTransaction(txHash: string, statusManager: StatusManager, processType: ProcessType, step: Step): Promise<StatusResponse>;
 export declare function getProcessMessage(type: ProcessType, status: Status): string | undefined;
 export declare function getSubstatusMessage(status: StatusMessage, substatus?: Substatus): string | undefined;
-export declare function updatedStepMeetsSlippageConditions(oldStep: Step, newStep: Step): boolean;
+export declare function checkStepSlippageThreshold(oldStep: Step, newStep: Step): boolean;