@lifi/sdk 2.3.1 → 3.0.0-alpha.10

package/dist/allowance/tokenApproval.d.ts

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

package/dist/allowance/tokenApproval.js

@@ -1,59 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { constants } from 'ethers';
-import { isSameToken } from '../helpers';
-import { isNativeTokenAddress } from '../utils/utils';
-import { getAllowanceViaMulticall, getApproved, groupByChain, setApproval, } from './utils';
-export const getTokenApproval = async (signer, token, approvalAddress) => {
-    // native token don't need approval
-    if (isNativeTokenAddress(token.address)) {
-        return;
-    }
-    const approved = await getApproved(signer, token.address, approvalAddress);
-    return approved.toFixed(0);
-};
-export const bulkGetTokenApproval = async (signer, tokenData) => {
-    // filter out native tokens
-    const filteredTokenData = tokenData.filter(({ token }) => !isNativeTokenAddress(token.address));
-    // group by chain
-    const tokenDataByChain = groupByChain(filteredTokenData);
-    const approvalPromises = Object.keys(tokenDataByChain).map(async (chainId) => {
-        const parsedChainId = Number.parseInt(chainId);
-        // get allowances for current chain and token list
-        return getAllowanceViaMulticall(signer, parsedChainId, tokenDataByChain[parsedChainId]);
-    });
-    const approvalsByChain = await Promise.all(approvalPromises);
-    const approvals = approvalsByChain.flat();
-    return tokenData.map(({ token }) => {
-        // native token don't need approval
-        if (isNativeTokenAddress(token.address)) {
-            return { token, approval: undefined };
-        }
-        const approved = approvals.find((approval) => isSameToken(approval.token, token));
-        return { token, approval: approved?.approvedAmount.toString() };
-    });
-};
-export const approveToken = async ({ signer, token, approvalAddress, amount, infiniteApproval = false, }) => {
-    // native token don't need approval
-    if (isNativeTokenAddress(token.address)) {
-        return;
-    }
-    const approvedAmount = await getApproved(signer, token.address, approvalAddress);
-    if (new BigNumber(amount).gt(approvedAmount)) {
-        const approvalAmount = infiniteApproval
-            ? constants.MaxUint256.toString()
-            : amount;
-        const approveTx = await setApproval(signer, token.address, approvalAddress, approvalAmount);
-        await approveTx.wait();
-    }
-};
-export const revokeTokenApproval = async ({ signer, token, approvalAddress, }) => {
-    // native token don't need approval
-    if (isNativeTokenAddress(token.address)) {
-        return;
-    }
-    const approvedAmount = await getApproved(signer, token.address, approvalAddress);
-    if (!approvedAmount.isZero()) {
-        const approveTx = await setApproval(signer, token.address, approvalAddress, '0');
-        await approveTx.wait();
-    }
-};

package/dist/allowance/utils.d.ts

@@ -1,14 +0,0 @@
-import { ChainId, Token } from '@lifi/types';
-import BigNumber from 'bignumber.js';
-import { ContractTransaction, PopulatedTransaction, 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, returnPopulatedTransaction?: boolean) => Promise<ContractTransaction | PopulatedTransaction>;
-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/allowance/utils.js

@@ -1,72 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { Contract, ethers, } from 'ethers';
-import ChainsService from '../services/ChainsService';
-import { ERC20_ABI } from '../types';
-import { ServerError } from '../utils/errors';
-import { fetchDataUsingMulticall } from '../utils/multicall';
-export const getApproved = async (signer, tokenAddress, contractAddress) => {
-    const signerAddress = await signer.getAddress();
-    const erc20 = new Contract(tokenAddress, ERC20_ABI, signer);
-    try {
-        const approved = await erc20.allowance(signerAddress, contractAddress);
-        return new BigNumber(approved.toString());
-    }
-    catch (e) {
-        return new BigNumber(0);
-    }
-};
-export const setApproval = async (signer, tokenAddress, contractAddress, amount, returnPopulatedTransaction) => {
-    const erc20 = new Contract(tokenAddress, ERC20_ABI, signer);
-    if (returnPopulatedTransaction) {
-        return erc20.populateTransaction.approve(contractAddress, amount);
-    }
-    const transactionRequest = await erc20.populateTransaction.approve(contractAddress, amount);
-    try {
-        const estimatedGasLimit = await signer.estimateGas(transactionRequest);
-        if (estimatedGasLimit) {
-            const formattedGasLimit = ethers.BigNumber.from(`${(BigInt(estimatedGasLimit.toString()) * 125n) / 100n}`);
-            transactionRequest.gasLimit = formattedGasLimit;
-        }
-    }
-    catch (error) { }
-    return signer.sendTransaction(transactionRequest);
-};
-export const getAllowanceViaMulticall = async (signer, chainId, tokenData) => {
-    const chainsService = ChainsService.getInstance();
-    const chain = await chainsService.getChainById(chainId);
-    if (!chain.multicallAddress) {
-        throw new ServerError(`No multicall address configured for chainId ${chainId}.`);
-    }
-    const ownerAddress = await signer.getAddress();
-    const calls = [];
-    tokenData.map(({ token, approvalAddress }) => {
-        calls.push({
-            address: token.address,
-            name: 'allowance',
-            params: [ownerAddress, approvalAddress],
-        });
-    });
-    const result = await fetchDataUsingMulticall(calls, ERC20_ABI, chainId, chain.multicallAddress);
-    if (!result.length) {
-        throw new ServerError(`Couldn't load allowance from chainId ${chainId} using multicall.`);
-    }
-    const parsedResult = result.map(({ data }) => ({
-        approvalAmount: data ?? new BigNumber(0),
-    }));
-    return tokenData.map(({ token, approvalAddress }, i) => ({
-        token,
-        approvalAddress,
-        approvedAmount: parsedResult[i].approvalAmount,
-    }));
-};
-export 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;
-};

package/dist/balance/checkBalance.d.ts

@@ -1,3 +0,0 @@
-import { ethers } from 'ethers';
-import { LifiStep } from '..';
-export declare const checkBalance: (signer: ethers.Signer, step: LifiStep, depth?: number) => Promise<void>;

package/dist/balance/checkBalance.js

@@ -1,38 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { BalanceError } from '../utils/errors';
-import { getTokenBalance } from './getTokenBalance';
-export const checkBalance = async (signer, step, depth = 0) => {
-    const tokenAmount = await getTokenBalance(await signer.getAddress(), step.action.fromToken);
-    if (tokenAmount) {
-        const currentBalance = new BigNumber(tokenAmount.amount).shiftedBy(tokenAmount.decimals);
-        const neededBalance = new BigNumber(step.action.fromAmount);
-        if (currentBalance.lt(neededBalance)) {
-            if (depth <= 3) {
-                await new Promise((resolve) => {
-                    setTimeout(resolve, 200);
-                });
-                await checkBalance(signer, step, depth + 1);
-            }
-            else if (neededBalance.multipliedBy(1 - step.action.slippage).lte(currentBalance)) {
-                // adjust amount in slippage limits
-                step.action.fromAmount = currentBalance.toFixed(0);
-            }
-            else {
-                const neeeded = neededBalance.shiftedBy(-tokenAmount.decimals).toFixed();
-                const current = currentBalance
-                    .shiftedBy(-tokenAmount.decimals)
-                    .toFixed();
-                let errorMessage = `Your ${tokenAmount.symbol} balance is too low, ` +
-                    `you try to transfer ${neeeded} ${tokenAmount.symbol}, ` +
-                    `but your wallet only holds ${current} ${tokenAmount.symbol}. ` +
-                    `No funds have been sent. `;
-                if (!currentBalance.isZero()) {
-                    errorMessage +=
-                        `If the problem consists, please delete this transfer and ` +
-                            `start a new one with a maximum of ${current} ${tokenAmount.symbol}.`;
-                }
-                throw new BalanceError('The balance is too low.', errorMessage);
-            }
-        }
-    }
-};

package/dist/balance/index.d.ts

@@ -1,13 +0,0 @@
-export * from './checkBalance';
-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 +0,0 @@
-export * from './checkBalance';
-export * from './getTokenBalance';
-import { checkBalance } from './checkBalance';
-import { getTokenBalance, getTokenBalances, getTokenBalancesForChains, } from './getTokenBalance';
-export default {
-    checkBalance,
-    getTokenBalance,
-    getTokenBalances,
-    getTokenBalancesForChains,
-};

package/dist/balance/utils.d.ts

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

package/dist/balance/utils.js

@@ -1,143 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { ethers } from 'ethers';
-import { getMulticallAddress, getRpcProvider } from '../connectors';
-import { fetchDataUsingMulticall } from '../utils/multicall';
-import { isZeroAddress } from '../utils/utils';
-const balanceAbi = [
-    {
-        constant: true,
-        inputs: [{ name: 'who', type: 'address' }],
-        name: 'balanceOf',
-        outputs: [{ name: '', type: 'uint256' }],
-        payable: false,
-        stateMutability: 'view',
-        type: 'function',
-    },
-    {
-        constant: true,
-        inputs: [{ name: 'addr', type: 'address' }],
-        name: 'getEthBalance',
-        outputs: [{ name: 'balance', type: 'uint256' }],
-        payable: false,
-        stateMutability: 'view',
-        type: 'function',
-    },
-];
-export const getBalances = async (walletAddress, tokens) => {
-    if (tokens.length === 0) {
-        return [];
-    }
-    const { chainId } = tokens[0];
-    tokens.forEach((token) => {
-        if (token.chainId !== chainId) {
-            // eslint-disable-next-line no-console
-            console.warn(`Requested tokens have to be on the same chain.`);
-            return [];
-        }
-    });
-    if ((await getMulticallAddress(chainId)) && tokens.length > 1) {
-        return getBalancesFromProviderUsingMulticall(walletAddress, tokens);
-    }
-    else {
-        return getBalancesFromProvider(walletAddress, tokens);
-    }
-};
-const getBalancesFromProviderUsingMulticall = async (walletAddress, tokens) => {
-    // Configuration
-    const { chainId } = tokens[0];
-    const multicallAddress = await getMulticallAddress(chainId);
-    if (!multicallAddress) {
-        throw new Error('No multicallAddress found for the given chain.');
-    }
-    return executeMulticall(walletAddress, tokens, multicallAddress, chainId);
-};
-const executeMulticall = async (walletAddress, tokens, multicallAddress, chainId) => {
-    // Collect calls we want to make
-    const calls = [];
-    tokens.map((token) => {
-        if (isZeroAddress(token.address)) {
-            calls.push({
-                address: multicallAddress,
-                name: 'getEthBalance',
-                params: [walletAddress],
-            });
-        }
-        else {
-            calls.push({
-                address: token.address,
-                name: 'balanceOf',
-                params: [walletAddress],
-            });
-        }
-    });
-    const res = await fetchViaMulticall(calls, balanceAbi, chainId, multicallAddress);
-    if (!res.length) {
-        return [];
-    }
-    return tokens.map((token, i) => {
-        const amount = new BigNumber(res[i].amount.toString() || '0')
-            .shiftedBy(-token.decimals)
-            .toFixed();
-        return {
-            ...token,
-            amount: amount || '0',
-            blockNumber: res[i].blockNumber,
-        };
-    });
-};
-const fetchViaMulticall = async (calls, abi, chainId, multicallAddress) => {
-    const result = await fetchDataUsingMulticall(calls, abi, chainId, multicallAddress);
-    return result.map(({ data, blockNumber }) => ({
-        amount: data ? data : new BigNumber(0),
-        blockNumber,
-    }));
-};
-const getBalancesFromProvider = async (walletAddress, tokens) => {
-    const chainId = tokens[0].chainId;
-    const rpc = await getRpcProvider(chainId);
-    const tokenAmountPromises = tokens.map(async (token) => {
-        let amount = '0';
-        let blockNumber;
-        try {
-            const balance = await getBalanceFromProvider(walletAddress, token.address, chainId, rpc);
-            amount = new BigNumber(balance.amount.toString())
-                .shiftedBy(-token.decimals)
-                .toString();
-            blockNumber = balance.blockNumber;
-        }
-        catch (e) {
-            // eslint-disable-next-line no-console
-            console.warn(e);
-        }
-        return {
-            ...token,
-            amount,
-            blockNumber,
-        };
-    });
-    return Promise.all(tokenAmountPromises);
-};
-const getBalanceFromProvider = async (walletAddress, assetId, chainId, provider) => {
-    const blockNumber = await getCurrentBlockNumber(chainId);
-    let balance;
-    if (isZeroAddress(assetId)) {
-        balance = await provider.getBalance(walletAddress, blockNumber);
-    }
-    else {
-        const contract = new ethers.Contract(assetId, ['function balanceOf(address owner) view returns (uint256)'], provider);
-        balance = await contract.balanceOf(walletAddress, {
-            blockTag: blockNumber,
-        });
-    }
-    return {
-        amount: balance,
-        blockNumber,
-    };
-};
-const getCurrentBlockNumber = async (chainId) => {
-    const rpc = await getRpcProvider(chainId);
-    return rpc.getBlockNumber();
-};
-export default {
-    getBalances,
-};

package/dist/cjs/LiFi.d.ts

@@ -1,164 +0,0 @@
-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 { RouteExecutionManager } from './execution/RouteExecutionManager';
-import { Config, ConfigUpdate, RevokeTokenData } 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
-     */
-    getConfig: () => Config;
-    /**
-     * Get the SDK configuration after all setup calls are finished
-     * @return {Promise<Config>} - 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
-     */
-    getRpcProvider: (chainId: number, archive?: boolean) => Promise<FallbackProvider>;
-    /**
-     * 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
-     */
-    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.
-     * @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
-     */
-    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
-     */
-    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
-     */
-    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
-     */
-    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
-     * @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
-     * @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.
-     */
-    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.
-     */
-    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.
-     */
-    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.
-     */
-    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.
-     * @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.
-     * @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.
-     * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-     */
-    getTokenBalancesForChains: (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
-     * @param token - The token that should be checked
-     * @param approvalAddress - The address that has be approved
-     */
-    getTokenApproval: (signer: Signer, token: Token, approvalAddress: string) => Promise<string | 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
-     */
-    bulkGetTokenApproval: (signer: Signer, tokenData: RevokeTokenData[]) => Promise<{
-        token: Token;
-        approval: string | undefined;
-    }[]>;
-    /**
-     * Set approval for a certain token and amount.
-     * @param { ApproveTokenRequest } request - The approval request
-     */
-    approveToken: (request: ApproveTokenRequest) => Promise<void>;
-    /**
-     * Revoke approval for a certain token.
-     * @param { RevokeApprovalRequest } request - The revoke request
-     */
-    revokeTokenApproval: (request: RevokeApprovalRequest) => Promise<void>;
-    /**
-     * Get all the available connections for swap/bridging tokens
-     * @param connectionRequest ConnectionsRequest
-     * @returns ConnectionsResponse
-     */
-    getConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;
-}

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

@@ -1,4 +0,0 @@
-import { PopulatedTransaction, Signer } from 'ethers';
-import { StatusManager } from '../execution/StatusManager';
-import { Chain, InternalExecutionSettings, LifiStep } from '../types';
-export declare const checkAllowance: (signer: Signer, step: LifiStep, statusManager: StatusManager, settings: InternalExecutionSettings, chain: Chain, allowUserInteraction?: boolean, shouldBatchTransactions?: boolean) => Promise<void | PopulatedTransaction>;

package/dist/cjs/allowance/checkAllowance.js

@@ -1,103 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkAllowance = void 0;
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const ethers_1 = require("ethers");
-const utils_1 = require("../allowance/utils");
-const getProvider_1 = require("../utils/getProvider");
-const parseError_1 = require("../utils/parseError");
-const checkAllowance = async (signer, step, statusManager, settings, chain, allowUserInteraction = false, shouldBatchTransactions = false) => {
-    // Ask the user to set an allowance
-    let allowanceProcess = statusManager.findOrCreateProcess(step, 'TOKEN_ALLOWANCE');
-    // Check allowance
-    try {
-        if (allowanceProcess.txHash && allowanceProcess.status !== 'DONE') {
-            if (allowanceProcess.status !== 'PENDING') {
-                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING');
-            }
-            await (0, getProvider_1.getProvider)(signer).waitForTransaction(allowanceProcess.txHash);
-            allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-        }
-        else {
-            const approvalRequest = {
-                from: step.action.fromToken.address,
-                to: step.estimate.approvalAddress,
-            };
-            if (settings.updateTransactionRequestHook) {
-                const config = await settings.updateTransactionRequestHook(approvalRequest);
-                approvalRequest.gasLimit = config.gasLimit;
-                approvalRequest.gasPrice = config.gasPrice;
-                approvalRequest.maxFeePerGas = config.maxFeePerGas;
-                approvalRequest.maxPriorityFeePerGas = config.maxPriorityFeePerGas;
-            }
-            if (!approvalRequest.from) {
-                throw new Error('Missing Signer address');
-            }
-            if (!approvalRequest.to) {
-                throw new Error('Missing ERC20 contract address');
-            }
-            const approved = await (0, utils_1.getApproved)(signer, approvalRequest.from, approvalRequest.to);
-            if (new bignumber_js_1.default(step.action.fromAmount).gt(approved)) {
-                if (!allowUserInteraction) {
-                    return;
-                }
-                const approvalAmount = settings.infiniteApproval
-                    ? ethers_1.constants.MaxUint256.toString()
-                    : step.action.fromAmount;
-                if (shouldBatchTransactions) {
-                    const populatedTransaction = await (0, utils_1.setApproval)(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount, true);
-                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-                    return populatedTransaction;
-                }
-                const approveTx = (await (0, utils_1.setApproval)(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount));
-                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
-                    txHash: approveTx.hash,
-                    txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + approveTx.hash,
-                });
-                // Wait for the transcation
-                await approveTx.wait();
-                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-            }
-            else {
-                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-            }
-        }
-    }
-    catch (e) {
-        if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
-            await transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
-        }
-        else {
-            const error = await (0, parseError_1.parseError)(e, step, allowanceProcess);
-            allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'FAILED', {
-                error: {
-                    message: error.message,
-                    htmlMessage: error.htmlMessage,
-                    code: error.code,
-                },
-            });
-            statusManager.updateExecution(step, 'FAILED');
-            throw error;
-        }
-    }
-};
-exports.checkAllowance = checkAllowance;
-const transactionReplaced = async (replacementTx, allowanceProcess, step, chain, statusManager) => {
-    try {
-        allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
-            txHash: replacementTx.hash,
-            txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + replacementTx.hash,
-        });
-        await replacementTx.wait();
-        allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-    }
-    catch (e) {
-        if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
-            await transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
-        }
-        throw e;
-    }
-};

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

@@ -1,2 +0,0 @@
-export * from './checkAllowance';
-export * from './tokenApproval';