@lifi/sdk 1.0.0

package/dist/Lifi.js

@@ -0,0 +1,461 @@
+"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) {
+        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 __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 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 utils_1 = require("./utils/utils");
+var LIFI = /** @class */ (function () {
+    function LIFI(configUpdate) {
+        var _this = this;
+        this.activeRouteDictionary = {};
+        /**
+         * Get the current configuration of the SDK
+         * @return {Config} - The config object
+         */
+        this.getConfig = function () {
+            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();
+        };
+        /**
+         * 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);
+        };
+        /**
+         * Get a set of current possibilities based on a request that specifies which chains, exchanges and bridges are preferred or unwanted.
+         * @param {PossibilitiesRequest} request - Object defining preferences regarding chain, exchanges and bridges
+         * @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)];
+            });
+        }); };
+        /**
+         * 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)];
+            });
+        }); };
+        /**
+         * 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)];
+            });
+        }); };
+        /**
+         * 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)];
+            });
+        }); };
+        /**
+         * 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)];
+            });
+        }); };
+        /**
+         * 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)];
+            });
+        }); };
+        /**
+         * 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()];
+            });
+        }); };
+        /**
+         * 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)];
+            });
+        }); };
+        /**
+         * 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)];
+            });
+        }); };
+        /**
+         * 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]) {
+                return route;
+            }
+            for (var _i = 0, _a = _this.activeRouteDictionary[route.id].executors; _i < _a.length; _i++) {
+                var executor = _a[_i];
+                executor.stopStepExecution({ allowUpdates: false });
+            }
+            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]) {
+                return;
+            }
+            for (var _i = 0, _a = _this.activeRouteDictionary[route.id].executors; _i < _a.length; _i++) {
+                var executor = _a[_i];
+                executor.stopStepExecution({ allowUpdates: true });
+            }
+        };
+        /**
+         * 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 = 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)];
+            });
+        }); };
+        /**
+         * 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 = function (signer, route, settings) { return __awaiter(_this, void 0, void 0, function () {
+            var clonedRoute, activeRoute, executionHalted, index, stepHasFailed;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                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];
+                    }
+                }
+                // remove last (failed) process
+                for (index = 0; index < clonedRoute.steps.length; index++) {
+                    stepHasFailed = ((_a = clonedRoute.steps[index].execution) === null || _a === void 0 ? void 0 : _a.status) === 'FAILED';
+                    if (stepHasFailed) {
+                        (_b = clonedRoute.steps[index].execution) === null || _b === void 0 ? void 0 : _b.process.pop();
+                    }
+                }
+                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 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.");
+            }
+            var config = _this.configService.getConfig();
+            _this.activeRouteDictionary[route.id].settings = __assign(__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; });
+        };
+        /**
+         * 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;
+        };
+        /**
+         * Returns the balances of a specific token a wallet holds across all aggregated chains.
+         * @param {string} walletAddress - A wallet address.
+         * @param {Token} token - A Token object.
+         * @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)];
+            });
+        }); };
+        /**
+         * Returns the balances for a list tokens a wallet holds  across all aggregated chains.
+         * @param {string} walletAddress - A wallet address.
+         * @param {Token[]} tokens - A list of Token objects.
+         * @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 method queries the balances of tokens for a specific list of chains for a given wallet.
+         * @param {string} walletAddress - A walletaddress.
+         * @param {{ [chainId: number]: Token[] }} tokensByChain - A list of Token objects organized by chain ids.
+         * @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)];
+            });
+        }); };
+        /**
+         * 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)];
+            });
+        }); };
+        /**
+         * 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)];
+            });
+        }); };
+        /**
+         * Set approval for a certain token and amount.
+         * @param { ApproveTokenRequest } request - The approval request
+         */
+        this.approveToken = function (request) {
+            return (0, allowance_1.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.configService = ConfigService_1.default.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);
+        });
+    }
+    return LIFI;
+}());
+exports.default = LIFI;

package/dist/allowance/index.d.ts

@@ -0,0 +1,22 @@
+import { Token } from '@lifi/types';
+import { Signer } from 'ethers';
+import { RevokeTokenData } from '../types';
+export interface ApproveTokenRequest {
+    signer: Signer;
+    token: Token;
+    approvalAddress: string;
+    amount: string;
+    infiniteApproval?: boolean;
+}
+export interface RevokeApprovalRequest {
+    signer: Signer;
+    token: Token;
+    approvalAddress: string;
+}
+export declare const getTokenApproval: (signer: Signer, token: Token, approvalAddress: string) => Promise<string | undefined>;
+export declare const bulkGetTokenApproval: (signer: Signer, tokenData: RevokeTokenData[]) => Promise<{
+    token: Token;
+    approval: string | undefined;
+}[]>;
+export declare const approveToken: ({ signer, token, approvalAddress, amount, infiniteApproval, }: ApproveTokenRequest) => Promise<void>;
+export declare const revokeTokenApproval: ({ signer, token, approvalAddress, }: RevokeApprovalRequest) => Promise<void>;

package/dist/allowance/index.js

@@ -0,0 +1,160 @@
+"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 __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 });
+exports.revokeTokenApproval = exports.approveToken = exports.bulkGetTokenApproval = exports.getTokenApproval = void 0;
+var bignumber_js_1 = __importDefault(require("bignumber.js"));
+var ethers_1 = require("ethers");
+var helpers_1 = require("../helpers");
+var utils_1 = require("../utils/utils");
+var utils_2 = require("./utils");
+var getTokenApproval = function (signer, token, approvalAddress) { return __awaiter(void 0, void 0, void 0, function () {
+    var approved;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                // native token don't need approval
+                if ((0, utils_1.isNativeTokenAddress)(token.address)) {
+                    return [2 /*return*/];
+                }
+                return [4 /*yield*/, (0, utils_2.getApproved)(signer, token.address, approvalAddress)];
+            case 1:
+                approved = _a.sent();
+                return [2 /*return*/, approved.toString()];
+        }
+    });
+}); };
+exports.getTokenApproval = getTokenApproval;
+var bulkGetTokenApproval = function (signer, tokenData) { return __awaiter(void 0, void 0, void 0, function () {
+    var filteredTokenData, tokenDataByChain, approvalPromises, approvalsByChain, approvals;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                filteredTokenData = tokenData.filter(function (_a) {
+                    var token = _a.token;
+                    return !(0, utils_1.isNativeTokenAddress)(token.address);
+                });
+                tokenDataByChain = (0, utils_2.groupByChain)(filteredTokenData);
+                approvalPromises = Object.keys(tokenDataByChain).map(function (chainId) { return __awaiter(void 0, void 0, void 0, function () {
+                    var parsedChainId;
+                    return __generator(this, function (_a) {
+                        parsedChainId = Number.parseInt(chainId);
+                        // get allowances for current chain and token list
+                        return [2 /*return*/, (0, utils_2.getAllowanceViaMulticall)(signer, parsedChainId, tokenDataByChain[parsedChainId])];
+                    });
+                }); });
+                return [4 /*yield*/, Promise.all(approvalPromises)];
+            case 1:
+                approvalsByChain = _a.sent();
+                approvals = approvalsByChain.flat();
+                return [2 /*return*/, tokenData.map(function (_a) {
+                        var token = _a.token;
+                        // native token don't need approval
+                        if ((0, utils_1.isNativeTokenAddress)(token.address)) {
+                            return { token: token, approval: undefined };
+                        }
+                        var approved = approvals.find(function (approval) {
+                            return (0, helpers_1.isSameToken)(approval.token, token);
+                        });
+                        return { token: token, approval: approved === null || approved === void 0 ? void 0 : approved.approvedAmount.toString() };
+                    })];
+        }
+    });
+}); };
+exports.bulkGetTokenApproval = bulkGetTokenApproval;
+var approveToken = function (_a) {
+    var signer = _a.signer, token = _a.token, approvalAddress = _a.approvalAddress, amount = _a.amount, _b = _a.infiniteApproval, infiniteApproval = _b === void 0 ? false : _b;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var approvedAmount, approvalAmount, approveTx;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    // native token don't need approval
+                    if ((0, utils_1.isNativeTokenAddress)(token.address)) {
+                        return [2 /*return*/];
+                    }
+                    return [4 /*yield*/, (0, utils_2.getApproved)(signer, token.address, approvalAddress)];
+                case 1:
+                    approvedAmount = _c.sent();
+                    if (!new bignumber_js_1.default(amount).gt(approvedAmount)) return [3 /*break*/, 4];
+                    approvalAmount = infiniteApproval
+                        ? ethers_1.constants.MaxUint256.toString()
+                        : amount;
+                    return [4 /*yield*/, (0, utils_2.setApproval)(signer, token.address, approvalAddress, approvalAmount)];
+                case 2:
+                    approveTx = _c.sent();
+                    return [4 /*yield*/, approveTx.wait()];
+                case 3:
+                    _c.sent();
+                    _c.label = 4;
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.approveToken = approveToken;
+var revokeTokenApproval = function (_a) {
+    var signer = _a.signer, token = _a.token, approvalAddress = _a.approvalAddress;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var approvedAmount, approveTx;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    // native token don't need approval
+                    if ((0, utils_1.isNativeTokenAddress)(token.address)) {
+                        return [2 /*return*/];
+                    }
+                    return [4 /*yield*/, (0, utils_2.getApproved)(signer, token.address, approvalAddress)];
+                case 1:
+                    approvedAmount = _b.sent();
+                    if (!!approvedAmount.isZero()) return [3 /*break*/, 4];
+                    return [4 /*yield*/, (0, utils_2.setApproval)(signer, token.address, approvalAddress, '0')];
+                case 2:
+                    approveTx = _b.sent();
+                    return [4 /*yield*/, approveTx.wait()];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.revokeTokenApproval = revokeTokenApproval;

package/dist/allowance/utils.d.ts

@@ -0,0 +1,14 @@
+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 setApproval: (signer: Signer, tokenAddress: string, contractAddress: string, amount: string) => Promise<ContractTransaction>;
+export declare const getAllowanceViaMulticall: (signer: Signer, chainId: ChainId, tokenData: RevokeTokenData[]) => Promise<{
+    token: Token;
+    approvalAddress: string;
+    approvedAmount: BigNumber;
+}[]>;
+export declare const groupByChain: (tokenDataList: RevokeTokenData[]) => {
+    [chainId: number]: RevokeTokenData[];
+};