@lifi/sdk 1.1.2 → 1.1.5

package/dist/connectors.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,143 +7,61 @@ 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 };
-};
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMulticallAddress = exports.getRpcProvider = exports.getRpcUrls = exports.getRpcUrl = void 0;
-var ethers_1 = require("ethers");
-var _1 = require(".");
-var types_1 = require("./types");
-var ConfigService_1 = __importDefault(require("./services/ConfigService"));
+import { providers } from 'ethers';
+import { getRandomNumber, ServerError } from '.';
+import { ChainId } from './types';
+import ConfigService from './services/ConfigService';
 // cached providers
-var chainProviders = {};
+const chainProviders = {};
 // Archive RPC Provider
-var archiveRpcs = (_a = {},
-    _a[types_1.ChainId.ETH] = 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/eth/mainnet/archive',
-    _a[types_1.ChainId.BSC] = 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/bsc/mainnet/archive',
-    _a[types_1.ChainId.POL] = 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/polygon/mainnet/archive',
-    _a[types_1.ChainId.FTM] = 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/fantom/mainnet',
-    _a);
-// RPC Urls
-var getRpcUrl = function (chainId, archive) {
-    if (archive === void 0) { archive = false; }
-    return __awaiter(void 0, void 0, void 0, function () {
-        var rpcUrls;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, (0, exports.getRpcUrls)(chainId, archive)];
-                case 1:
-                    rpcUrls = _a.sent();
-                    return [2 /*return*/, rpcUrls[0]];
-            }
-        });
-    });
-};
-exports.getRpcUrl = getRpcUrl;
-var getRpcUrls = function (chainId, archive) {
-    if (archive === void 0) { archive = false; }
-    return __awaiter(void 0, void 0, void 0, function () {
-        var configService, config;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (archive && archiveRpcs[chainId]) {
-                        return [2 /*return*/, [archiveRpcs[chainId]]];
-                    }
-                    configService = ConfigService_1.default.getInstance();
-                    return [4 /*yield*/, configService.getConfigAsync()];
-                case 1:
-                    config = _a.sent();
-                    return [2 /*return*/, config.rpcs[chainId]];
-            }
-        });
-    });
+const archiveRpcs = {
+    [ChainId.ETH]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/eth/mainnet/archive',
+    [ChainId.BSC]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/bsc/mainnet/archive',
+    [ChainId.POL]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/polygon/mainnet/archive',
+    [ChainId.FTM]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/fantom/mainnet',
 };
-exports.getRpcUrls = getRpcUrls;
-var getRandomProvider = function (providerList) {
-    var index = (0, _1.getRandomNumber)(0, providerList.length - 1);
+// RPC Urls
+export const getRpcUrl = (chainId, archive = false) => __awaiter(void 0, void 0, void 0, function* () {
+    const rpcUrls = yield getRpcUrls(chainId, archive);
+    return rpcUrls[0];
+});
+export const getRpcUrls = (chainId, archive = false) => __awaiter(void 0, void 0, void 0, function* () {
+    if (archive && archiveRpcs[chainId]) {
+        return [archiveRpcs[chainId]];
+    }
+    const configService = ConfigService.getInstance();
+    const config = yield configService.getConfigAsync();
+    return config.rpcs[chainId];
+});
+const getRandomProvider = (providerList) => {
+    const index = getRandomNumber(0, providerList.length - 1);
     return providerList[index];
 };
 // Provider
-var getRpcProvider = function (chainId, archive) {
-    if (archive === void 0) { archive = false; }
-    return __awaiter(void 0, void 0, void 0, function () {
-        var _a, _b, _c, _d, urls;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
-                case 0:
-                    if (!(archive && archiveRpcs[chainId])) return [3 /*break*/, 2];
-                    _b = (_a = ethers_1.providers.FallbackProvider).bind;
-                    _d = (_c = ethers_1.providers.StaticJsonRpcProvider).bind;
-                    return [4 /*yield*/, (0, exports.getRpcUrl)(chainId, archive)];
-                case 1: 
-                // return archive PRC, but don't cache it
-                return [2 /*return*/, new (_b.apply(_a, [void 0, [
-                            new (_d.apply(_c, [void 0, _e.sent(), chainId]))()
-                        ]]))()];
-                case 2:
-                    if (!!chainProviders[chainId]) return [3 /*break*/, 4];
-                    chainProviders[chainId] = [];
-                    return [4 /*yield*/, (0, exports.getRpcUrls)(chainId, archive)];
-                case 3:
-                    urls = _e.sent();
-                    urls.forEach(function (url) {
-                        chainProviders[chainId].push(new ethers_1.providers.FallbackProvider([
-                            new ethers_1.providers.StaticJsonRpcProvider(url, chainId),
-                        ]));
-                    });
-                    _e.label = 4;
-                case 4:
-                    if (!chainProviders[chainId].length) {
-                        throw new _1.ServerError("Unable to configure provider for chain ".concat(chainId));
-                    }
-                    return [2 /*return*/, getRandomProvider(chainProviders[chainId])];
-            }
+export const getRpcProvider = (chainId, archive = false) => __awaiter(void 0, void 0, void 0, function* () {
+    if (archive && archiveRpcs[chainId]) {
+        // return archive PRC, but don't cache it
+        return new providers.FallbackProvider([
+            new providers.StaticJsonRpcProvider(yield getRpcUrl(chainId, archive), chainId),
+        ]);
+    }
+    if (!chainProviders[chainId]) {
+        chainProviders[chainId] = [];
+        const urls = yield getRpcUrls(chainId, archive);
+        urls.forEach((url) => {
+            chainProviders[chainId].push(new providers.FallbackProvider([
+                new providers.StaticJsonRpcProvider(url, chainId),
+            ]));
         });
-    });
-};
-exports.getRpcProvider = getRpcProvider;
+    }
+    if (!chainProviders[chainId].length) {
+        throw new ServerError(`Unable to configure provider for chain ${chainId}`);
+    }
+    return getRandomProvider(chainProviders[chainId]);
+});
 // Multicall
-var getMulticallAddress = function (chainId) { return __awaiter(void 0, void 0, void 0, function () {
-    var configService, config;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                configService = ConfigService_1.default.getInstance();
-                return [4 /*yield*/, configService.getConfigAsync()];
-            case 1:
-                config = _a.sent();
-                return [2 /*return*/, config.multicallAddresses[chainId]];
-        }
-    });
-}); };
-exports.getMulticallAddress = getMulticallAddress;
+export const getMulticallAddress = (chainId) => __awaiter(void 0, void 0, void 0, function* () {
+    const configService = ConfigService.getInstance();
+    const config = yield configService.getConfigAsync();
+    return config.multicallAddresses[chainId];
+});

package/dist/execution/StatusManager.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatusManager = void 0;
-var types_1 = require("../types");
-var utils_1 = require("../utils/utils");
-var utils_2 = require("./utils");
+import { emptyExecution, } from '../types';
+import { deepClone } from '../utils/utils';
+import { getProcessMessage } from './utils';
 /**
  * Manages status updates of a route and provides various functions for tracking processes
  * @param  {Route} route  The route this StatusManger belongs to.
@@ -11,26 +8,25 @@ var utils_2 = require("./utils");
  * @param  {InternalUpdateRouteCallback} internalUpdateRouteCallback  Internal callback to propage route changes.
  * @return {StatusManager}       An instance of StatusManager.
  */
-var StatusManager = /** @class */ (function () {
-    function StatusManager(route, settings, internalUpdateRouteCallback) {
-        var _this = this;
+export 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 = function (step) {
-            var currentExecution = step.execution || (0, utils_1.deepClone)(types_1.emptyExecution);
+        this.initExecutionObject = (step) => {
+            const currentExecution = step.execution || deepClone(emptyExecution);
             if (!step.execution) {
                 step.execution = currentExecution;
                 step.execution.status = 'PENDING';
-                _this.updateStepInRoute(step);
+                this.updateStepInRoute(step);
             }
             // Change status to PENDING after resuming from FAILED
             if (currentExecution.status === 'FAILED') {
                 currentExecution.status = 'PENDING';
-                _this.updateStepInRoute(step);
+                this.updateStepInRoute(step);
             }
             return currentExecution;
         };
@@ -41,22 +37,22 @@ var StatusManager = /** @class */ (function () {
          * @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 = function (type, step, status) {
+        this.findOrCreateProcess = (type, step, status) => {
             if (!step.execution || !step.execution.process) {
                 throw new Error("Execution hasn't been initialized.");
             }
-            var process = step.execution.process.find(function (p) { return p.type === type; });
+            const process = step.execution.process.find((p) => p.type === type);
             if (process) {
                 return process;
             }
-            var newProcess = {
+            const newProcess = {
                 type: type,
                 startedAt: Date.now(),
-                message: (0, utils_2.getProcessMessage)(type, status !== null && status !== void 0 ? status : 'STARTED'),
+                message: 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);
+            this.updateStepInRoute(step);
             return newProcess;
         };
         /**
@@ -67,12 +63,12 @@ var StatusManager = /** @class */ (function () {
          * @param  {object} [params]   Additional parameters to append to the process.
          * @return {Process} The update process
          */
-        this.updateProcess = function (step, type, status, params) {
+        this.updateProcess = (step, type, status, params) => {
             var _a;
             if (!step.execution) {
                 throw new Error("Can't update an empty step execution.");
             }
-            var currentProcess = (_a = step === null || step === void 0 ? void 0 : step.execution) === null || _a === void 0 ? void 0 : _a.process.find(function (p) { return p.type === type; });
+            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.");
             }
@@ -100,15 +96,14 @@ var StatusManager = /** @class */ (function () {
                     break;
             }
             currentProcess.status = status;
-            currentProcess.message = (0, utils_2.getProcessMessage)(type, status);
+            currentProcess.message = getProcessMessage(type, status);
             // set extra parameters or overwritte the standard params set in the switch statement
             if (params) {
-                for (var _i = 0, _b = Object.entries(params); _i < _b.length; _i++) {
-                    var _c = _b[_i], key = _c[0], value = _c[1];
+                for (const [key, value] of Object.entries(params)) {
                     currentProcess[key] = value;
                 }
             }
-            _this.updateStepInRoute(step); // updates the step in the route
+            this.updateStepInRoute(step); // updates the step in the route
             return currentProcess;
         };
         /**
@@ -117,26 +112,26 @@ var StatusManager = /** @class */ (function () {
          * @param  {ProcessType} type  The process type to remove
          * @return {void}
          */
-        this.removeProcess = function (step, type) {
+        this.removeProcess = (step, type) => {
             if (!step.execution) {
                 throw new Error("Execution hasn't been initialized.");
             }
-            var index = step.execution.process.findIndex(function (p) { return p.type === type; });
+            const index = step.execution.process.findIndex((p) => p.type === type);
             step.execution.process.splice(index, 1);
-            _this.updateStepInRoute(step);
+            this.updateStepInRoute(step);
         };
-        this.updateStepInRoute = function (step) {
-            if (!_this.shouldUpdate) {
+        this.updateStepInRoute = (step) => {
+            if (!this.shouldUpdate) {
                 return step;
             }
-            var stepIndex = _this.route.steps.findIndex(function (routeStep) { return routeStep.id === step.id; });
+            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.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;
@@ -149,7 +144,7 @@ var StatusManager = /** @class */ (function () {
      * @param  {Receipt} receipt Optional. Information about received tokens
      * @return {Step}       The step with the updated execution object
      */
-    StatusManager.prototype.updateExecution = function (step, status, receipt) {
+    updateExecution(step, status, receipt) {
         if (!step.execution) {
             throw Error("Can't update empty execution.");
         }
@@ -161,10 +156,8 @@ var StatusManager = /** @class */ (function () {
         }
         this.updateStepInRoute(step);
         return step;
-    };
-    StatusManager.prototype.setShouldUpdate = function (value) {
+    }
+    setShouldUpdate(value) {
         this.shouldUpdate = value;
-    };
-    return StatusManager;
-}());
-exports.StatusManager = StatusManager;
+    }
+}

package/dist/execution/StepExecutor.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,121 +7,64 @@ 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.StepExecutor = void 0;
-var bridge_execute_1 = require("./bridges/bridge.execute");
-var swap_execute_1 = require("./exchanges/swap.execute");
-var switchChain_1 = require("./switchChain");
-var defaultExecutionHaltSettings = {
+import { BridgeExecutionManager } from './bridges/bridge.execute';
+import { SwapExecutionManager } from './exchanges/swap.execute';
+import { switchChain } from './switchChain';
+const defaultExecutionHaltSettings = {
     allowUpdates: true,
 };
-var StepExecutor = /** @class */ (function () {
-    function StepExecutor(statusManager, settings) {
-        var _this = this;
-        this.swapExecutionManager = new swap_execute_1.SwapExecutionManager();
-        this.bridgeExecutionManager = new bridge_execute_1.BridgeExecutionManager();
+export class StepExecutor {
+    constructor(statusManager, settings) {
+        this.swapExecutionManager = new SwapExecutionManager();
+        this.bridgeExecutionManager = new BridgeExecutionManager();
         this.executionStopped = false;
-        this.stopStepExecution = function (settings) {
-            var haltingSettings = __assign(__assign({}, defaultExecutionHaltSettings), settings);
-            _this.swapExecutionManager.setShouldContinue(false);
-            _this.bridgeExecutionManager.setShouldContinue(false);
-            _this.statusManager.setShouldUpdate(haltingSettings.allowUpdates);
-            _this.executionStopped = true;
+        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 = function (signer, step) { return __awaiter(_this, void 0, void 0, function () {
-            var updatedSigner, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, (0, switchChain_1.switchChain)(signer, this.statusManager, step, this.settings.switchChainHook, !this.executionStopped)];
-                    case 1:
-                        updatedSigner = _b.sent();
-                        if (!updatedSigner) {
-                            // chain switch was not successful, stop execution here
-                            return [2 /*return*/, step];
-                        }
-                        signer = updatedSigner;
-                        _a = step.type;
-                        switch (_a) {
-                            case 'lifi': return [3 /*break*/, 2];
-                            case 'cross': return [3 /*break*/, 2];
-                            case 'swap': return [3 /*break*/, 4];
-                        }
-                        return [3 /*break*/, 6];
-                    case 2: return [4 /*yield*/, this.executeCross(signer, step)];
-                    case 3:
-                        _b.sent();
-                        return [3 /*break*/, 7];
-                    case 4: return [4 /*yield*/, this.executeSwap(signer, step)];
-                    case 5:
-                        _b.sent();
-                        return [3 /*break*/, 7];
-                    case 6: throw new Error('Unsupported step type.');
-                    case 7: return [2 /*return*/, step];
-                }
-            });
-        }); };
-        this.executeSwap = function (signer, step) { return __awaiter(_this, void 0, void 0, function () {
-            var swapParams;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        swapParams = {
-                            signer: signer,
-                            step: step,
-                            settings: this.settings,
-                            statusManager: this.statusManager,
-                        };
-                        return [4 /*yield*/, this.swapExecutionManager.execute(swapParams)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        }); };
-        this.executeCross = function (signer, step) { return __awaiter(_this, void 0, void 0, function () {
-            var crossParams;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        crossParams = {
-                            signer: signer,
-                            step: step,
-                            settings: this.settings,
-                            statusManager: this.statusManager,
-                        };
-                        return [4 /*yield*/, this.bridgeExecutionManager.execute(crossParams)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        }); };
+        this.executeStep = (signer, step) => __awaiter(this, void 0, void 0, function* () {
+            // check if signer is for correct chain
+            const updatedSigner = yield 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;
     }
-    return StepExecutor;
-}());
-exports.StepExecutor = StepExecutor;
+}