@lifi/sdk 2.3.1 → 3.0.0-alpha.10

package/dist/execution/RouteExecutionManager.js

@@ -1,213 +0,0 @@
-import ConfigService from '../services/ConfigService';
-import { ValidationError } from '../utils/errors';
-import { handlePreRestart } from '../utils/preRestart';
-import { StatusManager } from './StatusManager';
-import { StepExecutor } from './StepExecutor';
-export class RouteExecutionManager {
-    constructor(configUpdate) {
-        this.executionDictionary = {};
-        this.executionPromiseDictionary = {};
-        /**
-         * Execute a route.
-         * @param {Signer} signer - The signer required to send the transactions.
-         * @param {Route} route - The route that should be executed. Cannot be an active route.
-         * @param {ExecutionSettings} settings - An object containing settings and callbacks.
-         * @return {Promise<Route>} The executed route.
-         * @throws {LifiError} Throws a LifiError if the execution fails.
-         */
-        this.executeRoute = async (signer, 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(signer, 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 {Signer} signer - The signer required to send the transactions.
-         * @param {Route} route - The route that is to be executed. Cannot be an active route.
-         * @param {ExecutionSettings} settings - An object containing settings and callbacks.
-         * @return {Promise<Route>} The executed route.
-         * @throws {LifiError} Throws a LifiError if the execution fails.
-         */
-        this.resumeRoute = async (signer, 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);
-                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 handlePreRestart(clonedRoute, signer);
-            const executionPromise = this.executeSteps(signer, clonedRoute, settings);
-            this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
-            return executionPromise;
-        };
-        this.executeSteps = async (signer, route, settings) => {
-            const config = this.configService.getConfig();
-            const execution = {
-                route,
-                executors: [],
-                settings: { ...config.defaultExecutionSettings, ...settings },
-            };
-            this.executionDictionary[route.id] = execution;
-            const statusManager = new 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 stepExecutor = new StepExecutor(statusManager, 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(signer, 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) {
-                        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} route - A route that is currently in execution.
-         * @param {boolean} 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 {ExecutionSettings} settings - An object with execution settings.
-         * @param {Route} 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 ValidationError("Can't set ExecutionSettings for the inactive route.");
-            }
-            const config = this.configService.getConfig();
-            execution.settings = {
-                ...config.defaultExecutionSettings,
-                ...settings,
-            };
-        };
-        /**
-         * Executes a route until a user interaction is necessary (signing transactions, etc.) and then halts until the route is resumed.
-         * @param {Route} route - A route that is currently in execution.
-         * @deprecated use updateRouteExecution instead.
-         */
-        this.moveExecutionToBackground = (route) => {
-            const execution = this.executionDictionary[route.id];
-            if (!execution) {
-                return;
-            }
-            for (const executor of execution.executors) {
-                executor.setInteraction({ allowInteraction: false, allowUpdates: true });
-            }
-            execution.settings = {
-                ...execution.settings,
-                executeInBackground: true,
-            };
-        };
-        /**
-         * Stops the execution of an active route.
-         * @param {Route} route - A route that is currently in execution.
-         * @return {Route} 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,
-                    stopExecution: true,
-                });
-            }
-            delete this.executionDictionary[route.id];
-            return route;
-        };
-        /**
-         * Get the list of active routes.
-         * @return {Route[]} 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} route - A route object.
-         * @return {Route} The updated route.
-         */
-        this.getActiveRoute = (route) => {
-            return this.executionDictionary[route.id]?.route;
-        };
-        this.configService = ConfigService.getInstance();
-        if (configUpdate) {
-            // Update API urls before we request chains
-            this.configService.updateConfig(configUpdate);
-        }
-    }
-}

package/dist/execution/StatusManager.d.ts

@@ -1,68 +0,0 @@
-import { Execution, InternalExecutionSettings, LifiStep, Process, ProcessType, Route, Status, Token } from '../types';
-interface Receipt {
-    fromAmount?: string;
-    toAmount?: string;
-    toToken?: Token;
-    gasPrice?: string;
-    gasUsed?: string;
-    gasToken?: Token;
-    gasAmount?: string;
-    gasAmountUSD?: string;
-}
-type InternalUpdateRouteCallback = (route: Route) => void;
-type OptionalParameters = Partial<Pick<Process, 'doneAt' | 'failedAt' | 'txHash' | 'txLink' | 'error' | 'substatus' | 'substatusMessage' | 'multisigTxHash'>>;
-/**
- * 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.
- * @return {StatusManager}       An instance of StatusManager.
- */
-export declare class StatusManager {
-    private readonly route;
-    private readonly settings;
-    private readonly internalUpdateRouteCallback;
-    private shouldUpdate;
-    constructor(route: Route, settings: InternalExecutionSettings, internalUpdateRouteCallback: InternalUpdateRouteCallback);
-    /**
-     * Initializes the execution object of a Step.
-     * @param  {LifiStep} step  The current step in execution
-     * @return {Execution}       The initialized execution object for this step and a function to update this step
-     */
-    initExecutionObject: (step: LifiStep) => Execution;
-    /**
-     * Updates the execution object of a Step.
-     * @param  {LifiStep} step  The current step in execution
-     * @param  {Status} status  The status for the execution
-     * @param  {Receipt} receipt Optional. Information about received tokens
-     * @return {Step}       The step with the updated execution object
-     */
-    updateExecution(step: LifiStep, status: Status, receipt?: Receipt): LifiStep;
-    /**
-     * Create and push a new process into the execution.
-     * @param  {ProcessType} type Type of the process. Used to identify already existing processes.
-     * @param  {LifiStep} step The step that should contain the new process.
-     * @param  {Status} status By default created procces is set to the STARTED status. We can override new process with the needed status.
-     * @return {Process}
-     */
-    findOrCreateProcess: (step: LifiStep, type: ProcessType, status?: Status) => Process;
-    /**
-     * Update a process object.
-     * @param  {LifiStep} step The step where the process should be updated
-     * @param  {ProcessType} type  The process type to update
-     * @param  {Status} status The status the process gets.
-     * @param  {object} [params]   Additional parameters to append to the process.
-     * @return {Process} The update process
-     */
-    updateProcess: (step: LifiStep, type: ProcessType, status: Status, params?: OptionalParameters) => Process;
-    /**
-     * Remove a process from the execution
-     * @param  {LifiStep} step The step where the process should be removed from
-     * @param  {ProcessType} type  The process type to remove
-     * @return {void}
-     */
-    removeProcess: (step: LifiStep, type: ProcessType) => void;
-    updateStepInRoute: (step: LifiStep) => LifiStep;
-    allowUpdates(value: boolean): void;
-}
-export {};

package/dist/execution/StatusManager.js

@@ -1,168 +0,0 @@
-import { emptyExecution, } from '../types';
-import { getProcessMessage } from './utils';
-/**
- * Manages status updates of a route and provides various functions for tracking processes
- * @param  {Route} route  The route this StatusManger belongs to.
- * @param  {InternalExecutionSettings} settings   The ExecutionSettings for this route.
- * @param  {InternalUpdateRouteCallback} internalUpdateRouteCallback  Internal callback to propage route changes.
- * @return {StatusManager}       An instance of StatusManager.
- */
-export class StatusManager {
-    constructor(route, settings, internalUpdateRouteCallback) {
-        this.shouldUpdate = true;
-        /**
-         * Initializes the execution object of a Step.
-         * @param  {LifiStep} step  The current step in execution
-         * @return {Execution}       The initialized execution object for this step and a function to update this step
-         */
-        this.initExecutionObject = (step) => {
-            const currentExecution = step.execution || structuredClone(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  {ProcessType} type Type of the process. Used to identify already existing processes.
-         * @param  {LifiStep} step The step that should contain the new process.
-         * @param  {Status} status By default created procces is set to the STARTED status. We can override new process with the needed status.
-         * @return {Process}
-         */
-        this.findOrCreateProcess = (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: getProcessMessage(type, status ?? 'STARTED'),
-                status: status ?? 'STARTED',
-            };
-            step.execution.process.push(newProcess);
-            this.updateStepInRoute(step);
-            return newProcess;
-        };
-        /**
-         * Update a process object.
-         * @param  {LifiStep} step The step where the process should be updated
-         * @param  {ProcessType} type  The process type to update
-         * @param  {Status} status The status the process gets.
-         * @param  {object} [params]   Additional parameters to append to the process.
-         * @return {Process} 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 = 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  {LifiStep} step The step where the process should be removed from
-         * @param  {ProcessType} type  The process type to remove
-         * @return {void}
-         */
-        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  {LifiStep} step  The current step in execution
-     * @param  {Status} status  The status for the execution
-     * @param  {Receipt} receipt Optional. Information about received tokens
-     * @return {Step}       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;
-    }
-}

package/dist/execution/StepExecutionManager.d.ts

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