@lifi/sdk 2.2.2 → 3.0.0-alpha.1

package/dist/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

package/dist/LiFi.js

@@ -1,6 +1,6 @@
-import { approveToken, bulkGetTokenApproval, getTokenApproval, revokeTokenApproval, } from './allowance';
+import { getTokenAllowance, getTokenAllowanceMulticall, revokeTokenApproval, setTokenAllowance, } from './allowance';
 import * as balance from './balance';
-import { getRpcProvider } from './connectors';
+import { getPublicClient } from './connectors';
 import { RouteExecutionManager } from './execution/RouteExecutionManager';
 import { checkPackageUpdates } from './helpers';
 import ApiService from './services/ApiService';
@@ -13,40 +13,40 @@ export class LiFi extends 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 getRpcProvider(chainId, archive);
+        this.getPublicClient = (chainId) => {
+            return 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) => {
@@ -54,40 +54,47 @@ export class LiFi extends 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.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.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.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.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) => {
@@ -95,7 +102,8 @@ export class LiFi extends 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) => {
@@ -103,43 +111,46 @@ export class LiFi extends 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.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.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.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) => {
@@ -153,9 +164,9 @@ export class LiFi extends 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) => {
@@ -170,12 +181,12 @@ export class LiFi extends 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 ValidationError('Missing walletAddress.');
             }
@@ -184,35 +195,35 @@ export class LiFi extends RouteExecutionManager {
             if (invalidTokens.length) {
                 throw new 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 getTokenApproval(signer, token, approvalAddress);
+        this.getTokenAllowance = async (token, ownerAddress, spenderAddress) => {
+            return 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 bulkGetTokenApproval(signer, tokenData);
+        this.getTokenAllowanceMulticall = async (ownerAddress, tokens) => {
+            return 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 approveToken(request);
+        this.setTokenApproval = (request) => {
+            return setTokenAllowance(request);
         };
         /**
          * Revoke approval for a certain token.
-         * @param { RevokeApprovalRequest } request - The revoke request
+         * @param request - The revoke request
          */
         this.revokeTokenApproval = (request) => {
             return revokeTokenApproval(request);

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

@@ -0,0 +1,78 @@
+import { getContract } from 'viem';
+import { getMulticallAddress, getPublicClient } from '../connectors';
+import { MulticallBatchSize } from '../constants';
+import { allowanceAbi } from '../types';
+import { isNativeTokenAddress } from '../utils/utils';
+export const getAllowance = async (chainId, tokenAddress, ownerAddress, spenderAddress) => {
+    const client = await getPublicClient(chainId);
+    const contract = getContract({
+        address: tokenAddress,
+        abi: allowanceAbi,
+        publicClient: client,
+    });
+    try {
+        const approved = (await contract.read.allowance([
+            ownerAddress,
+            spenderAddress,
+        ]));
+        return approved;
+    }
+    catch (e) {
+        return 0n;
+    }
+};
+export const getAllowanceMulticall = async (chainId, tokens, ownerAddress) => {
+    if (!tokens.length) {
+        return [];
+    }
+    const multicallAddress = await getMulticallAddress(chainId);
+    if (!multicallAddress) {
+        throw new Error(`No multicall address configured for chainId ${chainId}.`);
+    }
+    const client = await getPublicClient(chainId);
+    const contracts = tokens.map((token) => ({
+        address: token.token.address,
+        abi: allowanceAbi,
+        functionName: 'allowance',
+        args: [ownerAddress, token.spenderAddress],
+    }));
+    const results = await client.multicall({
+        contracts,
+        multicallAddress: multicallAddress,
+        batchSize: 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,
+    }));
+};
+export const getTokenAllowance = async (token, ownerAddress, spenderAddress) => {
+    // native token don't need approval
+    if (isNativeTokenAddress(token.address)) {
+        return;
+    }
+    const approved = await getAllowance(token.chainId, token.address, ownerAddress, spenderAddress);
+    return approved;
+};
+export const getTokenAllowanceMulticall = async (ownerAddress, tokens) => {
+    // filter out native tokens
+    const filteredTokens = tokens.filter(({ token }) => !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 getAllowanceMulticall(chainId, tokenDataByChain[chainId], ownerAddress);
+    }))).flat();
+    return allowances;
+};

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

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

package/dist/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>;