@lifi/sdk 1.7.2 → 2.0.0-beta.1

package/dist/cjs/execution/StatusManager.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatusManager = void 0;
 const types_1 = require("../types");
-const utils_1 = require("../utils/utils");
-const utils_2 = require("./utils");
+const utils_1 = require("./utils");
 /**
  * Manages status updates of a route and provides various functions for tracking processes
  * @param  {Route} route  The route this StatusManger belongs to.
@@ -20,7 +19,7 @@ class StatusManager {
          * @return {Execution}       The initialized execution object for this step and a function to update this step
          */
         this.initExecutionObject = (step) => {
-            const currentExecution = step.execution || (0, utils_1.deepClone)(types_1.emptyExecution);
+            const currentExecution = step.execution || structuredClone(types_1.emptyExecution);
             if (!step.execution) {
                 step.execution = currentExecution;
                 step.execution.status = 'PENDING';
@@ -41,8 +40,7 @@ class StatusManager {
          * @return {Process}
          */
         this.findOrCreateProcess = (step, type, status) => {
-            var _a;
-            if (!((_a = step.execution) === null || _a === void 0 ? void 0 : _a.process)) {
+            if (!step.execution?.process) {
                 throw new Error("Execution hasn't been initialized.");
             }
             const process = step.execution.process.find((p) => p.type === type);
@@ -56,8 +54,8 @@ class StatusManager {
             const newProcess = {
                 type: type,
                 startedAt: Date.now(),
-                message: (0, utils_2.getProcessMessage)(type, status !== null && status !== void 0 ? status : 'STARTED'),
-                status: status !== null && status !== void 0 ? status : 'STARTED',
+                message: (0, utils_1.getProcessMessage)(type, status ?? 'STARTED'),
+                status: status ?? 'STARTED',
             };
             step.execution.process.push(newProcess);
             this.updateStepInRoute(step);
@@ -72,11 +70,10 @@ class StatusManager {
          * @return {Process} The update process
          */
         this.updateProcess = (step, type, status, params) => {
-            var _a, _b, _c;
             if (!step.execution) {
                 throw new Error("Can't update an empty step execution.");
             }
-            const currentProcess = (_a = step === null || step === void 0 ? void 0 : step.execution) === null || _a === void 0 ? void 0 : _a.process.find((p) => p.type === type);
+            const currentProcess = step?.execution?.process.find((p) => p.type === type);
             if (!currentProcess) {
                 throw new Error("Can't find a process for the given type.");
             }
@@ -101,7 +98,7 @@ class StatusManager {
                     break;
             }
             currentProcess.status = status;
-            currentProcess.message = (0, utils_2.getProcessMessage)(type, status);
+            currentProcess.message = (0, utils_1.getProcessMessage)(type, status);
             // set extra parameters or overwritte the standard params set in the switch statement
             if (params) {
                 for (const [key, value] of Object.entries(params)) {
@@ -110,8 +107,8 @@ class StatusManager {
             }
             // Sort processes, the ones with DONE status go first
             step.execution.process = [
-                ...(_b = step === null || step === void 0 ? void 0 : step.execution) === null || _b === void 0 ? void 0 : _b.process.filter((process) => process.status === 'DONE'),
-                ...(_c = step === null || step === void 0 ? void 0 : step.execution) === null || _c === void 0 ? void 0 : _c.process.filter((process) => process.status !== 'DONE'),
+                ...step?.execution?.process.filter((process) => process.status === 'DONE'),
+                ...step?.execution?.process.filter((process) => process.status !== 'DONE'),
             ];
             this.updateStepInRoute(step); // updates the step in the route
             return currentProcess;
@@ -160,7 +157,10 @@ class StatusManager {
         }
         step.execution.status = status;
         if (receipt) {
-            step.execution = Object.assign(Object.assign({}, step.execution), receipt);
+            step.execution = {
+                ...step.execution,
+                ...receipt,
+            };
         }
         this.updateStepInRoute(step);
         return step;

package/dist/cjs/execution/StepExecutor.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StepExecutor = void 0;
 const ExecutionManager_1 = require("./ExecutionManager");
@@ -23,7 +14,10 @@ class StepExecutor {
         this.allowUserInteraction = true;
         this.executionStopped = false;
         this.setInteraction = (settings) => {
-            const interactionSettings = Object.assign(Object.assign({}, defaultInteractionSettings), settings);
+            const interactionSettings = {
+                ...defaultInteractionSettings,
+                ...settings,
+            };
             this.allowUserInteraction = interactionSettings.allowInteraction;
             this.executionManager.allowInteraction(interactionSettings.allowInteraction);
             this.statusManager.allowUpdates(interactionSettings.allowUpdates);
@@ -35,9 +29,9 @@ class StepExecutor {
         this.checkChain = () => {
             throw new Error('checkChain is not implemented.');
         };
-        this.executeStep = (signer, step) => __awaiter(this, void 0, void 0, function* () {
+        this.executeStep = async (signer, step) => {
             // Make sure that the chain is still correct
-            const updatedSigner = yield (0, switchChain_1.switchChain)(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
+            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;
@@ -49,9 +43,9 @@ class StepExecutor {
                 settings: this.settings,
                 statusManager: this.statusManager,
             };
-            yield this.executionManager.execute(parameters);
+            await this.executionManager.execute(parameters);
             return step;
-        });
+        };
         this.executionManager = new ExecutionManager_1.ExecutionManager();
         this.statusManager = statusManager;
         this.settings = settings;

package/dist/cjs/execution/stepComparison.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stepComparison = void 0;
 const errors_1 = require("../utils/errors");
@@ -23,16 +14,15 @@ const utils_1 = require("./utils");
  * @param acceptSlippageUpdateHook
  * @param allowUserInteraction
  */
-const stepComparison = (statusManager, oldStep, newStep, settings, allowUserInteraction) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+const stepComparison = async (statusManager, oldStep, newStep, settings, allowUserInteraction) => {
     // Check if changed exchange rate is in the range of slippage threshold
     if ((0, utils_1.checkStepSlippageThreshold)(oldStep, newStep)) {
         return statusManager.updateStepInRoute(newStep);
     }
-    const acceptExchangeRateUpdateHook = (_a = settings.acceptExchangeRateUpdateHook) !== null && _a !== void 0 ? _a : settings.acceptSlippageUpdateHook;
+    const acceptExchangeRateUpdateHook = settings.acceptExchangeRateUpdateHook ?? settings.acceptSlippageUpdateHook;
     let allowStepUpdate;
     if (allowUserInteraction) {
-        allowStepUpdate = yield acceptExchangeRateUpdateHook({
+        allowStepUpdate = await acceptExchangeRateUpdateHook({
             oldToAmount: oldStep.estimate.toAmount,
             newToAmount: newStep.estimate.toAmount,
             toToken: newStep.action.toToken,
@@ -46,5 +36,5 @@ const stepComparison = (statusManager, oldStep, newStep, settings, allowUserInte
       The exchange rate has changed and the previous estimation can not be fulfilled due to value loss.`);
     }
     return statusManager.updateStepInRoute(newStep);
-});
+};
 exports.stepComparison = stepComparison;

package/dist/cjs/execution/switchChain.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.switchChain = void 0;
 const errors_1 = require("../utils/errors");
@@ -22,9 +13,9 @@ const errors_1 = require("../utils/errors");
  * @param switchChainHook
  * @param allowUserInteraction
  */
-const switchChain = (signer, statusManager, step, switchChainHook, allowUserInteraction) => __awaiter(void 0, void 0, void 0, function* () {
+const switchChain = async (signer, statusManager, step, switchChainHook, allowUserInteraction) => {
     // if we are already on the correct chain we can proceed directly
-    if ((yield signer.getChainId()) === step.action.fromChainId) {
+    if ((await signer.getChainId()) === step.action.fromChainId) {
         return signer;
     }
     // -> set status message
@@ -35,8 +26,8 @@ const switchChain = (signer, statusManager, step, switchChainHook, allowUserInte
         return;
     }
     try {
-        const updatedSigner = yield switchChainHook(step.action.fromChainId);
-        const updatedChainId = yield (updatedSigner === null || updatedSigner === void 0 ? void 0 : updatedSigner.getChainId());
+        const updatedSigner = await switchChainHook(step.action.fromChainId);
+        const updatedChainId = await updatedSigner?.getChainId();
         if (updatedChainId !== step.action.fromChainId) {
             throw new errors_1.ProviderError(errors_1.LifiErrorCode.ChainSwitchError, 'Chain switch required.');
         }
@@ -54,5 +45,5 @@ const switchChain = (signer, statusManager, step, switchChainHook, allowUserInte
         statusManager.updateExecution(step, 'FAILED');
         throw error;
     }
-});
+};
 exports.switchChain = switchChain;

package/dist/cjs/execution/utils.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -18,51 +9,53 @@ const ApiService_1 = __importDefault(require("../services/ApiService"));
 const errors_1 = require("../utils/errors");
 const utils_1 = require("../utils/utils");
 const TRANSACTION_HASH_OBSERVERS = {};
-function waitForReceivingTransaction(txHash, statusManager, processType, step) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const getStatus = () => new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            let statusResponse;
-            try {
-                statusResponse = yield ApiService_1.default.getStatus({
-                    bridge: step.tool,
-                    fromChain: step.action.fromChainId,
-                    toChain: step.action.toChainId,
-                    txHash,
-                });
-            }
-            catch (e) {
-                console.debug('Fetching status from backend failed.', e);
-                return resolve(undefined);
-            }
-            switch (statusResponse.status) {
-                case 'DONE':
-                    return resolve(statusResponse);
-                case 'PENDING':
-                    statusManager === null || statusManager === void 0 ? void 0 : statusManager.updateProcess(step, processType, 'PENDING', Object.assign({ substatus: statusResponse.substatus, substatusMessage: statusResponse.substatusMessage ||
-                            getSubstatusMessage(statusResponse.status, statusResponse.substatus) }, (statusResponse.bridgeExplorerLink && {
-                        txLink: statusResponse.bridgeExplorerLink,
-                    })));
-                    return resolve(undefined);
-                case 'NOT_FOUND':
-                    return resolve(undefined);
-                case 'FAILED':
-                default:
-                    return reject();
-            }
-        }));
-        let status;
-        if (txHash in TRANSACTION_HASH_OBSERVERS) {
-            status = yield TRANSACTION_HASH_OBSERVERS[txHash];
+async function waitForReceivingTransaction(txHash, statusManager, processType, step) {
+    const getStatus = () => new Promise(async (resolve, reject) => {
+        let statusResponse;
+        try {
+            statusResponse = await ApiService_1.default.getStatus({
+                bridge: step.tool,
+                fromChain: step.action.fromChainId,
+                toChain: step.action.toChainId,
+                txHash,
+            });
         }
-        else {
-            TRANSACTION_HASH_OBSERVERS[txHash] = (0, utils_1.repeatUntilDone)(getStatus, 5000);
-            status = yield TRANSACTION_HASH_OBSERVERS[txHash];
+        catch (e) {
+            console.debug('Fetching status from backend failed.', e);
+            return resolve(undefined);
         }
-        if (!status.receiving) {
-            throw new errors_1.ServerError("Status doesn't contain receiving information.");
+        switch (statusResponse.status) {
+            case 'DONE':
+                return resolve(statusResponse);
+            case 'PENDING':
+                statusManager?.updateProcess(step, processType, 'PENDING', {
+                    substatus: statusResponse.substatus,
+                    substatusMessage: statusResponse.substatusMessage ||
+                        getSubstatusMessage(statusResponse.status, statusResponse.substatus),
+                    ...(statusResponse.bridgeExplorerLink && {
+                        txLink: statusResponse.bridgeExplorerLink,
+                    }),
+                });
+                return resolve(undefined);
+            case 'NOT_FOUND':
+                return resolve(undefined);
+            case 'FAILED':
+            default:
+                return reject();
         }
-        return status;
     });
+    let status;
+    if (txHash in TRANSACTION_HASH_OBSERVERS) {
+        status = await TRANSACTION_HASH_OBSERVERS[txHash];
+    }
+    else {
+        TRANSACTION_HASH_OBSERVERS[txHash] = (0, utils_1.repeatUntilDone)(getStatus, 5000);
+        status = await TRANSACTION_HASH_OBSERVERS[txHash];
+    }
+    if (!status.receiving) {
+        throw new errors_1.ServerError("Status doesn't contain receiving information.");
+    }
+    return status;
 }
 exports.waitForReceivingTransaction = waitForReceivingTransaction;
 const processMessages = {

package/dist/cjs/helpers.d.ts

@@ -1,4 +1,4 @@
-import { Token } from '@lifi/types';
+import { Route, Step, Token } from '@lifi/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.
@@ -17,3 +17,14 @@ export declare const getEthereumPublicKeyHook: (walletAddress: string) => () =>
 export declare const getRandomNumber: (min: number, max: number) => number;
 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.
+ * @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>;

package/dist/cjs/helpers.js

@@ -1,26 +1,19 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkPackageUpdates = exports.isSameToken = exports.getRandomNumber = exports.getEthereumPublicKeyHook = exports.getEthereumDecryptionHook = void 0;
+exports.request = exports.requestSettings = exports.convertQuoteToRoute = exports.checkPackageUpdates = exports.isSameToken = exports.getRandomNumber = exports.getEthereumPublicKeyHook = exports.getEthereumDecryptionHook = void 0;
+const errors_1 = require("./utils/errors");
+const utils_1 = require("./utils/utils");
 const version_1 = require("./version");
-const ethereumRequest = (method, params) => __awaiter(void 0, void 0, void 0, function* () {
+const ethereumRequest = async (method, params) => {
     // If ethereum.request() exists, the provider is probably EIP-1193 compliant.
-    if (!(ethereum === null || ethereum === void 0 ? void 0 : ethereum.request)) {
+    if (!ethereum?.request) {
         throw new Error('Provider not available.');
     }
     return ethereum.request({
         method,
         params,
     });
-});
+};
 /**
  * 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.
@@ -66,15 +59,15 @@ function semverCompare(a, b) {
         caseFirst: 'upper',
     });
 }
-const checkPackageUpdates = (packageName, packageVersion, disableCheck) => __awaiter(void 0, void 0, void 0, function* () {
+const checkPackageUpdates = async (packageName, packageVersion, disableCheck) => {
     if (disableCheck || process.env.NODE_ENV !== 'development') {
         return;
     }
     try {
-        const pkgName = packageName !== null && packageName !== void 0 ? packageName : version_1.name;
-        const response = yield (yield fetch(`https://registry.npmjs.org/${pkgName}/latest`)).json();
+        const pkgName = packageName ?? version_1.name;
+        const response = await (0, exports.request)(`https://registry.npmjs.org/${pkgName}/latest`);
         const latestVersion = response.version;
-        const currentVersion = packageVersion !== null && packageVersion !== void 0 ? packageVersion : version_1.version;
+        const currentVersion = packageVersion ?? version_1.version;
         if (semverCompare(latestVersion, currentVersion)) {
             console.warn(
             // eslint-disable-next-line max-len
@@ -84,5 +77,60 @@ const checkPackageUpdates = (packageName, packageVersion, disableCheck) => __awa
     catch (error) {
         // Cannot verify version, might be network error etc. We don't bother showing anything in that case
     }
-});
+};
 exports.checkPackageUpdates = checkPackageUpdates;
+/**
+ * Converts a quote to Route
+ * @param {Step} 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.
+ */
+const convertQuoteToRoute = (step) => {
+    if (!step.estimate.fromAmountUSD) {
+        throw new errors_1.ValidationError("Missing 'fromAmountUSD' in step estimate.");
+    }
+    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,
+        fromAmount: step.action.fromAmount,
+        toAmount: step.estimate.toAmount,
+        id: step.id,
+        fromChainId: step.action.fromToken.chainId,
+        toChainId: step.action.toToken.chainId,
+        fromAmountUSD: step.estimate.fromAmountUSD,
+        toAmountUSD: step.estimate.toAmountUSD,
+        steps: [lifiStep],
+        toAmountMin: step.estimate.toAmountMin,
+    };
+    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;
+    }
+};
+exports.request = request;

package/dist/cjs/services/ApiService.d.ts

@@ -1,15 +1,16 @@
-import { ContractCallQuoteRequest, GetStatusRequest, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
+import { ContractCallQuoteRequest, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
 import { ChainId, ChainKey, ExtendedChain, PossibilitiesRequest, PossibilitiesResponse, RoutesRequest, RoutesResponse, StatusResponse, Step, Token, ToolsRequest, ToolsResponse } from '../types';
 declare const _default: {
-    getPossibilities: (request?: PossibilitiesRequest | undefined, options?: RequestOptions | undefined) => Promise<PossibilitiesResponse>;
-    getToken: (chain: ChainKey | ChainId, token: string, options?: RequestOptions | undefined) => Promise<Token>;
-    getQuote: (request: QuoteRequest, options?: RequestOptions | undefined) => Promise<Step>;
-    getContractCallQuote: (request: ContractCallQuoteRequest, options?: RequestOptions | undefined) => Promise<Step>;
-    getStatus: ({ bridge, fromChain, toChain, txHash }: GetStatusRequest, options?: RequestOptions | undefined) => Promise<StatusResponse>;
     getChains: (options?: RequestOptions | undefined) => Promise<ExtendedChain[]>;
-    getRoutes: (request: RoutesRequest, options?: RequestOptions | undefined) => Promise<RoutesResponse>;
+    getContractCallQuote: (requestConfig: ContractCallQuoteRequest, options?: RequestOptions | undefined) => Promise<Step>;
+    getGasRecommendation: ({ chainId, fromChain, fromToken }: GasRecommendationRequest, options?: RequestOptions | undefined) => Promise<GasRecommendationResponse>;
+    getPossibilities: (requestConfig?: PossibilitiesRequest | undefined, options?: RequestOptions | undefined) => Promise<PossibilitiesResponse>;
+    getQuote: (requestConfig: QuoteRequest, options?: RequestOptions | undefined) => Promise<Step>;
+    getRoutes: (requestConfig: RoutesRequest, options?: RequestOptions | undefined) => Promise<RoutesResponse>;
+    getStatus: ({ bridge, fromChain, toChain, txHash }: GetStatusRequest, options?: RequestOptions | undefined) => Promise<StatusResponse>;
     getStepTransaction: (step: Step, options?: RequestOptions | undefined) => Promise<Step>;
-    getTools: (request?: ToolsRequest | undefined, options?: RequestOptions | undefined) => Promise<ToolsResponse>;
-    getTokens: (request?: TokensRequest | undefined, options?: RequestOptions | undefined) => Promise<TokensResponse>;
+    getToken: (chain: ChainKey | ChainId, token: string, options?: RequestOptions | undefined) => Promise<Token>;
+    getTokens: (requestConfig?: TokensRequest | undefined, options?: RequestOptions | undefined) => Promise<TokensResponse>;
+    getTools: (requestConfig?: ToolsRequest | undefined, options?: RequestOptions | undefined) => Promise<ToolsResponse>;
 };
 export default _default;