@lifi/sdk 2.2.2 → 3.0.0-alpha.1

package/dist/cjs/LiFi.js

@@ -42,40 +42,40 @@ class LiFi extends RouteExecutionManager_1.RouteExecutionManager {
         super(configUpdate);
         /**
          * Get the current configuration of the SDK
-         * @return {Config} - The config object
+         * @returns - 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
+         * @returns - The config object
          */
         this.getConfigAsync = () => {
             return this.configService.getConfigAsync();
         };
         /**
          * Get an instance of a provider for a specific chain
-         * @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
+         * @param chainId - Id of the chain the provider is for
+         * @returns The public client for the given chain
          */
-        this.getRpcProvider = (chainId, archive = false) => {
-            return (0, connectors_1.getRpcProvider)(chainId, archive);
+        this.getPublicClient = (chainId) => {
+            return (0, connectors_1.getPublicClient)(chainId);
         };
         /**
          * 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
+         * @param configUpdate - An object containing the configuration fields that should be updated.
+         * @returns 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.
+         * @param request - Object defining preferences regarding chain, exchanges and bridges
+         * @param options
+         * @returns Object listing current possibilities for any-to-any cross-chain-swaps based on the provided preferences.
+         * @throws {LiFiError} Throws a LiFiError if request fails.
          * @deprecated We don't want to support this endpoint anymore in the future. /chains, /tools, /connections, and /tokens should be used instead
          */
         this.getPossibilities = async (request, options) => {
@@ -83,40 +83,47 @@ class LiFi extends RouteExecutionManager_1.RouteExecutionManager {
         };
         /**
          * 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
+         * @param chain - Id or key of the chain that contains the token
+         * @param token - Address or symbol of the token on the requested chain
+         * @param options
+         * @throws {LiFiError} - Throws a LiFiError if request fails
          */
         this.getToken = async (chain, token, options) => {
             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
+         * @param request - The configuration of the requested quote
+         * @param options
+         * @throws {LiFiError} - Throws a LiFiError if request fails
          */
         this.getQuote = async (request, options) => {
             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
+         * @param request - The configuration of the requested destination call
+         * @param options
+         * @throws {LiFiError} - Throws a LiFiError if request fails
+         * @returns - Returns step.
          */
         this.getContractCallQuote = async (request, options) => {
             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
+         * @param request - Configuration of the requested status
+         * @param options - Rrquest options.
+         * @throws {LiFiError} - Throws a LiFiError if request fails
+         * @returns Returns status response.
          */
         this.getStatus = async (request, options) => {
             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
+         * @param request - The configuration of the requested tools
+         * @param options
          * @returns The tools that are available on the requested chains
          */
         this.getTools = async (request, options) => {
@@ -124,7 +131,8 @@ class LiFi extends RouteExecutionManager_1.RouteExecutionManager {
         };
         /**
          * Get all known tokens.
-         * @param {TokensRequest?} request - The configuration of the requested tokens
+         * @param request - The configuration of the requested tokens
+         * @param options
          * @returns The tokens that are available on the requested chains
          */
         this.getTokens = async (request, options) => {
@@ -132,43 +140,46 @@ class LiFi extends RouteExecutionManager_1.RouteExecutionManager {
         };
         /**
          * Get all available chains
-         * @return {Promise<Chain[]>} A list of all available chains
-         * @throws {LifiError} Throws a LifiError if request fails.
+         * @returns A list of all available chains
+         * @throws {LiFiError} Throws a LiFiError if request fails.
          */
         this.getChains = async () => {
             return this.chainsService.getChains();
         };
         /**
          * Get a set of routes for a request that describes a transfer of tokens.
-         * @param {RoutesRequest} request - A description of the transfer.
-         * @return {Promise<RoutesResponse>} The resulting routes that can be used to realize the described transfer of tokens.
-         * @throws {LifiError} Throws a LifiError if request fails.
+         * @param request - A description of the transfer.
+         * @param options
+         * @returns The resulting routes that can be used to realize the described transfer of tokens.
+         * @throws {LiFiError} Throws a LiFiError if request fails.
          */
         this.getRoutes = async (request, options) => {
             return ApiService_1.default.getRoutes(request, options);
         };
         /**
          * Get the transaction data for a single step of a route
-         * @param {LifiStep} step - The step object.
-         * @return {Promise<LifiStep>} The step populated with the transaction data.
-         * @throws {LifiError} Throws a LifiError if request fails.
+         * @param step - The step object.
+         * @param options
+         * @returns The step populated with the transaction data.
+         * @throws {LiFiError} Throws a LiFiError if request fails.
          */
         this.getStepTransaction = async (step, options) => {
             return ApiService_1.default.getStepTransaction(step, options);
         };
         /**
          * Get gas recommendation for a certain chain
-         * @param {GasRecommendationRequest} request - Configuration of the requested recommendation.
-         * @throws {LifiError} Throws a LifiError if request fails.
+         * @param request - Configuration of the requested recommendation.
+         * @param options
+         * @throws {LiFiError} Throws a LiFiError if request fails.
          */
         this.getGasRecommendation = async (request, options) => {
             return ApiService_1.default.getGasRecommendation(request, options);
         };
         /**
          * 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.
+         * @param walletAddress - A wallet address.
+         * @param token - A Token object.
+         * @returns An object containing the token and the amounts on different chains.
          * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
          */
         this.getTokenBalance = async (walletAddress, token) => {
@@ -182,9 +193,9 @@ class LiFi extends RouteExecutionManager_1.RouteExecutionManager {
         };
         /**
          * 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.
+         * @param walletAddress - A wallet address.
+         * @param tokens - A list of Token objects.
+         * @returns A list of objects containing the tokens and the amounts on different chains.
          * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
          */
         this.getTokenBalances = async (walletAddress, tokens) => {
@@ -199,12 +210,12 @@ class LiFi extends RouteExecutionManager_1.RouteExecutionManager {
         };
         /**
          * 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.
+         * @param walletAddress - A walletaddress.
+         * @param tokensByChain - A list of Token objects organized by chain ids.
+         * @returns 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 = async (walletAddress, tokensByChain) => {
+        this.getTokenBalancesByChain = async (walletAddress, tokensByChain) => {
             if (!walletAddress) {
                 throw new errors_1.ValidationError('Missing walletAddress.');
             }
@@ -213,35 +224,35 @@ class LiFi extends RouteExecutionManager_1.RouteExecutionManager {
             if (invalidTokens.length) {
                 throw new errors_1.ValidationError(`Invalid token passed: address "${invalidTokens[0].address}" on chainId "${invalidTokens[0].chainId}"`);
             }
-            return balance.getTokenBalancesForChains(walletAddress, tokensByChain);
+            return balance.getTokenBalancesByChain(walletAddress, tokensByChain);
         };
         /**
-         * Get the current approval for a certain token.
-         * @param signer - The signer owning the token
+         * Get the current allowance for a certain token.
          * @param token - The token that should be checked
-         * @param approvalAddress - The address that has be approved
+         * @param ownerAddress - The owner of the token
+         * @param spenderAddress - The spender address that has to be approved
          */
-        this.getTokenApproval = async (signer, token, approvalAddress) => {
-            return (0, allowance_1.getTokenApproval)(signer, token, approvalAddress);
+        this.getTokenAllowance = async (token, ownerAddress, spenderAddress) => {
+            return (0, allowance_1.getTokenAllowance)(token, ownerAddress, spenderAddress);
         };
         /**
-         * 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
+         * Get the current allowance for a list of token / spender address pairs.
+         * @param ownerAddress - The owner of the tokens
+         * @param tokens - A list of token and spender address pairs
          */
-        this.bulkGetTokenApproval = async (signer, tokenData) => {
-            return (0, allowance_1.bulkGetTokenApproval)(signer, tokenData);
+        this.getTokenAllowanceMulticall = async (ownerAddress, tokens) => {
+            return (0, allowance_1.getTokenAllowanceMulticall)(ownerAddress, tokens);
         };
         /**
          * Set approval for a certain token and amount.
-         * @param { ApproveTokenRequest } request - The approval request
+         * @param request - The approval request
          */
-        this.approveToken = (request) => {
-            return (0, allowance_1.approveToken)(request);
+        this.setTokenApproval = (request) => {
+            return (0, allowance_1.setTokenAllowance)(request);
         };
         /**
          * Revoke approval for a certain token.
-         * @param { RevokeApprovalRequest } request - The revoke request
+         * @param request - The revoke request
          */
         this.revokeTokenApproval = (request) => {
             return (0, allowance_1.revokeTokenApproval)(request);

package/dist/cjs/allowance/getAllowance.d.ts

@@ -0,0 +1,6 @@
+import type { ChainId, Token } from '@lifi/types';
+import type { TokenAllowance, TokenSpender, TokenSpenderAllowance } from './types';
+export declare const getAllowance: (chainId: ChainId, tokenAddress: string, ownerAddress: string, spenderAddress: string) => Promise<bigint>;
+export declare const getAllowanceMulticall: (chainId: ChainId, tokens: TokenSpender[], ownerAddress: string) => Promise<TokenSpenderAllowance[]>;
+export declare const getTokenAllowance: (token: Token, ownerAddress: string, spenderAddress: string) => Promise<bigint | undefined>;
+export declare const getTokenAllowanceMulticall: (ownerAddress: string, tokens: TokenSpender[]) => Promise<TokenAllowance[]>;

package/dist/cjs/allowance/getAllowance.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenAllowanceMulticall = exports.getTokenAllowance = exports.getAllowanceMulticall = exports.getAllowance = void 0;
+const viem_1 = require("viem");
+const connectors_1 = require("../connectors");
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+const utils_1 = require("../utils/utils");
+const getAllowance = async (chainId, tokenAddress, ownerAddress, spenderAddress) => {
+    const client = await (0, connectors_1.getPublicClient)(chainId);
+    const contract = (0, viem_1.getContract)({
+        address: tokenAddress,
+        abi: types_1.allowanceAbi,
+        publicClient: client,
+    });
+    try {
+        const approved = (await contract.read.allowance([
+            ownerAddress,
+            spenderAddress,
+        ]));
+        return approved;
+    }
+    catch (e) {
+        return 0n;
+    }
+};
+exports.getAllowance = getAllowance;
+const getAllowanceMulticall = async (chainId, tokens, ownerAddress) => {
+    if (!tokens.length) {
+        return [];
+    }
+    const multicallAddress = await (0, connectors_1.getMulticallAddress)(chainId);
+    if (!multicallAddress) {
+        throw new Error(`No multicall address configured for chainId ${chainId}.`);
+    }
+    const client = await (0, connectors_1.getPublicClient)(chainId);
+    const contracts = tokens.map((token) => ({
+        address: token.token.address,
+        abi: types_1.allowanceAbi,
+        functionName: 'allowance',
+        args: [ownerAddress, token.spenderAddress],
+    }));
+    const results = await client.multicall({
+        contracts,
+        multicallAddress: multicallAddress,
+        batchSize: constants_1.MulticallBatchSize,
+    });
+    if (!results.length) {
+        throw new Error(`Couldn't load allowance from chainId ${chainId} using multicall.`);
+    }
+    return tokens.map(({ token, spenderAddress }, i) => ({
+        token,
+        spenderAddress,
+        allowance: results[i].result,
+    }));
+};
+exports.getAllowanceMulticall = getAllowanceMulticall;
+const getTokenAllowance = async (token, ownerAddress, spenderAddress) => {
+    // native token don't need approval
+    if ((0, utils_1.isNativeTokenAddress)(token.address)) {
+        return;
+    }
+    const approved = await (0, exports.getAllowance)(token.chainId, token.address, ownerAddress, spenderAddress);
+    return approved;
+};
+exports.getTokenAllowance = getTokenAllowance;
+const getTokenAllowanceMulticall = async (ownerAddress, tokens) => {
+    // filter out native tokens
+    const filteredTokens = tokens.filter(({ token }) => !(0, utils_1.isNativeTokenAddress)(token.address));
+    // group by chain
+    const tokenDataByChain = {};
+    filteredTokens.forEach((data) => {
+        if (!tokenDataByChain[data.token.chainId]) {
+            tokenDataByChain[data.token.chainId] = [];
+        }
+        tokenDataByChain[data.token.chainId].push(data);
+    });
+    const chainKeys = Object.keys(tokenDataByChain).map(Number.parseInt);
+    const allowances = (await Promise.all(chainKeys.map(async (chainId) => {
+        // get allowances for current chain and token list
+        return (0, exports.getAllowanceMulticall)(chainId, tokenDataByChain[chainId], ownerAddress);
+    }))).flat();
+    return allowances;
+};
+exports.getTokenAllowanceMulticall = getTokenAllowanceMulticall;

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

@@ -1,2 +1,3 @@
-export * from './checkAllowance';
-export * from './tokenApproval';
+export * from './getAllowance';
+export * from './setAllowance';
+export * from './types';

package/dist/cjs/allowance/index.js

@@ -14,5 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./checkAllowance"), exports);
-__exportStar(require("./tokenApproval"), exports);
+__exportStar(require("./getAllowance"), exports);
+__exportStar(require("./setAllowance"), exports);
+__exportStar(require("./types"), exports);

package/dist/cjs/allowance/setAllowance.d.ts

@@ -0,0 +1,5 @@
+import type { Hash, WalletClient } from 'viem';
+import type { ApproveTokenRequest, RevokeApprovalRequest } from './types';
+export declare const setAllowance: (walletClient: WalletClient, tokenAddress: string, contractAddress: string, amount: bigint, returnPopulatedTransaction?: boolean) => Promise<Hash>;
+export declare const setTokenAllowance: ({ walletClient, token, spenderAddress, amount, infiniteApproval, }: ApproveTokenRequest) => Promise<Hash | undefined>;
+export declare const revokeTokenApproval: ({ walletClient, token, spenderAddress, }: RevokeApprovalRequest) => Promise<Hash | undefined>;

package/dist/cjs/allowance/setAllowance.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revokeTokenApproval = exports.setTokenAllowance = exports.setAllowance = void 0;
+const viem_1 = require("viem");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const utils_2 = require("../utils/utils");
+const getAllowance_1 = require("./getAllowance");
+const setAllowance = async (walletClient, tokenAddress, contractAddress, amount, returnPopulatedTransaction) => {
+    const data = (0, viem_1.encodeFunctionData)({
+        abi: types_1.approveAbi,
+        functionName: 'approve',
+        args: [contractAddress, amount],
+    });
+    if (returnPopulatedTransaction) {
+        return data;
+    }
+    const client = walletClient.extend(viem_1.publicActions);
+    let maxPriorityFeePerGas;
+    if (walletClient.account?.type === 'local') {
+        maxPriorityFeePerGas = await (0, utils_1.getMaxPriorityFeePerGas)(client);
+    }
+    return client.sendTransaction({
+        to: tokenAddress,
+        account: walletClient.account,
+        data,
+        maxPriorityFeePerGas,
+        chain: null,
+    });
+};
+exports.setAllowance = setAllowance;
+const setTokenAllowance = async ({ walletClient, token, spenderAddress, amount, infiniteApproval = false, }) => {
+    // native token don't need approval
+    if ((0, utils_2.isNativeTokenAddress)(token.address)) {
+        return;
+    }
+    const approvedAmount = await (0, getAllowance_1.getAllowance)(token.chainId, token.address, walletClient.account.address, spenderAddress);
+    if (amount > approvedAmount) {
+        const approvalAmount = infiniteApproval ? viem_1.maxUint256 : amount;
+        const approveTx = await (0, exports.setAllowance)(walletClient, token.address, spenderAddress, approvalAmount);
+        return approveTx;
+    }
+};
+exports.setTokenAllowance = setTokenAllowance;
+const revokeTokenApproval = async ({ walletClient, token, spenderAddress, }) => {
+    // native token don't need approval
+    if ((0, utils_2.isNativeTokenAddress)(token.address)) {
+        return;
+    }
+    const approvedAmount = await (0, getAllowance_1.getAllowance)(token.chainId, token.address, walletClient.account.address, spenderAddress);
+    if (approvedAmount > 0) {
+        const approveTx = await (0, exports.setAllowance)(walletClient, token.address, spenderAddress, 0n);
+        return approveTx;
+    }
+};
+exports.revokeTokenApproval = revokeTokenApproval;

package/dist/cjs/allowance/types.d.ts

@@ -0,0 +1,27 @@
+import type { Token } from '@lifi/types';
+import type { WalletClient } from 'viem';
+export type TokenSpender = {
+    token: Token;
+    spenderAddress: string;
+};
+export type TokenAllowance = {
+    token: Token;
+    allowance?: bigint;
+};
+export type TokenSpenderAllowance = {
+    token: Token;
+    spenderAddress: string;
+    allowance?: bigint;
+};
+export interface ApproveTokenRequest {
+    walletClient: WalletClient;
+    token: Token;
+    spenderAddress: string;
+    amount: bigint;
+    infiniteApproval?: boolean;
+}
+export interface RevokeApprovalRequest {
+    walletClient: WalletClient;
+    token: Token;
+    spenderAddress: string;
+}

package/dist/cjs/allowance/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/balance/getBalance.d.ts

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

package/dist/cjs/balance/getBalance.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBalance = void 0;
+const connectors_1 = require("../connectors");
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+const utils_1 = require("../utils/utils");
+const getBalance = async (walletAddress, tokens) => {
+    if (tokens.length === 0) {
+        return [];
+    }
+    const { chainId } = tokens[0];
+    tokens.forEach((token) => {
+        if (token.chainId !== chainId) {
+            console.warn(`Requested tokens have to be on the same chain.`);
+            return [];
+        }
+    });
+    const multicallAddress = await (0, connectors_1.getMulticallAddress)(chainId);
+    if (multicallAddress && tokens.length > 1) {
+        return getBalanceMulticall(chainId, tokens, walletAddress, multicallAddress);
+    }
+    else {
+        return getBalanceDefault(chainId, tokens, walletAddress);
+    }
+};
+exports.getBalance = getBalance;
+const getBalanceMulticall = async (chainId, tokens, walletAddress, multicallAddress) => {
+    const client = await (0, connectors_1.getPublicClient)(chainId);
+    const contracts = tokens.map((token) => {
+        if ((0, utils_1.isZeroAddress)(token.address)) {
+            return {
+                address: multicallAddress,
+                abi: types_1.getEthBalanceAbi,
+                functionName: 'getEthBalance',
+                args: [walletAddress],
+            };
+        }
+        return {
+            address: token.address,
+            abi: types_1.balanceOfAbi,
+            functionName: 'balanceOf',
+            args: [walletAddress],
+        };
+    });
+    const blockNumber = await client.getBlockNumber();
+    const results = await client.multicall({
+        contracts,
+        multicallAddress: multicallAddress,
+        blockNumber,
+        batchSize: constants_1.MulticallBatchSize,
+    });
+    if (!results.length) {
+        return [];
+    }
+    return tokens.map((token, i) => {
+        return {
+            ...token,
+            amount: results[i].result,
+            blockNumber,
+        };
+    });
+};
+const getBalanceDefault = async (chainId, tokens, walletAddress) => {
+    const client = await (0, connectors_1.getPublicClient)(chainId);
+    const blockNumber = await client.getBlockNumber();
+    const queue = tokens.map((token) => {
+        if ((0, utils_1.isZeroAddress)(token.address)) {
+            return client.getBalance({
+                address: walletAddress,
+            });
+        }
+        return client.readContract({
+            address: token.address,
+            abi: types_1.balanceOfAbi,
+            functionName: 'balanceOf',
+            args: [walletAddress],
+        });
+    });
+    const results = await Promise.allSettled(queue);
+    const tokenAmounts = tokens.map((token, index) => {
+        const result = results[index];
+        if (result.status === 'rejected') {
+            console.warn(result.reason);
+            return {
+                ...token,
+                blockNumber,
+            };
+        }
+        return {
+            ...token,
+            amount: result.value,
+            blockNumber,
+        };
+    });
+    return tokenAmounts;
+};

package/dist/cjs/balance/getTokenBalance.d.ts

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

package/dist/cjs/balance/getTokenBalance.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTokenBalancesForChains = exports.getTokenBalances = exports.getTokenBalance = void 0;
-const utils_1 = __importDefault(require("./utils"));
+exports.getTokenBalancesByChain = exports.getTokenBalances = exports.getTokenBalance = void 0;
+const getBalance_1 = require("./getBalance");
 const getTokenBalance = async (walletAddress, token) => {
     const tokenAmounts = await (0, exports.getTokenBalances)(walletAddress, [token]);
     return tokenAmounts.length ? tokenAmounts[0] : null;
@@ -19,18 +16,18 @@ const getTokenBalances = async (walletAddress, tokens) => {
         }
         tokensByChain[token.chainId].push(token);
     });
-    const tokenAmountsByChain = await (0, exports.getTokenBalancesForChains)(walletAddress, tokensByChain);
+    const tokenAmountsByChain = await (0, exports.getTokenBalancesByChain)(walletAddress, tokensByChain);
     return Object.values(tokenAmountsByChain).flat();
 };
 exports.getTokenBalances = getTokenBalances;
-const getTokenBalancesForChains = async (walletAddress, tokensByChain) => {
+const getTokenBalancesByChain = async (walletAddress, tokensByChain) => {
     const tokenAmountsByChain = {};
     const promises = Object.keys(tokensByChain).map(async (chainIdStr) => {
         const chainId = parseInt(chainIdStr);
-        const tokenAmounts = await utils_1.default.getBalances(walletAddress, tokensByChain[chainId]);
+        const tokenAmounts = await (0, getBalance_1.getBalance)(walletAddress, tokensByChain[chainId]);
         tokenAmountsByChain[chainId] = tokenAmounts;
     });
     await Promise.allSettled(promises);
     return tokenAmountsByChain;
 };
-exports.getTokenBalancesForChains = getTokenBalancesForChains;
+exports.getTokenBalancesByChain = getTokenBalancesByChain;

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

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

package/dist/cjs/balance/index.js

@@ -14,13 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./checkBalance"), exports);
+__exportStar(require("./getBalance"), exports);
 __exportStar(require("./getTokenBalance"), exports);
-const checkBalance_1 = require("./checkBalance");
-const getTokenBalance_1 = require("./getTokenBalance");
-exports.default = {
-    checkBalance: checkBalance_1.checkBalance,
-    getTokenBalance: getTokenBalance_1.getTokenBalance,
-    getTokenBalances: getTokenBalance_1.getTokenBalances,
-    getTokenBalancesForChains: getTokenBalance_1.getTokenBalancesForChains,
-};