@lifi/sdk 2.2.2 → 3.0.0-alpha.1

package/package.json

@@ -1,33 +1,35 @@
 {
   "name": "@lifi/sdk",
-  "version": "2.2.2",
+  "version": "3.0.0-alpha.1",
   "description": "LI.FI Any-to-Any Cross-Chain-Swap SDK",
   "main": "./dist/cjs/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "watch": "tsc -w -p ./tsconfig.json",
+    "addscope": "node tools/packagejson name @lifi/sdk",
     "build": "yarn clean && tsc --project ./tsconfig.json && tsc --project ./tsconfig.cjs.json",
     "clean": "node tools/cleanup",
+    "coverage": "vitest run --coverage",
+    "lint": "eslint --ext .tsx --ext .ts ./src",
+    "lint:fix": "eslint --ext .tsx --ext .ts ./src --fix",
     "package": "npm run build && npm pack",
+    "postpublish": "npm run use:gitReadme && pinst --enable",
+    "pre-commit": "lint-staged",
+    "pre-push": "yarn types:check && yarn build && yarn test:unit",
+    "prepare": "husky install",
+    "prepublishOnly": "run-s build use:npmReadme && pinst --enable",
+    "prettier:fix": "prettier --write ./src/.",
+    "release": "standard-version -a",
+    "release:alpha": "standard-version -a --prerelease alpha --skip.changelog",
+    "release:beta": "standard-version -a --prerelease beta --skip.changelog",
     "test": "vitest --run --dangerouslyIgnoreUnhandledErrors",
-    "test:unit": "yarn test .unit.spec.ts",
     "test:cov": "yarn test --coverage",
     "test:e2e": "yarn test -c vitest.e2e.config.ts",
-    "addscope": "node tools/packagejson name @lifi/sdk",
-    "pre-commit": "lint-staged",
-    "pre-push": "yarn types:check && yarn build && yarn test:unit",
-    "lint": "eslint --ext .tsx --ext .ts ./src",
-    "lint:fix": "eslint --ext .tsx --ext .ts ./src --fix",
+    "test:unit": "yarn test .unit.spec.ts",
     "types:check": "tsc --noEmit",
-    "prettier:fix": "prettier --write ./src/.",
-    "use:npmReadme": "mv 'README.md' 'git.README.md' && mv 'npm.README.md' 'README.md'",
     "use:gitReadme": "mv 'README.md' 'npm.README.md' && mv 'git.README.md' 'README.md'",
-    "prepublishOnly": "run-s build use:npmReadme && pinst --enable",
-    "postpublish": "npm run use:gitReadme && pinst --enable",
-    "prepare": "husky install",
-    "release": "standard-version -a",
-    "release:beta": "standard-version -a --prerelease beta --skip.changelog"
+    "use:npmReadme": "mv 'README.md' 'git.README.md' && mv 'npm.README.md' 'README.md'",
+    "watch": "tsc -w -p ./tsconfig.json"
   },
   "standard-version": {
     "scripts": {
@@ -75,33 +77,32 @@
     "url": "https://github.com/lifinance/sdk/issues"
   },
   "dependencies": {
-    "@ethersproject/abi": "^5.7.0",
-    "@ethersproject/contracts": "^5.7.0",
-    "@lifi/types": "^8.0.4",
-    "bignumber.js": "^9.1.1",
+    "@lifi/types": "^9.0.0-alpha.0",
     "eth-rpc-errors": "^4.0.3",
-    "ethers": "^5.7.2"
+    "viem": "^1.5.2"
   },
   "devDependencies": {
     "@commitlint/cli": "^17.6.7",
     "@commitlint/config-conventional": "^17.6.7",
     "@mswjs/interceptors": "^0.22.16",
-    "@typescript-eslint/eslint-plugin": "^6.1.0",
-    "@typescript-eslint/parser": "^6.1.0",
-    "@vitest/coverage-c8": "^0.33.0",
+    "@types/ws": "^8.5.5",
+    "@typescript-eslint/eslint-plugin": "^6.2.1",
+    "@typescript-eslint/parser": "^6.2.1",
+    "@vitest/coverage-v8": "^0.34.1",
     "cross-fetch": "^4.0.0",
-    "eslint": "^8.45.0",
-    "eslint-config-prettier": "^8.8.0",
+    "eslint": "^8.46.0",
+    "eslint-config-prettier": "^8.10.0",
+    "eslint-plugin-jsdoc": "^46.4.5",
     "eslint-plugin-prettier": "^5.0.0",
     "husky": "^8.0.3",
     "lint-staged": "^13.2.3",
     "msw": "1.0.1",
     "npm-run-all": "^4.1.5",
     "pinst": "^3.0.0",
-    "prettier": "^3.0.0",
+    "prettier": "^3.0.1",
     "standard-version": "^9.5.0",
     "typescript": "^5.1.6",
-    "vitest": "^0.33.0"
+    "vitest": "^0.34.1"
   },
   "directories": {
     "test": "test"

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

@@ -1,96 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { constants, } from 'ethers';
-import { getApproved, setApproval } from '../allowance/utils';
-import { getProvider } from '../utils/getProvider';
-import { parseError } from '../utils/parseError';
-export 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 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 getApproved(signer, approvalRequest.from, approvalRequest.to, approvalRequest);
-            if (new BigNumber(step.action.fromAmount).gt(approved)) {
-                if (!allowUserInteraction) {
-                    return;
-                }
-                const approvalAmount = settings.infiniteApproval
-                    ? constants.MaxUint256.toString()
-                    : step.action.fromAmount;
-                if (shouldBatchTransactions) {
-                    const populatedTransaction = await setApproval(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount, true);
-                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-                    return populatedTransaction;
-                }
-                const approveTx = (await 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 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;
-        }
-    }
-};
-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/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,15 +0,0 @@
-import { TransactionRequest } from '@ethersproject/abstract-provider';
-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, transactionRequest?: TransactionRequest) => 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,77 +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, transactionRequest) => {
-    const signerAddress = await signer.getAddress();
-    const erc20 = new Contract(tokenAddress, ERC20_ABI, signer);
-    try {
-        const approved = await erc20.allowance(signerAddress, contractAddress, {
-            gasLimit: transactionRequest?.gasLimit,
-            gasPrice: transactionRequest?.gasPrice,
-            maxFeePerGas: transactionRequest?.maxFeePerGas,
-            maxPriorityFeePerGas: transactionRequest?.maxPriorityFeePerGas,
-        });
-        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/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/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>;