@lifi/sdk 3.0.0-alpha.6 → 3.0.0-alpha.8

package/dist/execution/EVMStepExecutor.js

@@ -0,0 +1,285 @@
+import { publicActions } from 'viem';
+import ApiService from '../services/ApiService';
+import { ChainsService } from '../services/ChainsService';
+import { ConfigService } from '../services/ConfigService';
+import { getMaxPriorityFeePerGas } from '../utils';
+import { LiFiErrorCode, TransactionError, ValidationError, } from '../utils/errors';
+import { getTransactionFailedMessage, parseError } from '../utils/parseError';
+import { isZeroAddress } from '../utils/utils';
+import { BaseStepExecutor } from './BaseStepExecutor';
+import { checkAllowance } from './checkAllowance';
+import { checkBalance } from './checkBalance';
+import { updateMultisigRouteProcess } from './multisig';
+import { stepComparison } from './stepComparison';
+import { switchChain } from './switchChain';
+import { getSubstatusMessage } from './utils';
+import { waitForReceivingTransaction } from './waitForReceivingTransaction';
+export class EVMStepExecutor extends 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 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(publicActions);
+            const config = ConfigService.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.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 &&
+                !isZeroAddress(step.action.fromToken.address) &&
+                (shouldBatchTransactions || !isMultisigWalletClient);
+            if (checkForAllowance) {
+                const data = await 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 ValidationError('Multisig internal transaction hash is undefined.');
+                        }
+                        await updateMultisigRouteProcess(multisigTxHash, step, this.statusManager, process.type, fromChain);
+                    }
+                    let txHash;
+                    if (process.txHash) {
+                        // Make sure that the chain is still correct
+                        const updatedWalletClient = await 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 checkBalance(client.account.address, step);
+                        // Create new transaction
+                        if (!step.transactionRequest) {
+                            const updatedStep = await ApiService.getStepTransaction(step);
+                            const comparedStep = await stepComparison(this.statusManager, step, updatedStep, this.settings, this.allowUserInteraction);
+                            step = {
+                                ...comparedStep,
+                                execution: step.execution,
+                            };
+                        }
+                        if (!step.transactionRequest) {
+                            throw new TransactionError(LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                        }
+                        // STEP 3: Send the transaction
+                        // Make sure that the chain is still correct
+                        const updatedWalletClient = await 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 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 TransactionError(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 TransactionError(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 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 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 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 ||
+                        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 getTransactionFailedMessage(step, process.txLink);
+                process = this.statusManager.updateProcess(step, process.type, 'FAILED', {
+                    error: {
+                        code: 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;
+    }
+}

package/dist/execution/RouteExecutionManager.d.ts

@@ -1,30 +1,30 @@
 import type { Route } from '@lifi/types';
-import type { WalletClient } from 'viem';
-import ConfigService from '../services/ConfigService';
-import type { ConfigUpdate, ExecutionSettings } from '../types';
+import type { ProviderType, SDKProvider } from '../providers';
+import { ConfigService } from '../services/ConfigService';
+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.
@@ -56,4 +56,5 @@ export declare class RouteExecutionManager {
      * @returns The updated route.
      */
     getActiveRoute: (route: Route) => Route | undefined;
+    getProvider: (type: ProviderType) => SDKProvider | undefined;
 }

package/dist/execution/RouteExecutionManager.js

@@ -1,21 +1,19 @@
-import ConfigService from '../services/ConfigService';
+import { ConfigService } from '../services/ConfigService';
 import { ValidationError } from '../utils/errors';
 import { StatusManager } from './StatusManager';
-import { StepExecutor } from './StepExecutor';
 import { prepareRestart } from './prepareRestart';
 export 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];
@@ -23,24 +21,23 @@ export 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, {
@@ -50,12 +47,12 @@ export class RouteExecutionManager {
                     return executionPromise ?? clonedRoute;
                 }
             }
-            await prepareRestart(clonedRoute, walletClient);
-            const executionPromise = this.executeSteps(walletClient, clonedRoute, settings);
+            await 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,
@@ -87,17 +84,24 @@ export class RouteExecutionManager {
                     step.action.fromAmount = previousStep.execution.toAmount;
                 }
                 try {
-                    const stepExecutor = new StepExecutor(statusManager, execution.settings);
+                    const provider = this.providers?.find((provider) => provider.isProviderStep(step));
+                    if (!provider) {
+                        throw new Error('SDK Execution Provider not found.');
+                    }
+                    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;
                     }
                 }
@@ -163,7 +167,7 @@ export class RouteExecutionManager {
                 executor.setInteraction({
                     allowInteraction: false,
                     allowUpdates: false,
-                    stopExecution: true,
+                    allowExecution: false,
                 });
             }
             delete this.executionDictionary[route.id];
@@ -186,10 +190,11 @@ export class RouteExecutionManager {
         this.getActiveRoute = (route) => {
             return this.executionDictionary[route.id]?.route;
         };
+        this.getProvider = (type) => {
+            return this.providers?.find((provider) => provider.type === type);
+        };
         this.configService = ConfigService.getInstance();
-        if (configUpdate) {
-            // Update API urls before we request chains
-            this.configService.updateConfig(configUpdate);
-        }
+        this.configService.updateConfig(options);
+        this.providers = options.providers;
     }
 }

package/dist/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/execution/StatusManager.js

@@ -1,4 +1,4 @@
-import { emptyExecution } from '../types';
+import { emptyExecution } from '@lifi/types';
 import { getProcessMessage } from './utils';
 /**
  * Manages status updates of a route and provides various functions for tracking processes

package/dist/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>;
 }

package/dist/execution/StepExecutionManager.js

@@ -1,7 +1,7 @@
 import { publicActions } from 'viem';
 import ApiService from '../services/ApiService';
-import ChainsService from '../services/ChainsService';
-import ConfigService from '../services/ConfigService';
+import { ChainsService } from '../services/ChainsService';
+import { ConfigService } from '../services/ConfigService';
 import { getMaxPriorityFeePerGas } from '../utils';
 import { LiFiErrorCode, TransactionError, ValidationError, } from '../utils/errors';
 import { getTransactionFailedMessage, parseError } from '../utils/parseError';
@@ -67,7 +67,7 @@ export class StepExecutionManager {
                         const updatedWalletClient = await switchChain(walletClient, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
                         if (!updatedWalletClient) {
                             // Chain switch was not successful, stop execution here
-                            return step.execution;
+                            return step;
                         }
                         walletClient = updatedWalletClient;
                         // Load exiting transaction
@@ -94,12 +94,12 @@ export class StepExecutionManager {
                         const updatedWalletClient = await switchChain(walletClient, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
                         if (!updatedWalletClient) {
                             // Chain switch was not successful, stop execution here
-                            return step.execution;
+                            return step;
                         }
                         walletClient = updatedWalletClient;
                         process = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED');
                         if (!this.allowUserInteraction) {
-                            return step.execution;
+                            return step;
                         }
                         let transactionRequest = {
                             to: step.transactionRequest.to,
@@ -259,7 +259,7 @@ export class StepExecutionManager {
                 throw e;
             }
             // DONE
-            return step.execution;
+            return step;
         };
     }
 }

package/dist/execution/checkAllowance.d.ts

@@ -1,4 +1,5 @@
+import type { Chain, LiFiStep } from '@lifi/types';
 import type { Hash, WalletClient } from 'viem';
 import type { StatusManager } from '../execution/StatusManager';
-import type { Chain, InternalExecutionSettings, LifiStep } from '../types';
-export declare const checkAllowance: (walletClient: WalletClient, step: LifiStep, statusManager: StatusManager, settings: InternalExecutionSettings, chain: Chain, allowUserInteraction?: boolean, shouldBatchTransactions?: boolean) => Promise<Hash | void>;
+import type { InternalExecutionSettings } from './types';
+export declare const checkAllowance: (walletClient: WalletClient, step: LiFiStep, statusManager: StatusManager, settings: InternalExecutionSettings, chain: Chain, allowUserInteraction?: boolean, shouldBatchTransactions?: boolean) => Promise<Hash | void>;

package/dist/execution/checkBalance.d.ts

@@ -1,2 +1,2 @@
-import type { LifiStep } from '..';
-export declare const checkBalance: (walletAddress: string, step: LifiStep, depth?: number) => Promise<void>;
+import type { LiFiStep } from '@lifi/types';
+export declare const checkBalance: (walletAddress: string, step: LiFiStep, depth?: number) => Promise<void>;

package/dist/execution/index.d.ts

@@ -1 +1,2 @@
 export * from './StatusManager';
+export * from './types';

package/dist/execution/index.js

@@ -1 +1,2 @@
 export * from './StatusManager';
+export * from './types';

package/dist/execution/multisig.d.ts

@@ -1,4 +1,4 @@
-import type { ExtendedChain, LifiStep, ProcessType } from '@lifi/types';
+import type { ExtendedChain, LiFiStep, ProcessType } from '@lifi/types';
 import type { Hash } from 'viem';
 import type { StatusManager } from './StatusManager';
-export declare const updateMultisigRouteProcess: (internalTxHash: Hash, step: LifiStep, statusManager: StatusManager, processType: ProcessType, fromChain: ExtendedChain) => Promise<void>;
+export declare const updateMultisigRouteProcess: (internalTxHash: Hash, step: LiFiStep, statusManager: StatusManager, processType: ProcessType, fromChain: ExtendedChain) => Promise<void>;

package/dist/execution/multisig.js

@@ -1,4 +1,4 @@
-import ConfigService from '../services/ConfigService';
+import { ConfigService } from '../services/ConfigService';
 import { LiFiErrorCode, TransactionError } from '../utils/errors';
 export const updateMultisigRouteProcess = async (internalTxHash, step, statusManager, processType, fromChain) => {
     const config = ConfigService.getInstance().getConfig();

package/dist/execution/prepareRestart.d.ts

@@ -1,3 +1,2 @@
-import { type WalletClient } from 'viem';
-import type { Route } from '../types';
-export declare const prepareRestart: (route: Route, walletClient: WalletClient) => Promise<void>;
+import type { Route } from '@lifi/types';
+export declare const prepareRestart: (route: Route) => Promise<void>;

package/dist/execution/prepareRestart.js

@@ -1,11 +1,11 @@
 import { publicActions } from 'viem';
 import { LiFiErrorCode } from '../utils/errors';
-export const prepareRestart = async (route, walletClient) => {
+export const prepareRestart = async (route) => {
     for (let index = 0; index < route.steps.length; index++) {
         const step = route.steps[index];
         const stepHasFailed = step.execution?.status === 'FAILED';
         if (stepHasFailed) {
-            await handleErrorType(walletClient, step);
+            // await handleErrorType(walletClient, step)
             deleteFailedProcesses(step);
             deleteTransactionData(step);
         }

package/dist/execution/stepComparison.d.ts

@@ -1,5 +1,6 @@
-import type { InternalExecutionSettings, LifiStep } from '../types';
+import type { LiFiStep } from '@lifi/types';
 import type { StatusManager } from './StatusManager';
+import type { InternalExecutionSettings } from './types';
 /**
  * This method checks whether the new and updated Step meets the required exchange rate conditions.
  * If yes it returns the updated Step.
@@ -9,6 +10,6 @@ import type { StatusManager } from './StatusManager';
  * @param newStep
  * @param settings
  * @param allowUserInteraction
- * @returns Return LifiStep
+ * @returns Return LiFiStep
  */
-export declare const stepComparison: (statusManager: StatusManager, oldStep: LifiStep, newStep: LifiStep, settings: InternalExecutionSettings, allowUserInteraction: boolean) => Promise<LifiStep>;
+export declare const stepComparison: (statusManager: StatusManager, oldStep: LiFiStep, newStep: LiFiStep, settings: InternalExecutionSettings, allowUserInteraction: boolean) => Promise<LiFiStep>;