@moonwell-fi/moonwell-sdk/_esm/actions/governance/getStakingInfo.js

TypeScript Interface for Moonwell

import { base } from "viem/chains";
import { Amount, DAYS_PER_YEAR, SECONDS_PER_DAY, getEnvironmentsFromArgs, } from "../../common/index.js";
import { publicEnvironments, } from "../../environments/index.js";
import { getMerklStakingApr } from "./common.js";
export async function getStakingInfo(client, args) {
    const environments = getEnvironmentsFromArgs(client, args);
    const envsWithStaking = environments.filter((env) => env.config.contracts.stakingToken);
    const envStakingInfoSettlements = await Promise.allSettled(envsWithStaking.map(async (environment) => {
        const homeEnvironment = Object.values(publicEnvironments).find((e) => e.custom?.governance?.chainIds?.includes(environment.chainId)) || environment;
        const isBase = environment.chainId === base.id;
        const settlements = await Promise.allSettled([
            environment.contracts.views?.read.getStakingInfo(),
            homeEnvironment.contracts.views?.read.getGovernanceTokenPrice(),
            ...(isBase
                ? [
                    environment.contracts.views?.read.getStakingInfo({
                        blockNumber: BigInt(34149943),
                    }),
                ]
                : []),
        ]);
        return settlements.map((s) => s.status === "fulfilled" ? s.value : undefined);
    }));
    const envStakingInfo = envStakingInfoSettlements
        .filter((s) => s.status === "fulfilled")
        .map((s) => s.value)
        .filter((val) => val !== undefined);
    const baseEnv = envsWithStaking.find((env) => env.chainId === base.id);
    const stakingTokenKey = baseEnv?.config.contracts.stakingToken;
    const baseStkToken = baseEnv != null && stakingTokenKey != null
        ? baseEnv.config.tokens[stakingTokenKey]
        : undefined;
    const baseStakingApr = baseStkToken != null ? await getMerklStakingApr(baseStkToken.address) : 0;
    const result = envsWithStaking.flatMap((curr, index) => {
        const token = curr.config.tokens[curr.config.contracts.governanceToken];
        const stakingToken = curr.config.tokens[curr.config.contracts.stakingToken];
        const envStakingInfoData = envStakingInfo[index][0];
        const envGovernanceTokenPriceData = envStakingInfo[index][1];
        const envStakingInfoDataAfterX28Proposal = envStakingInfo[index][2];
        const isBase = curr.chainId === base.id;
        if (!envStakingInfoData ||
            (isBase && !envStakingInfoDataAfterX28Proposal)) {
            return [];
        }
        const { cooldown, distributionEnd, emissionPerSecond: emissionPerSecondRaw, totalSupply: totalSupplyRaw, unstakeWindow, } = envStakingInfoData;
        //Quick workaround to get governance token price from some other environment
        const governanceTokenPrice = new Amount((envGovernanceTokenPriceData ?? 0n), 18);
        const totalSupply = new Amount(totalSupplyRaw, 18);
        const emissionPerSecond = new Amount(emissionPerSecondRaw, 18);
        const emissionPerYear = emissionPerSecond.value * SECONDS_PER_DAY * DAYS_PER_YEAR;
        const apr = ((emissionPerYear + totalSupply.value) / totalSupply.value - 1) * 100;
        const stakingInfo = {
            apr: isBase ? baseStakingApr : apr,
            chainId: curr.chainId,
            cooldown: Number(cooldown),
            distributionEnd: Number(distributionEnd),
            token,
            tokenPrice: governanceTokenPrice.value,
            stakingToken,
            totalSupply,
            totalSupplyUSD: totalSupply.value * governanceTokenPrice.value,
            unstakeWindow: Number(unstakeWindow),
        };
        return stakingInfo;
    });
    return result;
}
//# sourceMappingURL=getStakingInfo.js.map