@lifi/sdk 2.2.3 → 3.0.0-alpha.2

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

@@ -1,63 +1,71 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMulticallAddress = exports.getRpcProvider = exports.getRpcUrls = exports.getRpcUrl = void 0;
-const providers_1 = require("@ethersproject/providers");
-const helpers_1 = require("./helpers");
+exports.getMulticallAddress = exports.getPublicClient = exports.getRpcUrls = exports.getRpcUrl = exports.getChainById = void 0;
+const viem_1 = require("viem");
+const chains = __importStar(require("viem/chains")); // TODO: optimize using BE chains
 const ConfigService_1 = __importDefault(require("./services/ConfigService"));
-const types_1 = require("./types");
 const errors_1 = require("./utils/errors");
 // cached providers
-const chainProviders = {};
-// Archive RPC Provider
-const archiveRpcs = {
-    [types_1.ChainId.ETH]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/eth/mainnet/archive',
-    [types_1.ChainId.BSC]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/bsc/mainnet/archive',
-    [types_1.ChainId.POL]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/polygon/mainnet/archive',
-    [types_1.ChainId.FTM]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/fantom/mainnet',
+const publicClients = {};
+const getChainById = (chainId) => {
+    return Object.values(chains).find((chain) => chain.id === chainId);
 };
+exports.getChainById = getChainById;
 // RPC Urls
-const getRpcUrl = async (chainId, archive = false) => {
-    const rpcUrls = await (0, exports.getRpcUrls)(chainId, archive);
+const getRpcUrl = async (chainId) => {
+    const rpcUrls = await (0, exports.getRpcUrls)(chainId);
     return rpcUrls[0];
 };
 exports.getRpcUrl = getRpcUrl;
-const getRpcUrls = async (chainId, archive = false) => {
-    if (archive && archiveRpcs[chainId]) {
-        return [archiveRpcs[chainId]];
-    }
+const getRpcUrls = async (chainId) => {
     const configService = ConfigService_1.default.getInstance();
     const config = await configService.getConfigAsync();
     return config.rpcs[chainId];
 };
 exports.getRpcUrls = getRpcUrls;
-const getRandomProvider = (providerList) => {
-    const index = (0, helpers_1.getRandomNumber)(0, providerList.length - 1);
-    return providerList[index];
-};
-// Provider
-const getRpcProvider = async (chainId, archive = false) => {
-    if (archive && archiveRpcs[chainId]) {
-        // return archive PRC, but don't cache it
-        return new providers_1.FallbackProvider([
-            new providers_1.StaticJsonRpcProvider(await (0, exports.getRpcUrl)(chainId, archive), chainId),
-        ]);
-    }
-    if (!chainProviders[chainId]?.length) {
-        chainProviders[chainId] = [];
-        const urls = await (0, exports.getRpcUrls)(chainId, archive);
-        urls.forEach((url) => {
-            chainProviders[chainId].push(new providers_1.FallbackProvider([new providers_1.StaticJsonRpcProvider(url, chainId)]));
+const getPublicClient = async (chainId) => {
+    if (!publicClients[chainId]) {
+        const urls = await (0, exports.getRpcUrls)(chainId);
+        const fallbackTransports = urls.map((url) => (0, viem_1.http)(url, {
+            batch: true,
+        }));
+        publicClients[chainId] = (0, viem_1.createPublicClient)({
+            chain: (0, exports.getChainById)(chainId),
+            transport: (0, viem_1.fallback)(fallbackTransports),
         });
     }
-    if (!chainProviders[chainId].length) {
+    if (!publicClients[chainId]) {
         throw new errors_1.ServerError(`Unable to configure provider for chain ${chainId}`);
     }
-    return getRandomProvider(chainProviders[chainId]);
+    return publicClients[chainId];
 };
-exports.getRpcProvider = getRpcProvider;
+exports.getPublicClient = getPublicClient;
 // Multicall
 const getMulticallAddress = async (chainId) => {
     const configService = ConfigService_1.default.getInstance();

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulticallBatchSize = exports.AlternativeAddressZero = exports.AddressZero = void 0;
+exports.AddressZero = '0x0000000000000000000000000000000000000000';
+exports.AlternativeAddressZero = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+/**
+ * Cronos require bigger multicall chunks than default 1024 (1 KB)
+ */
+exports.MulticallBatchSize = 16384; // 16 Kilobytes (KB)

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

@@ -6,22 +6,22 @@ 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");
+const prepareRestart_1 = require("./prepareRestart");
 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];
@@ -29,19 +29,19 @@ 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];
@@ -56,12 +56,12 @@ class RouteExecutionManager {
                     return executionPromise ?? clonedRoute;
                 }
             }
-            await (0, preRestart_1.handlePreRestart)(clonedRoute, signer);
-            const executionPromise = this.executeSteps(signer, clonedRoute, settings);
+            await (0, prepareRestart_1.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,
@@ -97,7 +97,7 @@ 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);
@@ -118,8 +118,8 @@ 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];
@@ -140,8 +140,8 @@ 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) => {
@@ -155,28 +155,10 @@ 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];
@@ -195,7 +177,7 @@ 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)
@@ -204,8 +186,8 @@ 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/cjs/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/cjs/execution/StatusManager.js

@@ -5,18 +5,18 @@ const types_1 = require("../types");
 const utils_1 = require("./utils");
 /**
  * Manages status updates of a route and provides various functions for tracking processes
- * @param  {Route} route  The route this StatusManger belongs to.
- * @param  {InternalExecutionSettings} settings   The ExecutionSettings for this route.
- * @param  {InternalUpdateRouteCallback} internalUpdateRouteCallback  Internal callback to propage route changes.
- * @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.
  */
 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(types_1.emptyExecution);
@@ -34,10 +34,10 @@ 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) {
@@ -63,11 +63,11 @@ 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) {
@@ -115,9 +115,8 @@ 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) {
@@ -146,10 +145,10 @@ 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) {

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

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