@lifi/sdk 3.0.0-alpha.4 → 3.0.0-alpha.7

package/dist/cjs/allowance/setAllowance.js

@@ -6,7 +6,7 @@ const types_1 = require("../types");
 const utils_1 = require("../utils");
 const utils_2 = require("../utils/utils");
 const getAllowance_1 = require("./getAllowance");
-const setAllowance = async (walletClient, tokenAddress, contractAddress, amount, returnPopulatedTransaction) => {
+const setAllowance = async (walletClient, tokenAddress, contractAddress, amount, settings, returnPopulatedTransaction) => {
     const data = (0, viem_1.encodeFunctionData)({
         abi: types_1.approveAbi,
         functionName: 'approve',
@@ -16,15 +16,31 @@ const setAllowance = async (walletClient, tokenAddress, contractAddress, amount,
         return data;
     }
     const client = walletClient.extend(viem_1.publicActions);
-    let maxPriorityFeePerGas;
-    if (walletClient.account?.type === 'local') {
-        maxPriorityFeePerGas = await (0, utils_1.getMaxPriorityFeePerGas)(client);
+    let transactionRequest = {
+        to: tokenAddress,
+        data,
+        maxPriorityFeePerGas: walletClient.account?.type === 'local'
+            ? await (0, utils_1.getMaxPriorityFeePerGas)(client)
+            : undefined,
+    };
+    if (settings?.updateTransactionRequestHook) {
+        const customizedTransactionRequest = await settings.updateTransactionRequestHook({
+            requestType: 'approve',
+            ...transactionRequest,
+        });
+        transactionRequest = {
+            ...transactionRequest,
+            ...customizedTransactionRequest,
+        };
     }
     return client.sendTransaction({
-        to: tokenAddress,
+        to: transactionRequest.to,
         account: walletClient.account,
-        data,
-        maxPriorityFeePerGas,
+        data: transactionRequest.data,
+        gas: transactionRequest.gas,
+        gasPrice: transactionRequest.gasPrice,
+        maxFeePerGas: transactionRequest.maxFeePerGas,
+        maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
         chain: null,
     });
 };

package/dist/cjs/connectors.d.ts

@@ -1,6 +1,6 @@
+import type { ChainId } from '@lifi/types';
 import type { PublicClient } from 'viem';
 import type { Chain } from 'viem/chains';
-import type { ChainId } from './types';
 export declare const getChainById: (chainId: ChainId) => Chain | undefined;
 export declare const getRpcUrl: (chainId: ChainId) => Promise<string>;
 export declare const getRpcUrls: (chainId: ChainId) => Promise<string[]>;

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

@@ -0,0 +1,12 @@
+import type { LiFiStep } from '@lifi/types';
+import type { StatusManager } from './StatusManager';
+import type { InteractionSettings, InternalExecutionSettings, StepExecutorOptions } from './types';
+export declare abstract class BaseStepExecutor {
+    settings: InternalExecutionSettings;
+    statusManager: StatusManager;
+    allowUserInteraction: boolean;
+    allowExecution: boolean;
+    constructor(options: StepExecutorOptions);
+    setInteraction: (settings?: InteractionSettings) => void;
+    abstract executeStep(step: LiFiStep): Promise<LiFiStep>;
+}

package/dist/cjs/execution/BaseStepExecutor.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseStepExecutor = void 0;
+// Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
+const defaultInteractionSettings = {
+    allowInteraction: true,
+    allowUpdates: true,
+    allowExecution: true,
+};
+class BaseStepExecutor {
+    constructor(options) {
+        this.allowUserInteraction = true;
+        this.allowExecution = true;
+        this.setInteraction = (settings) => {
+            const interactionSettings = {
+                ...defaultInteractionSettings,
+                ...settings,
+            };
+            this.allowUserInteraction = interactionSettings.allowInteraction;
+            this.statusManager.allowUpdates(interactionSettings.allowUpdates);
+            this.allowExecution = interactionSettings.allowExecution;
+        };
+        this.statusManager = options.statusManager;
+        this.settings = options.settings;
+    }
+}
+exports.BaseStepExecutor = BaseStepExecutor;

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

@@ -0,0 +1,13 @@
+import type { LiFiStep } from '@lifi/types';
+import type { WalletClient } from 'viem';
+import { BaseStepExecutor } from './BaseStepExecutor';
+import type { StepExecutorOptions } from './types';
+export interface EVMStepExecutorOptions extends StepExecutorOptions {
+    walletClient: WalletClient;
+}
+export declare class EVMStepExecutor extends BaseStepExecutor {
+    walletClient: WalletClient;
+    constructor(options: EVMStepExecutorOptions);
+    checkChain: () => never;
+    executeStep: (step: LiFiStep) => Promise<LiFiStep>;
+}

package/dist/cjs/execution/EVMStepExecutor.js

@@ -0,0 +1,292 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMStepExecutor = void 0;
+const viem_1 = require("viem");
+const ApiService_1 = __importDefault(require("../services/ApiService"));
+const ChainsService_1 = __importDefault(require("../services/ChainsService"));
+const ConfigService_1 = __importDefault(require("../services/ConfigService"));
+const utils_1 = require("../utils");
+const errors_1 = require("../utils/errors");
+const parseError_1 = require("../utils/parseError");
+const utils_2 = require("../utils/utils");
+const BaseStepExecutor_1 = require("./BaseStepExecutor");
+const checkAllowance_1 = require("./checkAllowance");
+const checkBalance_1 = require("./checkBalance");
+const multisig_1 = require("./multisig");
+const stepComparison_1 = require("./stepComparison");
+const switchChain_1 = require("./switchChain");
+const utils_3 = require("./utils");
+const waitForReceivingTransaction_1 = require("./waitForReceivingTransaction");
+class EVMStepExecutor extends BaseStepExecutor_1.BaseStepExecutor {
+    constructor(options) {
+        super(options);
+        // TODO: add checkChain method and update wallet client 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 = async (step) => {
+            // Make sure that the chain is still correct
+            // Find if it's bridging and the step is waiting for a transaction on the receiving chain
+            const recievingChainProcess = step.execution?.process.find((process) => process.type === 'RECEIVING_CHAIN');
+            // If the step is waiting for a transaction on the receiving chain, we do not switch the chain
+            // All changes are already done from the source chain
+            // Return the step
+            if (recievingChainProcess?.substatus !== 'WAIT_DESTINATION_TRANSACTION' ||
+                !recievingChainProcess) {
+                const updatedWalletClient = await (0, switchChain_1.switchChain)(this.walletClient, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
+                if (!updatedWalletClient) {
+                    // Chain switch was not successful, stop execution here
+                    return step;
+                }
+                this.walletClient = updatedWalletClient;
+            }
+            const client = this.walletClient.extend(viem_1.publicActions);
+            const config = ConfigService_1.default.getInstance().getConfig();
+            const isMultisigWalletClient = !!config.multisig?.isMultisigWalletClient;
+            const multisigBatchTransactions = [];
+            const shouldBatchTransactions = config.multisig?.shouldBatchTransactions &&
+                !!config.multisig.sendBatchTransaction;
+            step.execution = this.statusManager.initExecutionObject(step);
+            const chainsService = ChainsService_1.default.getInstance();
+            const fromChain = await chainsService.getChainById(step.action.fromChainId);
+            const toChain = await chainsService.getChainById(step.action.toChainId);
+            const isBridgeExecution = fromChain.id !== toChain.id;
+            const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP';
+            // STEP 1: Check allowance
+            const existingProcess = step.execution.process.find((p) => p.type === currentProcessType);
+            // Check token approval only if fromToken is not the native token => no approval needed in that case
+            const checkForAllowance = !existingProcess?.txHash &&
+                !(0, utils_2.isZeroAddress)(step.action.fromToken.address) &&
+                (shouldBatchTransactions || !isMultisigWalletClient);
+            if (checkForAllowance) {
+                const data = await (0, checkAllowance_1.checkAllowance)(client, step, this.statusManager, this.settings, fromChain, this.allowUserInteraction, shouldBatchTransactions);
+                if (data) {
+                    // allowance doesn't need value
+                    const baseTransaction = {
+                        to: step.action.fromToken.address,
+                        data,
+                    };
+                    multisigBatchTransactions.push(baseTransaction);
+                }
+            }
+            // STEP 2: Get transaction
+            let process = this.statusManager.findOrCreateProcess(step, currentProcessType);
+            if (process.status !== 'DONE') {
+                const multisigProcess = step.execution.process.find((p) => !!p.multisigTxHash);
+                try {
+                    if (isMultisigWalletClient && multisigProcess) {
+                        const multisigTxHash = multisigProcess.multisigTxHash;
+                        if (!multisigTxHash) {
+                            throw new errors_1.ValidationError('Multisig internal transaction hash is undefined.');
+                        }
+                        await (0, multisig_1.updateMultisigRouteProcess)(multisigTxHash, step, this.statusManager, process.type, fromChain);
+                    }
+                    let txHash;
+                    if (process.txHash) {
+                        // Make sure that the chain is still correct
+                        const updatedWalletClient = await (0, switchChain_1.switchChain)(this.walletClient, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
+                        if (!updatedWalletClient) {
+                            // Chain switch was not successful, stop execution here
+                            return step;
+                        }
+                        this.walletClient = updatedWalletClient;
+                        // Load exiting transaction
+                        txHash = process.txHash;
+                    }
+                    else {
+                        process = this.statusManager.updateProcess(step, process.type, 'STARTED');
+                        // Check balance
+                        await (0, checkBalance_1.checkBalance)(client.account.address, step);
+                        // Create new transaction
+                        if (!step.transactionRequest) {
+                            const updatedStep = await ApiService_1.default.getStepTransaction(step);
+                            const comparedStep = await (0, stepComparison_1.stepComparison)(this.statusManager, step, updatedStep, this.settings, this.allowUserInteraction);
+                            step = {
+                                ...comparedStep,
+                                execution: step.execution,
+                            };
+                        }
+                        if (!step.transactionRequest) {
+                            throw new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                        }
+                        // STEP 3: Send the transaction
+                        // Make sure that the chain is still correct
+                        const updatedWalletClient = await (0, switchChain_1.switchChain)(this.walletClient, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
+                        if (!updatedWalletClient) {
+                            // Chain switch was not successful, stop execution here
+                            return step;
+                        }
+                        this.walletClient = updatedWalletClient;
+                        process = this.statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED');
+                        if (!this.allowUserInteraction) {
+                            return step;
+                        }
+                        let transactionRequest = {
+                            to: step.transactionRequest.to,
+                            from: step.transactionRequest.from,
+                            data: step.transactionRequest.data,
+                            value: step.transactionRequest.value
+                                ? BigInt(step.transactionRequest.value)
+                                : undefined,
+                            gas: step.transactionRequest.gasLimit
+                                ? BigInt(step.transactionRequest.gasLimit)
+                                : undefined,
+                            // gasPrice: step.transactionRequest.gasPrice
+                            //   ? BigInt(step.transactionRequest.gasPrice as string)
+                            //   : undefined,
+                            // maxFeePerGas: step.transactionRequest.maxFeePerGas
+                            //   ? BigInt(step.transactionRequest.maxFeePerGas as string)
+                            //   : undefined,
+                            maxPriorityFeePerGas: this.walletClient.account?.type === 'local'
+                                ? await (0, utils_1.getMaxPriorityFeePerGas)(client)
+                                : step.transactionRequest.maxPriorityFeePerGas
+                                    ? BigInt(step.transactionRequest.maxPriorityFeePerGas)
+                                    : undefined,
+                        };
+                        if (this.settings.updateTransactionRequestHook) {
+                            const customizedTransactionRequest = await this.settings.updateTransactionRequestHook({
+                                requestType: 'transaction',
+                                ...transactionRequest,
+                            });
+                            transactionRequest = {
+                                ...transactionRequest,
+                                ...customizedTransactionRequest,
+                            };
+                        }
+                        if (shouldBatchTransactions &&
+                            config.multisig?.sendBatchTransaction) {
+                            if (transactionRequest.to && transactionRequest.data) {
+                                const populatedTransaction = {
+                                    value: transactionRequest.value,
+                                    to: transactionRequest.to,
+                                    data: transactionRequest.data,
+                                };
+                                multisigBatchTransactions.push(populatedTransaction);
+                                txHash = await config.multisig?.sendBatchTransaction(multisigBatchTransactions);
+                            }
+                            else {
+                                throw new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                            }
+                        }
+                        else {
+                            txHash = await this.walletClient.sendTransaction({
+                                to: transactionRequest.to,
+                                account: this.walletClient.account,
+                                data: transactionRequest.data,
+                                gas: transactionRequest.gas,
+                                gasPrice: transactionRequest.gasPrice,
+                                maxFeePerGas: transactionRequest.maxFeePerGas,
+                                maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
+                                chain: null,
+                            });
+                        }
+                        // STEP 4: Wait for the transaction
+                        if (isMultisigWalletClient) {
+                            process = this.statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED', {
+                                multisigTxHash: txHash,
+                            });
+                        }
+                        else {
+                            process = this.statusManager.updateProcess(step, process.type, 'PENDING', {
+                                txHash: txHash,
+                                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
+                            });
+                        }
+                    }
+                    let replacementReason;
+                    const transactionReceipt = await client.waitForTransactionReceipt({
+                        hash: txHash,
+                        onReplaced: (response) => {
+                            replacementReason = response.reason;
+                            this.statusManager.updateProcess(step, process.type, 'PENDING', {
+                                txHash: response.transaction.hash,
+                                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
+                            });
+                        },
+                    });
+                    if (replacementReason === 'cancelled') {
+                        throw new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionCanceled, 'User canceled transaction.');
+                    }
+                    // if it's multisig wallet client and the process is in ACTION_REQUIRED
+                    // then signatures are still needed
+                    if (isMultisigWalletClient && process.status === 'ACTION_REQUIRED') {
+                        await (0, multisig_1.updateMultisigRouteProcess)(transactionReceipt.transactionHash, step, this.statusManager, process.type, fromChain);
+                    }
+                    if (!isMultisigWalletClient) {
+                        process = this.statusManager.updateProcess(step, process.type, 'PENDING', {
+                            txHash: transactionReceipt.transactionHash,
+                            txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
+                        });
+                    }
+                    if (isBridgeExecution) {
+                        process = this.statusManager.updateProcess(step, process.type, 'DONE');
+                    }
+                }
+                catch (e) {
+                    const error = await (0, parseError_1.parseError)(e, step, process);
+                    process = this.statusManager.updateProcess(step, process.type, 'FAILED', {
+                        error: {
+                            message: error.message,
+                            htmlMessage: error.htmlMessage,
+                            code: error.code,
+                        },
+                    });
+                    this.statusManager.updateExecution(step, 'FAILED');
+                    throw error;
+                }
+            }
+            // STEP 5: Wait for the receiving chain
+            const processTxHash = process.txHash;
+            if (isBridgeExecution) {
+                process = this.statusManager.findOrCreateProcess(step, 'RECEIVING_CHAIN', 'PENDING');
+            }
+            let statusResponse;
+            try {
+                if (!processTxHash) {
+                    throw new Error('Transaction hash is undefined.');
+                }
+                statusResponse = (await (0, waitForReceivingTransaction_1.waitForReceivingTransaction)(processTxHash, this.statusManager, process.type, step));
+                const statusReceiving = statusResponse.receiving;
+                process = this.statusManager.updateProcess(step, process.type, 'DONE', {
+                    substatus: statusResponse.substatus,
+                    substatusMessage: statusResponse.substatusMessage ||
+                        (0, utils_3.getSubstatusMessage)(statusResponse.status, statusResponse.substatus),
+                    txHash: statusReceiving?.txHash,
+                    txLink: `${toChain.metamask.blockExplorerUrls[0]}tx/${statusReceiving?.txHash}`,
+                });
+                this.statusManager.updateExecution(step, 'DONE', {
+                    fromAmount: statusResponse.sending.amount,
+                    toAmount: statusReceiving?.amount,
+                    toToken: statusReceiving?.token,
+                    gasAmount: statusResponse.sending.gasAmount,
+                    gasAmountUSD: statusResponse.sending.gasAmountUSD,
+                    gasPrice: statusResponse.sending.gasPrice,
+                    gasToken: statusResponse.sending.gasToken,
+                    gasUsed: statusResponse.sending.gasUsed,
+                });
+            }
+            catch (e) {
+                const htmlMessage = await (0, parseError_1.getTransactionFailedMessage)(step, process.txLink);
+                process = this.statusManager.updateProcess(step, process.type, 'FAILED', {
+                    error: {
+                        code: errors_1.LiFiErrorCode.TransactionFailed,
+                        message: 'Failed while waiting for receiving chain.',
+                        htmlMessage,
+                    },
+                });
+                this.statusManager.updateExecution(step, 'FAILED');
+                console.warn(e);
+                throw e;
+            }
+            // DONE
+            return step;
+        };
+        this.walletClient = options.walletClient;
+    }
+}
+exports.EVMStepExecutor = EVMStepExecutor;

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

@@ -1,30 +1,29 @@
 import type { Route } from '@lifi/types';
-import type { WalletClient } from 'viem';
 import ConfigService from '../services/ConfigService';
-import type { ConfigUpdate, ExecutionSettings } from '../types';
+import type { SDKOptions } from '../types';
+import type { ExecutionSettings } from './types';
 export declare class RouteExecutionManager {
     private executionDictionary;
     private executionPromiseDictionary;
     protected configService: ConfigService;
-    constructor(configUpdate: ConfigUpdate);
+    private providers;
+    constructor(options: SDKOptions);
     /**
      * Execute a route.
-     * @param walletClient - The walletClient required to send the transactions.
      * @param route - The route that should be executed. Cannot be an active route.
      * @param settings - An object containing settings and callbacks.
      * @returns The executed route.
      * @throws {LiFiError} Throws a LiFiError if the execution fails.
      */
-    executeRoute: (walletClient: WalletClient, route: Route, settings?: ExecutionSettings) => Promise<Route>;
+    executeRoute: (route: Route, settings?: ExecutionSettings) => Promise<Route>;
     /**
      * Resume the execution of a route that has been stopped or had an error while executing.
-     * @param walletClient - The walletClient required to send the transactions.
      * @param route - The route that is to be executed. Cannot be an active route.
      * @param settings - An object containing settings and callbacks.
      * @returns The executed route.
      * @throws {LiFiError} Throws a LiFiError if the execution fails.
      */
-    resumeRoute: (walletClient: WalletClient, route: Route, settings?: ExecutionSettings) => Promise<Route>;
+    resumeRoute: (route: Route, settings?: ExecutionSettings) => Promise<Route>;
     private executeSteps;
     /**
      * Updates route execution to background or foreground state.

package/dist/cjs/execution/RouteExecutionManager.js

@@ -4,24 +4,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouteExecutionManager = void 0;
+const EVMProvider_1 = require("../providers/EVMProvider");
 const ConfigService_1 = __importDefault(require("../services/ConfigService"));
 const errors_1 = require("../utils/errors");
 const StatusManager_1 = require("./StatusManager");
-const StepExecutor_1 = require("./StepExecutor");
 const prepareRestart_1 = require("./prepareRestart");
 class RouteExecutionManager {
-    constructor(configUpdate) {
+    constructor(options) {
         this.executionDictionary = {};
         this.executionPromiseDictionary = {};
         /**
          * Execute a route.
-         * @param walletClient - The walletClient required to send the transactions.
          * @param route - The route that should be executed. Cannot be an active route.
          * @param settings - An object containing settings and callbacks.
          * @returns The executed route.
          * @throws {LiFiError} Throws a LiFiError if the execution fails.
          */
-        this.executeRoute = async (walletClient, route, settings) => {
+        this.executeRoute = async (route, settings) => {
             // Deep clone to prevent side effects
             const clonedRoute = structuredClone(route);
             let executionPromise = this.executionPromiseDictionary[clonedRoute.id];
@@ -29,24 +28,23 @@ class RouteExecutionManager {
             if (executionPromise) {
                 return executionPromise;
             }
-            executionPromise = this.executeSteps(walletClient, clonedRoute, settings);
+            executionPromise = this.executeSteps(clonedRoute, settings);
             this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
             return executionPromise;
         };
         /**
          * Resume the execution of a route that has been stopped or had an error while executing.
-         * @param walletClient - The walletClient required to send the transactions.
          * @param route - The route that is to be executed. Cannot be an active route.
          * @param settings - An object containing settings and callbacks.
          * @returns The executed route.
          * @throws {LiFiError} Throws a LiFiError if the execution fails.
          */
-        this.resumeRoute = async (walletClient, route, settings) => {
+        this.resumeRoute = async (route, settings) => {
             // Deep clone to prevent side effects
             const clonedRoute = structuredClone(route);
             const execution = this.executionDictionary[clonedRoute.id];
             if (execution) {
-                const executionHalted = execution.executors.some((executor) => executor.executionStopped);
+                const executionHalted = execution.executors.some((executor) => !executor.allowExecution);
                 if (!executionHalted) {
                     // Check if we want to resume route execution in the background
                     this.updateRouteExecution(route, {
@@ -56,12 +54,12 @@ class RouteExecutionManager {
                     return executionPromise ?? clonedRoute;
                 }
             }
-            await (0, prepareRestart_1.prepareRestart)(clonedRoute, walletClient);
-            const executionPromise = this.executeSteps(walletClient, clonedRoute, settings);
+            await (0, prepareRestart_1.prepareRestart)(clonedRoute);
+            const executionPromise = this.executeSteps(clonedRoute, settings);
             this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
             return executionPromise;
         };
-        this.executeSteps = async (walletClient, route, settings) => {
+        this.executeSteps = async (route, settings) => {
             const config = this.configService.getConfig();
             const execution = {
                 route,
@@ -93,17 +91,21 @@ class RouteExecutionManager {
                     step.action.fromAmount = previousStep.execution.toAmount;
                 }
                 try {
-                    const stepExecutor = new StepExecutor_1.StepExecutor(statusManager, execution.settings);
+                    const provider = this.providers.find((provider) => provider.isProviderStep(step));
+                    const stepExecutor = await provider.getStepExecutor({
+                        statusManager,
+                        settings: execution.settings,
+                    });
                     execution.executors.push(stepExecutor);
                     // Check if we want to execute this step in the background
                     this.updateRouteExecution(route, execution.settings);
-                    const executedStep = await stepExecutor.executeStep(walletClient, step);
+                    const executedStep = await stepExecutor.executeStep(step);
                     // We may reach this point if user interaction isn't allowed. We want to stop execution until we resume it
                     if (executedStep.execution?.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) {
+                    if (stepExecutor.allowExecution) {
                         return route;
                     }
                 }
@@ -169,7 +171,7 @@ class RouteExecutionManager {
                 executor.setInteraction({
                     allowInteraction: false,
                     allowUpdates: false,
-                    stopExecution: true,
+                    allowExecution: false,
                 });
             }
             delete this.executionDictionary[route.id];
@@ -193,10 +195,8 @@ class RouteExecutionManager {
             return this.executionDictionary[route.id]?.route;
         };
         this.configService = ConfigService_1.default.getInstance();
-        if (configUpdate) {
-            // Update API urls before we request chains
-            this.configService.updateConfig(configUpdate);
-        }
+        this.configService.updateConfig(options);
+        this.providers = options.providers ?? [new EVMProvider_1.EVMProvider()];
     }
 }
 exports.RouteExecutionManager = RouteExecutionManager;

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

@@ -1,4 +1,5 @@
-import type { Execution, InternalExecutionSettings, LifiStep, Process, ProcessType, Route, Status, Token } from '../types';
+import type { Execution, LiFiStep, Process, ProcessType, Route, Status, Token } from '@lifi/types';
+import type { InternalExecutionSettings } from './types';
 interface Receipt {
     fromAmount?: string;
     toAmount?: string;
@@ -29,7 +30,7 @@ export declare class StatusManager {
      * @param step  The current step in execution
      * @returns The initialized execution object for this step and a function to update this step
      */
-    initExecutionObject: (step: LifiStep) => Execution;
+    initExecutionObject: (step: LiFiStep) => Execution;
     /**
      * Updates the execution object of a Step.
      * @param step  The current step in execution
@@ -37,7 +38,7 @@ export declare class StatusManager {
      * @param receipt Optional. Information about received tokens
      * @returns       The step with the updated execution object
      */
-    updateExecution(step: LifiStep, status: Status, receipt?: Receipt): LifiStep;
+    updateExecution(step: LiFiStep, status: Status, receipt?: Receipt): LiFiStep;
     /**
      * Create and push a new process into the execution.
      * @param step The step that should contain the new process.
@@ -45,7 +46,7 @@ export declare class StatusManager {
      * @param status By default created procces is set to the STARTED status. We can override new process with the needed status.
      * @returns Returns process.
      */
-    findOrCreateProcess: (step: LifiStep, type: ProcessType, status?: Status) => Process;
+    findOrCreateProcess: (step: LiFiStep, type: ProcessType, status?: Status) => Process;
     /**
      * Update a process object.
      * @param step The step where the process should be updated
@@ -54,14 +55,14 @@ export declare class StatusManager {
      * @param [params]   Additional parameters to append to the process.
      * @returns The update process
      */
-    updateProcess: (step: LifiStep, type: ProcessType, status: Status, params?: OptionalParameters) => Process;
+    updateProcess: (step: LiFiStep, type: ProcessType, status: Status, params?: OptionalParameters) => Process;
     /**
      * Remove a process from the execution
      * @param step The step where the process should be removed from
      * @param type  The process type to remove
      */
-    removeProcess: (step: LifiStep, type: ProcessType) => void;
-    updateStepInRoute: (step: LifiStep) => LifiStep;
+    removeProcess: (step: LiFiStep, type: ProcessType) => void;
+    updateStepInRoute: (step: LiFiStep) => LiFiStep;
     allowUpdates(value: boolean): void;
 }
 export {};

package/dist/cjs/execution/StatusManager.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatusManager = void 0;
-const types_1 = require("../types");
+const types_1 = require("@lifi/types");
 const utils_1 = require("./utils");
 /**
  * Manages status updates of a route and provides various functions for tracking processes

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

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