@lifi/sdk 2.2.2 → 3.0.0-alpha.1

package/dist/cjs/utils/utils.js

@@ -1,69 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNativeTokenAddress = exports.isZeroAddress = exports.loadTransactionReceipt = exports.repeatUntilDone = exports.formatTokenAmountOnly = exports.splitListIntoChunks = exports.personalizeStep = exports.sleep = void 0;
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const ethers_1 = require("ethers");
-const connectors_1 = require("../connectors");
-const sleep = (mills) => {
+exports.isNativeTokenAddress = exports.isZeroAddress = exports.repeatUntilDone = exports.wait = void 0;
+const constants_1 = require("../constants");
+const wait = (ms) => {
     return new Promise((resolve) => {
-        setTimeout(resolve, mills);
+        setTimeout(resolve, ms);
     });
 };
-exports.sleep = sleep;
-const personalizeStep = async (signer, step) => {
-    if (step.action.toAddress && step.action.fromAddress) {
-        return step;
-    }
-    const address = await signer.getAddress();
-    const fromAddress = step.action.fromAddress || address;
-    const toAddress = step.action.toAddress || address;
-    return {
-        ...step,
-        action: {
-            ...step.action,
-            fromAddress,
-            toAddress,
-        },
-    };
-};
-exports.personalizeStep = personalizeStep;
-const splitListIntoChunks = (list, chunkSize) => list.reduce((resultList, item, index) => {
-    const chunkIndex = Math.floor(index / chunkSize);
-    if (!resultList[chunkIndex]) {
-        resultList[chunkIndex] = []; // start a new chunk
-    }
-    resultList[chunkIndex].push(item);
-    return resultList;
-}, []);
-exports.splitListIntoChunks = splitListIntoChunks;
-const formatTokenAmountOnly = (token, amount) => {
-    if (!amount) {
-        return '0.0';
-    }
-    let floated;
-    if (typeof amount === 'string') {
-        if (amount === '0') {
-            return '0.0';
-        }
-        floated = new bignumber_js_1.default(amount).shiftedBy(-token.decimals);
-    }
-    else {
-        floated = amount;
-        if (floated.isZero()) {
-            return '0.0';
-        }
-    }
-    // show at least 4 decimal places and at least two non-zero digests
-    let decimalPlaces = 3;
-    while (floated.lt(1 / 10 ** decimalPlaces)) {
-        decimalPlaces++;
-    }
-    return floated.toFixed(decimalPlaces + 1, 1);
-};
-exports.formatTokenAmountOnly = formatTokenAmountOnly;
+exports.wait = wait;
 /**
  * Repeatedly calls a given asynchronous function until it resolves with a value
  * @param toRepeat The function that should be repeated
@@ -75,35 +19,22 @@ const repeatUntilDone = async (toRepeat, timeout = 5000) => {
     while (!result) {
         result = await toRepeat();
         if (!result) {
-            await (0, exports.sleep)(timeout);
+            await (0, exports.wait)(timeout);
         }
     }
     return result;
 };
 exports.repeatUntilDone = repeatUntilDone;
-/**
- * Loads a transaction receipt using the rpc for the given chain id
- * @param chainId The chain id where the transaction should be loaded from
- * @param txHash The hash of the transaction
- * @returns TransactionReceipt
- */
-const loadTransactionReceipt = async (chainId, txHash) => {
-    const rpc = await (0, connectors_1.getRpcProvider)(chainId);
-    const tx = await rpc.getTransaction(txHash);
-    return tx.wait();
-};
-exports.loadTransactionReceipt = loadTransactionReceipt;
 const isZeroAddress = (address) => {
-    if (address === ethers_1.constants.AddressZero ||
-        address === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee') {
+    if (address === constants_1.AddressZero || address === constants_1.AlternativeAddressZero) {
         return true;
     }
     return false;
 };
 exports.isZeroAddress = isZeroAddress;
 const isNativeTokenAddress = (address) => {
-    if (address === ethers_1.constants.AddressZero ||
-        address === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee' ||
+    if (address === constants_1.AddressZero ||
+        address === constants_1.AlternativeAddressZero ||
         // CELO native token
         address === '0x471ece3750da237f93b8e339c536989b8978a438') {
         return true;

package/dist/cjs/version.d.ts

@@ -1,2 +1,2 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "2.2.2";
+export declare const version = "3.0.0-alpha.1";

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.2.2';
+exports.version = '3.0.0-alpha.1';

package/dist/connectors.d.ts

@@ -1,6 +1,8 @@
-import { FallbackProvider } from '@ethersproject/providers';
-import { ChainId } from './types';
-export declare const getRpcUrl: (chainId: ChainId, archive?: boolean) => Promise<string>;
-export declare const getRpcUrls: (chainId: ChainId, archive?: boolean) => Promise<string[]>;
-export declare const getRpcProvider: (chainId: number, archive?: boolean) => Promise<FallbackProvider>;
+import type { PublicClient } from 'viem';
+import type { Chain } from 'viem/chains';
+import type { ChainId } from './types';
+export declare const getChainById: (chainId: ChainId) => Chain | undefined;
+export declare const getRpcUrl: (chainId: ChainId) => Promise<string>;
+export declare const getRpcUrls: (chainId: ChainId) => Promise<string[]>;
+export declare const getPublicClient: (chainId: number) => Promise<PublicClient>;
 export declare const getMulticallAddress: (chainId: ChainId) => Promise<string | undefined>;

package/dist/connectors.js

@@ -1,53 +1,37 @@
-import { FallbackProvider, StaticJsonRpcProvider, } from '@ethersproject/providers';
-import { getRandomNumber } from './helpers';
+import { createPublicClient, fallback, http } from 'viem';
+import * as chains from 'viem/chains'; // TODO: optimize using BE chains
 import ConfigService from './services/ConfigService';
-import { ChainId } from './types';
 import { ServerError } from './utils/errors';
 // cached providers
-const chainProviders = {};
-// Archive RPC Provider
-const archiveRpcs = {
-    [ChainId.ETH]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/eth/mainnet/archive',
-    [ChainId.BSC]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/bsc/mainnet/archive',
-    [ChainId.POL]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/polygon/mainnet/archive',
-    [ChainId.FTM]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/fantom/mainnet',
+const publicClients = {};
+export const getChainById = (chainId) => {
+    return Object.values(chains).find((chain) => chain.id === chainId);
 };
 // RPC Urls
-export const getRpcUrl = async (chainId, archive = false) => {
-    const rpcUrls = await getRpcUrls(chainId, archive);
+export const getRpcUrl = async (chainId) => {
+    const rpcUrls = await getRpcUrls(chainId);
     return rpcUrls[0];
 };
-export const getRpcUrls = async (chainId, archive = false) => {
-    if (archive && archiveRpcs[chainId]) {
-        return [archiveRpcs[chainId]];
-    }
+export const getRpcUrls = async (chainId) => {
     const configService = ConfigService.getInstance();
     const config = await configService.getConfigAsync();
     return config.rpcs[chainId];
 };
-const getRandomProvider = (providerList) => {
-    const index = getRandomNumber(0, providerList.length - 1);
-    return providerList[index];
-};
-// Provider
-export const getRpcProvider = async (chainId, archive = false) => {
-    if (archive && archiveRpcs[chainId]) {
-        // return archive PRC, but don't cache it
-        return new FallbackProvider([
-            new StaticJsonRpcProvider(await getRpcUrl(chainId, archive), chainId),
-        ]);
-    }
-    if (!chainProviders[chainId]?.length) {
-        chainProviders[chainId] = [];
-        const urls = await getRpcUrls(chainId, archive);
-        urls.forEach((url) => {
-            chainProviders[chainId].push(new FallbackProvider([new StaticJsonRpcProvider(url, chainId)]));
+export const getPublicClient = async (chainId) => {
+    if (!publicClients[chainId]) {
+        const urls = await getRpcUrls(chainId);
+        const fallbackTransports = urls.map((url) => http(url, {
+            batch: true,
+        }));
+        publicClients[chainId] = createPublicClient({
+            chain: getChainById(chainId),
+            transport: fallback(fallbackTransports),
         });
     }
-    if (!chainProviders[chainId].length) {
+    if (!publicClients[chainId]) {
         throw new ServerError(`Unable to configure provider for chain ${chainId}`);
     }
-    return getRandomProvider(chainProviders[chainId]);
+    return publicClients[chainId];
 };
 // Multicall
 export const getMulticallAddress = async (chainId) => {

package/dist/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const AddressZero = "0x0000000000000000000000000000000000000000";
+export declare const AlternativeAddressZero = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+/**
+ * Cronos require bigger multicall chunks than default 1024 (1 KB)
+ */
+export declare const MulticallBatchSize = 16384;

package/dist/constants.js

@@ -0,0 +1,6 @@
+export const AddressZero = '0x0000000000000000000000000000000000000000';
+export const AlternativeAddressZero = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+/**
+ * Cronos require bigger multicall chunks than default 1024 (1 KB)
+ */
+export const MulticallBatchSize = 16384; // 16 Kilobytes (KB)

package/dist/execution/RouteExecutionManager.d.ts

@@ -1,7 +1,7 @@
-import { Route } from '@lifi/types';
-import { Signer } from 'ethers';
+import type { Route } from '@lifi/types';
+import type { WalletClient } from 'viem';
 import ConfigService from '../services/ConfigService';
-import { ConfigUpdate, ExecutionSettings } from '../types';
+import type { ConfigUpdate, ExecutionSettings } from '../types';
 export declare class RouteExecutionManager {
     private executionDictionary;
     private executionPromiseDictionary;
@@ -9,57 +9,51 @@ export declare class RouteExecutionManager {
     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.
+     * @param walletClient - The walletClient required to send the transactions.
+     * @param route - The route that should be executed. Cannot be an active route.
+     * @param settings - An object containing settings and callbacks.
+     * @returns The executed route.
+     * @throws {LiFiError} Throws a LiFiError if the execution fails.
      */
-    executeRoute: (signer: Signer, route: Route, settings?: ExecutionSettings) => Promise<Route>;
+    executeRoute: (walletClient: WalletClient, 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.
+     * @param walletClient - The walletClient required to send the transactions.
+     * @param route - The route that is to be executed. Cannot be an active route.
+     * @param settings - An object containing settings and callbacks.
+     * @returns The executed route.
+     * @throws {LiFiError} Throws a LiFiError if the execution fails.
      */
-    resumeRoute: (signer: Signer, route: Route, settings?: ExecutionSettings) => Promise<Route>;
+    resumeRoute: (walletClient: WalletClient, 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.
+     * @param route - A route that is currently in execution.
+     * @param 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.
+     * @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.
      */
     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.
+     * @param route - A route that is currently in execution.
+     * @returns The stopped route.
      */
     stopExecution: (route: Route) => Route;
     /**
      * Get the list of active routes.
-     * @return {Route[]} A list of routes.
+     * @returns 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.
+     * @param route - A route object.
+     * @returns The updated route.
      */
     getActiveRoute: (route: Route) => Route | undefined;
 }

package/dist/execution/RouteExecutionManager.js

@@ -1,21 +1,21 @@
 import ConfigService from '../services/ConfigService';
 import { ValidationError } from '../utils/errors';
-import { handlePreRestart } from '../utils/preRestart';
 import { StatusManager } from './StatusManager';
 import { StepExecutor } from './StepExecutor';
+import { prepareRestart } from './prepareRestart';
 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.
+         * @param walletClient - The walletClient required to send the transactions.
+         * @param route - The route that should be executed. Cannot be an active route.
+         * @param settings - An object containing settings and callbacks.
+         * @returns The executed route.
+         * @throws {LiFiError} Throws a LiFiError if the execution fails.
          */
-        this.executeRoute = async (signer, route, settings) => {
+        this.executeRoute = async (walletClient, route, settings) => {
             // Deep clone to prevent side effects
             const clonedRoute = structuredClone(route);
             let executionPromise = this.executionPromiseDictionary[clonedRoute.id];
@@ -23,19 +23,19 @@ export class RouteExecutionManager {
             if (executionPromise) {
                 return executionPromise;
             }
-            executionPromise = this.executeSteps(signer, clonedRoute, settings);
+            executionPromise = this.executeSteps(walletClient, 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.
+         * @param walletClient - The walletClient required to send the transactions.
+         * @param route - The route that is to be executed. Cannot be an active route.
+         * @param settings - An object containing settings and callbacks.
+         * @returns The executed route.
+         * @throws {LiFiError} Throws a LiFiError if the execution fails.
          */
-        this.resumeRoute = async (signer, route, settings) => {
+        this.resumeRoute = async (walletClient, route, settings) => {
             // Deep clone to prevent side effects
             const clonedRoute = structuredClone(route);
             const execution = this.executionDictionary[clonedRoute.id];
@@ -50,12 +50,12 @@ export class RouteExecutionManager {
                     return executionPromise ?? clonedRoute;
                 }
             }
-            await handlePreRestart(clonedRoute, signer);
-            const executionPromise = this.executeSteps(signer, clonedRoute, settings);
+            await prepareRestart(clonedRoute, walletClient);
+            const executionPromise = this.executeSteps(walletClient, clonedRoute, settings);
             this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
             return executionPromise;
         };
-        this.executeSteps = async (signer, route, settings) => {
+        this.executeSteps = async (walletClient, route, settings) => {
             const config = this.configService.getConfig();
             const execution = {
                 route,
@@ -91,7 +91,7 @@ export class RouteExecutionManager {
                     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);
+                    const executedStep = await stepExecutor.executeStep(walletClient, 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);
@@ -112,8 +112,8 @@ export class RouteExecutionManager {
         };
         /**
          * 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.
+         * @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];
@@ -134,8 +134,8 @@ export class RouteExecutionManager {
         };
         /**
          * 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.
+         * @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) => {
@@ -149,28 +149,10 @@ export class RouteExecutionManager {
                 ...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.
+         * @param route - A route that is currently in execution.
+         * @returns The stopped route.
          */
         this.stopExecution = (route) => {
             const execution = this.executionDictionary[route.id];
@@ -189,7 +171,7 @@ export class RouteExecutionManager {
         };
         /**
          * Get the list of active routes.
-         * @return {Route[]} A list of routes.
+         * @returns A list of routes.
          */
         this.getActiveRoutes = () => {
             return Object.values(this.executionDictionary)
@@ -198,8 +180,8 @@ export class RouteExecutionManager {
         };
         /**
          * 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.
+         * @param route - A route object.
+         * @returns The updated route.
          */
         this.getActiveRoute = (route) => {
             return this.executionDictionary[route.id]?.route;

package/dist/execution/StatusManager.d.ts

@@ -1,4 +1,4 @@
-import { Execution, InternalExecutionSettings, LifiStep, Process, ProcessType, Route, Status, Token } from '../types';
+import type { Execution, InternalExecutionSettings, LifiStep, Process, ProcessType, Route, Status, Token } from '../types';
 interface Receipt {
     fromAmount?: string;
     toAmount?: string;
@@ -13,10 +13,10 @@ 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.
+ * @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.
  */
 export declare class StatusManager {
     private readonly route;
@@ -26,40 +26,39 @@ export declare class StatusManager {
     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
+     * @param step  The current step in execution
+     * @returns The initialized execution object for this step and a function to update this step
      */
     initExecutionObject: (step: LifiStep) => Execution;
     /**
      * 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
+     * @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: 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}
+     * @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.
      */
     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
+     * @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
      */
     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}
+     * @param step The step where the process should be removed from
+     * @param type  The process type to remove
      */
     removeProcess: (step: LifiStep, type: ProcessType) => void;
     updateStepInRoute: (step: LifiStep) => LifiStep;

package/dist/execution/StatusManager.js

@@ -1,19 +1,19 @@
-import { emptyExecution, } from '../types';
+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.
+ * @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.
  */
 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
+         * @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(emptyExecution);
@@ -31,10 +31,10 @@ export class StatusManager {
         };
         /**
          * 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}
+         * @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) {
@@ -60,11 +60,11 @@ export class StatusManager {
         };
         /**
          * 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
+         * @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) {
@@ -112,9 +112,8 @@ export class StatusManager {
         };
         /**
          * 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}
+         * @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) {
@@ -143,10 +142,10 @@ export class StatusManager {
     }
     /**
      * 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
+     * @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) {