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

package/dist/execution/RouteExecutionManager.js

@@ -0,0 +1,213 @@
+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;
+                }
+            }
+            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(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/{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/execution/{ExecutionManager.js → StepExecutionManager.js}

@@ -9,7 +9,7 @@ import { isZeroAddress, personalizeStep } from '../utils/utils';
 import { stepComparison } from './stepComparison';
 import { switchChain } from './switchChain';
 import { getSubstatusMessage, waitForReceivingTransaction } from './utils';
-export class ExecutionManager {
+export class StepExecutionManager {
     constructor() {
         this.allowUserInteraction = true;
         this.allowInteraction = (value) => {

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

@@ -1,4 +1,4 @@
-import { ExecutionManager } from './ExecutionManager';
+import { StepExecutionManager } from './StepExecutionManager';
 import { switchChain } from './switchChain';
 // Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
 const defaultInteractionSettings = {
@@ -16,7 +16,7 @@ export 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;
         };
@@ -40,10 +40,10 @@ export class StepExecutor {
                 settings: this.settings,
                 statusManager: this.statusManager,
             };
-            await this.executionManager.execute(parameters);
+            await this.stepExecutionManager.execute(parameters);
             return step;
         };
-        this.executionManager = new ExecutionManager();
+        this.stepExecutionManager = new StepExecutionManager();
         this.statusManager = statusManager;
         this.settings = settings;
     }

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

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

package/dist/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/services/ApiService.js

@@ -272,18 +272,20 @@ const getTokens = async (requestConfig, options) => {
     });
     return response;
 };
-const getGasRecommendation = async (requestConfig, options) => {
+const getGasRecommendation = async ({ chainId, fromChain, fromToken }, options) => {
     const config = ConfigService.getInstance().getConfig();
-    Object.keys(requestConfig).forEach((key) => !requestConfig[key] &&
-        delete requestConfig[key]);
-    if (!requestConfig.chainId) {
+    if (!chainId) {
         throw new 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 request(`${config.apiUrl}/gas/suggestion/${requestConfig.chainId}?${new URLSearchParams({
-            fromChain: requestConfig.fromChain,
-            fromToken: requestConfig.fromToken,
-        })}`, {
+        const response = await request(url, {
             signal: options?.signal,
         });
         return response;

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifi/sdk",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.4",
   "description": "LI.FI Any-to-Any Cross-Chain-Swap SDK",
   "main": "./dist/cjs/index.js",
   "module": "./dist/index.js",
@@ -76,7 +76,7 @@
   "dependencies": {
     "@ethersproject/abi": "^5.7.0",
     "@ethersproject/contracts": "^5.7.0",
-    "@lifi/types": "^2.3.0",
+    "@lifi/types": "^2.4.1",
     "bignumber.js": "^9.1.1",
     "eth-rpc-errors": "^4.0.3",
     "ethers": "^5.7.2"
@@ -88,11 +88,11 @@
     "@typescript-eslint/parser": "^5.54.1",
     "@vitest/coverage-c8": "^0.29.2",
     "cross-fetch": "^3.1.5",
-    "eslint": "^8.35.0",
+    "eslint": "^8.36.0",
     "eslint-config-prettier": "^8.7.0",
     "eslint-plugin-prettier": "^4.2.1",
     "husky": "^8.0.3",
-    "lint-staged": "^13.1.4",
+    "lint-staged": "^13.2.0",
     "msw": "1.0.1",
     "npm-run-all": "^4.1.5",
     "pinst": "^3.0.0",