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

package/dist/cjs/execution/RouteExecutionManager.js

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteExecutionManager = void 0;
+const ConfigService_1 = __importDefault(require("../services/ConfigService"));
+const errors_1 = require("../utils/errors");
+const preRestart_1 = require("../utils/preRestart");
+const StatusManager_1 = require("./StatusManager");
+const StepExecutor_1 = require("./StepExecutor");
+class RouteExecutionManager {
+    constructor(configUpdate) {
+        this.executionDictionary = {};
+        this.executionPromiseDictionary = {};
+        /**
+         * Execute a route.
+         * @param {Signer} signer - The signer required to send the transactions.
+         * @param {Route} route - The route that should be executed. Cannot be an active route.
+         * @param {ExecutionSettings} settings - An object containing settings and callbacks.
+         * @return {Promise<Route>} The executed route.
+         * @throws {LifiError} Throws a LifiError if the execution fails.
+         */
+        this.executeRoute = async (signer, route, settings) => {
+            // Deep clone to prevent side effects
+            const clonedRoute = structuredClone(route);
+            let executionPromise = this.executionPromiseDictionary[clonedRoute.id];
+            // Check if route is already running
+            if (executionPromise) {
+                return executionPromise;
+            }
+            executionPromise = this.executeSteps(signer, clonedRoute, settings);
+            this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
+            return executionPromise;
+        };
+        /**
+         * Resume the execution of a route that has been stopped or had an error while executing.
+         * @param {Signer} signer - The signer required to send the transactions.
+         * @param {Route} route - The route that is to be executed. Cannot be an active route.
+         * @param {ExecutionSettings} settings - An object containing settings and callbacks.
+         * @return {Promise<Route>} The executed route.
+         * @throws {LifiError} Throws a LifiError if the execution fails.
+         */
+        this.resumeRoute = async (signer, route, settings) => {
+            // Deep clone to prevent side effects
+            const clonedRoute = structuredClone(route);
+            const execution = this.executionDictionary[clonedRoute.id];
+            if (execution) {
+                const executionHalted = execution.executors.some((executor) => executor.executionStopped);
+                if (!executionHalted) {
+                    // Check if we want to resume route execution in the background
+                    this.updateRouteExecution(route, {
+                        executeInBackground: settings?.executeInBackground,
+                    });
+                    const executionPromise = this.executionPromiseDictionary[clonedRoute.id];
+                    return executionPromise ?? clonedRoute;
+                }
+            }
+            (0, preRestart_1.handlePreRestart)(clonedRoute);
+            const executionPromise = this.executeSteps(signer, clonedRoute, settings);
+            this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
+            return executionPromise;
+        };
+        this.executeSteps = async (signer, route, settings) => {
+            const config = this.configService.getConfig();
+            const execution = {
+                route,
+                executors: [],
+                settings: { ...config.defaultExecutionSettings, ...settings },
+            };
+            this.executionDictionary[route.id] = execution;
+            const statusManager = new StatusManager_1.StatusManager(route, execution.settings, (route) => {
+                if (this.executionDictionary[route.id]) {
+                    execution.route = route;
+                }
+            });
+            // Loop over steps and execute them
+            for (let index = 0; index < route.steps.length; index++) {
+                const execution = this.executionDictionary[route.id];
+                // Check if execution has stopped in the meantime
+                if (!execution) {
+                    break;
+                }
+                const step = route.steps[index];
+                const previousStep = route.steps[index - 1];
+                // Check if the step is already done
+                //
+                if (step.execution?.status === 'DONE') {
+                    continue;
+                }
+                // Update amount using output of previous execution. In the future this should be handled by calling `updateRoute`
+                if (previousStep?.execution?.toAmount) {
+                    step.action.fromAmount = previousStep.execution.toAmount;
+                }
+                try {
+                    const stepExecutor = new StepExecutor_1.StepExecutor(statusManager, execution.settings);
+                    execution.executors.push(stepExecutor);
+                    // Check if we want to execute this step in the background
+                    this.updateRouteExecution(route, execution.settings);
+                    const executedStep = await stepExecutor.executeStep(signer, step);
+                    // We may reach this point if user interaction isn't allowed. We want to stop execution until we resume it
+                    if (executedStep.execution?.status !== 'DONE') {
+                        this.stopExecution(route);
+                    }
+                    // Execution stopped during the current step, we don't want to continue to the next step so we return already
+                    if (stepExecutor.executionStopped) {
+                        return route;
+                    }
+                }
+                catch (e) {
+                    this.stopExecution(route);
+                    throw e;
+                }
+            }
+            // Clean up after the execution
+            delete this.executionDictionary[route.id];
+            return route;
+        };
+        /**
+         * Updates route execution to background or foreground state.
+         * @param {Route} route - A route that is currently in execution.
+         * @param {boolean} settings - An object with execution settings.
+         */
+        this.updateRouteExecution = (route, settings) => {
+            const execution = this.executionDictionary[route.id];
+            if (!execution) {
+                return;
+            }
+            for (const executor of execution.executors) {
+                executor.setInteraction({
+                    allowInteraction: !settings.executeInBackground,
+                    allowUpdates: true,
+                });
+            }
+            // Update active route settings so we know what the current state of execution is
+            execution.settings = {
+                ...execution.settings,
+                ...settings,
+            };
+        };
+        /**
+         * Update the ExecutionSettings for an active route.
+         * @param {ExecutionSettings} settings - An object with execution settings.
+         * @param {Route} route - The active route that gets the new execution settings.
+         * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
+         */
+        this.updateExecutionSettings = (settings, route) => {
+            const execution = this.executionDictionary[route.id];
+            if (!execution) {
+                throw new errors_1.ValidationError("Can't set ExecutionSettings for the inactive route.");
+            }
+            const config = this.configService.getConfig();
+            execution.settings = {
+                ...config.defaultExecutionSettings,
+                ...settings,
+            };
+        };
+        /**
+         * Executes a route until a user interaction is necessary (signing transactions, etc.) and then halts until the route is resumed.
+         * @param {Route} route - A route that is currently in execution.
+         * @deprecated use updateRouteExecution instead.
+         */
+        this.moveExecutionToBackground = (route) => {
+            const execution = this.executionDictionary[route.id];
+            if (!execution) {
+                return;
+            }
+            for (const executor of execution.executors) {
+                executor.setInteraction({ allowInteraction: false, allowUpdates: true });
+            }
+            execution.settings = {
+                ...execution.settings,
+                executeInBackground: true,
+            };
+        };
+        /**
+         * Stops the execution of an active route.
+         * @param {Route} route - A route that is currently in execution.
+         * @return {Route} The stopped route.
+         */
+        this.stopExecution = (route) => {
+            const execution = this.executionDictionary[route.id];
+            if (!execution) {
+                return route;
+            }
+            for (const executor of execution.executors) {
+                executor.setInteraction({
+                    allowInteraction: false,
+                    allowUpdates: false,
+                    stopExecution: true,
+                });
+            }
+            delete this.executionDictionary[route.id];
+            return route;
+        };
+        /**
+         * Get the list of active routes.
+         * @return {Route[]} A list of routes.
+         */
+        this.getActiveRoutes = () => {
+            return Object.values(this.executionDictionary)
+                .map((dict) => dict?.route)
+                .filter(Boolean);
+        };
+        /**
+         * Return the current route information for given route. The route has to be active.
+         * @param {Route} route - A route object.
+         * @return {Route} The updated route.
+         */
+        this.getActiveRoute = (route) => {
+            return this.executionDictionary[route.id]?.route;
+        };
+        this.configService = ConfigService_1.default.getInstance();
+        if (configUpdate) {
+            // Update API urls before we request chains
+            this.configService.updateConfig(configUpdate);
+        }
+    }
+}
+exports.RouteExecutionManager = RouteExecutionManager;

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

@@ -15,7 +15,7 @@ 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) => {
@@ -35,7 +35,7 @@ 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}
          */
@@ -63,7 +63,7 @@ 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.
@@ -115,7 +115,7 @@ 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}
          */
@@ -146,7 +146,7 @@ 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/cjs/execution/{ExecutionManager.d.ts → StepExecutionManager.d.ts}

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

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

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

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

@@ -1,9 +1,9 @@
 import { Signer } from 'ethers';
-import { InteractionSettings, InternalExecutionSettings, Step } from '../types';
-import { ExecutionManager } from './ExecutionManager';
+import { 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/cjs/execution/StepExecutor.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StepExecutor = void 0;
-const ExecutionManager_1 = require("./ExecutionManager");
+const StepExecutionManager_1 = require("./StepExecutionManager");
 const switchChain_1 = require("./switchChain");
 // Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
 const defaultInteractionSettings = {
@@ -19,7 +19,7 @@ class StepExecutor {
                 ...settings,
             };
             this.allowUserInteraction = interactionSettings.allowInteraction;
-            this.executionManager.allowInteraction(interactionSettings.allowInteraction);
+            this.stepExecutionManager.allowInteraction(interactionSettings.allowInteraction);
             this.statusManager.allowUpdates(interactionSettings.allowUpdates);
             this.executionStopped = interactionSettings.stopExecution;
         };
@@ -31,22 +31,30 @@ class StepExecutor {
         };
         this.executeStep = async (signer, step) => {
             // Make sure that the chain is still correct
-            const updatedSigner = await (0, switchChain_1.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 (0, switchChain_1.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_1.ExecutionManager();
+        this.stepExecutionManager = new StepExecutionManager_1.StepExecutionManager();
         this.statusManager = statusManager;
         this.settings = settings;
     }

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

@@ -11,7 +11,7 @@ const utils_1 = require("./utils");
  * @param statusManager
  * @param oldStep
  * @param newStep
- * @param acceptSlippageUpdateHook
+ * @param settings
  * @param allowUserInteraction
  */
 const stepComparison = async (statusManager, oldStep, newStep, settings, allowUserInteraction) => {
@@ -19,15 +19,12 @@ const stepComparison = async (statusManager, oldStep, newStep, settings, allowUs
     if ((0, utils_1.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/cjs/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/cjs/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/cjs/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>;

package/dist/cjs/helpers.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.request = exports.requestSettings = exports.convertQuoteToRoute = exports.checkPackageUpdates = exports.isSameToken = exports.getRandomNumber = exports.getEthereumPublicKeyHook = exports.getEthereumDecryptionHook = void 0;
+exports.fetchTxErrorDetails = exports.convertQuoteToRoute = exports.checkPackageUpdates = exports.isSameToken = exports.getRandomNumber = exports.getEthereumPublicKeyHook = exports.getEthereumDecryptionHook = void 0;
+const request_1 = require("./request");
 const errors_1 = require("./utils/errors");
-const utils_1 = require("./utils/utils");
 const version_1 = require("./version");
 const ethereumRequest = async (method, params) => {
     // If ethereum.request() exists, the provider is probably EIP-1193 compliant.
@@ -65,7 +65,7 @@ const checkPackageUpdates = async (packageName, packageVersion, disableCheck) =>
     }
     try {
         const pkgName = packageName ?? version_1.name;
-        const response = await (0, exports.request)(`https://registry.npmjs.org/${pkgName}/latest`);
+        const response = await (0, request_1.request)(`https://registry.npmjs.org/${pkgName}/latest`, { skipTrackingHeaders: true });
         const latestVersion = response.version;
         const currentVersion = packageVersion ?? version_1.version;
         if (semverCompare(latestVersion, currentVersion)) {
@@ -81,7 +81,7 @@ const checkPackageUpdates = async (packageName, packageVersion, disableCheck) =>
 exports.checkPackageUpdates = checkPackageUpdates;
 /**
  * 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.
  */
@@ -92,11 +92,6 @@ const convertQuoteToRoute = (step) => {
     if (!step.estimate.toAmountUSD) {
         throw new errors_1.ValidationError("Missing 'toAmountUSD' in step estimate.");
     }
-    const lifiStep = {
-        ...step,
-        type: 'lifi',
-        includedSteps: [],
-    };
     const route = {
         fromToken: step.action.fromToken,
         toToken: step.action.toToken,
@@ -107,30 +102,15 @@ const convertQuoteToRoute = (step) => {
         toChainId: step.action.toToken.chainId,
         fromAmountUSD: step.estimate.fromAmountUSD,
         toAmountUSD: step.estimate.toAmountUSD,
-        steps: [lifiStep],
+        steps: [step],
         toAmountMin: step.estimate.toAmountMin,
+        insurance: { state: 'NOT_INSURABLE', feeAmountUsd: '0' },
     };
     return route;
 };
 exports.convertQuoteToRoute = convertQuoteToRoute;
-exports.requestSettings = {
-    retries: 1,
-};
-const request = async (url, options, retries = exports.requestSettings.retries) => {
-    try {
-        const response = await fetch(url, options);
-        if (!response.ok) {
-            throw new errors_1.HTTPError(response);
-        }
-        const data = await response.json();
-        return data;
-    }
-    catch (error) {
-        if (retries > 0 && error?.status === 500) {
-            await (0, utils_1.sleep)(500);
-            return (0, exports.request)(url, options, retries - 1);
-        }
-        throw error;
-    }
+const fetchTxErrorDetails = async (txHash, chainId) => {
+    const response = await (0, request_1.request)(`https://api.tenderly.co/api/v1/public-contract/${chainId}/tx/${txHash}`);
+    return response;
 };
-exports.request = request;
+exports.fetchTxErrorDetails = fetchTxErrorDetails;

package/dist/cjs/index.d.ts

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

package/dist/cjs/index.js

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