@lifi/sdk 1.1.2 → 1.1.5

package/dist/Lifi.js

@@ -1,15 +1,3 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 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) {
@@ -19,66 +7,34 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var allowance_1 = require("./allowance");
-var balances_1 = __importDefault(require("./balances"));
-var connectors_1 = require("./connectors");
-var StatusManager_1 = require("./execution/StatusManager");
-var StepExecutor_1 = require("./execution/StepExecutor");
-var ApiService_1 = __importDefault(require("./services/ApiService"));
-var ChainsService_1 = __importDefault(require("./services/ChainsService"));
-var ConfigService_1 = __importDefault(require("./services/ConfigService"));
-var typeguards_1 = require("./typeguards");
-var errors_1 = require("./utils/errors");
-var preRestart_1 = require("./utils/preRestart");
-var utils_1 = require("./utils/utils");
-var LIFI = /** @class */ (function () {
-    function LIFI(configUpdate) {
-        var _this = this;
+import { approveToken, bulkGetTokenApproval, getTokenApproval, revokeTokenApproval, } from './allowance';
+import balances from './balances';
+import { getRpcProvider } from './connectors';
+import { StatusManager } from './execution/StatusManager';
+import { StepExecutor } from './execution/StepExecutor';
+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 { deepClone } from './utils/utils';
+export default class LIFI {
+    constructor(configUpdate) {
         this.activeRouteDictionary = {};
         /**
          * Get the current configuration of the SDK
          * @return {Config} - The config object
          */
-        this.getConfig = function () {
-            return _this.configService.getConfig();
+        this.getConfig = () => {
+            return this.configService.getConfig();
         };
         /**
          * Get the SDK configuration after all setup calls are finished
          * @return {Promise<Config>} - The config object
          */
-        this.getConfigAsync = function () {
-            return _this.configService.getConfigAsync();
+        this.getConfigAsync = () => {
+            return this.configService.getConfigAsync();
         };
         /**
          * Get an instance of a provider for a specific cahin
@@ -86,17 +42,16 @@ var LIFI = /** @class */ (function () {
          * @param {boolean} archive - Whether to use an archive provider that is based on a default rpc or not. defaults to false
          * @return {FallbackProvider} The provider for the given chain
          */
-        this.getRpcProvider = function (chainId, archive) {
-            if (archive === void 0) { archive = false; }
-            return (0, connectors_1.getRpcProvider)(chainId, archive);
+        this.getRpcProvider = (chainId, archive = false) => {
+            return getRpcProvider(chainId, archive);
         };
         /**
          * Set a new confuration for the SDK
          * @param {ConfigUpdate} configUpdate - An object containing the configuration fields that should be updated.
          * @return {Config} The renewed config object
          */
-        this.setConfig = function (configUpdate) {
-            return _this.configService.updateConfig(configUpdate);
+        this.setConfig = (configUpdate) => {
+            return this.configService.updateConfig(configUpdate);
         };
         /**
          * Get a set of current possibilities based on a request that specifies which chains, exchanges and bridges are preferred or unwanted.
@@ -104,130 +59,108 @@ var LIFI = /** @class */ (function () {
          * @return {Promise<PossibilitiesResponse>} Object listing current possibilities for any-to-any cross-chain-swaps based on the provided preferences.
          * @throws {LifiError} Throws a LifiError if request fails.
          */
-        this.getPossibilities = function (request, options) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, ApiService_1.default.getPossibilities(request, options)];
-            });
-        }); };
+        this.getPossibilities = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            return ApiService.getPossibilities(request, options);
+        });
         /**
          * Fetch information about a Token
          * @param {ChainKey | ChainId} chain - Id or key of the chain that contains the token
          * @param {string} token - Address or symbol of the token on the requested chain
          * @throws {LifiError} - Throws a LifiError if request fails
          */
-        this.getToken = function (chain, token, options) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, ApiService_1.default.getToken(chain, token, options)];
-            });
-        }); };
+        this.getToken = (chain, token, options) => __awaiter(this, void 0, void 0, function* () {
+            return ApiService.getToken(chain, token, options);
+        });
         /**
          * Get a quote for a token transfer
          * @param {QuoteRequest} request - The configuration of the requested quote
          * @throws {LifiError} - Throws a LifiError if request fails
          */
-        this.getQuote = function (request, options) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, ApiService_1.default.getQuote(request, options)];
-            });
-        }); };
+        this.getQuote = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            return ApiService.getQuote(request, options);
+        });
         /**
          * 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
          */
-        this.getContractCallQuote = function (request, options) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, ApiService_1.default.getContractCallQuote(request, options)];
-            });
-        }); };
+        this.getContractCallQuote = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            return ApiService.getContractCallQuote(request, options);
+        });
         /**
          * Check the status of a transfer. For cross chain transfers, the "bridge" parameter is required.
          * @param {GetStatusRequest} request - Configuration of the requested status
          * @throws {LifiError} - Throws a LifiError if request fails
          */
-        this.getStatus = function (request, options) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, ApiService_1.default.getStatus(request, options)];
-            });
-        }); };
+        this.getStatus = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            return ApiService.getStatus(request, options);
+        });
         /**
          * Get the available tools to bridge and swap tokens.
          * @param {ToolsRequest?} request - The configuration of the requested tools
          * @returns The tools that are available on the requested chains
          */
-        this.getTools = function (request, options) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, ApiService_1.default.getTools(request || {}, options)];
-            });
-        }); };
+        this.getTools = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            return ApiService.getTools(request || {}, options);
+        });
         /**
          * Get all known tokens.
          * @param {TokensRequest?} request - The configuration of the requested tokens
          * @returns The tokens that are available on the requested chains
          */
-        this.getTokens = function (request, options) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, ApiService_1.default.getTokens(request || {}, options)];
-            });
-        }); };
+        this.getTokens = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            return ApiService.getTokens(request || {}, options);
+        });
         /**
          * Get all available chains
          * @return {Promise<Chain[]>} A list of all available chains
          * @throws {LifiError} Throws a LifiError if request fails.
          */
-        this.getChains = function () { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.chainsService.getChains()];
-            });
-        }); };
+        this.getChains = () => __awaiter(this, void 0, void 0, function* () {
+            return this.chainsService.getChains();
+        });
         /**
          * Get a set of routes for a request that describes a transfer of tokens.
          * @param {RoutesRequest} routesRequest - 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.
          */
-        this.getRoutes = function (request, options) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, ApiService_1.default.getRoutes(request, options)];
-            });
-        }); };
+        this.getRoutes = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            return ApiService.getRoutes(request, options);
+        });
         /**
          * Get the transaction data for a single step of a route
          * @param {Step} step - The step object.
          * @return {Promise<Step>} The step populated with the transaction data.
          * @throws {LifiError} Throws a LifiError if request fails.
          */
-        this.getStepTransaction = function (step, options) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, ApiService_1.default.getStepTransaction(step, options)];
-            });
-        }); };
+        this.getStepTransaction = (step, options) => __awaiter(this, void 0, void 0, function* () {
+            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 = function (route) {
-            if (!_this.activeRouteDictionary[route.id]) {
+        this.stopExecution = (route) => {
+            if (!this.activeRouteDictionary[route.id]) {
                 return route;
             }
-            for (var _i = 0, _a = _this.activeRouteDictionary[route.id].executors; _i < _a.length; _i++) {
-                var executor = _a[_i];
+            for (const executor of this.activeRouteDictionary[route.id].executors) {
                 executor.stopStepExecution({ allowUpdates: false });
             }
-            delete _this.activeRouteDictionary[route.id];
+            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.
          */
-        this.moveExecutionToBackground = function (route) {
-            if (!_this.activeRouteDictionary[route.id]) {
+        this.moveExecutionToBackground = (route) => {
+            if (!this.activeRouteDictionary[route.id]) {
                 return;
             }
-            for (var _i = 0, _a = _this.activeRouteDictionary[route.id].executors; _i < _a.length; _i++) {
-                var executor = _a[_i];
+            for (const executor of this.activeRouteDictionary[route.id].executors) {
                 executor.stopStepExecution({ allowUpdates: true });
             }
         };
@@ -239,19 +172,15 @@ var LIFI = /** @class */ (function () {
          * @return {Promise<Route>} The executed route.
          * @throws {LifiError} Throws a LifiError if the execution fails.
          */
-        this.executeRoute = function (signer, route, settings) { return __awaiter(_this, void 0, void 0, function () {
-            var clonedRoute;
-            return __generator(this, function (_a) {
-                clonedRoute = (0, utils_1.deepClone)(route) // deep clone to prevent side effects
-                ;
-                // check if route is already running
-                if (this.activeRouteDictionary[clonedRoute.id]) {
-                    // TODO: maybe inform user why nothing happens?
-                    return [2 /*return*/, clonedRoute];
-                }
-                return [2 /*return*/, this.executeSteps(signer, clonedRoute, settings)];
-            });
-        }); };
+        this.executeRoute = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
+            const clonedRoute = deepClone(route); // deep clone to prevent side effects
+            // check if route is already running
+            if (this.activeRouteDictionary[clonedRoute.id]) {
+                // TODO: maybe inform user why nothing happens?
+                return clonedRoute;
+            }
+            return this.executeSteps(signer, clonedRoute, settings);
+        });
         /**
          * 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.
@@ -260,113 +189,92 @@ var LIFI = /** @class */ (function () {
          * @return {Promise<Route>} The executed route.
          * @throws {LifiError} Throws a LifiError if the execution fails.
          */
-        this.resumeRoute = function (signer, route, settings) { return __awaiter(_this, void 0, void 0, function () {
-            var clonedRoute, activeRoute, executionHalted;
-            return __generator(this, function (_a) {
-                clonedRoute = (0, utils_1.deepClone)(route) // deep clone to prevent side effects
-                ;
-                activeRoute = this.activeRouteDictionary[clonedRoute.id];
-                if (activeRoute) {
-                    executionHalted = activeRoute.executors.some(function (executor) { return executor.executionStopped; });
-                    if (!executionHalted) {
-                        return [2 /*return*/, clonedRoute];
-                    }
+        this.resumeRoute = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
+            const clonedRoute = deepClone(route); // deep clone to prevent side effects
+            const activeRoute = this.activeRouteDictionary[clonedRoute.id];
+            if (activeRoute) {
+                const executionHalted = activeRoute.executors.some((executor) => executor.executionStopped);
+                if (!executionHalted) {
+                    return clonedRoute;
+                }
+            }
+            handlePreRestart(clonedRoute);
+            return this.executeSteps(signer, clonedRoute, settings);
+        });
+        this.executeSteps = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
+            const config = this.configService.getConfig();
+            const execData = {
+                route,
+                executors: [],
+                settings: Object.assign(Object.assign({}, config.defaultExecutionSettings), settings),
+            };
+            this.activeRouteDictionary[route.id] = execData;
+            const statusManager = new StatusManager(route, this.activeRouteDictionary[route.id].settings, (route) => (this.activeRouteDictionary[route.id].route = route));
+            // loop over steps and execute them
+            for (let index = 0; index < route.steps.length; index++) {
+                //check if execution has stopped in meantime
+                if (!this.activeRouteDictionary[route.id]) {
+                    break;
+                }
+                const step = route.steps[index];
+                const previousStep = index !== 0 ? route.steps[index - 1] : undefined;
+                // check if step already done
+                if (step.execution && step.execution.status === 'DONE') {
+                    continue;
                 }
-                (0, preRestart_1.handlePreRestart)(clonedRoute);
-                return [2 /*return*/, this.executeSteps(signer, clonedRoute, settings)];
-            });
-        }); };
-        this.executeSteps = function (signer, route, settings) { return __awaiter(_this, void 0, void 0, function () {
-            var config, execData, statusManager, index, step, previousStep, stepExecutor, e_1;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        config = this.configService.getConfig();
-                        execData = {
-                            route: route,
-                            executors: [],
-                            settings: __assign(__assign({}, config.defaultExecutionSettings), settings),
-                        };
-                        this.activeRouteDictionary[route.id] = execData;
-                        statusManager = new StatusManager_1.StatusManager(route, this.activeRouteDictionary[route.id].settings, function (route) { return (_this.activeRouteDictionary[route.id].route = route); });
-                        index = 0;
-                        _a.label = 1;
-                    case 1:
-                        if (!(index < route.steps.length)) return [3 /*break*/, 7];
-                        //check if execution has stopped in meantime
-                        if (!this.activeRouteDictionary[route.id]) {
-                            return [3 /*break*/, 7];
-                        }
-                        step = route.steps[index];
-                        previousStep = index !== 0 ? route.steps[index - 1] : undefined;
-                        // check if step already done
-                        if (step.execution && step.execution.status === 'DONE') {
-                            return [3 /*break*/, 6];
-                        }
-                        // update amount using output of previous execution. In the future this should be handled by calling `updateRoute`
-                        if (previousStep &&
-                            previousStep.execution &&
-                            previousStep.execution.toAmount) {
-                            step.action.fromAmount = previousStep.execution.toAmount;
-                        }
-                        stepExecutor = void 0;
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
-                        stepExecutor = new StepExecutor_1.StepExecutor(statusManager, this.activeRouteDictionary[route.id].settings);
-                        this.activeRouteDictionary[route.id].executors.push(stepExecutor);
-                        return [4 /*yield*/, stepExecutor.executeStep(signer, step)];
-                    case 3:
-                        _a.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        e_1 = _a.sent();
-                        this.stopExecution(route);
-                        throw e_1;
-                    case 5:
-                        // execution stopped during the current step, we don't want to continue to the next step so we return already
-                        if (stepExecutor.executionStopped) {
-                            return [2 /*return*/, route];
-                        }
-                        _a.label = 6;
-                    case 6:
-                        index++;
-                        return [3 /*break*/, 1];
-                    case 7:
-                        //clean up after execution
-                        delete this.activeRouteDictionary[route.id];
-                        return [2 /*return*/, route];
+                // update amount using output of previous execution. In the future this should be handled by calling `updateRoute`
+                if (previousStep &&
+                    previousStep.execution &&
+                    previousStep.execution.toAmount) {
+                    step.action.fromAmount = previousStep.execution.toAmount;
                 }
-            });
-        }); };
+                let stepExecutor;
+                try {
+                    stepExecutor = new StepExecutor(statusManager, this.activeRouteDictionary[route.id].settings);
+                    this.activeRouteDictionary[route.id].executors.push(stepExecutor);
+                    yield stepExecutor.executeStep(signer, step);
+                }
+                catch (e) {
+                    this.stopExecution(route);
+                    throw e;
+                }
+                // 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;
+                }
+            }
+            //clean up after 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 = function (settings, route) {
-            if (!_this.activeRouteDictionary[route.id]) {
-                throw new errors_1.ValidationError("Can't set ExecutionSettings for the inactive route.");
+        this.updateExecutionSettings = (settings, route) => {
+            if (!this.activeRouteDictionary[route.id]) {
+                throw new ValidationError("Can't set ExecutionSettings for the inactive route.");
             }
-            var config = _this.configService.getConfig();
-            _this.activeRouteDictionary[route.id].settings = __assign(__assign({}, config.defaultExecutionSettings), settings);
+            const config = this.configService.getConfig();
+            this.activeRouteDictionary[route.id].settings = Object.assign(Object.assign({}, config.defaultExecutionSettings), settings);
         };
         /**
          * Get the list of active routes.
          * @return {Route[]} A list of routes.
          */
-        this.getActiveRoutes = function () {
-            return Object.values(_this.activeRouteDictionary).map(function (dict) { return dict.route; });
+        this.getActiveRoutes = () => {
+            return Object.values(this.activeRouteDictionary).map((dict) => dict.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.
          */
-        this.getActiveRoute = function (route) {
-            return _this.activeRouteDictionary[route.id].route;
+        this.getActiveRoute = (route) => {
+            var _a;
+            return (_a = this.activeRouteDictionary[route.id]) === null || _a === void 0 ? void 0 : _a.route;
         };
         /**
          * Returns the balances of a specific token a wallet holds across all aggregated chains.
@@ -375,17 +283,15 @@ var LIFI = /** @class */ (function () {
          * @return {Promise<TokenAmount | null>} An object containing the token and the amounts on different chains.
          * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
          */
-        this.getTokenBalance = function (walletAddress, token) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (!walletAddress) {
-                    throw new errors_1.ValidationError('Missing walletAddress.');
-                }
-                if (!(0, typeguards_1.isToken)(token)) {
-                    throw new errors_1.ValidationError("Invalid token passed: address \"".concat(token.address, "\" on chainId \"").concat(token.chainId, "\""));
-                }
-                return [2 /*return*/, balances_1.default.getTokenBalance(walletAddress, token)];
-            });
-        }); };
+        this.getTokenBalance = (walletAddress, token) => __awaiter(this, void 0, void 0, function* () {
+            if (!walletAddress) {
+                throw new ValidationError('Missing walletAddress.');
+            }
+            if (!isToken(token)) {
+                throw new ValidationError(`Invalid token passed: address "${token.address}" on chainId "${token.chainId}"`);
+            }
+            return balances.getTokenBalance(walletAddress, token);
+        });
         /**
          * Returns the balances for a list tokens a wallet holds  across all aggregated chains.
          * @param {string} walletAddress - A wallet address.
@@ -393,19 +299,16 @@ var LIFI = /** @class */ (function () {
          * @return {Promise<TokenAmount[]>} A list of objects containing the tokens and the amounts on different chains.
          * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
          */
-        this.getTokenBalances = function (walletAddress, tokens) { return __awaiter(_this, void 0, void 0, function () {
-            var invalidTokens;
-            return __generator(this, function (_a) {
-                if (!walletAddress) {
-                    throw new errors_1.ValidationError('Missing walletAddress.');
-                }
-                invalidTokens = tokens.filter(function (token) { return !(0, typeguards_1.isToken)(token); });
-                if (invalidTokens.length) {
-                    throw new errors_1.ValidationError("Invalid token passed: address \"".concat(invalidTokens[0].address, "\" on chainId \"").concat(invalidTokens[0].chainId, "\""));
-                }
-                return [2 /*return*/, balances_1.default.getTokenBalances(walletAddress, tokens)];
-            });
-        }); };
+        this.getTokenBalances = (walletAddress, tokens) => __awaiter(this, void 0, void 0, function* () {
+            if (!walletAddress) {
+                throw new ValidationError('Missing walletAddress.');
+            }
+            const invalidTokens = tokens.filter((token) => !isToken(token));
+            if (invalidTokens.length) {
+                throw new ValidationError(`Invalid token passed: address "${invalidTokens[0].address}" on chainId "${invalidTokens[0].chainId}"`);
+            }
+            return balances.getTokenBalances(walletAddress, tokens);
+        });
         /**
          * This method queries the balances of tokens for a specific list of chains for a given wallet.
          * @param {string} walletAddress - A walletaddress.
@@ -413,64 +316,55 @@ var LIFI = /** @class */ (function () {
          * @return {Promise<{ [chainId: number]: TokenAmount[] }} A list of objects containing the tokens and the amounts on different chains organized by the chosen chains.
          * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
          */
-        this.getTokenBalancesForChains = function (walletAddress, tokensByChain) { return __awaiter(_this, void 0, void 0, function () {
-            var tokenList, invalidTokens;
-            return __generator(this, function (_a) {
-                if (!walletAddress) {
-                    throw new errors_1.ValidationError('Missing walletAddress.');
-                }
-                tokenList = Object.values(tokensByChain).flat();
-                invalidTokens = tokenList.filter(function (token) { return !(0, typeguards_1.isToken)(token); });
-                if (invalidTokens.length) {
-                    throw new errors_1.ValidationError("Invalid token passed: address \"".concat(invalidTokens[0].address, "\" on chainId \"").concat(invalidTokens[0].chainId, "\""));
-                }
-                return [2 /*return*/, balances_1.default.getTokenBalancesForChains(walletAddress, tokensByChain)];
-            });
-        }); };
+        this.getTokenBalancesForChains = (walletAddress, tokensByChain) => __awaiter(this, void 0, void 0, function* () {
+            if (!walletAddress) {
+                throw new ValidationError('Missing walletAddress.');
+            }
+            const tokenList = Object.values(tokensByChain).flat();
+            const invalidTokens = tokenList.filter((token) => !isToken(token));
+            if (invalidTokens.length) {
+                throw new ValidationError(`Invalid token passed: address "${invalidTokens[0].address}" on chainId "${invalidTokens[0].chainId}"`);
+            }
+            return balances.getTokenBalancesForChains(walletAddress, tokensByChain);
+        });
         /**
          * Get the current approval for a certain token.
          * @param signer - The signer owning the token
          * @param token - The token that should be checked
          * @param approvalAddress - The address that has be approved
          */
-        this.getTokenApproval = function (signer, token, approvalAddress) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, (0, allowance_1.getTokenApproval)(signer, token, approvalAddress)];
-            });
-        }); };
+        this.getTokenApproval = (signer, token, approvalAddress) => __awaiter(this, void 0, void 0, function* () {
+            return getTokenApproval(signer, token, approvalAddress);
+        });
         /**
          * Get the current approval for a list of token / approval address pairs.
          * @param signer - The signer owning the tokens
          * @param tokenData - A list of token and approval address pairs
          */
-        this.bulkGetTokenApproval = function (signer, tokenData) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, (0, allowance_1.bulkGetTokenApproval)(signer, tokenData)];
-            });
-        }); };
+        this.bulkGetTokenApproval = (signer, tokenData) => __awaiter(this, void 0, void 0, function* () {
+            return bulkGetTokenApproval(signer, tokenData);
+        });
         /**
          * Set approval for a certain token and amount.
          * @param { ApproveTokenRequest } request - The approval request
          */
-        this.approveToken = function (request) {
-            return (0, allowance_1.approveToken)(request);
+        this.approveToken = (request) => {
+            return approveToken(request);
         };
         /**
          * Revoke approval for a certain token.
          * @param { RevokeApprovalRequest } request - The revoke request
          */
-        this.revokeTokenApproval = function (request) {
-            return (0, allowance_1.revokeTokenApproval)(request);
+        this.revokeTokenApproval = (request) => {
+            return revokeTokenApproval(request);
         };
-        this.configService = ConfigService_1.default.getInstance();
+        this.configService = ConfigService.getInstance();
         if (configUpdate) {
             this.configService.updateConfig(configUpdate); // update API urls before we request chains
         }
-        this.chainsService = ChainsService_1.default.getInstance();
-        this.chainsService.getChains().then(function (chains) {
-            _this.configService.updateChains(chains);
+        this.chainsService = ChainsService.getInstance();
+        this.chainsService.getChains().then((chains) => {
+            this.configService.updateChains(chains);
         });
     }
-    return LIFI;
-}());
-exports.default = LIFI;
+}