@lifi/sdk 2.2.3 → 3.0.0-alpha.2

package/dist/allowance/setAllowance.js

@@ -0,0 +1,50 @@
+import { encodeFunctionData, maxUint256, publicActions } from 'viem';
+import { approveAbi } from '../types';
+import { getMaxPriorityFeePerGas } from '../utils';
+import { isNativeTokenAddress } from '../utils/utils';
+import { getAllowance } from './getAllowance';
+export const setAllowance = async (walletClient, tokenAddress, contractAddress, amount, returnPopulatedTransaction) => {
+    const data = encodeFunctionData({
+        abi: approveAbi,
+        functionName: 'approve',
+        args: [contractAddress, amount],
+    });
+    if (returnPopulatedTransaction) {
+        return data;
+    }
+    const client = walletClient.extend(publicActions);
+    let maxPriorityFeePerGas;
+    if (walletClient.account?.type === 'local') {
+        maxPriorityFeePerGas = await getMaxPriorityFeePerGas(client);
+    }
+    return client.sendTransaction({
+        to: tokenAddress,
+        account: walletClient.account,
+        data,
+        maxPriorityFeePerGas,
+        chain: null,
+    });
+};
+export const setTokenAllowance = async ({ walletClient, token, spenderAddress, amount, infiniteApproval = false, }) => {
+    // native token don't need approval
+    if (isNativeTokenAddress(token.address)) {
+        return;
+    }
+    const approvedAmount = await getAllowance(token.chainId, token.address, walletClient.account.address, spenderAddress);
+    if (amount > approvedAmount) {
+        const approvalAmount = infiniteApproval ? maxUint256 : amount;
+        const approveTx = await setAllowance(walletClient, token.address, spenderAddress, approvalAmount);
+        return approveTx;
+    }
+};
+export const revokeTokenApproval = async ({ walletClient, token, spenderAddress, }) => {
+    // native token don't need approval
+    if (isNativeTokenAddress(token.address)) {
+        return;
+    }
+    const approvedAmount = await getAllowance(token.chainId, token.address, walletClient.account.address, spenderAddress);
+    if (approvedAmount > 0) {
+        const approveTx = await setAllowance(walletClient, token.address, spenderAddress, 0n);
+        return approveTx;
+    }
+};

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

@@ -0,0 +1 @@
+export {};

package/dist/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/balance/getBalance.js

@@ -0,0 +1,93 @@
+import { getMulticallAddress, getPublicClient } from '../connectors';
+import { MulticallBatchSize } from '../constants';
+import { balanceOfAbi, getEthBalanceAbi } from '../types';
+import { isZeroAddress } from '../utils/utils';
+export 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 getMulticallAddress(chainId);
+    if (multicallAddress && tokens.length > 1) {
+        return getBalanceMulticall(chainId, tokens, walletAddress, multicallAddress);
+    }
+    else {
+        return getBalanceDefault(chainId, tokens, walletAddress);
+    }
+};
+const getBalanceMulticall = async (chainId, tokens, walletAddress, multicallAddress) => {
+    const client = await getPublicClient(chainId);
+    const contracts = tokens.map((token) => {
+        if (isZeroAddress(token.address)) {
+            return {
+                address: multicallAddress,
+                abi: getEthBalanceAbi,
+                functionName: 'getEthBalance',
+                args: [walletAddress],
+            };
+        }
+        return {
+            address: token.address,
+            abi: balanceOfAbi,
+            functionName: 'balanceOf',
+            args: [walletAddress],
+        };
+    });
+    const blockNumber = await client.getBlockNumber();
+    const results = await client.multicall({
+        contracts,
+        multicallAddress: multicallAddress,
+        blockNumber,
+        batchSize: 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 getPublicClient(chainId);
+    const blockNumber = await client.getBlockNumber();
+    const queue = tokens.map((token) => {
+        if (isZeroAddress(token.address)) {
+            return client.getBalance({
+                address: walletAddress,
+            });
+        }
+        return client.readContract({
+            address: token.address,
+            abi: 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/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/balance/getTokenBalance.js

@@ -1,4 +1,4 @@
-import utils from './utils';
+import { getBalance } from './getBalance';
 export const getTokenBalance = async (walletAddress, token) => {
     const tokenAmounts = await getTokenBalances(walletAddress, [token]);
     return tokenAmounts.length ? tokenAmounts[0] : null;
@@ -12,14 +12,14 @@ export const getTokenBalances = async (walletAddress, tokens) => {
         }
         tokensByChain[token.chainId].push(token);
     });
-    const tokenAmountsByChain = await getTokenBalancesForChains(walletAddress, tokensByChain);
+    const tokenAmountsByChain = await getTokenBalancesByChain(walletAddress, tokensByChain);
     return Object.values(tokenAmountsByChain).flat();
 };
-export const getTokenBalancesForChains = async (walletAddress, tokensByChain) => {
+export const getTokenBalancesByChain = async (walletAddress, tokensByChain) => {
     const tokenAmountsByChain = {};
     const promises = Object.keys(tokensByChain).map(async (chainIdStr) => {
         const chainId = parseInt(chainIdStr);
-        const tokenAmounts = await utils.getBalances(walletAddress, tokensByChain[chainId]);
+        const tokenAmounts = await getBalance(walletAddress, tokensByChain[chainId]);
         tokenAmountsByChain[chainId] = tokenAmounts;
     });
     await Promise.allSettled(promises);

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

@@ -1,10 +1,2 @@
-export * from './checkBalance';
+export * from './getBalance';
 export * from './getTokenBalance';
-import { checkBalance } from './checkBalance';
-import { getTokenBalance, getTokenBalances, getTokenBalancesForChains, } from './getTokenBalance';
-export default {
-    checkBalance,
-    getTokenBalance,
-    getTokenBalances,
-    getTokenBalancesForChains,
-};

package/dist/cjs/LiFi.d.ts

@@ -1,160 +1,167 @@
-import { FallbackProvider } from '@ethersproject/providers';
-import { ChainId, ChainKey, ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, ExtendedChain, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, PossibilitiesRequest, PossibilitiesResponse, QuoteRequest, RequestOptions, RoutesRequest, RoutesResponse, StatusResponse, Token, TokenAmount, TokensRequest, TokensResponse, ToolsRequest, ToolsResponse } from '@lifi/types';
-import { Signer } from 'ethers';
-import { ApproveTokenRequest, RevokeApprovalRequest } from './allowance';
+import type { ChainId, ChainKey, ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, ExtendedChain, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, PossibilitiesRequest, PossibilitiesResponse, QuoteRequest, RequestOptions, RoutesRequest, RoutesResponse, StatusResponse, Token, TokenAmount, TokensRequest, TokensResponse, ToolsRequest, ToolsResponse } from '@lifi/types';
+import type { Hash, PublicClient } from 'viem';
+import type { ApproveTokenRequest, RevokeApprovalRequest, TokenAllowance, TokenSpender } from './allowance';
 import { RouteExecutionManager } from './execution/RouteExecutionManager';
-import { Config, ConfigUpdate, RevokeTokenData } from './types';
+import type { Config, ConfigUpdate } from './types';
 export declare class LiFi extends RouteExecutionManager {
     private chainsService;
     constructor(configUpdate: ConfigUpdate);
     /**
      * Get the current configuration of the SDK
-     * @return {Config} - The config object
+     * @returns - The config object
      */
     getConfig: () => Config;
     /**
      * Get the SDK configuration after all setup calls are finished
-     * @return {Promise<Config>} - The config object
+     * @returns - The config object
      */
     getConfigAsync: () => Promise<Config>;
     /**
      * 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
      */
-    getRpcProvider: (chainId: number, archive?: boolean) => Promise<FallbackProvider>;
+    getPublicClient: (chainId: number) => Promise<PublicClient>;
     /**
      * 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
      */
     setConfig: (configUpdate: Partial<ConfigUpdate>) => Config;
     /**
      * 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
      */
     getPossibilities: (request?: PossibilitiesRequest, options?: RequestOptions) => Promise<PossibilitiesResponse>;
     /**
      * 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
      */
     getToken: (chain: ChainKey | ChainId, token: string, options?: RequestOptions) => Promise<Token>;
     /**
      * 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
      */
     getQuote: (request: QuoteRequest, options?: RequestOptions) => Promise<LifiStep>;
     /**
      * 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.
      */
     getContractCallQuote: (request: ContractCallQuoteRequest, options?: RequestOptions) => Promise<LifiStep>;
     /**
      * 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.
      */
     getStatus: (request: GetStatusRequest, options?: RequestOptions) => Promise<StatusResponse>;
     /**
      * 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
      */
     getTools: (request?: ToolsRequest, options?: RequestOptions) => Promise<ToolsResponse>;
     /**
      * 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
      */
     getTokens: (request?: TokensRequest, options?: RequestOptions) => Promise<TokensResponse>;
     /**
      * 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.
      */
     getChains: () => Promise<ExtendedChain[]>;
     /**
      * 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.
      */
     getRoutes: (request: RoutesRequest, options?: RequestOptions) => Promise<RoutesResponse>;
     /**
      * 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.
      */
     getStepTransaction: (step: LifiStep, options?: RequestOptions) => Promise<LifiStep>;
     /**
      * 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.
      */
     getGasRecommendation: (request: GasRecommendationRequest, options?: RequestOptions) => Promise<GasRecommendationResponse>;
     /**
      * 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.
      */
     getTokenBalance: (walletAddress: string, token: Token) => Promise<TokenAmount | null>;
     /**
      * 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.
      */
     getTokenBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
     /**
      * 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.
      */
-    getTokenBalancesForChains: (walletAddress: string, tokensByChain: {
+    getTokenBalancesByChain: (walletAddress: string, tokensByChain: {
         [chainId: number]: Token[];
     }) => Promise<{
         [chainId: number]: TokenAmount[];
     }>;
     /**
-     * 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
      */
-    getTokenApproval: (signer: Signer, token: Token, approvalAddress: string) => Promise<string | undefined>;
+    getTokenAllowance: (token: Token, ownerAddress: string, spenderAddress: string) => Promise<bigint | undefined>;
     /**
-     * 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
      */
-    bulkGetTokenApproval: (signer: Signer, tokenData: RevokeTokenData[]) => Promise<{
-        token: Token;
-        approval: string | undefined;
-    }[]>;
+    getTokenAllowanceMulticall: (ownerAddress: string, tokens: TokenSpender[]) => Promise<TokenAllowance[]>;
     /**
      * Set approval for a certain token and amount.
-     * @param { ApproveTokenRequest } request - The approval request
+     * @param request - The approval request
      */
-    approveToken: (request: ApproveTokenRequest) => Promise<void>;
+    setTokenApproval: (request: ApproveTokenRequest) => Promise<Hash | void>;
     /**
      * Revoke approval for a certain token.
-     * @param { RevokeApprovalRequest } request - The revoke request
+     * @param request - The revoke request
      */
-    revokeTokenApproval: (request: RevokeApprovalRequest) => Promise<void>;
+    revokeTokenApproval: (request: RevokeApprovalRequest) => Promise<Hash | void>;
     /**
      * Get all the available connections for swap/bridging tokens
      * @param connectionRequest ConnectionsRequest