@lifi/sdk 1.1.2 → 1.1.5

package/dist/execution/exchanges/swap.execute.js

@@ -1,15 +1,3 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 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) {
@@ -19,222 +7,151 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwapExecutionManager = void 0;
-var ethers_1 = require("ethers");
-var ApiService_1 = __importDefault(require("../../services/ApiService"));
-var ChainsService_1 = __importDefault(require("../../services/ChainsService"));
-var errors_1 = require("../../utils/errors");
-var getProvider_1 = require("../../utils/getProvider");
-var parseError_1 = require("../../utils/parseError");
-var utils_1 = require("../../utils/utils");
-var allowance_execute_1 = require("../allowance.execute");
-var balanceCheck_execute_1 = require("../balanceCheck.execute");
-var stepComparison_1 = require("../stepComparison");
-var switchChain_1 = require("../switchChain");
-var utils_2 = require("../utils");
-var SwapExecutionManager = /** @class */ (function () {
-    function SwapExecutionManager() {
-        var _this = this;
+import { constants } from 'ethers';
+import ApiService from '../../services/ApiService';
+import ChainsService from '../../services/ChainsService';
+import { LifiErrorCode, TransactionError } from '../../utils/errors';
+import { getProvider } from '../../utils/getProvider';
+import { getTransactionFailedMessage, parseError } from '../../utils/parseError';
+import { personalizeStep } from '../../utils/utils';
+import { checkAllowance } from '../allowance.execute';
+import { balanceCheck } from '../balanceCheck.execute';
+import { stepComparison } from '../stepComparison';
+import { switchChain } from '../switchChain';
+import { waitForReceivingTransaction } from '../utils';
+export class SwapExecutionManager {
+    constructor() {
         this.shouldContinue = true;
-        this.setShouldContinue = function (val) {
-            _this.shouldContinue = val;
+        this.setShouldContinue = (val) => {
+            this.shouldContinue = val;
         };
-        this.execute = function (_a) {
-            var signer = _a.signer, step = _a.step, statusManager = _a.statusManager, settings = _a.settings;
-            return __awaiter(_this, void 0, void 0, function () {
-                var action, estimate, chainsService, fromChain, swapProcess, tx, personalizedStep, updatedStep, _b, transactionRequest, updatedSigner, e_1, error, receipt, e_2, error, statusResponse, e_3;
-                var _c, _d, _e, _f;
-                return __generator(this, function (_g) {
-                    switch (_g.label) {
-                        case 0:
-                            action = step.action, estimate = step.estimate;
-                            step.execution = statusManager.initExecutionObject(step);
-                            chainsService = ChainsService_1.default.getInstance();
-                            return [4 /*yield*/, chainsService.getChainById(action.fromChainId)
-                                // Approval
-                            ];
-                        case 1:
-                            fromChain = _g.sent();
-                            if (!(action.fromToken.address !== ethers_1.constants.AddressZero)) return [3 /*break*/, 3];
-                            return [4 /*yield*/, (0, allowance_execute_1.checkAllowance)(signer, step, fromChain, action.fromToken, action.fromAmount, estimate.approvalAddress, statusManager, settings.infiniteApproval, this.shouldContinue)];
-                        case 2:
-                            _g.sent();
-                            _g.label = 3;
-                        case 3:
-                            swapProcess = statusManager.findOrCreateProcess('SWAP', step);
-                            _g.label = 4;
-                        case 4:
-                            _g.trys.push([4, 14, , 16]);
-                            if (!swapProcess.txHash) return [3 /*break*/, 6];
-                            return [4 /*yield*/, (0, getProvider_1.getProvider)(signer).getTransaction(swapProcess.txHash)];
-                        case 5:
-                            // -> restore existing tx
-                            tx = _g.sent();
-                            return [3 /*break*/, 13];
-                        case 6: 
-                        // -> check balance
-                        return [4 /*yield*/, (0, balanceCheck_execute_1.balanceCheck)(signer, step)
-                            // -> get tx from backend
-                        ];
-                        case 7:
-                            // -> check balance
-                            _g.sent();
-                            return [4 /*yield*/, (0, utils_1.personalizeStep)(signer, step)];
-                        case 8:
-                            personalizedStep = _g.sent();
-                            return [4 /*yield*/, ApiService_1.default.getStepTransaction(personalizedStep)];
-                        case 9:
-                            updatedStep = _g.sent();
-                            _b = [{}];
-                            return [4 /*yield*/, (0, stepComparison_1.stepComparison)(statusManager, personalizedStep, updatedStep, settings.acceptSlippageUpdateHook, this.shouldContinue)];
-                        case 10:
-                            step = __assign.apply(void 0, [__assign.apply(void 0, _b.concat([(_g.sent())])), { execution: step.execution }]);
-                            transactionRequest = step.transactionRequest;
-                            if (!transactionRequest) {
-                                throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
-                            }
-                            return [4 /*yield*/, (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.shouldContinue)];
-                        case 11:
-                            updatedSigner = _g.sent();
-                            if (!updatedSigner) {
-                                // chain switch was not successful, stop execution here
-                                return [2 /*return*/, step.execution];
-                            }
-                            signer = updatedSigner;
-                            // -> set step.execution
-                            swapProcess = swapProcess = statusManager.updateProcess(step, swapProcess.type, 'ACTION_REQUIRED');
-                            if (!this.shouldContinue) {
-                                return [2 /*return*/, step.execution]; // stop before user interaction is needed
-                            }
-                            return [4 /*yield*/, signer.sendTransaction(transactionRequest)];
-                        case 12:
-                            // -> submit tx
-                            tx = _g.sent();
-                            _g.label = 13;
-                        case 13: return [3 /*break*/, 16];
-                        case 14:
-                            e_1 = _g.sent();
-                            return [4 /*yield*/, (0, parseError_1.parseError)(e_1, step, swapProcess)];
-                        case 15:
-                            error = _g.sent();
-                            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
-                                error: {
-                                    message: error.message,
-                                    htmlMessage: error.htmlMessage,
-                                    code: error.code,
-                                },
-                            });
-                            statusManager.updateExecution(step, 'FAILED');
-                            throw error;
-                        case 16:
-                            // Wait for Transaction
-                            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
-                                txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + tx.hash,
-                                txHash: tx.hash,
-                            });
-                            _g.label = 17;
-                        case 17:
-                            _g.trys.push([17, 19, , 23]);
-                            return [4 /*yield*/, tx.wait()];
-                        case 18:
-                            receipt = _g.sent();
-                            return [3 /*break*/, 23];
-                        case 19:
-                            e_2 = _g.sent();
-                            if (!(e_2.code === 'TRANSACTION_REPLACED' && e_2.replacement)) return [3 /*break*/, 20];
-                            receipt = e_2.replacement;
-                            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
-                                txHash: e_2.replacement.hash,
-                                txLink: fromChain.metamask.blockExplorerUrls[0] +
-                                    'tx/' +
-                                    e_2.replacement.hash,
-                            });
-                            return [3 /*break*/, 22];
-                        case 20: return [4 /*yield*/, (0, parseError_1.parseError)(e_2)];
-                        case 21:
-                            error = _g.sent();
-                            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
-                                error: {
-                                    message: error.message,
-                                    htmlMessage: error.htmlMessage,
-                                    code: error.code,
-                                },
-                            });
-                            statusManager.updateExecution(step, 'FAILED');
-                            throw error;
-                        case 22: return [3 /*break*/, 23];
-                        case 23:
-                            _g.trys.push([23, 25, , 26]);
-                            if (!swapProcess.txHash) {
-                                throw new Error('Transaction hash is undefined.');
-                            }
-                            return [4 /*yield*/, (0, utils_2.waitForReceivingTransaction)(swapProcess.txHash, statusManager, swapProcess.type, step)];
-                        case 24:
-                            statusResponse = _g.sent();
-                            return [3 /*break*/, 26];
-                        case 25:
-                            e_3 = _g.sent();
-                            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
-                                error: {
-                                    code: errors_1.LifiErrorCode.TransactionFailed,
-                                    message: 'Failed while waiting for receiving chain.',
-                                    htmlMessage: (0, parseError_1.getTransactionFailedMessage)(step, swapProcess.txLink),
-                                },
-                            });
-                            statusManager.updateExecution(step, 'FAILED');
-                            throw e_3;
-                        case 26:
-                            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'DONE', {
-                                txHash: (_c = statusResponse.receiving) === null || _c === void 0 ? void 0 : _c.txHash,
-                                txLink: fromChain.metamask.blockExplorerUrls[0] +
-                                    'tx/' +
-                                    ((_d = statusResponse.receiving) === null || _d === void 0 ? void 0 : _d.txHash),
-                            });
-                            statusManager.updateExecution(step, 'DONE', {
-                                fromAmount: statusResponse.sending.amount,
-                                toAmount: (_e = statusResponse.receiving) === null || _e === void 0 ? void 0 : _e.amount,
-                                toToken: (_f = statusResponse.receiving) === null || _f === void 0 ? void 0 : _f.token,
-                                gasUsed: statusResponse.sending.gasUsed,
-                                gasPrice: statusResponse.sending.gasPrice,
-                            });
-                            // DONE
-                            return [2 /*return*/, step.execution];
+        this.execute = ({ signer, step, statusManager, settings, }) => __awaiter(this, void 0, void 0, function* () {
+            // setup
+            var _a, _b, _c, _d;
+            const { action, estimate } = step;
+            step.execution = statusManager.initExecutionObject(step);
+            const chainsService = ChainsService.getInstance();
+            const fromChain = yield chainsService.getChainById(action.fromChainId);
+            // Approval
+            if (action.fromToken.address !== constants.AddressZero) {
+                yield checkAllowance(signer, step, fromChain, action.fromToken, action.fromAmount, estimate.approvalAddress, statusManager, settings.infiniteApproval, this.shouldContinue);
+            }
+            // Start Swap
+            // -> set step.execution
+            let swapProcess = statusManager.findOrCreateProcess('SWAP', step);
+            // -> swapping
+            let tx;
+            try {
+                if (swapProcess.txHash) {
+                    // -> restore existing tx
+                    tx = yield getProvider(signer).getTransaction(swapProcess.txHash);
+                }
+                else {
+                    // -> check balance
+                    yield balanceCheck(signer, step);
+                    // -> get tx from backend
+                    const personalizedStep = yield personalizeStep(signer, step);
+                    const updatedStep = yield ApiService.getStepTransaction(personalizedStep);
+                    step = Object.assign(Object.assign({}, (yield stepComparison(statusManager, personalizedStep, updatedStep, settings.acceptSlippageUpdateHook, this.shouldContinue))), { execution: step.execution });
+                    const { transactionRequest } = step;
+                    if (!transactionRequest) {
+                        throw new TransactionError(LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                    }
+                    // make sure that chain is still correct
+                    const updatedSigner = yield switchChain(signer, statusManager, step, settings.switchChainHook, this.shouldContinue);
+                    if (!updatedSigner) {
+                        // chain switch was not successful, stop execution here
+                        return step.execution;
                     }
+                    signer = updatedSigner;
+                    // -> set step.execution
+                    swapProcess = swapProcess = statusManager.updateProcess(step, swapProcess.type, 'ACTION_REQUIRED');
+                    if (!this.shouldContinue) {
+                        return step.execution; // stop before user interaction is needed
+                    }
+                    // -> submit tx
+                    tx = yield signer.sendTransaction(transactionRequest);
+                }
+            }
+            catch (e) {
+                const error = yield parseError(e, step, swapProcess);
+                swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
+                    error: {
+                        message: error.message,
+                        htmlMessage: error.htmlMessage,
+                        code: error.code,
+                    },
                 });
+                statusManager.updateExecution(step, 'FAILED');
+                throw error;
+            }
+            // Wait for Transaction
+            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
+                txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + tx.hash,
+                txHash: tx.hash,
             });
-        };
+            // -> waiting
+            let receipt;
+            try {
+                receipt = yield tx.wait();
+            }
+            catch (e) {
+                // -> set status
+                if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
+                    receipt = e.replacement;
+                    swapProcess = statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
+                        txHash: e.replacement.hash,
+                        txLink: fromChain.metamask.blockExplorerUrls[0] +
+                            'tx/' +
+                            e.replacement.hash,
+                    });
+                }
+                else {
+                    const error = yield parseError(e);
+                    swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
+                        error: {
+                            message: error.message,
+                            htmlMessage: error.htmlMessage,
+                            code: error.code,
+                        },
+                    });
+                    statusManager.updateExecution(step, 'FAILED');
+                    throw error;
+                }
+            }
+            let statusResponse;
+            try {
+                if (!swapProcess.txHash) {
+                    throw new Error('Transaction hash is undefined.');
+                }
+                statusResponse = yield waitForReceivingTransaction(swapProcess.txHash, statusManager, swapProcess.type, step);
+            }
+            catch (e) {
+                swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
+                    error: {
+                        code: LifiErrorCode.TransactionFailed,
+                        message: 'Failed while waiting for receiving chain.',
+                        htmlMessage: getTransactionFailedMessage(step, swapProcess.txLink),
+                    },
+                });
+                statusManager.updateExecution(step, 'FAILED');
+                throw e;
+            }
+            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'DONE', {
+                txHash: (_a = statusResponse.receiving) === null || _a === void 0 ? void 0 : _a.txHash,
+                txLink: fromChain.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;
+        });
     }
-    return SwapExecutionManager;
-}());
-exports.SwapExecutionManager = SwapExecutionManager;
+}

package/dist/execution/index.js

@@ -1,17 +1 @@
-"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("./StatusManager"), exports);
+export * from './StatusManager';

package/dist/execution/stepComparison.js

@@ -1,4 +1,3 @@
-"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) {
@@ -8,38 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stepComparison = void 0;
-var errors_1 = require("../utils/errors");
-var parseError_1 = require("../utils/parseError");
-var utils_1 = require("./utils");
+import { LifiErrorCode, TransactionError } from '../utils/errors';
+import { getSlippageNotMetMessage } from '../utils/parseError';
+import { updatedStepMeetsSlippageConditions } from './utils';
 /**
  * This method checks whether the new and updated Step meets the required slippage conditions.
  * If yes it returns the updated Step.
@@ -51,31 +21,22 @@ var utils_1 = require("./utils");
  * @param acceptSlippageUpdateHook
  * @param allowUserInteraction
  */
-var stepComparison = function (statusManager, oldStep, newStep, acceptSlippageUpdateHook, allowUserInteraction) { return __awaiter(void 0, void 0, void 0, function () {
-    var allowStepUpdate;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if ((0, utils_1.updatedStepMeetsSlippageConditions)(oldStep, newStep)) {
-                    return [2 /*return*/, statusManager.updateStepInRoute(newStep)];
-                }
-                if (!allowUserInteraction) return [3 /*break*/, 2];
-                return [4 /*yield*/, acceptSlippageUpdateHook({
-                        oldToAmount: oldStep.estimate.toAmount,
-                        newToAmount: newStep.estimate.toAmount,
-                        toToken: newStep.action.toToken,
-                        oldSlippage: oldStep.action.slippage,
-                        newSlippage: newStep.action.slippage,
-                    })];
-            case 1:
-                allowStepUpdate = _a.sent();
-                _a.label = 2;
-            case 2:
-                if (!allowStepUpdate) {
-                    throw new errors_1.TransactionError(errors_1.LifiErrorCode.SlippageNotMet, 'Slippage conditions not met!', (0, parseError_1.getSlippageNotMetMessage)(oldStep));
-                }
-                return [2 /*return*/, statusManager.updateStepInRoute(newStep)];
-        }
-    });
-}); };
-exports.stepComparison = stepComparison;
+export const stepComparison = (statusManager, oldStep, newStep, acceptSlippageUpdateHook, allowUserInteraction) => __awaiter(void 0, void 0, void 0, function* () {
+    if (updatedStepMeetsSlippageConditions(oldStep, newStep)) {
+        return statusManager.updateStepInRoute(newStep);
+    }
+    let allowStepUpdate;
+    if (allowUserInteraction) {
+        allowStepUpdate = yield acceptSlippageUpdateHook({
+            oldToAmount: oldStep.estimate.toAmount,
+            newToAmount: newStep.estimate.toAmount,
+            toToken: newStep.action.toToken,
+            oldSlippage: oldStep.action.slippage,
+            newSlippage: newStep.action.slippage,
+        });
+    }
+    if (!allowStepUpdate) {
+        throw new TransactionError(LifiErrorCode.SlippageNotMet, 'Slippage conditions not met!', getSlippageNotMetMessage(oldStep));
+    }
+    return statusManager.updateStepInRoute(newStep);
+});

package/dist/execution/switchChain.js

@@ -1,4 +1,3 @@
-"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) {
@@ -8,36 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.switchChain = void 0;
-var errors_1 = require("../utils/errors");
+import { LifiErrorCode, ProviderError } from '../utils/errors';
 /**
  * This method checks whether the signer is configured for the correct chain.
  * If yes it returns the signer.
@@ -49,54 +19,36 @@ var errors_1 = require("../utils/errors");
  * @param switchChainHook
  * @param allowUserInteraction
  */
-var switchChain = function (signer, statusManager, step, switchChainHook, allowUserInteraction) { return __awaiter(void 0, void 0, void 0, function () {
-    var switchProcess, updatedSigner, _a, error_1;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0: return [4 /*yield*/, signer.getChainId()];
-            case 1:
-                // if we are already on the correct chain we can proceed directly
-                if ((_b.sent()) === step.action.fromChainId) {
-                    return [2 /*return*/, signer];
-                }
-                // -> set status message
-                step.execution = statusManager.initExecutionObject(step);
-                statusManager.updateExecution(step, 'CHAIN_SWITCH_REQUIRED');
-                switchProcess = statusManager.findOrCreateProcess('SWITCH_CHAIN', step, 'PENDING');
-                if (!allowUserInteraction) {
-                    return [2 /*return*/];
-                }
-                _b.label = 2;
-            case 2:
-                _b.trys.push([2, 6, , 7]);
-                return [4 /*yield*/, switchChainHook(step.action.fromChainId)];
-            case 3:
-                updatedSigner = _b.sent();
-                _a = !updatedSigner;
-                if (_a) return [3 /*break*/, 5];
-                return [4 /*yield*/, updatedSigner.getChainId()];
-            case 4:
-                _a = (_b.sent()) !== step.action.fromChainId;
-                _b.label = 5;
-            case 5:
-                if (_a) {
-                    throw new errors_1.ProviderError(errors_1.LifiErrorCode.ChainSwitchError, 'Chain switch required.');
-                }
-                switchProcess = statusManager.updateProcess(step, switchProcess.type, 'DONE');
-                statusManager.updateExecution(step, 'PENDING');
-                return [2 /*return*/, updatedSigner];
-            case 6:
-                error_1 = _b.sent();
-                switchProcess = statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
-                    error: {
-                        message: error_1.message,
-                        code: error_1.code,
-                    },
-                });
-                statusManager.updateExecution(step, 'FAILED');
-                throw error_1;
-            case 7: return [2 /*return*/];
+export const switchChain = (signer, statusManager, step, switchChainHook, allowUserInteraction) => __awaiter(void 0, void 0, void 0, function* () {
+    // if we are already on the correct chain we can proceed directly
+    if ((yield signer.getChainId()) === step.action.fromChainId) {
+        return signer;
+    }
+    // -> set status message
+    step.execution = statusManager.initExecutionObject(step);
+    statusManager.updateExecution(step, 'CHAIN_SWITCH_REQUIRED');
+    let switchProcess = statusManager.findOrCreateProcess('SWITCH_CHAIN', step, 'PENDING');
+    if (!allowUserInteraction) {
+        return;
+    }
+    try {
+        const updatedSigner = yield switchChainHook(step.action.fromChainId);
+        const updatedChainId = yield (updatedSigner === null || updatedSigner === void 0 ? void 0 : updatedSigner.getChainId());
+        if (updatedChainId !== step.action.fromChainId) {
+            throw new ProviderError(LifiErrorCode.ChainSwitchError, 'Chain switch required.');
         }
-    });
-}); };
-exports.switchChain = switchChain;
+        switchProcess = statusManager.updateProcess(step, switchProcess.type, 'DONE');
+        statusManager.updateExecution(step, 'PENDING');
+        return updatedSigner;
+    }
+    catch (error) {
+        switchProcess = statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
+            error: {
+                message: error.message,
+                code: error.code,
+            },
+        });
+        statusManager.updateExecution(step, 'FAILED');
+        throw error;
+    }
+});