@lifi/sdk 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/connectors.js

@@ -1,7 +1,7 @@
-import { providers } from 'ethers';
-import { ChainId } from './types';
-import ConfigService from './services/ConfigService';
+import { FallbackProvider, StaticJsonRpcProvider, } from '@ethersproject/providers';
 import { getRandomNumber } from './helpers';
+import ConfigService from './services/ConfigService';
+import { ChainId } from './types';
 import { ServerError } from './utils/errors';
 // cached providers
 const chainProviders = {};
@@ -33,17 +33,15 @@ const getRandomProvider = (providerList) => {
 export const getRpcProvider = async (chainId, archive = false) => {
     if (archive && archiveRpcs[chainId]) {
         // return archive PRC, but don't cache it
-        return new providers.FallbackProvider([
-            new providers.StaticJsonRpcProvider(await getRpcUrl(chainId, archive), chainId),
+        return new FallbackProvider([
+            new StaticJsonRpcProvider(await getRpcUrl(chainId, archive), chainId),
         ]);
     }
-    if (!chainProviders[chainId]) {
+    if (!chainProviders[chainId]?.length) {
         chainProviders[chainId] = [];
         const urls = await getRpcUrls(chainId, archive);
         urls.forEach((url) => {
-            chainProviders[chainId].push(new providers.FallbackProvider([
-                new providers.StaticJsonRpcProvider(url, chainId),
-            ]));
+            chainProviders[chainId].push(new FallbackProvider([new StaticJsonRpcProvider(url, chainId)]));
         });
     }
     if (!chainProviders[chainId].length) {

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;
+}

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/StatusManager.d.ts

@@ -1,4 +1,4 @@
-import { Execution, InternalExecutionSettings, Process, ProcessType, Route, Status, Step, Token } from '../types';
+import { Execution, InternalExecutionSettings, LifiStep, Process, ProcessType, Route, Status, Token } from '../types';
 interface Receipt {
     fromAmount?: string;
     toAmount?: string;
@@ -26,43 +26,43 @@ export declare class StatusManager {
     constructor(route: Route, settings: InternalExecutionSettings, internalUpdateRouteCallback: InternalUpdateRouteCallback);
     /**
      * Initializes the execution object of a Step.
-     * @param  {Step} step  The current step in execution
+     * @param  {LifiStep} step  The current step in execution
      * @return {Execution}       The initialized execution object for this step and a function to update this step
      */
-    initExecutionObject: (step: Step) => Execution;
+    initExecutionObject: (step: LifiStep) => Execution;
     /**
      * Updates the execution object of a Step.
-     * @param  {Step} step  The current step in execution
+     * @param  {LifiStep} step  The current step in execution
      * @param  {Status} status  The status for the execution
      * @param  {Receipt} receipt Optional. Information about received tokens
      * @return {Step}       The step with the updated execution object
      */
-    updateExecution(step: Step, status: Status, receipt?: Receipt): Step;
+    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  {Step} step The step that should contain the new process.
+     * @param  {LifiStep} step The step that should contain the new process.
      * @param  {Status} status By default created procces is set to the STARTED status. We can override new process with the needed status.
      * @return {Process}
      */
-    findOrCreateProcess: (step: Step, type: ProcessType, status?: Status) => Process;
+    findOrCreateProcess: (step: LifiStep, type: ProcessType, status?: Status) => Process;
     /**
      * Update a process object.
-     * @param  {Step} step The step where the process should be updated
+     * @param  {LifiStep} step The step where the process should be updated
      * @param  {ProcessType} type  The process type to update
      * @param  {Status} status The status the process gets.
      * @param  {object} [params]   Additional parameters to append to the process.
      * @return {Process} The update process
      */
-    updateProcess: (step: Step, type: ProcessType, status: Status, params?: OptionalParameters) => Process;
+    updateProcess: (step: LifiStep, type: ProcessType, status: Status, params?: OptionalParameters) => Process;
     /**
      * Remove a process from the execution
-     * @param  {Step} step The step where the process should be removed from
+     * @param  {LifiStep} step The step where the process should be removed from
      * @param  {ProcessType} type  The process type to remove
      * @return {void}
      */
-    removeProcess: (step: Step, type: ProcessType) => void;
-    updateStepInRoute: (step: Step) => Step;
+    removeProcess: (step: LifiStep, type: ProcessType) => void;
+    updateStepInRoute: (step: LifiStep) => LifiStep;
     allowUpdates(value: boolean): void;
 }
 export {};

package/dist/execution/StatusManager.js

@@ -12,7 +12,7 @@ export class StatusManager {
         this.shouldUpdate = true;
         /**
          * Initializes the execution object of a Step.
-         * @param  {Step} step  The current step in execution
+         * @param  {LifiStep} step  The current step in execution
          * @return {Execution}       The initialized execution object for this step and a function to update this step
          */
         this.initExecutionObject = (step) => {
@@ -32,7 +32,7 @@ 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  {Step} step The step that should contain the new process.
+         * @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}
          */
@@ -60,7 +60,7 @@ export class StatusManager {
         };
         /**
          * Update a process object.
-         * @param  {Step} step The step where the process should be updated
+         * @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.
@@ -112,7 +112,7 @@ export class StatusManager {
         };
         /**
          * Remove a process from the execution
-         * @param  {Step} step The step where the process should be removed from
+         * @param  {LifiStep} step The step where the process should be removed from
          * @param  {ProcessType} type  The process type to remove
          * @return {void}
          */
@@ -143,7 +143,7 @@ export class StatusManager {
     }
     /**
      * Updates the execution object of a Step.
-     * @param  {Step} step  The current step in execution
+     * @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

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) => {
@@ -75,6 +75,14 @@ export class ExecutionManager {
                         if (!this.allowUserInteraction) {
                             return step.execution;
                         }
+                        if (settings.updateTransactionRequest) {
+                            const customConfig = await settings.updateTransactionRequest(transactionRequest);
+                            transactionRequest.gasLimit = customConfig.gasLimit;
+                            transactionRequest.gasPrice = customConfig.gasPrice;
+                            transactionRequest.maxPriorityFeePerGas =
+                                customConfig.maxPriorityFeePerGas;
+                            transactionRequest.maxFeePerGas = customConfig.maxFeePerGas;
+                        }
                         // Submit the transaction
                         transaction = await signer.sendTransaction(transactionRequest);
                         // STEP 4: Wait for the transaction

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 { InteractionSettings, InternalExecutionSettings, LifiStep } from '../types';
 import { StatusManager } from './StatusManager';
+import { StepExecutionManager } from './StepExecutionManager';
 export declare class StepExecutor {
-    executionManager: ExecutionManager;
+    stepExecutionManager: StepExecutionManager;
     statusManager: StatusManager;
     settings: InternalExecutionSettings;
     allowUserInteraction: boolean;
@@ -11,5 +11,5 @@ export declare class StepExecutor {
     constructor(statusManager: StatusManager, settings: InternalExecutionSettings);
     setInteraction: (settings?: InteractionSettings) => void;
     checkChain: () => never;
-    executeStep: (signer: Signer, step: Step) => Promise<Step>;
+    executeStep: (signer: Signer, step: LifiStep) => Promise<LifiStep>;
 }

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;
         };
@@ -28,22 +28,30 @@ export class StepExecutor {
         };
         this.executeStep = async (signer, step) => {
             // Make sure that the chain is still correct
-            const updatedSigner = await switchChain(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
-            if (!updatedSigner) {
-                // Chain switch was not successful, stop execution here
-                return step;
+            // Find if it's bridging and the step is waiting for a transaction on the receiving chain
+            const recievingChainProcess = step.execution?.process.find((process) => process.type === 'RECEIVING_CHAIN');
+            // If the step is waiting for a transaction on the receiving chain, we do not switch the chain
+            // All changes are already done from the source chain
+            // Return the step
+            if (recievingChainProcess?.substatus !== 'WAIT_DESTINATION_TRANSACTION' ||
+                !recievingChainProcess) {
+                const updatedSigner = await switchChain(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
+                if (!updatedSigner) {
+                    // Chain switch was not successful, stop execution here
+                    return step;
+                }
+                signer = updatedSigner;
             }
-            signer = updatedSigner;
             const parameters = {
                 signer,
                 step,
                 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/execution/stepComparison.d.ts

@@ -1,5 +1,5 @@
 import { StatusManager } from '.';
-import { InternalExecutionSettings, Step } from '../types';
+import { InternalExecutionSettings, LifiStep } from '../types';
 /**
  * This method checks whether the new and updated Step meets the required exchange rate conditions.
  * If yes it returns the updated Step.
@@ -8,7 +8,7 @@ import { InternalExecutionSettings, Step } from '../types';
  * @param statusManager
  * @param oldStep
  * @param newStep
- * @param acceptSlippageUpdateHook
+ * @param settings
  * @param allowUserInteraction
  */
-export declare const stepComparison: (statusManager: StatusManager, oldStep: Step, newStep: Step, settings: InternalExecutionSettings, allowUserInteraction: boolean) => Promise<Step>;
+export declare const stepComparison: (statusManager: StatusManager, oldStep: LifiStep, newStep: LifiStep, settings: InternalExecutionSettings, allowUserInteraction: boolean) => Promise<LifiStep>;

package/dist/execution/stepComparison.js

@@ -8,7 +8,7 @@ import { checkStepSlippageThreshold } from './utils';
  * @param statusManager
  * @param oldStep
  * @param newStep
- * @param acceptSlippageUpdateHook
+ * @param settings
  * @param allowUserInteraction
  */
 export const stepComparison = async (statusManager, oldStep, newStep, settings, allowUserInteraction) => {
@@ -16,15 +16,12 @@ export const stepComparison = async (statusManager, oldStep, newStep, settings,
     if (checkStepSlippageThreshold(oldStep, newStep)) {
         return statusManager.updateStepInRoute(newStep);
     }
-    const acceptExchangeRateUpdateHook = settings.acceptExchangeRateUpdateHook ?? settings.acceptSlippageUpdateHook;
     let allowStepUpdate;
     if (allowUserInteraction) {
-        allowStepUpdate = await acceptExchangeRateUpdateHook({
+        allowStepUpdate = await settings.acceptExchangeRateUpdateHook({
             oldToAmount: oldStep.estimate.toAmount,
             newToAmount: newStep.estimate.toAmount,
             toToken: newStep.action.toToken,
-            oldSlippage: oldStep.action.slippage,
-            newSlippage: newStep.action.slippage,
         });
     }
     if (!allowStepUpdate) {

package/dist/execution/switchChain.d.ts

@@ -1,4 +1,4 @@
-import { Step } from '@lifi/types';
+import { LifiStep } from '@lifi/types';
 import { Signer } from 'ethers';
 import { SwitchChainHook } from '../types';
 import { StatusManager } from './StatusManager';
@@ -13,4 +13,4 @@ import { StatusManager } from './StatusManager';
  * @param switchChainHook
  * @param allowUserInteraction
  */
-export declare const switchChain: (signer: Signer, statusManager: StatusManager, step: Step, switchChainHook: SwitchChainHook, allowUserInteraction: boolean) => Promise<Signer | undefined>;
+export declare const switchChain: (signer: Signer, statusManager: StatusManager, step: LifiStep, switchChainHook: SwitchChainHook, allowUserInteraction: boolean) => Promise<Signer | undefined>;

package/dist/execution/utils.d.ts

@@ -1,6 +1,6 @@
-import { ProcessType, Status, StatusMessage, StatusResponse, Step, Substatus } from '@lifi/types';
+import { LifiStep, ProcessType, Status, StatusMessage, StatusResponse, Substatus } from '@lifi/types';
 import { StatusManager } from '..';
-export declare function waitForReceivingTransaction(txHash: string, statusManager: StatusManager, processType: ProcessType, step: Step): Promise<StatusResponse>;
+export declare function waitForReceivingTransaction(txHash: string, statusManager: StatusManager, processType: ProcessType, step: LifiStep): Promise<StatusResponse>;
 export declare function getProcessMessage(type: ProcessType, status: Status): string | undefined;
 export declare function getSubstatusMessage(status: StatusMessage, substatus?: Substatus): string | undefined;
-export declare function checkStepSlippageThreshold(oldStep: Step, newStep: Step): boolean;
+export declare function checkStepSlippageThreshold(oldStep: LifiStep, newStep: LifiStep): boolean;

package/dist/helpers.d.ts

@@ -1,4 +1,5 @@
-import { Route, Step, Token } from '@lifi/types';
+import { LifiStep, Route, Token } from '@lifi/types';
+import { TenderlyResponse } from './types';
 /**
  * Predefined hook that decrypts calldata using EIP-1193 compliant wallet functions.
  * @param {string} walletAddress - The wallet address of the user that should decrypt the calldata.
@@ -19,12 +20,9 @@ export declare const isSameToken: (tokenA: Token, tokenB: Token) => boolean;
 export declare const checkPackageUpdates: (packageName?: string, packageVersion?: string, disableCheck?: boolean) => Promise<void>;
 /**
  * Converts a quote to Route
- * @param {Step} step - Step returned from the quote endpoint.
+ * @param {LifiStep} step - Step returned from the quote endpoint.
  * @return {Route} - The route to be executed.
  * @throws {ValidationError} Throws a ValidationError if the step has missing values.
  */
-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 convertQuoteToRoute: (step: LifiStep) => Route;
+export declare const fetchTxErrorDetails: (txHash: string, chainId: number) => Promise<TenderlyResponse>;