@lifi/sdk 1.1.2 → 1.1.5

package/dist/cjs/Lifi.js

@@ -0,0 +1,376 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const allowance_1 = require("./allowance");
+const balances_1 = __importDefault(require("./balances"));
+const connectors_1 = require("./connectors");
+const StatusManager_1 = require("./execution/StatusManager");
+const StepExecutor_1 = require("./execution/StepExecutor");
+const ApiService_1 = __importDefault(require("./services/ApiService"));
+const ChainsService_1 = __importDefault(require("./services/ChainsService"));
+const ConfigService_1 = __importDefault(require("./services/ConfigService"));
+const typeguards_1 = require("./typeguards");
+const errors_1 = require("./utils/errors");
+const preRestart_1 = require("./utils/preRestart");
+const utils_1 = require("./utils/utils");
+class LIFI {
+    constructor(configUpdate) {
+        this.activeRouteDictionary = {};
+        /**
+         * Get the current configuration of the SDK
+         * @return {Config} - The config object
+         */
+        this.getConfig = () => {
+            return this.configService.getConfig();
+        };
+        /**
+         * Get the SDK configuration after all setup calls are finished
+         * @return {Promise<Config>} - The config object
+         */
+        this.getConfigAsync = () => {
+            return this.configService.getConfigAsync();
+        };
+        /**
+         * Get an instance of a provider for a specific cahin
+         * @param {number} chainId - Id of the chain the provider is for
+         * @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 = (chainId, archive = false) => {
+            return (0, connectors_1.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 = (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 = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            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 = (chain, token, options) => __awaiter(this, void 0, void 0, function* () {
+            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 = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            return ApiService_1.default.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 = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            return ApiService_1.default.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 = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            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 = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            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 = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            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 = () => __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 = (request, options) => __awaiter(this, void 0, void 0, function* () {
+            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 = (step, options) => __awaiter(this, void 0, void 0, function* () {
+            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 = (route) => {
+            if (!this.activeRouteDictionary[route.id]) {
+                return route;
+            }
+            for (const executor of this.activeRouteDictionary[route.id].executors) {
+                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 = (route) => {
+            if (!this.activeRouteDictionary[route.id]) {
+                return;
+            }
+            for (const executor of this.activeRouteDictionary[route.id].executors) {
+                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 = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
+            const 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 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.
+         * @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 = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
+            const clonedRoute = (0, utils_1.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;
+                }
+            }
+            (0, preRestart_1.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_1.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;
+                }
+                // 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_1.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 = (settings, route) => {
+            if (!this.activeRouteDictionary[route.id]) {
+                throw new errors_1.ValidationError("Can't set ExecutionSettings for the inactive route.");
+            }
+            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 = () => {
+            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 = (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.
+         * @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 = (walletAddress, token) => __awaiter(this, void 0, void 0, function* () {
+            if (!walletAddress) {
+                throw new errors_1.ValidationError('Missing walletAddress.');
+            }
+            if (!(0, typeguards_1.isToken)(token)) {
+                throw new errors_1.ValidationError(`Invalid token passed: address "${token.address}" on chainId "${token.chainId}"`);
+            }
+            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 = (walletAddress, tokens) => __awaiter(this, void 0, void 0, function* () {
+            if (!walletAddress) {
+                throw new errors_1.ValidationError('Missing walletAddress.');
+            }
+            const invalidTokens = tokens.filter((token) => !(0, typeguards_1.isToken)(token));
+            if (invalidTokens.length) {
+                throw new errors_1.ValidationError(`Invalid token passed: address "${invalidTokens[0].address}" on chainId "${invalidTokens[0].chainId}"`);
+            }
+            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 = (walletAddress, tokensByChain) => __awaiter(this, void 0, void 0, function* () {
+            if (!walletAddress) {
+                throw new errors_1.ValidationError('Missing walletAddress.');
+            }
+            const tokenList = Object.values(tokensByChain).flat();
+            const invalidTokens = tokenList.filter((token) => !(0, typeguards_1.isToken)(token));
+            if (invalidTokens.length) {
+                throw new errors_1.ValidationError(`Invalid token passed: address "${invalidTokens[0].address}" on chainId "${invalidTokens[0].chainId}"`);
+            }
+            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 = (signer, token, approvalAddress) => __awaiter(this, void 0, void 0, function* () {
+            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 = (signer, tokenData) => __awaiter(this, void 0, void 0, function* () {
+            return (0, allowance_1.bulkGetTokenApproval)(signer, tokenData);
+        });
+        /**
+         * Set approval for a certain token and amount.
+         * @param { ApproveTokenRequest } request - The approval request
+         */
+        this.approveToken = (request) => {
+            return (0, allowance_1.approveToken)(request);
+        };
+        /**
+         * Revoke approval for a certain token.
+         * @param { RevokeApprovalRequest } request - The revoke request
+         */
+        this.revokeTokenApproval = (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((chains) => {
+            this.configService.updateChains(chains);
+        });
+    }
+}
+exports.default = LIFI;

package/dist/cjs/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/cjs/allowance/index.js

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

package/dist/cjs/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[];
+};

package/dist/cjs/allowance/utils.js

@@ -0,0 +1,82 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupByChain = exports.getAllowanceViaMulticall = exports.setApproval = exports.getApproved = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ethers_1 = require("ethers");
+const ChainsService_1 = __importDefault(require("../services/ChainsService"));
+const types_1 = require("../types");
+const errors_1 = require("../utils/errors");
+const multicall_1 = require("../utils/multicall");
+const getApproved = (signer, tokenAddress, contractAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const signerAddress = yield signer.getAddress();
+    const erc20 = new ethers_1.Contract(tokenAddress, types_1.ERC20_ABI, signer);
+    try {
+        const approved = yield erc20.allowance(signerAddress, contractAddress);
+        return new bignumber_js_1.default(approved.toString());
+    }
+    catch (e) {
+        return new bignumber_js_1.default(0);
+    }
+});
+exports.getApproved = getApproved;
+const setApproval = (signer, tokenAddress, contractAddress, amount) => {
+    const erc20 = new ethers_1.Contract(tokenAddress, types_1.ERC20_ABI, signer);
+    return erc20.approve(contractAddress, amount);
+};
+exports.setApproval = setApproval;
+const getAllowanceViaMulticall = (signer, chainId, tokenData) => __awaiter(void 0, void 0, void 0, function* () {
+    const chainsService = ChainsService_1.default.getInstance();
+    const chain = yield chainsService.getChainById(chainId);
+    if (!chain.multicallAddress) {
+        throw new errors_1.ServerError(`No multicall address configured for chainId ${chainId}.`);
+    }
+    const ownerAddress = yield signer.getAddress();
+    const calls = [];
+    tokenData.map(({ token, approvalAddress }) => {
+        calls.push({
+            address: token.address,
+            name: 'allowance',
+            params: [ownerAddress, approvalAddress],
+        });
+    });
+    const result = yield (0, multicall_1.fetchDataUsingMulticall)(calls, types_1.ERC20_ABI, chainId, chain.multicallAddress);
+    if (!result.length) {
+        throw new errors_1.ServerError(`Couldn't load allowance from chainId ${chainId} using multicall.`);
+    }
+    const parsedResult = result.map(({ data }) => {
+        var _a;
+        return ({
+            approvalAmount: (_a = data) !== null && _a !== void 0 ? _a : new bignumber_js_1.default(0),
+        });
+    });
+    return tokenData.map(({ token, approvalAddress }, i) => ({
+        token,
+        approvalAddress,
+        approvedAmount: parsedResult[i].approvalAmount,
+    }));
+});
+exports.getAllowanceViaMulticall = getAllowanceViaMulticall;
+const groupByChain = (tokenDataList) => {
+    // group by chain
+    const tokenDataByChain = {};
+    tokenDataList.forEach((tokenData) => {
+        if (!tokenDataByChain[tokenData.token.chainId]) {
+            tokenDataByChain[tokenData.token.chainId] = [];
+        }
+        tokenDataByChain[tokenData.token.chainId].push(tokenData);
+    });
+    return tokenDataByChain;
+};
+exports.groupByChain = groupByChain;

package/dist/cjs/balances/index.d.ts

@@ -0,0 +1,11 @@
+import { Token, TokenAmount } from '@lifi/types';
+declare const _default: {
+    getTokenBalance: (walletAddress: string, token: Token) => Promise<TokenAmount | null>;
+    getTokenBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
+    getTokenBalancesForChains: (walletAddress: string, tokensByChain: {
+        [chainId: number]: Token[];
+    }) => Promise<{
+        [chainId: number]: TokenAmount[];
+    }>;
+};
+export default _default;

package/dist/cjs/balances/index.js

@@ -0,0 +1,46 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = __importDefault(require("./utils"));
+const getTokenBalance = (walletAddress, token) => __awaiter(void 0, void 0, void 0, function* () {
+    const tokenAmounts = yield getTokenBalances(walletAddress, [token]);
+    return tokenAmounts.length ? tokenAmounts[0] : null;
+});
+const getTokenBalances = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+    // split by chain
+    const tokensByChain = {};
+    tokens.forEach((token) => {
+        if (!tokensByChain[token.chainId]) {
+            tokensByChain[token.chainId] = [];
+        }
+        tokensByChain[token.chainId].push(token);
+    });
+    const tokenAmountsByChain = yield getTokenBalancesForChains(walletAddress, tokensByChain);
+    return Object.values(tokenAmountsByChain).flat();
+});
+const getTokenBalancesForChains = (walletAddress, tokensByChain) => __awaiter(void 0, void 0, void 0, function* () {
+    const tokenAmountsByChain = {};
+    const promises = Object.keys(tokensByChain).map((chainIdStr) => __awaiter(void 0, void 0, void 0, function* () {
+        const chainId = parseInt(chainIdStr);
+        const tokenAmounts = yield utils_1.default.getBalances(walletAddress, tokensByChain[chainId]);
+        tokenAmountsByChain[chainId] = tokenAmounts;
+    }));
+    yield Promise.allSettled(promises);
+    return tokenAmountsByChain;
+});
+exports.default = {
+    getTokenBalance,
+    getTokenBalances,
+    getTokenBalancesForChains,
+};

package/dist/cjs/balances/utils.d.ts

@@ -0,0 +1,5 @@
+import { Token, TokenAmount } from '@lifi/types';
+declare const _default: {
+    getBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
+};
+export default _default;