@augustdigital/pools/lib/staking.js

External services interactions

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getRewardsStakingPositions = getRewardsStakingPositions;
const utils_1 = require("@augustdigital/utils");
const abis_1 = require("@augustdigital/abis");
const ethers_1 = require("ethers");
const REWARDS_CHAIN = 43114;
const REWARDS_SYMBOL = 'AVAX';
const REWARDS_DECIMALS = 18;
const REWARDS_NAME = 'Avalanche';
const APR_MULTIPLIER = 31536000;
const UP_AUSD_SYMBOL = 'upAUSD';
async function getRewardsStakingPositions({ rpcUrl, wallet, env, coinGeckoKey, }) {
    try {
        const provider = (0, utils_1.createProvider)(rpcUrl);
        const chainId = Number((await provider.getNetwork())?.chainId);
        if (chainId !== REWARDS_CHAIN) {
            console.warn('#getStakingPositions: no rewards distributor on chain_id', chainId);
            return [];
        }
        if (wallet && !(0, ethers_1.isAddress)(wallet)) {
            console.warn('#getStakingPositions: wallet passed is not a valid address', wallet);
            return [];
        }
        const rewardDistributorAddresses = (0, utils_1.REWARD_DISTRIBUTOR_ADDRESS)(chainId);
        const positions = await Promise.all(rewardDistributorAddresses.map(async (contract, i) => {
            const rewardContract = (0, utils_1.createContract)({
                address: contract,
                provider: provider,
                abi: abis_1.ABI_REWARD_DISTRIBUTOR,
            });
            const totalStaked = await rewardContract.totalStaked();
            const rewardsPerSecond = await rewardContract.rewardsPerSecond();
            const stakingTokenCalls = ['decimals', 'symbol', 'name', 'totalSupply'];
            const stakingTokenAddress = (await rewardContract.stakingToken());
            const stakingTokenContract = (0, utils_1.createContract)({
                address: stakingTokenAddress,
                provider: provider,
                abi: abis_1.ABI_ERC20,
            });
            const [decimals, symbol, name, totalSupply] = await Promise.all(stakingTokenCalls.map((staking) => stakingTokenContract[staking]()));
            let balance;
            let earned;
            if (wallet) {
                const formattedWallet = (0, ethers_1.getAddress)(wallet);
                balance = await rewardContract.balanceOf(formattedWallet);
                earned = await rewardContract.earned(formattedWallet);
            }
            const rewardTokenPriceInUsd = await (0, utils_1.fetchTokenPrice)(REWARDS_SYMBOL, null, coinGeckoKey);
            const normalizedRewardTokenPrice = (0, utils_1.toNormalizedBn)(rewardTokenPriceInUsd);
            const normalizedTotalStakedInPool = (0, utils_1.toNormalizedBn)(totalStaked, decimals);
            const normalizedTotalSupply = (0, utils_1.toNormalizedBn)(totalSupply, decimals);
            const normalizedRedeemable = (0, utils_1.toNormalizedBn)(earned, REWARDS_DECIMALS);
            const normalizedRewardsPerSecond = (0, utils_1.toNormalizedBn)(rewardsPerSecond, REWARDS_DECIMALS);
            const normalizedTotalStakedBalance = (0, utils_1.toNormalizedBn)(balance, decimals);
            const rewardTokenPriceToMultiply = symbol === UP_AUSD_SYMBOL
                ? Number(normalizedRewardTokenPrice?.normalized)
                : 1;
            const STAKED_APR = ((Number(normalizedRewardsPerSecond?.normalized) *
                APR_MULTIPLIER *
                rewardTokenPriceToMultiply) /
                (Number(normalizedTotalStakedInPool?.normalized) * Number(1))) *
                100;
            const MAX_APR = ((Number(normalizedRewardsPerSecond?.normalized) *
                APR_MULTIPLIER *
                rewardTokenPriceToMultiply) /
                (Number(normalizedTotalStakedInPool?.normalized) * Number(1))) *
                100;
            const activePosition = {
                id: String(i),
                rewardToken: {
                    decimals: REWARDS_DECIMALS,
                    symbol: REWARDS_SYMBOL,
                    address: ethers_1.ZeroAddress,
                    chain: REWARDS_CHAIN,
                    redeemable: normalizedRedeemable,
                    usd: normalizedRewardTokenPrice,
                    name: REWARDS_NAME,
                },
                stakingToken: {
                    decimals: Number(decimals),
                    symbol: symbol,
                    address: stakingTokenAddress,
                    chain: REWARDS_CHAIN,
                    totalStaked: normalizedTotalStakedBalance,
                    usd: normalizedRewardTokenPrice,
                    totalSupply: normalizedTotalStakedInPool,
                    name: name,
                },
                rewardDistributor: contract,
                rewardPerSecond: (0, utils_1.toNormalizedBn)(rewardsPerSecond),
                apy: STAKED_APR,
                maxApy: MAX_APR,
                chainId: REWARDS_CHAIN,
            };
            return activePosition;
        }));
        return positions;
    }
    catch (e) {
        console.error('#getStakingPositions:', e);
    }
}
//# sourceMappingURL=staking.js.map