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

package/dist/{Lifi.d.ts → LiFi.d.ts}

@@ -1,11 +1,10 @@
 import { FallbackProvider } from '@ethersproject/providers';
-import { ChainId, ChainKey, ContractCallQuoteRequest, ExtendedChain, GetStatusRequest, PossibilitiesRequest, PossibilitiesResponse, QuoteRequest, RequestOptions, Route, RoutesRequest, RoutesResponse, StatusResponse, Step, Token, TokenAmount, TokensRequest, TokensResponse, ToolsRequest, ToolsResponse } from '@lifi/types';
+import { ChainId, ChainKey, ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, ExtendedChain, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, PossibilitiesRequest, PossibilitiesResponse, QuoteRequest, RequestOptions, RoutesRequest, RoutesResponse, StatusResponse, Token, TokenAmount, TokensRequest, TokensResponse, ToolsRequest, ToolsResponse } from '@lifi/types';
 import { Signer } from 'ethers';
 import { ApproveTokenRequest, RevokeApprovalRequest } from './allowance';
-import { Config, ConfigUpdate, ExecutionSettings, RevokeTokenData } from './types';
-export default class LIFI {
-    private activeRouteDictionary;
-    private configService;
+import { RouteExecutionManager } from './execution/RouteExecutionManager';
+import { Config, ConfigUpdate, RevokeTokenData } from './types';
+export declare class LiFi extends RouteExecutionManager {
     private chainsService;
     constructor(configUpdate?: ConfigUpdate);
     /**
@@ -50,13 +49,13 @@ export default class LIFI {
      * @param {QuoteRequest} request - The configuration of the requested quote
      * @throws {LifiError} - Throws a LifiError if request fails
      */
-    getQuote: (request: QuoteRequest, options?: RequestOptions) => Promise<Step>;
+    getQuote: (request: QuoteRequest, options?: RequestOptions) => Promise<LifiStep>;
     /**
      * Get a quote for a destination contract call
      * @param {ContractCallQuoteRequest} request - The configuration of the requested destination call
      * @throws {LifiError} - Throws a LifiError if request fails
      */
-    getContractCallQuote: (request: ContractCallQuoteRequest, options?: RequestOptions) => Promise<Step>;
+    getContractCallQuote: (request: ContractCallQuoteRequest, options?: RequestOptions) => Promise<LifiStep>;
     /**
      * Check the status of a transfer. For cross chain transfers, the "bridge" parameter is required.
      * @param {GetStatusRequest} request - Configuration of the requested status
@@ -83,73 +82,24 @@ export default class LIFI {
     getChains: () => Promise<ExtendedChain[]>;
     /**
      * Get a set of routes for a request that describes a transfer of tokens.
-     * @param {RoutesRequest} routesRequest - A description of the transfer.
+     * @param {RoutesRequest} request - A description of the transfer.
      * @return {Promise<RoutesResponse>} The resulting routes that can be used to realize the described transfer of tokens.
      * @throws {LifiError} Throws a LifiError if request fails.
      */
     getRoutes: (request: RoutesRequest, options?: RequestOptions) => Promise<RoutesResponse>;
     /**
      * Get the transaction data for a single step of a route
-     * @param {Step} step - The step object.
+     * @param {LifiStep} step - The step object.
      * @return {Promise<Step>} The step populated with the transaction data.
      * @throws {LifiError} Throws a LifiError if request fails.
      */
-    getStepTransaction: (step: Step, options?: RequestOptions) => Promise<Step>;
+    getStepTransaction: (step: LifiStep, options?: RequestOptions) => Promise<LifiStep>;
     /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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.
+     * Get gas recommendation for a certain chain
+     * @param {GasRecommendationRequest} request - Configuration of the requested recommendation.
+     * @throws {LifiError} Throws a LifiError if request fails.
      */
-    getActiveRoute: (route: Route) => Route | undefined;
+    getGasRecommendation: (request: GasRecommendationRequest, options?: RequestOptions) => Promise<GasRecommendationResponse>;
     /**
      * Returns the balances of a specific token a wallet holds across all aggregated chains.
      * @param {string} walletAddress - A wallet address.
@@ -205,3 +155,9 @@ export default class LIFI {
      */
     revokeTokenApproval: (request: RevokeApprovalRequest) => Promise<void>;
 }
+/**
+ * Get all the available connections for swap/bridging tokens
+ * @param connectionRequest ConnectionsRequest
+ * @returns ConnectionsResponse
+ */
+export declare const getConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;

package/dist/{Lifi.js → LiFi.js}

@@ -1,19 +1,16 @@
 import { approveToken, bulkGetTokenApproval, getTokenApproval, revokeTokenApproval, } from './allowance';
 import * as balance from './balance';
 import { getRpcProvider } from './connectors';
-import { StatusManager } from './execution/StatusManager';
-import { StepExecutor } from './execution/StepExecutor';
+import { RouteExecutionManager } from './execution/RouteExecutionManager';
 import { checkPackageUpdates } from './helpers';
 import ApiService from './services/ApiService';
 import ChainsService from './services/ChainsService';
-import ConfigService from './services/ConfigService';
 import { isToken } from './typeguards';
 import { ValidationError } from './utils/errors';
-import { handlePreRestart } from './utils/preRestart';
 import { name, version } from './version';
-export default class LIFI {
+export class LiFi extends RouteExecutionManager {
     constructor(configUpdate) {
-        this.activeRouteDictionary = {};
+        super(configUpdate);
         /**
          * Get the current configuration of the SDK
          * @return {Config} - The config object
@@ -113,7 +110,7 @@ export default class LIFI {
         };
         /**
          * Get a set of routes for a request that describes a transfer of tokens.
-         * @param {RoutesRequest} routesRequest - A description of the transfer.
+         * @param {RoutesRequest} request - A description of the transfer.
          * @return {Promise<RoutesResponse>} The resulting routes that can be used to realize the described transfer of tokens.
          * @throws {LifiError} Throws a LifiError if request fails.
          */
@@ -122,7 +119,7 @@ export default class LIFI {
         };
         /**
          * Get the transaction data for a single step of a route
-         * @param {Step} step - The step object.
+         * @param {LifiStep} step - The step object.
          * @return {Promise<Step>} The step populated with the transaction data.
          * @throws {LifiError} Throws a LifiError if request fails.
          */
@@ -130,206 +127,12 @@ export default class LIFI {
             return ApiService.getStepTransaction(step, options);
         };
         /**
-         * 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) => {
-            if (!this.activeRouteDictionary[route.id]) {
-                return route;
-            }
-            const { executionData } = this.activeRouteDictionary[route.id];
-            for (const executor of executionData.executors) {
-                executor.setInteraction({
-                    allowInteraction: false,
-                    allowUpdates: false,
-                    stopExecution: true,
-                });
-            }
-            delete this.activeRouteDictionary[route.id];
-            return route;
-        };
-        /**
-         * 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 { executionData } = this.activeRouteDictionary[route.id];
-            if (!executionData) {
-                return;
-            }
-            for (const executor of executionData.executors) {
-                executor.setInteraction({ allowInteraction: false, allowUpdates: true });
-            }
-            executionData.settings = {
-                ...executionData.settings,
-                executeInBackground: true,
-            };
-        };
-        /**
-         * 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 { executionData } = this.activeRouteDictionary[route.id];
-            if (!executionData) {
-                return;
-            }
-            for (const executor of executionData.executors) {
-                executor.setInteraction({
-                    allowInteraction: !settings.executeInBackground,
-                    allowUpdates: true,
-                });
-            }
-            // Update active route settings so we know what the current state of execution is
-            executionData.settings = {
-                ...executionData.settings,
-                ...settings,
-            };
-        };
-        /**
-         * 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);
-            // Check if route is already running
-            if (this.activeRouteDictionary[clonedRoute.id]) {
-                // TODO: maybe inform user why nothing happens?
-                return this.activeRouteDictionary[clonedRoute.id].executionPromise;
-            }
-            const executionPromise = this.executeSteps(signer, clonedRoute, settings);
-            this.activeRouteDictionary[clonedRoute.id] = {
-                ...this.activeRouteDictionary[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 { executionData, executionPromise } = this.activeRouteDictionary[clonedRoute.id];
-            if (executionData) {
-                const executionHalted = executionData.executors.some((executor) => executor.executionStopped);
-                if (!executionHalted) {
-                    // Check if we want to resume route execution in the background
-                    this.updateRouteExecution(route, {
-                        executeInBackground: settings?.executeInBackground,
-                    });
-                    return executionPromise;
-                }
-            }
-            handlePreRestart(clonedRoute);
-            const newExecutionPromise = this.executeSteps(signer, clonedRoute, settings);
-            this.activeRouteDictionary[clonedRoute.id] = {
-                ...this.activeRouteDictionary[clonedRoute.id],
-                executionPromise: newExecutionPromise,
-            };
-            return newExecutionPromise;
-        };
-        this.executeSteps = async (signer, route, settings) => {
-            const config = this.configService.getConfig();
-            const updatedExecutionData = {
-                route,
-                executors: [],
-                settings: { ...config.defaultExecutionSettings, ...settings },
-            };
-            this.activeRouteDictionary[route.id].executionData = {
-                ...updatedExecutionData,
-            };
-            const { executionData } = this.activeRouteDictionary[route.id];
-            const statusManager = new StatusManager(route, executionData.settings, (route) => {
-                if (this.activeRouteDictionary[route.id]) {
-                    executionData.route = route;
-                }
-            });
-            // Loop over steps and execute them
-            for (let index = 0; index < route.steps.length; index++) {
-                const { executionData } = this.activeRouteDictionary[route.id];
-                // Check if execution has stopped in the meantime
-                if (!executionData) {
-                    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, executionData.settings);
-                    executionData.executors.push(stepExecutor);
-                    // Check if we want to execute this step in the background
-                    this.updateRouteExecution(route, executionData.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.activeRouteDictionary[route.id];
-            return route;
-        };
-        /**
-         * 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) => {
-            if (!this.activeRouteDictionary[route.id]) {
-                throw new ValidationError("Can't set ExecutionSettings for the inactive route.");
-            }
-            const config = this.configService.getConfig();
-            this.activeRouteDictionary[route.id].executionData.settings = {
-                ...config.defaultExecutionSettings,
-                ...settings,
-            };
-        };
-        /**
-         * Get the list of active routes.
-         * @return {Route[]} A list of routes.
-         */
-        this.getActiveRoutes = () => {
-            return Object.values(this.activeRouteDictionary).map((dict) => dict.executionData.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.
+         * Get gas recommendation for a certain chain
+         * @param {GasRecommendationRequest} request - Configuration of the requested recommendation.
+         * @throws {LifiError} Throws a LifiError if request fails.
          */
-        this.getActiveRoute = (route) => {
-            return this.activeRouteDictionary[route.id]?.executionData.route;
+        this.getGasRecommendation = async (request, options) => {
+            return ApiService.getGasRecommendation(request, options);
         };
         /**
          * Returns the balances of a specific token a wallet holds across all aggregated chains.
@@ -413,11 +216,6 @@ export default class LIFI {
         this.revokeTokenApproval = (request) => {
             return revokeTokenApproval(request);
         };
-        this.configService = ConfigService.getInstance();
-        if (configUpdate) {
-            // Update API urls before we request chains
-            this.configService.updateConfig(configUpdate);
-        }
         this.chainsService = ChainsService.getInstance();
         this.chainsService.getChains().then((chains) => {
             this.configService.updateChains(chains);
@@ -425,3 +223,12 @@ export default class LIFI {
         checkPackageUpdates(name, version, configUpdate?.disableVersionCheck);
     }
 }
+/**
+ * Get all the available connections for swap/bridging tokens
+ * @param connectionRequest ConnectionsRequest
+ * @returns ConnectionsResponse
+ */
+export const getConnections = async (connectionRequest) => {
+    const connections = await ApiService.getAvailableConnections(connectionRequest);
+    return connections;
+};

package/dist/allowance/checkAllowance.d.ts

@@ -1,4 +1,4 @@
 import { Signer } from 'ethers';
 import { StatusManager } from '../execution/StatusManager';
-import { Chain, InternalExecutionSettings, Step } from '../types';
-export declare const checkAllowance: (signer: Signer, step: Step, statusManager: StatusManager, settings: InternalExecutionSettings, chain: Chain, allowUserInteraction?: boolean) => Promise<void>;
+import { Chain, InternalExecutionSettings, LifiStep } from '../types';
+export declare const checkAllowance: (signer: Signer, step: LifiStep, statusManager: StatusManager, settings: InternalExecutionSettings, chain: Chain, allowUserInteraction?: boolean) => Promise<void>;

package/dist/allowance/checkAllowance.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
 import BigNumber from 'bignumber.js';
 import { constants } from 'ethers';
 import { getApproved, setApproval } from '../allowance/utils';
@@ -17,7 +16,22 @@ export const checkAllowance = async (signer, step, statusManager, settings, chai
             allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
         }
         else {
-            const approved = await getApproved(signer, step.action.fromToken.address, step.estimate.approvalAddress);
+            const approvalRequest = {
+                from: step.action.fromToken.address,
+                to: step.estimate.approvalAddress,
+            };
+            if (settings.updateTransactionRequest) {
+                const config = await settings.updateTransactionRequest(approvalRequest);
+                approvalRequest.gasLimit = config.gasLimit;
+                approvalRequest.gasPrice = config.gasPrice;
+            }
+            if (!approvalRequest.from) {
+                throw new Error('Missing Signer address');
+            }
+            if (!approvalRequest.to) {
+                throw new Error('Missing ERC20 contract address');
+            }
+            const approved = await getApproved(signer, approvalRequest.from, approvalRequest.to, approvalRequest);
             if (new BigNumber(step.action.fromAmount).gt(approved)) {
                 if (!allowUserInteraction) {
                     return;

package/dist/allowance/utils.d.ts

@@ -1,8 +1,9 @@
+import { TransactionRequest } from '@ethersproject/abstract-provider';
 import { ChainId, Token } from '@lifi/types';
 import BigNumber from 'bignumber.js';
 import { ContractTransaction, Signer } from 'ethers';
 import { RevokeTokenData } from '../types';
-export declare const getApproved: (signer: Signer, tokenAddress: string, contractAddress: string) => Promise<BigNumber>;
+export declare const getApproved: (signer: Signer, tokenAddress: string, contractAddress: string, transactionRequest?: TransactionRequest) => Promise<BigNumber>;
 export declare const setApproval: (signer: Signer, tokenAddress: string, contractAddress: string, amount: string) => Promise<ContractTransaction>;
 export declare const getAllowanceViaMulticall: (signer: Signer, chainId: ChainId, tokenData: RevokeTokenData[]) => Promise<{
     token: Token;

package/dist/allowance/utils.js

@@ -4,11 +4,16 @@ import ChainsService from '../services/ChainsService';
 import { ERC20_ABI } from '../types';
 import { ServerError } from '../utils/errors';
 import { fetchDataUsingMulticall } from '../utils/multicall';
-export const getApproved = async (signer, tokenAddress, contractAddress) => {
+export const getApproved = async (signer, tokenAddress, contractAddress, transactionRequest) => {
     const signerAddress = await signer.getAddress();
     const erc20 = new Contract(tokenAddress, ERC20_ABI, signer);
     try {
-        const approved = await erc20.allowance(signerAddress, contractAddress);
+        const approved = await erc20.allowance(signerAddress, contractAddress, {
+            gasLimit: transactionRequest?.gasLimit,
+            gasPrice: transactionRequest?.gasPrice,
+            maxFeePerGas: transactionRequest?.maxFeePerGas,
+            maxPriorityFeePerGas: transactionRequest?.maxPriorityFeePerGas,
+        });
         return new BigNumber(approved.toString());
     }
     catch (e) {

package/dist/balance/checkBalance.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-import { Step } from '..';
-export declare const checkBalance: (signer: ethers.Signer, step: Step, depth?: number) => Promise<void>;
+import { LifiStep } from '..';
+export declare const checkBalance: (signer: ethers.Signer, step: LifiStep, depth?: number) => Promise<void>;

package/dist/balance/index.d.ts

@@ -1,7 +1,7 @@
 export * from './checkBalance';
 export * from './getTokenBalance';
 declare const _default: {
-    checkBalance: (signer: import("ethers").Signer, step: import("@lifi/types").Step, depth?: number) => Promise<void>;
+    checkBalance: (signer: import("ethers").Signer, step: import("@lifi/types").LifiStep, depth?: number) => Promise<void>;
     getTokenBalance: (walletAddress: string, token: import("@lifi/types").Token) => Promise<import("@lifi/types").TokenAmount | null>;
     getTokenBalances: (walletAddress: string, tokens: import("@lifi/types").Token[]) => Promise<import("@lifi/types").TokenAmount[]>;
     getTokenBalancesForChains: (walletAddress: string, tokensByChain: {

package/dist/cjs/{Lifi.d.ts → LiFi.d.ts}

@@ -1,11 +1,10 @@
 import { FallbackProvider } from '@ethersproject/providers';
-import { ChainId, ChainKey, ContractCallQuoteRequest, ExtendedChain, GetStatusRequest, PossibilitiesRequest, PossibilitiesResponse, QuoteRequest, RequestOptions, Route, RoutesRequest, RoutesResponse, StatusResponse, Step, Token, TokenAmount, TokensRequest, TokensResponse, ToolsRequest, ToolsResponse } from '@lifi/types';
+import { ChainId, ChainKey, ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, ExtendedChain, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, PossibilitiesRequest, PossibilitiesResponse, QuoteRequest, RequestOptions, RoutesRequest, RoutesResponse, StatusResponse, Token, TokenAmount, TokensRequest, TokensResponse, ToolsRequest, ToolsResponse } from '@lifi/types';
 import { Signer } from 'ethers';
 import { ApproveTokenRequest, RevokeApprovalRequest } from './allowance';
-import { Config, ConfigUpdate, ExecutionSettings, RevokeTokenData } from './types';
-export default class LIFI {
-    private activeRouteDictionary;
-    private configService;
+import { RouteExecutionManager } from './execution/RouteExecutionManager';
+import { Config, ConfigUpdate, RevokeTokenData } from './types';
+export declare class LiFi extends RouteExecutionManager {
     private chainsService;
     constructor(configUpdate?: ConfigUpdate);
     /**
@@ -50,13 +49,13 @@ export default class LIFI {
      * @param {QuoteRequest} request - The configuration of the requested quote
      * @throws {LifiError} - Throws a LifiError if request fails
      */
-    getQuote: (request: QuoteRequest, options?: RequestOptions) => Promise<Step>;
+    getQuote: (request: QuoteRequest, options?: RequestOptions) => Promise<LifiStep>;
     /**
      * Get a quote for a destination contract call
      * @param {ContractCallQuoteRequest} request - The configuration of the requested destination call
      * @throws {LifiError} - Throws a LifiError if request fails
      */
-    getContractCallQuote: (request: ContractCallQuoteRequest, options?: RequestOptions) => Promise<Step>;
+    getContractCallQuote: (request: ContractCallQuoteRequest, options?: RequestOptions) => Promise<LifiStep>;
     /**
      * Check the status of a transfer. For cross chain transfers, the "bridge" parameter is required.
      * @param {GetStatusRequest} request - Configuration of the requested status
@@ -83,73 +82,24 @@ export default class LIFI {
     getChains: () => Promise<ExtendedChain[]>;
     /**
      * Get a set of routes for a request that describes a transfer of tokens.
-     * @param {RoutesRequest} routesRequest - A description of the transfer.
+     * @param {RoutesRequest} request - A description of the transfer.
      * @return {Promise<RoutesResponse>} The resulting routes that can be used to realize the described transfer of tokens.
      * @throws {LifiError} Throws a LifiError if request fails.
      */
     getRoutes: (request: RoutesRequest, options?: RequestOptions) => Promise<RoutesResponse>;
     /**
      * Get the transaction data for a single step of a route
-     * @param {Step} step - The step object.
+     * @param {LifiStep} step - The step object.
      * @return {Promise<Step>} The step populated with the transaction data.
      * @throws {LifiError} Throws a LifiError if request fails.
      */
-    getStepTransaction: (step: Step, options?: RequestOptions) => Promise<Step>;
+    getStepTransaction: (step: LifiStep, options?: RequestOptions) => Promise<LifiStep>;
     /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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.
+     * Get gas recommendation for a certain chain
+     * @param {GasRecommendationRequest} request - Configuration of the requested recommendation.
+     * @throws {LifiError} Throws a LifiError if request fails.
      */
-    getActiveRoute: (route: Route) => Route | undefined;
+    getGasRecommendation: (request: GasRecommendationRequest, options?: RequestOptions) => Promise<GasRecommendationResponse>;
     /**
      * Returns the balances of a specific token a wallet holds across all aggregated chains.
      * @param {string} walletAddress - A wallet address.
@@ -205,3 +155,9 @@ export default class LIFI {
      */
     revokeTokenApproval: (request: RevokeApprovalRequest) => Promise<void>;
 }
+/**
+ * Get all the available connections for swap/bridging tokens
+ * @param connectionRequest ConnectionsRequest
+ * @returns ConnectionsResponse
+ */
+export declare const getConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;