@moonwell-fi/moonwell-sdk/_esm/actions/governance/proposals/getProposals.js

TypeScript Interface for Moonwell

import { moonbeam, moonriver } from "viem/chains";
import { Amount, getEnvironmentsFromArgs } from "../../../common/index.js";
import * as logger from "../../../logger/console.js";
import { fetchAllProposals } from "../governor-api-client.js";
import { appendProposalExtendedData, formatApiProposalData, getCrossChainProposalData, getExtendedProposalData, getProposalData, getProposalsOnChainData, isMultichainProposal, } from "./common.js";
export async function getProposals(client, args) {
    const logId = logger.start("getProposals", "Starting to get proposals...");
    const environments = getEnvironmentsFromArgs(client, args);
    const governanceEnvironments = environments.filter((environment) => environment.chainId === moonbeam.id ||
        environment.chainId === moonriver.id);
    if (governanceEnvironments.length === 0) {
        logger.end(logId);
        return [];
    }
    const allProposals = await Promise.all(governanceEnvironments.map(async (governanceEnvironment) => {
        if (governanceEnvironment.chainId === moonbeam.id) {
            // Moonbeam: Use new Governor API
            return getMoonbeamProposals(governanceEnvironment);
        }
        else {
            // Moonriver: Use old Ponder approach
            return getMoonriverProposals(governanceEnvironment);
        }
    }));
    const proposals = allProposals.flat();
    const sortedProposals = proposals.sort((a, b) => b.proposalId - a.proposalId);
    logger.end(logId);
    return sortedProposals;
}
/**
 * Fetch proposals for Moonbeam using the new Governor API
 */
async function getMoonbeamProposals(governanceEnvironment) {
    const apiProposals = await fetchAllProposals(governanceEnvironment);
    const onChainDataList = await getProposalsOnChainData(apiProposals, governanceEnvironment);
    const proposals = apiProposals.map((apiProposal, index) => {
        const onChainData = onChainDataList[index];
        const formattedData = formatApiProposalData(apiProposal);
        let proposalState = onChainData.state;
        const now = Math.floor(Date.now() / 1000);
        if (proposalState === 0 &&
            now >= apiProposal.votingStartTime &&
            now <= apiProposal.votingEndTime) {
            proposalState = 1; // Active
        }
        const isMultichain = isMultichainProposal(apiProposal.targets);
        if (formattedData.executed) {
            proposalState = 7; // ProposalState.Executed
        }
        else if (isMultichain &&
            onChainData.votesCollected &&
            now > apiProposal.votingEndTime &&
            proposalState < 5) {
            proposalState = 5; // ProposalState.Queued
        }
        const proposal = {
            id: apiProposal.proposalId,
            chainId: apiProposal.chainId,
            proposalId: apiProposal.proposalId,
            proposer: apiProposal.proposer,
            eta: onChainData.eta,
            startTimestamp: apiProposal.votingStartTime,
            endTimestamp: apiProposal.votingEndTime,
            startBlock: Number(apiProposal.blockNumber),
            forVotes: formattedData.forVotes,
            againstVotes: formattedData.againstVotes,
            abstainVotes: formattedData.abstainVotes,
            totalVotes: formattedData.totalVotes,
            canceled: formattedData.canceled,
            executed: formattedData.executed,
            quorum: new Amount(onChainData.quorum, 18),
            state: proposalState,
            // Extended data
            title: formattedData.title,
            subtitle: formattedData.subtitle,
            description: apiProposal.description,
            targets: apiProposal.targets,
            calldatas: apiProposal.calldatas,
            signatures: [],
            stateChanges: formattedData.stateChanges,
            environment: governanceEnvironment,
        };
        if (isMultichain) {
            proposal.multichain = {
                id: apiProposal.proposalId,
                votesCollected: onChainData.votesCollected,
            };
        }
        return proposal;
    });
    return proposals;
}
/**
 * Fetch proposals for Moonriver using the old Ponder-based approach
 */
async function getMoonriverProposals(governanceEnvironment) {
    const [_proposals, _xcProposals, _extendedDatas] = await Promise.all([
        getProposalData({ environment: governanceEnvironment }),
        getCrossChainProposalData({ environment: governanceEnvironment }),
        getExtendedProposalData({ environment: governanceEnvironment }),
    ]);
    const proposals = [..._proposals, ..._xcProposals];
    proposals.forEach((proposal) => {
        proposal.environment = governanceEnvironment;
    });
    appendProposalExtendedData(proposals, _extendedDatas);
    return proposals;
}
//# sourceMappingURL=getProposals.js.map