@lifi/sdk 3.0.0-alpha.9 → 3.0.0-beta.0

package/dist/cjs/execution/RouteExecutionManager.js

@@ -1,204 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteExecutionManager = void 0;
-const ConfigService_1 = require("../services/ConfigService");
-const errors_1 = require("../utils/errors");
-const StatusManager_1 = require("./StatusManager");
-const prepareRestart_1 = require("./prepareRestart");
-class RouteExecutionManager {
-    constructor(options) {
-        this.executionDictionary = {};
-        this.executionPromiseDictionary = {};
-        /**
-         * Execute a route.
-         * @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 (route, settings) => {
-            // Deep clone to prevent side effects
-            const clonedRoute = structuredClone(route);
-            let executionPromise = this.executionPromiseDictionary[clonedRoute.id];
-            // Check if route is already running
-            if (executionPromise) {
-                return executionPromise;
-            }
-            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 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 (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.allowExecution);
-                if (!executionHalted) {
-                    // Check if we want to resume route execution in the background
-                    this.updateRouteExecution(route, {
-                        executeInBackground: settings?.executeInBackground,
-                    });
-                    const executionPromise = this.executionPromiseDictionary[clonedRoute.id];
-                    return executionPromise ?? clonedRoute;
-                }
-            }
-            await (0, prepareRestart_1.prepareRestart)(clonedRoute);
-            const executionPromise = this.executeSteps(clonedRoute, settings);
-            this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
-            return executionPromise;
-        };
-        this.executeSteps = async (route, settings) => {
-            const config = this.configService.getConfig();
-            const execution = {
-                route,
-                executors: [],
-                settings: { ...config.defaultExecutionSettings, ...settings },
-            };
-            this.executionDictionary[route.id] = execution;
-            const statusManager = new StatusManager_1.StatusManager(route, execution.settings, (route) => {
-                if (this.executionDictionary[route.id]) {
-                    execution.route = route;
-                }
-            });
-            // Loop over steps and execute them
-            for (let index = 0; index < route.steps.length; index++) {
-                const execution = this.executionDictionary[route.id];
-                // Check if execution has stopped in the meantime
-                if (!execution) {
-                    break;
-                }
-                const step = route.steps[index];
-                const previousStep = route.steps[index - 1];
-                // Check if the step is already done
-                //
-                if (step.execution?.status === 'DONE') {
-                    continue;
-                }
-                // Update amount using output of previous execution. In the future this should be handled by calling `updateRoute`
-                if (previousStep?.execution?.toAmount) {
-                    step.action.fromAmount = previousStep.execution.toAmount;
-                }
-                try {
-                    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(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.allowExecution) {
-                        return route;
-                    }
-                }
-                catch (e) {
-                    this.stopExecution(route);
-                    throw e;
-                }
-            }
-            // Clean up after the execution
-            delete this.executionDictionary[route.id];
-            return route;
-        };
-        /**
-         * Updates route execution to background or foreground state.
-         * @param route - A route that is currently in execution.
-         * @param settings - An object with execution settings.
-         */
-        this.updateRouteExecution = (route, settings) => {
-            const execution = this.executionDictionary[route.id];
-            if (!execution) {
-                return;
-            }
-            for (const executor of execution.executors) {
-                executor.setInteraction({
-                    allowInteraction: !settings.executeInBackground,
-                    allowUpdates: true,
-                });
-            }
-            // Update active route settings so we know what the current state of execution is
-            execution.settings = {
-                ...execution.settings,
-                ...settings,
-            };
-        };
-        /**
-         * Update the ExecutionSettings for an active route.
-         * @param settings - An object with execution settings.
-         * @param route - The active route that gets the new execution settings.
-         * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-         */
-        this.updateExecutionSettings = (settings, route) => {
-            const execution = this.executionDictionary[route.id];
-            if (!execution) {
-                throw new errors_1.ValidationError("Can't set ExecutionSettings for the inactive route.");
-            }
-            const config = this.configService.getConfig();
-            execution.settings = {
-                ...config.defaultExecutionSettings,
-                ...settings,
-            };
-        };
-        /**
-         * Stops the execution of an active route.
-         * @param route - A route that is currently in execution.
-         * @returns The stopped route.
-         */
-        this.stopExecution = (route) => {
-            const execution = this.executionDictionary[route.id];
-            if (!execution) {
-                return route;
-            }
-            for (const executor of execution.executors) {
-                executor.setInteraction({
-                    allowInteraction: false,
-                    allowUpdates: false,
-                    allowExecution: false,
-                });
-            }
-            delete this.executionDictionary[route.id];
-            return route;
-        };
-        /**
-         * Get the list of active routes.
-         * @returns A list of routes.
-         */
-        this.getActiveRoutes = () => {
-            return Object.values(this.executionDictionary)
-                .map((dict) => dict?.route)
-                .filter(Boolean);
-        };
-        /**
-         * Return the current route information for given route. The route has to be active.
-         * @param route - A route object.
-         * @returns The updated route.
-         */
-        this.getActiveRoute = (route) => {
-            return this.executionDictionary[route.id]?.route;
-        };
-        this.getProvider = (type) => {
-            return this.providers?.find((provider) => provider.type === type);
-        };
-        this.configService = ConfigService_1.ConfigService.getInstance();
-        this.configService.updateConfig(options);
-        this.providers = options.providers;
-    }
-}
-exports.RouteExecutionManager = RouteExecutionManager;

package/dist/cjs/execution/StatusManager.js

@@ -1,171 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatusManager = void 0;
-const types_1 = require("@lifi/types");
-const utils_1 = require("./utils");
-/**
- * Manages status updates of a route and provides various functions for tracking processes
- * @param {Route} route The route this StatusManger belongs to.
- * @param {InternalExecutionSettings} settings The ExecutionSettings for this route.
- * @param {InternalUpdateRouteCallback} internalUpdateRouteCallback Internal callback to propage route changes.
- * @returns {StatusManager} An instance of StatusManager.
- */
-class StatusManager {
-    constructor(route, settings, internalUpdateRouteCallback) {
-        this.shouldUpdate = true;
-        /**
-         * Initializes the execution object of a Step.
-         * @param step  The current step in execution
-         * @returns The initialized execution object for this step and a function to update this step
-         */
-        this.initExecutionObject = (step) => {
-            const currentExecution = step.execution || structuredClone(types_1.emptyExecution);
-            if (!step.execution) {
-                step.execution = currentExecution;
-                step.execution.status = 'PENDING';
-                this.updateStepInRoute(step);
-            }
-            // Change status to PENDING after resuming from FAILED
-            if (currentExecution.status === 'FAILED') {
-                currentExecution.status = 'PENDING';
-                this.updateStepInRoute(step);
-            }
-            return currentExecution;
-        };
-        /**
-         * Create and push a new process into the execution.
-         * @param step The step that should contain the new process.
-         * @param type Type of the process. Used to identify already existing processes.
-         * @param status By default created procces is set to the STARTED status. We can override new process with the needed status.
-         * @returns Returns process.
-         */
-        this.findOrCreateProcess = (step, type, status) => {
-            if (!step.execution?.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 = {
-                type: type,
-                startedAt: Date.now(),
-                message: (0, utils_1.getProcessMessage)(type, status ?? 'STARTED'),
-                status: status ?? 'STARTED',
-            };
-            step.execution.process.push(newProcess);
-            this.updateStepInRoute(step);
-            return newProcess;
-        };
-        /**
-         * Update a process object.
-         * @param step The step where the process should be updated
-         * @param type  The process type to update
-         * @param status The status the process gets.
-         * @param [params]   Additional parameters to append to the process.
-         * @returns The update process
-         */
-        this.updateProcess = (step, type, status, params) => {
-            if (!step.execution) {
-                throw new Error("Can't update an empty step execution.");
-            }
-            const currentProcess = step?.execution?.process.find((p) => p.type === type);
-            if (!currentProcess) {
-                throw new Error("Can't find a process for the given type.");
-            }
-            switch (status) {
-                case 'CANCELLED':
-                    currentProcess.doneAt = Date.now();
-                    break;
-                case 'FAILED':
-                    currentProcess.doneAt = Date.now();
-                    step.execution.status = 'FAILED';
-                    break;
-                case 'DONE':
-                    currentProcess.doneAt = Date.now();
-                    break;
-                case 'PENDING':
-                    step.execution.status = 'PENDING';
-                    break;
-                case 'ACTION_REQUIRED':
-                    step.execution.status = 'ACTION_REQUIRED';
-                    break;
-                default:
-                    break;
-            }
-            currentProcess.status = status;
-            currentProcess.message = (0, utils_1.getProcessMessage)(type, status);
-            // set extra parameters or overwritte the standard params set in the switch statement
-            if (params) {
-                for (const [key, value] of Object.entries(params)) {
-                    currentProcess[key] = value;
-                }
-            }
-            // Sort processes, the ones with DONE status go first
-            step.execution.process = [
-                ...step?.execution?.process.filter((process) => process.status === 'DONE'),
-                ...step?.execution?.process.filter((process) => process.status !== 'DONE'),
-            ];
-            this.updateStepInRoute(step); // updates the step in the route
-            return currentProcess;
-        };
-        /**
-         * Remove a process from the execution
-         * @param step The step where the process should be removed from
-         * @param type  The process type to remove
-         */
-        this.removeProcess = (step, type) => {
-            if (!step.execution) {
-                throw new Error("Execution hasn't been initialized.");
-            }
-            const index = step.execution.process.findIndex((p) => p.type === type);
-            step.execution.process.splice(index, 1);
-            this.updateStepInRoute(step);
-        };
-        this.updateStepInRoute = (step) => {
-            if (!this.shouldUpdate) {
-                return step;
-            }
-            const stepIndex = this.route.steps.findIndex((routeStep) => routeStep.id === step.id);
-            if (stepIndex === -1) {
-                throw new Error("Couldn't find a step to update.");
-            }
-            this.route.steps[stepIndex] = Object.assign(this.route.steps[stepIndex], step);
-            this.settings.updateRouteHook(this.route);
-            this.internalUpdateRouteCallback(this.route);
-            return this.route.steps[stepIndex];
-        };
-        this.route = route;
-        this.settings = settings;
-        this.internalUpdateRouteCallback = internalUpdateRouteCallback;
-    }
-    /**
-     * Updates the execution object of a Step.
-     * @param step  The current step in execution
-     * @param status  The status for the execution
-     * @param receipt Optional. Information about received tokens
-     * @returns       The step with the updated execution object
-     */
-    updateExecution(step, status, receipt) {
-        if (!step.execution) {
-            throw Error("Can't update empty execution.");
-        }
-        step.execution.status = status;
-        if (receipt) {
-            step.execution = {
-                ...step.execution,
-                ...receipt,
-            };
-        }
-        this.updateStepInRoute(step);
-        return step;
-    }
-    allowUpdates(value) {
-        this.shouldUpdate = value;
-    }
-}
-exports.StatusManager = StatusManager;

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

@@ -1,7 +0,0 @@
-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<LiFiStep>;
-}

package/dist/cjs/execution/StepExecutionManager.js

@@ -1,272 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StepExecutionManager = void 0;
-const viem_1 = require("viem");
-const ApiService_1 = __importDefault(require("../services/ApiService"));
-const ChainsService_1 = require("../services/ChainsService");
-const ConfigService_1 = 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 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 StepExecutionManager {
-    constructor() {
-        this.allowUserInteraction = true;
-        this.allowInteraction = (value) => {
-            this.allowUserInteraction = value;
-        };
-        this.execute = async ({ walletClient, step, statusManager, settings, }) => {
-            const client = walletClient.extend(viem_1.publicActions);
-            const config = ConfigService_1.ConfigService.getInstance().getConfig();
-            const isMultisigWalletClient = !!config.multisig?.isMultisigWalletClient;
-            const multisigBatchTransactions = [];
-            const shouldBatchTransactions = config.multisig?.shouldBatchTransactions &&
-                !!config.multisig.sendBatchTransaction;
-            step.execution = statusManager.initExecutionObject(step);
-            const chainsService = ChainsService_1.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 &&
-                !(0, utils_2.isZeroAddress)(step.action.fromToken.address) &&
-                (shouldBatchTransactions || !isMultisigWalletClient);
-            if (checkForAllowance) {
-                const data = await (0, checkAllowance_1.checkAllowance)(client, step, statusManager, 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 = 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, statusManager, process.type, fromChain);
-                    }
-                    let txHash;
-                    if (process.txHash) {
-                        // Make sure that the chain is still correct
-                        const updatedWalletClient = await (0, switchChain_1.switchChain)(walletClient, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
-                        if (!updatedWalletClient) {
-                            // Chain switch was not successful, stop execution here
-                            return step;
-                        }
-                        walletClient = updatedWalletClient;
-                        // Load exiting transaction
-                        txHash = process.txHash;
-                    }
-                    else {
-                        process = 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)(statusManager, step, updatedStep, 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)(walletClient, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
-                        if (!updatedWalletClient) {
-                            // Chain switch was not successful, stop execution here
-                            return step;
-                        }
-                        walletClient = updatedWalletClient;
-                        process = 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: walletClient.account?.type === 'local'
-                                ? await (0, utils_1.getMaxPriorityFeePerGas)(client)
-                                : step.transactionRequest.maxPriorityFeePerGas
-                                    ? BigInt(step.transactionRequest.maxPriorityFeePerGas)
-                                    : undefined,
-                        };
-                        if (settings.updateTransactionRequestHook) {
-                            const customizedTransactionRequest = await 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 walletClient.sendTransaction({
-                                to: transactionRequest.to,
-                                account: 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 = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED', {
-                                multisigTxHash: txHash,
-                            });
-                        }
-                        else {
-                            process = 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;
-                            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, statusManager, process.type, fromChain);
-                    }
-                    if (!isMultisigWalletClient) {
-                        process = statusManager.updateProcess(step, process.type, 'PENDING', {
-                            txHash: transactionReceipt.transactionHash,
-                            txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
-                        });
-                    }
-                    if (isBridgeExecution) {
-                        process = statusManager.updateProcess(step, process.type, 'DONE');
-                    }
-                }
-                catch (e) {
-                    const error = await (0, parseError_1.parseError)(e, step, process);
-                    process = statusManager.updateProcess(step, process.type, 'FAILED', {
-                        error: {
-                            message: error.message,
-                            htmlMessage: error.htmlMessage,
-                            code: error.code,
-                        },
-                    });
-                    statusManager.updateExecution(step, 'FAILED');
-                    throw error;
-                }
-            }
-            // STEP 5: Wait for the receiving chain
-            const processTxHash = process.txHash;
-            if (isBridgeExecution) {
-                process = 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, statusManager, process.type, step));
-                const statusReceiving = statusResponse.receiving;
-                process = 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}`,
-                });
-                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 = statusManager.updateProcess(step, process.type, 'FAILED', {
-                    error: {
-                        code: errors_1.LiFiErrorCode.TransactionFailed,
-                        message: 'Failed while waiting for receiving chain.',
-                        htmlMessage,
-                    },
-                });
-                statusManager.updateExecution(step, 'FAILED');
-                console.warn(e);
-                throw e;
-            }
-            // DONE
-            return step;
-        };
-    }
-}
-exports.StepExecutionManager = StepExecutionManager;

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

@@ -1,5 +0,0 @@
-import type { Chain, LiFiStep } from '@lifi/types';
-import type { Hash, WalletClient } from 'viem';
-import type { StatusManager } from '../execution/StatusManager';
-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/cjs/execution/index.d.ts

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