@lifi/sdk 1.3.1 → 1.5.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [1.5.0](https://github.com/lifinance/sdk/compare/v1.4.1...v1.5.0) (2022-09-06)
+
+
+### Features
+
+* add an option to start or resume execution in background ([#103](https://github.com/lifinance/sdk/issues/103)) ([c452559](https://github.com/lifinance/sdk/commit/c45255991ebcf494715c094db77f6c7599080c5d)), closes [#106](https://github.com/lifinance/sdk/issues/106) [#104](https://github.com/lifinance/sdk/issues/104)
+
+### [1.4.1](https://github.com/lifinance/sdk/compare/v1.4.0...v1.4.1) (2022-09-06)
+
+## [1.4.0](https://github.com/lifinance/sdk/compare/v1.3.1...v1.4.0) (2022-09-05)
+
+
+### Features
+
+* skip step tx generation if tx data already provided ([#100](https://github.com/lifinance/sdk/issues/100)) ([280de4a](https://github.com/lifinance/sdk/commit/280de4a3d96b8077893e0bc1e0ed944f4772c5fb))
+
 ### [1.3.1](https://github.com/lifinance/sdk/compare/v1.3.0...v1.3.1) (2022-09-05)
 
 

package/dist/Lifi.d.ts

@@ -104,8 +104,15 @@ export default class LIFI {
     /**
      * Executes a route until a user interaction is necessary (signing transactions, etc.) and then halts until the route is resumed.
      * @param {Route} route - A route that is currently in execution.
+     * @deprecated use updateRouteExecution instead.
      */
     moveExecutionToBackground: (route: Route) => void;
+    /**
+     * Updates route execution to background or foreground state.
+     * @param {Route} route - A route that is currently in execution.
+     * @param {boolean} settings - An object with execution settings.
+     */
+    updateRouteExecution: (route: Route, settings: Pick<ExecutionSettings, 'executeInBackground'>) => void;
     /**
      * Execute a route.
      * @param {Signer} signer - The signer required to send the transactions.

package/dist/Lifi.js

@@ -149,7 +149,11 @@ export default class LIFI {
                 return route;
             }
             for (const executor of this.activeRouteDictionary[route.id].executors) {
-                executor.stopStepExecution({ allowUpdates: false });
+                executor.setInteraction({
+                    allowInteraction: false,
+                    allowUpdates: false,
+                    stopExecution: true,
+                });
             }
             delete this.activeRouteDictionary[route.id];
             return route;
@@ -157,14 +161,36 @@ export default class LIFI {
         /**
          * Executes a route until a user interaction is necessary (signing transactions, etc.) and then halts until the route is resumed.
          * @param {Route} route - A route that is currently in execution.
+         * @deprecated use updateRouteExecution instead.
          */
         this.moveExecutionToBackground = (route) => {
-            if (!this.activeRouteDictionary[route.id]) {
+            const activeRoute = this.activeRouteDictionary[route.id];
+            if (!activeRoute) {
                 return;
             }
-            for (const executor of this.activeRouteDictionary[route.id].executors) {
-                executor.stopStepExecution({ allowUpdates: true });
+            for (const executor of activeRoute.executors) {
+                executor.setInteraction({ allowInteraction: false, allowUpdates: true });
             }
+            activeRoute.settings = Object.assign(Object.assign({}, activeRoute.settings), { executeInBackground: true });
+        };
+        /**
+         * Updates route execution to background or foreground state.
+         * @param {Route} route - A route that is currently in execution.
+         * @param {boolean} settings - An object with execution settings.
+         */
+        this.updateRouteExecution = (route, settings) => {
+            const activeRoute = this.activeRouteDictionary[route.id];
+            if (!activeRoute) {
+                return;
+            }
+            for (const executor of activeRoute.executors) {
+                executor.setInteraction({
+                    allowInteraction: !settings.executeInBackground,
+                    allowUpdates: true,
+                });
+            }
+            // Update active route settings so we know what the current state of execution is
+            activeRoute.settings = Object.assign(Object.assign({}, activeRoute.settings), settings);
         };
         /**
          * Execute a route.
@@ -175,8 +201,9 @@ export default class LIFI {
          * @throws {LifiError} Throws a LifiError if the execution fails.
          */
         this.executeRoute = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
-            const clonedRoute = deepClone(route); // deep clone to prevent side effects
-            // check if route is already running
+            // Deep clone to prevent side effects
+            const clonedRoute = deepClone(route);
+            // Check if route is already running
             if (this.activeRouteDictionary[clonedRoute.id]) {
                 // TODO: maybe inform user why nothing happens?
                 return clonedRoute;
@@ -192,11 +219,16 @@ export default class LIFI {
          * @throws {LifiError} Throws a LifiError if the execution fails.
          */
         this.resumeRoute = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
-            const clonedRoute = deepClone(route); // deep clone to prevent side effects
+            // Deep clone to prevent side effects
+            const clonedRoute = deepClone(route);
             const activeRoute = this.activeRouteDictionary[clonedRoute.id];
             if (activeRoute) {
                 const executionHalted = activeRoute.executors.some((executor) => executor.executionStopped);
                 if (!executionHalted) {
+                    // Check if we want to resume route execution in the background
+                    this.updateRouteExecution(route, {
+                        executeInBackground: settings === null || settings === void 0 ? void 0 : settings.executeInBackground,
+                    });
                     return clonedRoute;
                 }
             }
@@ -204,48 +236,57 @@ export default class LIFI {
             return this.executeSteps(signer, clonedRoute, settings);
         });
         this.executeSteps = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
             const config = this.configService.getConfig();
-            const execData = {
+            const executionData = {
                 route,
                 executors: [],
                 settings: Object.assign(Object.assign({}, config.defaultExecutionSettings), settings),
             };
-            this.activeRouteDictionary[route.id] = execData;
-            const statusManager = new StatusManager(route, this.activeRouteDictionary[route.id].settings, (route) => (this.activeRouteDictionary[route.id].route = route));
-            // loop over steps and execute them
+            this.activeRouteDictionary[route.id] = executionData;
+            const statusManager = new StatusManager(route, this.activeRouteDictionary[route.id].settings, (route) => {
+                if (this.activeRouteDictionary[route.id]) {
+                    this.activeRouteDictionary[route.id].route = route;
+                }
+            });
+            // Loop over steps and execute them
             for (let index = 0; index < route.steps.length; index++) {
-                //check if execution has stopped in meantime
-                if (!this.activeRouteDictionary[route.id]) {
+                const activeRoute = this.activeRouteDictionary[route.id];
+                // Check if execution has stopped in the meantime
+                if (!activeRoute) {
                     break;
                 }
                 const step = route.steps[index];
-                const previousStep = index !== 0 ? route.steps[index - 1] : undefined;
-                // check if step already done
-                if (step.execution && step.execution.status === 'DONE') {
+                const previousStep = route.steps[index - 1];
+                // Check if the step is already done
+                if (((_a = step.execution) === null || _a === void 0 ? void 0 : _a.status) === 'DONE') {
                     continue;
                 }
-                // update amount using output of previous execution. In the future this should be handled by calling `updateRoute`
-                if (previousStep &&
-                    previousStep.execution &&
-                    previousStep.execution.toAmount) {
+                // Update amount using output of previous execution. In the future this should be handled by calling `updateRoute`
+                if ((_b = previousStep === null || previousStep === void 0 ? void 0 : previousStep.execution) === null || _b === void 0 ? void 0 : _b.toAmount) {
                     step.action.fromAmount = previousStep.execution.toAmount;
                 }
-                let stepExecutor;
                 try {
-                    stepExecutor = new StepExecutor(statusManager, this.activeRouteDictionary[route.id].settings);
-                    this.activeRouteDictionary[route.id].executors.push(stepExecutor);
-                    yield stepExecutor.executeStep(signer, step);
+                    const stepExecutor = new StepExecutor(statusManager, activeRoute.settings);
+                    activeRoute.executors.push(stepExecutor);
+                    // Check if we want to execute this step in the background
+                    this.updateRouteExecution(route, activeRoute.settings);
+                    const executedStep = yield stepExecutor.executeStep(signer, step);
+                    // We may reach this point if user interaction isn't allowed. We want to stop execution until we resume it
+                    if (((_c = executedStep.execution) === null || _c === void 0 ? void 0 : _c.status) !== 'DONE') {
+                        this.stopExecution(route);
+                    }
+                    // Execution stopped during the current step, we don't want to continue to the next step so we return already
+                    if (stepExecutor.executionStopped) {
+                        return route;
+                    }
                 }
                 catch (e) {
                     this.stopExecution(route);
                     throw e;
                 }
-                // execution stopped during the current step, we don't want to continue to the next step so we return already
-                if (stepExecutor.executionStopped) {
-                    return route;
-                }
             }
-            //clean up after execution
+            // Clean up after the execution
             delete this.activeRouteDictionary[route.id];
             return route;
         });
@@ -362,7 +403,8 @@ export default class LIFI {
         };
         this.configService = ConfigService.getInstance();
         if (configUpdate) {
-            this.configService.updateConfig(configUpdate); // update API urls before we request chains
+            // Update API urls before we request chains
+            this.configService.updateConfig(configUpdate);
         }
         this.chainsService = ChainsService.getInstance();
         this.chainsService.getChains().then((chains) => {

package/dist/cjs/Lifi.d.ts

@@ -104,8 +104,15 @@ export default class LIFI {
     /**
      * Executes a route until a user interaction is necessary (signing transactions, etc.) and then halts until the route is resumed.
      * @param {Route} route - A route that is currently in execution.
+     * @deprecated use updateRouteExecution instead.
      */
     moveExecutionToBackground: (route: Route) => void;
+    /**
+     * Updates route execution to background or foreground state.
+     * @param {Route} route - A route that is currently in execution.
+     * @param {boolean} settings - An object with execution settings.
+     */
+    updateRouteExecution: (route: Route, settings: Pick<ExecutionSettings, 'executeInBackground'>) => void;
     /**
      * Execute a route.
      * @param {Signer} signer - The signer required to send the transactions.

package/dist/cjs/Lifi.js

@@ -154,7 +154,11 @@ class LIFI {
                 return route;
             }
             for (const executor of this.activeRouteDictionary[route.id].executors) {
-                executor.stopStepExecution({ allowUpdates: false });
+                executor.setInteraction({
+                    allowInteraction: false,
+                    allowUpdates: false,
+                    stopExecution: true,
+                });
             }
             delete this.activeRouteDictionary[route.id];
             return route;
@@ -162,14 +166,36 @@ class LIFI {
         /**
          * Executes a route until a user interaction is necessary (signing transactions, etc.) and then halts until the route is resumed.
          * @param {Route} route - A route that is currently in execution.
+         * @deprecated use updateRouteExecution instead.
          */
         this.moveExecutionToBackground = (route) => {
-            if (!this.activeRouteDictionary[route.id]) {
+            const activeRoute = this.activeRouteDictionary[route.id];
+            if (!activeRoute) {
                 return;
             }
-            for (const executor of this.activeRouteDictionary[route.id].executors) {
-                executor.stopStepExecution({ allowUpdates: true });
+            for (const executor of activeRoute.executors) {
+                executor.setInteraction({ allowInteraction: false, allowUpdates: true });
             }
+            activeRoute.settings = Object.assign(Object.assign({}, activeRoute.settings), { executeInBackground: true });
+        };
+        /**
+         * Updates route execution to background or foreground state.
+         * @param {Route} route - A route that is currently in execution.
+         * @param {boolean} settings - An object with execution settings.
+         */
+        this.updateRouteExecution = (route, settings) => {
+            const activeRoute = this.activeRouteDictionary[route.id];
+            if (!activeRoute) {
+                return;
+            }
+            for (const executor of activeRoute.executors) {
+                executor.setInteraction({
+                    allowInteraction: !settings.executeInBackground,
+                    allowUpdates: true,
+                });
+            }
+            // Update active route settings so we know what the current state of execution is
+            activeRoute.settings = Object.assign(Object.assign({}, activeRoute.settings), settings);
         };
         /**
          * Execute a route.
@@ -180,8 +206,9 @@ class LIFI {
          * @throws {LifiError} Throws a LifiError if the execution fails.
          */
         this.executeRoute = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
-            const clonedRoute = (0, utils_1.deepClone)(route); // deep clone to prevent side effects
-            // check if route is already running
+            // Deep clone to prevent side effects
+            const clonedRoute = (0, utils_1.deepClone)(route);
+            // Check if route is already running
             if (this.activeRouteDictionary[clonedRoute.id]) {
                 // TODO: maybe inform user why nothing happens?
                 return clonedRoute;
@@ -197,11 +224,16 @@ class LIFI {
          * @throws {LifiError} Throws a LifiError if the execution fails.
          */
         this.resumeRoute = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
-            const clonedRoute = (0, utils_1.deepClone)(route); // deep clone to prevent side effects
+            // Deep clone to prevent side effects
+            const clonedRoute = (0, utils_1.deepClone)(route);
             const activeRoute = this.activeRouteDictionary[clonedRoute.id];
             if (activeRoute) {
                 const executionHalted = activeRoute.executors.some((executor) => executor.executionStopped);
                 if (!executionHalted) {
+                    // Check if we want to resume route execution in the background
+                    this.updateRouteExecution(route, {
+                        executeInBackground: settings === null || settings === void 0 ? void 0 : settings.executeInBackground,
+                    });
                     return clonedRoute;
                 }
             }
@@ -209,48 +241,57 @@ class LIFI {
             return this.executeSteps(signer, clonedRoute, settings);
         });
         this.executeSteps = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
             const config = this.configService.getConfig();
-            const execData = {
+            const executionData = {
                 route,
                 executors: [],
                 settings: Object.assign(Object.assign({}, config.defaultExecutionSettings), settings),
             };
-            this.activeRouteDictionary[route.id] = execData;
-            const statusManager = new StatusManager_1.StatusManager(route, this.activeRouteDictionary[route.id].settings, (route) => (this.activeRouteDictionary[route.id].route = route));
-            // loop over steps and execute them
+            this.activeRouteDictionary[route.id] = executionData;
+            const statusManager = new StatusManager_1.StatusManager(route, this.activeRouteDictionary[route.id].settings, (route) => {
+                if (this.activeRouteDictionary[route.id]) {
+                    this.activeRouteDictionary[route.id].route = route;
+                }
+            });
+            // Loop over steps and execute them
             for (let index = 0; index < route.steps.length; index++) {
-                //check if execution has stopped in meantime
-                if (!this.activeRouteDictionary[route.id]) {
+                const activeRoute = this.activeRouteDictionary[route.id];
+                // Check if execution has stopped in the meantime
+                if (!activeRoute) {
                     break;
                 }
                 const step = route.steps[index];
-                const previousStep = index !== 0 ? route.steps[index - 1] : undefined;
-                // check if step already done
-                if (step.execution && step.execution.status === 'DONE') {
+                const previousStep = route.steps[index - 1];
+                // Check if the step is already done
+                if (((_a = step.execution) === null || _a === void 0 ? void 0 : _a.status) === 'DONE') {
                     continue;
                 }
-                // update amount using output of previous execution. In the future this should be handled by calling `updateRoute`
-                if (previousStep &&
-                    previousStep.execution &&
-                    previousStep.execution.toAmount) {
+                // Update amount using output of previous execution. In the future this should be handled by calling `updateRoute`
+                if ((_b = previousStep === null || previousStep === void 0 ? void 0 : previousStep.execution) === null || _b === void 0 ? void 0 : _b.toAmount) {
                     step.action.fromAmount = previousStep.execution.toAmount;
                 }
-                let stepExecutor;
                 try {
-                    stepExecutor = new StepExecutor_1.StepExecutor(statusManager, this.activeRouteDictionary[route.id].settings);
-                    this.activeRouteDictionary[route.id].executors.push(stepExecutor);
-                    yield stepExecutor.executeStep(signer, step);
+                    const stepExecutor = new StepExecutor_1.StepExecutor(statusManager, activeRoute.settings);
+                    activeRoute.executors.push(stepExecutor);
+                    // Check if we want to execute this step in the background
+                    this.updateRouteExecution(route, activeRoute.settings);
+                    const executedStep = yield stepExecutor.executeStep(signer, step);
+                    // We may reach this point if user interaction isn't allowed. We want to stop execution until we resume it
+                    if (((_c = executedStep.execution) === null || _c === void 0 ? void 0 : _c.status) !== 'DONE') {
+                        this.stopExecution(route);
+                    }
+                    // Execution stopped during the current step, we don't want to continue to the next step so we return already
+                    if (stepExecutor.executionStopped) {
+                        return route;
+                    }
                 }
                 catch (e) {
                     this.stopExecution(route);
                     throw e;
                 }
-                // execution stopped during the current step, we don't want to continue to the next step so we return already
-                if (stepExecutor.executionStopped) {
-                    return route;
-                }
             }
-            //clean up after execution
+            // Clean up after the execution
             delete this.activeRouteDictionary[route.id];
             return route;
         });
@@ -367,7 +408,8 @@ class LIFI {
         };
         this.configService = ConfigService_1.default.getInstance();
         if (configUpdate) {
-            this.configService.updateConfig(configUpdate); // update API urls before we request chains
+            // Update API urls before we request chains
+            this.configService.updateConfig(configUpdate);
         }
         this.chainsService = ChainsService_1.default.getInstance();
         this.chainsService.getChains().then((chains) => {

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

@@ -42,7 +42,7 @@ export declare class StatusManager {
      * @param  {Status} status By default created procces is set to the STARTED status. We can override new process with the needed status.
      * @return {Process}
      */
-    findOrCreateProcess: (type: ProcessType, step: Step, status?: Status) => Process;
+    findOrCreateProcess: (step: Step, type: ProcessType, status?: Status) => Process;
     /**
      * Update a process object.
      * @param  {Step} step The step where the process should be updated
@@ -60,6 +60,6 @@ export declare class StatusManager {
      */
     removeProcess: (step: Step, type: ProcessType) => void;
     updateStepInRoute: (step: Step) => Step;
-    setShouldUpdate(value: boolean): void;
+    allowUpdates(value: boolean): void;
 }
 export {};

package/dist/cjs/execution/StatusManager.js

@@ -40,12 +40,17 @@ class StatusManager {
          * @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) {
+        this.findOrCreateProcess = (step, type, status) => {
+            var _a;
+            if (!((_a = step.execution) === null || _a === void 0 ? void 0 : _a.process)) {
                 throw new Error("Execution hasn't been initialized.");
             }
             const process = step.execution.process.find((p) => p.type === type);
             if (process) {
+                if (status && process.status !== status) {
+                    process.status = status;
+                    this.updateStepInRoute(step);
+                }
                 return process;
             }
             const newProcess = {
@@ -67,7 +72,7 @@ class StatusManager {
          * @return {Process} The update process
          */
         this.updateProcess = (step, type, status, params) => {
-            var _a;
+            var _a, _b, _c;
             if (!step.execution) {
                 throw new Error("Can't update an empty step execution.");
             }
@@ -92,9 +97,6 @@ class StatusManager {
                 case 'ACTION_REQUIRED':
                     step.execution.status = 'ACTION_REQUIRED';
                     break;
-                case 'CHAIN_SWITCH_REQUIRED':
-                    step.execution.status = 'CHAIN_SWITCH_REQUIRED';
-                    break;
                 default:
                     break;
             }
@@ -106,6 +108,11 @@ class StatusManager {
                     currentProcess[key] = value;
                 }
             }
+            // Sort processes, the ones with DONE status go first
+            step.execution.process = [
+                ...(_b = step === null || step === void 0 ? void 0 : step.execution) === null || _b === void 0 ? void 0 : _b.process.filter((process) => process.status === 'DONE'),
+                ...(_c = step === null || step === void 0 ? void 0 : step.execution) === null || _c === void 0 ? void 0 : _c.process.filter((process) => process.status !== 'DONE'),
+            ];
             this.updateStepInRoute(step); // updates the step in the route
             return currentProcess;
         };
@@ -160,7 +167,7 @@ class StatusManager {
         this.updateStepInRoute(step);
         return step;
     }
-    setShouldUpdate(value) {
+    allowUpdates(value) {
         this.shouldUpdate = value;
     }
 }

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

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

package/dist/cjs/execution/StepExecutor.js

@@ -13,26 +13,37 @@ 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 = {
+// Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
+const defaultInteractionSettings = {
+    allowInteraction: true,
     allowUpdates: true,
+    stopExecution: false,
 };
 class StepExecutor {
     constructor(statusManager, settings) {
         this.swapExecutionManager = new swap_execute_1.SwapExecutionManager();
         this.bridgeExecutionManager = new bridge_execute_1.BridgeExecutionManager();
+        this.allowUserInteraction = true;
         this.executionStopped = false;
-        this.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.setInteraction = (settings) => {
+            const interactionSettings = Object.assign(Object.assign({}, defaultInteractionSettings), settings);
+            this.allowUserInteraction = interactionSettings.allowInteraction;
+            this.swapExecutionManager.allowInteraction(interactionSettings.allowInteraction);
+            this.bridgeExecutionManager.allowInteraction(interactionSettings.allowInteraction);
+            this.statusManager.allowUpdates(interactionSettings.allowUpdates);
+            this.executionStopped = interactionSettings.stopExecution;
+        };
+        // TODO: add checkChain method and update signer inside executors
+        // This can come in handy when we execute multiple routes simultaneously and
+        // should be sure that we are on the right chain when waiting for transactions.
+        this.checkChain = () => {
+            throw new Error('checkChain is not implemented.');
         };
         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);
+            // Make sure that the chain is still correct
+            const updatedSigner = yield (0, switchChain_1.switchChain)(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
             if (!updatedSigner) {
-                // chain switch was not successful, stop execution here
+                // Chain switch was not successful, stop execution here
                 return step;
             }
             signer = updatedSigner;
@@ -49,24 +60,24 @@ class StepExecutor {
             }
             return step;
         });
-        this.executeSwap = (signer, step) => __awaiter(this, void 0, void 0, function* () {
+        this.executeSwap = (signer, step) => {
             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* () {
+            return this.swapExecutionManager.execute(swapParams);
+        };
+        this.executeCross = (signer, step) => {
             const crossParams = {
                 signer,
                 step,
                 settings: this.settings,
                 statusManager: this.statusManager,
             };
-            return yield this.bridgeExecutionManager.execute(crossParams);
-        });
+            return this.bridgeExecutionManager.execute(crossParams);
+        };
         this.statusManager = statusManager;
         this.settings = settings;
     }

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

@@ -1,4 +1,4 @@
 import { Signer } from 'ethers';
-import { Chain, Step, Token } from '../types';
+import { Chain, InternalExecutionSettings, Step } 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>;
+export declare const checkAllowance: (signer: Signer, step: Step, statusManager: StatusManager, settings: InternalExecutionSettings, chain: Chain, allowUserInteraction?: boolean) => Promise<void>;