@moonwell-fi/moonwell-sdk/_esm/actions/core/getUserBalances.js

TypeScript Interface for Moonwell

import { getContract, parseAbi, zeroAddress, } from "viem";
import { Amount, getEnvironmentsFromArgs } from "../../common/index.js";
import { findTokenByAddress } from "../../environments/utils/index.js";
const getTokenBalance = async (environment, userAddress, tokenAddress) => {
    if (tokenAddress === zeroAddress) {
        return new Promise((resolve) => {
            environment.publicClient
                .getBalance({
                address: userAddress,
            })
                .then((balance) => {
                resolve({ amount: BigInt(balance), token: tokenAddress });
            })
                .catch(() => {
                resolve({ amount: 0n, token: tokenAddress });
            });
        });
    }
    const erc20Abi = parseAbi([
        "function balanceOf(address owner) view returns (uint256)",
    ]);
    const erc20Contract = getContract({
        address: tokenAddress,
        abi: erc20Abi,
        client: environment.publicClient,
    });
    const result = new Promise((resolve) => {
        erc20Contract.read
            .balanceOf([userAddress])
            .then((balance) => {
            resolve({ amount: BigInt(balance), token: tokenAddress });
        })
            .catch(() => {
            resolve({ amount: 0n, token: tokenAddress });
        });
    });
    return result;
};
export async function getUserBalances(client, args) {
    const { userAddress } = args;
    const environments = getEnvironmentsFromArgs(client, args, false);
    const environmentsTokensBalances = await Promise.all(environments.map((environment) => {
        if (environment.contracts.views) {
            return Promise.all([
                environment.contracts.views.read.getTokensBalances([
                    Object.values(environment.config.tokens).map((token) => token.address),
                    userAddress,
                ]),
            ]);
        }
        return Promise.all([
            Promise.all(Object.values(environment.config.tokens).map((token) => getTokenBalance(environment, userAddress, token.address))),
        ]);
    }));
    // Fetch morpho staking balances
    await Promise.all(environments.map(async (env, index) => {
        if (!env.config.vaults)
            return;
        const vaultBalances = await Promise.all(Object.values(env.config.vaults)
            .filter((vault) => vault.multiReward)
            .map((vault) => getTokenBalance(env, userAddress, vault.multiReward)));
        const envBalances = environmentsTokensBalances[index]?.[0];
        if (envBalances) {
            environmentsTokensBalances[index][0] = [
                ...envBalances,
                ...vaultBalances,
            ];
        }
    }));
    const result = environments.flatMap((env, index) => {
        const balances = environmentsTokensBalances[index][0];
        const userBalances = balances
            .map((balance) => {
            const token = findTokenByAddress(env, balance.token);
            const vault = Object.values(env.config.vaults || {}).find((v) => v.multiReward === balance.token);
            if (token) {
                const result = {
                    chainId: env.chainId,
                    account: userAddress,
                    token,
                    tokenBalance: new Amount(balance.amount, token.decimals),
                };
                return result;
            }
            if (vault?.multiReward) {
                const vaultToken = env.config.tokens[vault.vaultToken];
                const result = {
                    chainId: env.chainId,
                    account: userAddress,
                    token: {
                        address: vault.multiReward,
                        decimals: vaultToken.decimals,
                        name: `stk${vaultToken.symbol}`,
                        symbol: `stk${vaultToken.symbol}`,
                    },
                    tokenBalance: new Amount(balance.amount, vaultToken.decimals),
                };
                return result;
            }
            return undefined;
        })
            .filter((balance) => balance !== undefined);
        return userBalances;
    });
    return result;
}
//# sourceMappingURL=getUserBalances.js.map