@lifi/sdk 2.0.0-beta.3 → 2.0.0-beta.4

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

@@ -0,0 +1,65 @@
+import { Route } from '@lifi/types';
+import { Signer } from 'ethers';
+import ConfigService from '../services/ConfigService';
+import { ConfigUpdate, ExecutionSettings } from '../types';
+export declare class RouteExecutionManager {
+    private executionDictionary;
+    private executionPromiseDictionary;
+    protected configService: ConfigService;
+    constructor(configUpdate?: ConfigUpdate);
+    /**
+     * 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.
+     */
+    executeRoute: (signer: Signer, route: Route, settings?: ExecutionSettings) => Promise<Route>;
+    /**
+     * 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.
+     */
+    resumeRoute: (signer: Signer, route: Route, settings?: ExecutionSettings) => Promise<Route>;
+    private executeSteps;
+    /**
+     * Updates route execution to background or foreground state.
+     * @param {Route} route - A route that is currently in execution.
+     * @param {boolean} settings - An object with execution settings.
+     */
+    updateRouteExecution: (route: Route, settings: Pick<ExecutionSettings, 'executeInBackground'>) => void;
+    /**
+     * 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.
+     */
+    updateExecutionSettings: (settings: ExecutionSettings, route: Route) => void;
+    /**
+     * Executes a route until a user interaction is necessary (signing transactions, etc.) and then halts until the route is resumed.
+     * @param {Route} route - A route that is currently in execution.
+     * @deprecated use updateRouteExecution instead.
+     */
+    moveExecutionToBackground: (route: Route) => void;
+    /**
+     * Stops the execution of an active route.
+     * @param {Route} route - A route that is currently in execution.
+     * @return {Route} The stopped route.
+     */
+    stopExecution: (route: Route) => Route;
+    /**
+     * Get the list of active routes.
+     * @return {Route[]} A list of routes.
+     */
+    getActiveRoutes: () => Route[];
+    /**
+     * 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.
+     */
+    getActiveRoute: (route: Route) => Route | undefined;
+}

package/dist/cjs/execution/RouteExecutionManager.js

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteExecutionManager = void 0;
+const ConfigService_1 = __importDefault(require("../services/ConfigService"));
+const errors_1 = require("../utils/errors");
+const preRestart_1 = require("../utils/preRestart");
+const StatusManager_1 = require("./StatusManager");
+const StepExecutor_1 = require("./StepExecutor");
+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;
+                }
+            }
+            (0, preRestart_1.handlePreRestart)(clonedRoute);
+            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_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 stepExecutor = new StepExecutor_1.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 errors_1.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_1.default.getInstance();
+        if (configUpdate) {
+            // Update API urls before we request chains
+            this.configService.updateConfig(configUpdate);
+        }
+    }
+}
+exports.RouteExecutionManager = RouteExecutionManager;

package/dist/cjs/execution/{ExecutionManager.d.ts → StepExecutionManager.d.ts}

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

package/dist/cjs/execution/{ExecutionManager.js → StepExecutionManager.js}

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecutionManager = void 0;
+exports.StepExecutionManager = void 0;
 const allowance_1 = require("../allowance");
 const balance_1 = require("../balance");
 const ApiService_1 = __importDefault(require("../services/ApiService"));
@@ -15,7 +15,7 @@ const utils_1 = require("../utils/utils");
 const stepComparison_1 = require("./stepComparison");
 const switchChain_1 = require("./switchChain");
 const utils_2 = require("./utils");
-class ExecutionManager {
+class StepExecutionManager {
     constructor() {
         this.allowUserInteraction = true;
         this.allowInteraction = (value) => {
@@ -172,4 +172,4 @@ class ExecutionManager {
         };
     }
 }
-exports.ExecutionManager = ExecutionManager;
+exports.StepExecutionManager = StepExecutionManager;

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

@@ -1,9 +1,9 @@
 import { Signer } from 'ethers';
 import { InteractionSettings, InternalExecutionSettings, Step } from '../types';
-import { ExecutionManager } from './ExecutionManager';
 import { StatusManager } from './StatusManager';
+import { StepExecutionManager } from './StepExecutionManager';
 export declare class StepExecutor {
-    executionManager: ExecutionManager;
+    stepExecutionManager: StepExecutionManager;
     statusManager: StatusManager;
     settings: InternalExecutionSettings;
     allowUserInteraction: boolean;

package/dist/cjs/execution/StepExecutor.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StepExecutor = void 0;
-const ExecutionManager_1 = require("./ExecutionManager");
+const StepExecutionManager_1 = require("./StepExecutionManager");
 const switchChain_1 = require("./switchChain");
 // Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
 const defaultInteractionSettings = {
@@ -19,7 +19,7 @@ class StepExecutor {
                 ...settings,
             };
             this.allowUserInteraction = interactionSettings.allowInteraction;
-            this.executionManager.allowInteraction(interactionSettings.allowInteraction);
+            this.stepExecutionManager.allowInteraction(interactionSettings.allowInteraction);
             this.statusManager.allowUpdates(interactionSettings.allowUpdates);
             this.executionStopped = interactionSettings.stopExecution;
         };
@@ -43,10 +43,10 @@ class StepExecutor {
                 settings: this.settings,
                 statusManager: this.statusManager,
             };
-            await this.executionManager.execute(parameters);
+            await this.stepExecutionManager.execute(parameters);
             return step;
         };
-        this.executionManager = new ExecutionManager_1.ExecutionManager();
+        this.stepExecutionManager = new StepExecutionManager_1.StepExecutionManager();
         this.statusManager = statusManager;
         this.settings = settings;
     }

package/dist/cjs/helpers.d.ts

@@ -27,4 +27,4 @@ export declare const convertQuoteToRoute: (step: Step) => Route;
 export declare const requestSettings: {
     retries: number;
 };
-export declare const request: <T = Response>(url: string, options?: RequestInit, retries?: number) => Promise<T>;
+export declare const request: <T = Response>(url: RequestInfo | URL, options?: RequestInit, retries?: number) => Promise<T>;

package/dist/cjs/index.d.ts

@@ -1,6 +1,5 @@
-import LIFI from './Lifi';
 export * from './execution';
 export * from './helpers';
+export { LiFi } from './LiFi';
 export * from './types';
 export * from './utils/errors';
-export default LIFI;

package/dist/cjs/index.js

@@ -13,15 +13,12 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiFi = void 0;
 // expose types and helpers
-const Lifi_1 = __importDefault(require("./Lifi"));
 __exportStar(require("./execution"), exports);
 __exportStar(require("./helpers"), exports);
+var LiFi_1 = require("./LiFi");
+Object.defineProperty(exports, "LiFi", { enumerable: true, get: function () { return LiFi_1.LiFi; } });
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils/errors"), exports);
-// expose sdk
-exports.default = Lifi_1.default;

package/dist/cjs/services/ApiService.d.ts

@@ -3,7 +3,7 @@ import { ChainId, ChainKey, ExtendedChain, PossibilitiesRequest, PossibilitiesRe
 declare const _default: {
     getChains: (options?: RequestOptions | undefined) => Promise<ExtendedChain[]>;
     getContractCallQuote: (requestConfig: ContractCallQuoteRequest, options?: RequestOptions | undefined) => Promise<Step>;
-    getGasRecommendation: (requestConfig: GasRecommendationRequest, options?: RequestOptions | undefined) => Promise<GasRecommendationResponse>;
+    getGasRecommendation: ({ chainId, fromChain, fromToken }: GasRecommendationRequest, options?: RequestOptions | undefined) => Promise<GasRecommendationResponse>;
     getPossibilities: (requestConfig?: PossibilitiesRequest | undefined, options?: RequestOptions | undefined) => Promise<PossibilitiesResponse>;
     getQuote: (requestConfig: QuoteRequest, options?: RequestOptions | undefined) => Promise<Step>;
     getRoutes: (requestConfig: RoutesRequest, options?: RequestOptions | undefined) => Promise<RoutesResponse>;

package/dist/cjs/services/ApiService.js

@@ -277,18 +277,20 @@ const getTokens = async (requestConfig, options) => {
     });
     return response;
 };
-const getGasRecommendation = async (requestConfig, options) => {
+const getGasRecommendation = async ({ chainId, fromChain, fromToken }, options) => {
     const config = ConfigService_1.default.getInstance().getConfig();
-    Object.keys(requestConfig).forEach((key) => !requestConfig[key] &&
-        delete requestConfig[key]);
-    if (!requestConfig.chainId) {
+    if (!chainId) {
         throw new errors_1.ValidationError('Required parameter "chainId" is missing.');
     }
+    const url = new URL(`${config.apiUrl}/gas/suggestion/${chainId}`);
+    if (fromChain) {
+        url.searchParams.append('fromChain', fromChain);
+    }
+    if (fromToken) {
+        url.searchParams.append('fromToken', fromToken);
+    }
     try {
-        const response = await (0, helpers_1.request)(`${config.apiUrl}/gas/suggestion/${requestConfig.chainId}?${new URLSearchParams({
-            fromChain: requestConfig.fromChain,
-            fromToken: requestConfig.fromToken,
-        })}`, {
+        const response = await (0, helpers_1.request)(url, {
             signal: options?.signal,
         });
         return response;

package/dist/cjs/types/internal.types.d.ts

@@ -54,7 +54,7 @@ export interface ExchangeRateUpdateParams {
     newToAmount: string;
 }
 export type AcceptExchangeRateUpdateHook = (params: ExchangeRateUpdateParams) => Promise<boolean | undefined>;
-export interface ExecutionData {
+export interface RouteExecutionData {
     route: Route;
     executors: StepExecutor[];
     settings: InternalExecutionSettings;
@@ -71,12 +71,8 @@ export interface InternalExecutionSettings {
 export type EnforcedObjectProperties<T> = T & {
     [P in keyof T]-?: T[P];
 };
-export interface ActiveRouteDictionary {
-    [k: string]: {
-        executionData: ExecutionData;
-        executionPromise: Promise<Route>;
-    };
-}
+export type RouteExecutionDictionary = Partial<Record<string, RouteExecutionData>>;
+export type RouteExecutionPromiseDictionary = Partial<Record<string, Promise<Route>>>;
 export type RevokeTokenData = {
     token: Token;
     approvalAddress: string;

package/dist/cjs/version.d.ts

@@ -1,2 +1,2 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "2.0.0-beta.3";
+export declare const version = "2.0.0-beta.4";

package/dist/cjs/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = exports.name = void 0;
 exports.name = '@lifi/sdk';
-exports.version = '2.0.0-beta.3';
+exports.version = '2.0.0-beta.4';

package/dist/execution/RouteExecutionManager.d.ts

@@ -0,0 +1,65 @@
+import { Route } from '@lifi/types';
+import { Signer } from 'ethers';
+import ConfigService from '../services/ConfigService';
+import { ConfigUpdate, ExecutionSettings } from '../types';
+export declare class RouteExecutionManager {
+    private executionDictionary;
+    private executionPromiseDictionary;
+    protected configService: ConfigService;
+    constructor(configUpdate?: ConfigUpdate);
+    /**
+     * 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.
+     */
+    executeRoute: (signer: Signer, route: Route, settings?: ExecutionSettings) => Promise<Route>;
+    /**
+     * 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.
+     */
+    resumeRoute: (signer: Signer, route: Route, settings?: ExecutionSettings) => Promise<Route>;
+    private executeSteps;
+    /**
+     * Updates route execution to background or foreground state.
+     * @param {Route} route - A route that is currently in execution.
+     * @param {boolean} settings - An object with execution settings.
+     */
+    updateRouteExecution: (route: Route, settings: Pick<ExecutionSettings, 'executeInBackground'>) => void;
+    /**
+     * 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.
+     */
+    updateExecutionSettings: (settings: ExecutionSettings, route: Route) => void;
+    /**
+     * Executes a route until a user interaction is necessary (signing transactions, etc.) and then halts until the route is resumed.
+     * @param {Route} route - A route that is currently in execution.
+     * @deprecated use updateRouteExecution instead.
+     */
+    moveExecutionToBackground: (route: Route) => void;
+    /**
+     * Stops the execution of an active route.
+     * @param {Route} route - A route that is currently in execution.
+     * @return {Route} The stopped route.
+     */
+    stopExecution: (route: Route) => Route;
+    /**
+     * Get the list of active routes.
+     * @return {Route[]} A list of routes.
+     */
+    getActiveRoutes: () => Route[];
+    /**
+     * 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.
+     */
+    getActiveRoute: (route: Route) => Route | undefined;
+}