@lifi/sdk 1.1.4 → 1.1.5

package/dist/cjs/execution/StatusManager.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusManager = void 0;
+const types_1 = require("../types");
+const utils_1 = require("../utils/utils");
+const utils_2 = require("./utils");
+/**
+ * Manages status updates of a route and provides various functions for tracking processes
+ * @param  {Route} route  The route this StatusManger belongs to.
+ * @param  {InternalExecutionSettings} settings   The ExecutionSettings for this route.
+ * @param  {InternalUpdateRouteCallback} internalUpdateRouteCallback  Internal callback to propage route changes.
+ * @return {StatusManager}       An instance of StatusManager.
+ */
+class StatusManager {
+    constructor(route, settings, internalUpdateRouteCallback) {
+        this.shouldUpdate = true;
+        /**
+         * Initializes the execution object of a Step.
+         * @param  {Step} step  The current step in execution
+         * @return {Execution}       The initialized execution object for this step and a function to update this step
+         */
+        this.initExecutionObject = (step) => {
+            const currentExecution = step.execution || (0, utils_1.deepClone)(types_1.emptyExecution);
+            if (!step.execution) {
+                step.execution = currentExecution;
+                step.execution.status = 'PENDING';
+                this.updateStepInRoute(step);
+            }
+            // Change status to PENDING after resuming from FAILED
+            if (currentExecution.status === 'FAILED') {
+                currentExecution.status = 'PENDING';
+                this.updateStepInRoute(step);
+            }
+            return currentExecution;
+        };
+        /**
+         * Create and push a new process into the execution.
+         * @param  {ProcessType} type Type of the process. Used to identify already existing processes.
+         * @param  {Step} step The step that should contain the new process.
+         * @param  {Status} status By default created procces is set to the STARTED status. We can override new process with the needed status.
+         * @return {Process}
+         */
+        this.findOrCreateProcess = (type, step, status) => {
+            if (!step.execution || !step.execution.process) {
+                throw new Error("Execution hasn't been initialized.");
+            }
+            const process = step.execution.process.find((p) => p.type === type);
+            if (process) {
+                return process;
+            }
+            const newProcess = {
+                type: type,
+                startedAt: Date.now(),
+                message: (0, utils_2.getProcessMessage)(type, status !== null && status !== void 0 ? status : 'STARTED'),
+                status: status !== null && status !== void 0 ? status : 'STARTED',
+            };
+            step.execution.process.push(newProcess);
+            this.updateStepInRoute(step);
+            return newProcess;
+        };
+        /**
+         * Update a process object.
+         * @param  {Step} step The step where the process should be updated
+         * @param  {ProcessType} type  The process type to update
+         * @param  {Status} status The status the process gets.
+         * @param  {object} [params]   Additional parameters to append to the process.
+         * @return {Process} The update process
+         */
+        this.updateProcess = (step, type, status, params) => {
+            var _a;
+            if (!step.execution) {
+                throw new Error("Can't update an empty step execution.");
+            }
+            const currentProcess = (_a = step === null || step === void 0 ? void 0 : step.execution) === null || _a === void 0 ? void 0 : _a.process.find((p) => p.type === type);
+            if (!currentProcess) {
+                throw new Error("Can't find a process for the given type.");
+            }
+            switch (status) {
+                case 'CANCELLED':
+                    currentProcess.doneAt = Date.now();
+                    break;
+                case 'FAILED':
+                    currentProcess.doneAt = Date.now();
+                    step.execution.status = 'FAILED';
+                    break;
+                case 'DONE':
+                    currentProcess.doneAt = Date.now();
+                    break;
+                case 'PENDING':
+                    step.execution.status = 'PENDING';
+                    break;
+                case 'ACTION_REQUIRED':
+                    step.execution.status = 'ACTION_REQUIRED';
+                    break;
+                case 'CHAIN_SWITCH_REQUIRED':
+                    step.execution.status = 'CHAIN_SWITCH_REQUIRED';
+                    break;
+                default:
+                    break;
+            }
+            currentProcess.status = status;
+            currentProcess.message = (0, utils_2.getProcessMessage)(type, status);
+            // set extra parameters or overwritte the standard params set in the switch statement
+            if (params) {
+                for (const [key, value] of Object.entries(params)) {
+                    currentProcess[key] = value;
+                }
+            }
+            this.updateStepInRoute(step); // updates the step in the route
+            return currentProcess;
+        };
+        /**
+         * Remove a process from the execution
+         * @param  {Step} step The step where the process should be removed from
+         * @param  {ProcessType} type  The process type to remove
+         * @return {void}
+         */
+        this.removeProcess = (step, type) => {
+            if (!step.execution) {
+                throw new Error("Execution hasn't been initialized.");
+            }
+            const index = step.execution.process.findIndex((p) => p.type === type);
+            step.execution.process.splice(index, 1);
+            this.updateStepInRoute(step);
+        };
+        this.updateStepInRoute = (step) => {
+            if (!this.shouldUpdate) {
+                return step;
+            }
+            const stepIndex = this.route.steps.findIndex((routeStep) => routeStep.id === step.id);
+            if (stepIndex === -1) {
+                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.internalUpdateRouteCallback(this.route);
+            return this.route.steps[stepIndex];
+        };
+        this.route = route;
+        this.settings = settings;
+        this.internalUpdateRouteCallback = internalUpdateRouteCallback;
+    }
+    /**
+     * Updates the execution object of a Step.
+     * @param  {Step} step  The current step in execution
+     * @param  {Status} status  The status for the execution
+     * @param  {Receipt} receipt Optional. Information about received tokens
+     * @return {Step}       The step with the updated execution object
+     */
+    updateExecution(step, status, receipt) {
+        if (!step.execution) {
+            throw Error("Can't update empty execution.");
+        }
+        step.execution.status = status;
+        if (receipt) {
+            step.execution.fromAmount = receipt.fromAmount;
+            step.execution.toAmount = receipt.toAmount;
+            step.execution.toToken = receipt.toToken;
+        }
+        this.updateStepInRoute(step);
+        return step;
+    }
+    setShouldUpdate(value) {
+        this.shouldUpdate = value;
+    }
+}
+exports.StatusManager = StatusManager;

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

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

package/dist/cjs/execution/StepExecutor.js

@@ -0,0 +1,74 @@
+"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());
+    });
+};
+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 switchChain_1 = require("./switchChain");
+const defaultExecutionHaltSettings = {
+    allowUpdates: true,
+};
+class StepExecutor {
+    constructor(statusManager, settings) {
+        this.swapExecutionManager = new swap_execute_1.SwapExecutionManager();
+        this.bridgeExecutionManager = new bridge_execute_1.BridgeExecutionManager();
+        this.executionStopped = false;
+        this.stopStepExecution = (settings) => {
+            const haltingSettings = Object.assign(Object.assign({}, defaultExecutionHaltSettings), settings);
+            this.swapExecutionManager.setShouldContinue(false);
+            this.bridgeExecutionManager.setShouldContinue(false);
+            this.statusManager.setShouldUpdate(haltingSettings.allowUpdates);
+            this.executionStopped = true;
+        };
+        this.executeStep = (signer, step) => __awaiter(this, void 0, void 0, function* () {
+            // check if signer is for correct chain
+            const updatedSigner = yield (0, switchChain_1.switchChain)(signer, this.statusManager, step, this.settings.switchChainHook, !this.executionStopped);
+            if (!updatedSigner) {
+                // chain switch was not successful, stop execution here
+                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) => __awaiter(this, void 0, void 0, function* () {
+            const swapParams = {
+                signer,
+                step,
+                settings: this.settings,
+                statusManager: this.statusManager,
+            };
+            return yield this.swapExecutionManager.execute(swapParams);
+        });
+        this.executeCross = (signer, step) => __awaiter(this, void 0, void 0, function* () {
+            const crossParams = {
+                signer,
+                step,
+                settings: this.settings,
+                statusManager: this.statusManager,
+            };
+            return yield this.bridgeExecutionManager.execute(crossParams);
+        });
+        this.statusManager = statusManager;
+        this.settings = settings;
+    }
+}
+exports.StepExecutor = StepExecutor;

package/dist/cjs/execution/allowance.execute.d.ts

@@ -0,0 +1,4 @@
+import { Signer } from 'ethers';
+import { Chain, Step, Token } from '../types';
+import { StatusManager } from './StatusManager';
+export declare const checkAllowance: (signer: Signer, step: Step, chain: Chain, token: Token, amount: string, spenderAddress: string, statusManager: StatusManager, infiniteApproval?: boolean, allowUserInteraction?: boolean) => Promise<void>;

package/dist/cjs/execution/allowance.execute.js

@@ -0,0 +1,97 @@
+"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.checkAllowance = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ethers_1 = require("ethers");
+const utils_1 = require("../allowance/utils");
+const getProvider_1 = require("../utils/getProvider");
+const parseError_1 = require("../utils/parseError");
+const checkAllowance = (signer, step, chain, token, amount, spenderAddress, statusManager, infiniteApproval = false, allowUserInteraction = false
+// eslint-disable-next-line max-params
+) => __awaiter(void 0, void 0, void 0, function* () {
+    // Ask user to set allowance
+    // -> set currentExecution
+    let allowanceProcess = statusManager.findOrCreateProcess('TOKEN_ALLOWANCE', step);
+    // -> check allowance
+    try {
+        if (allowanceProcess.txHash) {
+            allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING');
+            yield (0, getProvider_1.getProvider)(signer).waitForTransaction(allowanceProcess.txHash);
+            allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
+            // TODO: Do we need this check?
+        }
+        else if (allowanceProcess.status === 'DONE') {
+            allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
+        }
+        else {
+            const approved = yield (0, utils_1.getApproved)(signer, token.address, spenderAddress);
+            if (new bignumber_js_1.default(amount).gt(approved)) {
+                if (!allowUserInteraction) {
+                    return;
+                }
+                const approvalAmount = infiniteApproval
+                    ? ethers_1.constants.MaxUint256.toString()
+                    : amount;
+                const approveTx = yield (0, utils_1.setApproval)(signer, token.address, spenderAddress, approvalAmount);
+                // update currentExecution
+                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
+                    txHash: approveTx.hash,
+                    txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + approveTx.hash,
+                });
+                // wait for transcation
+                yield approveTx.wait();
+                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
+            }
+            else {
+                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
+            }
+        }
+    }
+    catch (e) {
+        // -> set status
+        if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
+            yield transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
+        }
+        else {
+            const error = yield (0, parseError_1.parseError)(e, step, allowanceProcess);
+            allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'FAILED', {
+                error: {
+                    message: error.message,
+                    htmlMessage: error.htmlMessage,
+                    code: error.code,
+                },
+            });
+            statusManager.updateExecution(step, 'FAILED');
+            throw error;
+        }
+    }
+});
+exports.checkAllowance = checkAllowance;
+const transactionReplaced = (replacementTx, allowanceProcess, step, chain, statusManager) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
+            txHash: replacementTx.hash,
+            txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + replacementTx.hash,
+        });
+        yield replacementTx.wait();
+        allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
+    }
+    catch (e) {
+        if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
+            yield transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
+        }
+        throw e;
+    }
+});

package/dist/cjs/execution/balanceCheck.execute.d.ts

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

package/dist/cjs/execution/balanceCheck.execute.js

@@ -0,0 +1,48 @@
+"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.balanceCheck = 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);
+    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)) {
+                // adjust amount in slippage limits
+                step.action.fromAmount = currentBalance.toFixed(0);
+            }
+            else {
+                const neeeded = neededBalance.shiftedBy(-tokenAmount.decimals).toFixed();
+                const current = currentBalance
+                    .shiftedBy(-tokenAmount.decimals)
+                    .toFixed();
+                let errorMessage = `Your ${tokenAmount.symbol} balance is too low, ` +
+                    `you try to transfer ${neeeded} ${tokenAmount.symbol}, ` +
+                    `but your wallet only holds ${current} ${tokenAmount.symbol}. ` +
+                    `No funds have been sent. `;
+                if (!currentBalance.isZero()) {
+                    errorMessage +=
+                        `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);
+            }
+        }
+    }
+});
+exports.balanceCheck = balanceCheck;

package/dist/cjs/execution/bridges/bridge.execute.d.ts

@@ -0,0 +1,7 @@
+import { Execution } from '@lifi/types';
+import { ExecuteCrossParams } from '../../types';
+export declare class BridgeExecutionManager {
+    shouldContinue: boolean;
+    setShouldContinue: (val: boolean) => void;
+    execute: ({ signer, step, statusManager, settings, }: ExecuteCrossParams) => Promise<Execution>;
+}

package/dist/cjs/execution/bridges/bridge.execute.js

@@ -0,0 +1,154 @@
+"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.BridgeExecutionManager = void 0;
+const ethers_1 = require("ethers");
+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 {
+    constructor() {
+        this.shouldContinue = true;
+        this.setShouldContinue = (val) => {
+            this.shouldContinue = val;
+        };
+        this.execute = ({ signer, step, statusManager, settings, }) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const { action, estimate } = step;
+            step.execution = statusManager.initExecutionObject(step);
+            const chainsService = ChainsService_1.default.getInstance();
+            const fromChain = yield chainsService.getChainById(action.fromChainId);
+            const toChain = yield chainsService.getChainById(action.toChainId);
+            // STEP 1: Check Allowance ////////////////////////////////////////////////
+            // approval still needed?
+            const oldCrossProcess = step.execution.process.find((p) => p.type === 'CROSS_CHAIN');
+            if (!(oldCrossProcess === null || oldCrossProcess === void 0 ? void 0 : oldCrossProcess.txHash)) {
+                if (action.fromToken.address !== ethers_1.constants.AddressZero) {
+                    // Check Token Approval only if fromToken is not the native token => no approval needed in that case
+                    yield (0, allowance_execute_1.checkAllowance)(signer, step, fromChain, action.fromToken, action.fromAmount, estimate.approvalAddress, statusManager, settings.infiniteApproval, this.shouldContinue);
+                }
+            }
+            // STEP 2: Get Transaction ////////////////////////////////////////////////
+            let crossChainProcess = statusManager.findOrCreateProcess('CROSS_CHAIN', step);
+            try {
+                let tx;
+                if (crossChainProcess.txHash) {
+                    // load exiting transaction
+                    tx = yield (0, getProvider_1.getProvider)(signer).getTransaction(crossChainProcess.txHash);
+                }
+                else {
+                    // check balance
+                    yield (0, balanceCheck_execute_1.balanceCheck)(signer, step);
+                    // create new transaction
+                    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.shouldContinue))), { execution: step.execution });
+                    const { transactionRequest } = step;
+                    if (!transactionRequest) {
+                        throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                    }
+                    // STEP 3: Send Transaction ///////////////////////////////////////////////
+                    // make sure that chain is still correct
+                    const updatedSigner = yield (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.shouldContinue);
+                    if (!updatedSigner) {
+                        // chain switch was not successful, stop execution here
+                        return step.execution;
+                    }
+                    signer = updatedSigner;
+                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'ACTION_REQUIRED');
+                    if (!this.shouldContinue) {
+                        return step.execution;
+                    }
+                    tx = yield signer.sendTransaction(transactionRequest);
+                    // STEP 4: Wait for Transaction ///////////////////////////////////////////
+                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'PENDING', {
+                        txHash: tx.hash,
+                        txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + tx.hash,
+                    });
+                }
+                yield tx.wait();
+            }
+            catch (e) {
+                if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
+                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'PENDING', {
+                        txHash: e.replacement.hash,
+                        txLink: fromChain.metamask.blockExplorerUrls[0] +
+                            'tx/' +
+                            e.replacement.hash,
+                    });
+                }
+                else {
+                    const error = yield (0, parseError_1.parseError)(e, step, crossChainProcess);
+                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'FAILED', {
+                        error: {
+                            message: error.message,
+                            htmlMessage: error.htmlMessage,
+                            code: error.code,
+                        },
+                    });
+                    statusManager.updateExecution(step, 'FAILED');
+                    throw error;
+                }
+            }
+            crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'DONE');
+            // STEP 5: Wait for Receiver //////////////////////////////////////
+            let receivingChainProcess = statusManager.findOrCreateProcess('RECEIVING_CHAIN', step, 'PENDING');
+            let statusResponse;
+            try {
+                if (!crossChainProcess.txHash) {
+                    throw new Error('Transaction hash is undefined.');
+                }
+                statusResponse = yield (0, utils_2.waitForReceivingTransaction)(crossChainProcess.txHash, statusManager, receivingChainProcess.type, step);
+            }
+            catch (e) {
+                receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'FAILED', {
+                    error: {
+                        code: errors_1.LifiErrorCode.TransactionFailed,
+                        message: 'Failed while waiting for receiving chain.',
+                        htmlMessage: (0, parseError_1.getTransactionFailedMessage)(step, crossChainProcess.txLink),
+                    },
+                });
+                statusManager.updateExecution(step, 'FAILED');
+                throw e;
+            }
+            receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'DONE', {
+                substatus: statusResponse.substatus,
+                substatusMessage: statusResponse.substatusMessage ||
+                    (0, utils_2.getSubstatusMessage)(statusResponse.status, statusResponse.substatus),
+                txHash: (_a = statusResponse.receiving) === null || _a === void 0 ? void 0 : _a.txHash,
+                txLink: toChain.metamask.blockExplorerUrls[0] +
+                    'tx/' +
+                    ((_b = statusResponse.receiving) === null || _b === void 0 ? void 0 : _b.txHash),
+            });
+            statusManager.updateExecution(step, 'DONE', {
+                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,
+                gasPrice: statusResponse.sending.gasPrice,
+            });
+            // DONE
+            return step.execution;
+        });
+    }
+}
+exports.BridgeExecutionManager = BridgeExecutionManager;

package/dist/cjs/execution/exchanges/swap.execute.d.ts

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