@moonwell-fi/moonwell-sdk 0.20.2 → 0.20.4

package/actions/governance/proposals/common.ts

@@ -1,16 +1,12 @@
 import axios from "axios";
-import last from "lodash/last.js";
-import { moonriver } from "viem/chains";
 import { Amount } from "../../../common/index.js";
 import type { Environment } from "../../../environments/index.js";
 import { publicEnvironments } from "../../../environments/index.js";
 import {
   MultichainProposalState,
   MultichainProposalStateMapping,
-  type Proposal,
   ProposalState,
 } from "../../../types/proposal.js";
-import { postWithRetry } from "../../axiosWithRetry.js";
 import type { ApiProposal } from "../governor-api-client.js";
 
 export const WORMHOLE_CONTRACT = "0xc8e2b0cd52cf01b0ce87d389daa3d414d4ce29f3"; // Moonbeam
@@ -25,21 +21,6 @@ const MULTICHAIN_WORMHOLE_BRIDGES: ReadonlySet<string> = new Set([
   "0x98f3c9e6e3face36baad05fe09d375ef1464288b", // Ethereum
 ]);
 
-type PonderExtendedProposalData = {
-  id: number;
-  title: string;
-  subtitle: string;
-  description: string;
-  targets: string[];
-  calldatas: string[];
-  signatures: string[];
-  stateChanges: {
-    blockNumber: number;
-    transactionHash: string;
-    state: string;
-  }[];
-};
-
 axios.defaults.timeout = 5_000;
 
 /**
@@ -143,15 +124,26 @@ export const isMultichainHomeChain = (chainId: number): boolean => {
  * falls back to the home/bridge checks. Omit it or pass `undefined` when the
  * count read failed so the unknown-cutoff bias above applies. (No `= 0` default:
  * that would coerce an explicit `undefined` back to 0 and defeat the bias.)
+ *
+ * `hasMultichainGovernor` gates rule 4: the unknown-cutoff bias only makes sense
+ * on a chain that actually has a multichain governor to route to. On a
+ * legacy-only chain (Moonriver — legacy `governor`, no `multichainGovernor`) a
+ * failed Artemis count must NOT flip the proposal to multichain, which would
+ * route reads to a null contract and surface a spurious `multichain` field.
+ * Defaults to `true` so callers that don't supply it keep the dual-governor
+ * (Moonbeam) bias behavior.
  */
 export const classifyProposalMultichain = (
   proposal: { targets?: string[]; proposalId: number; chainId: number },
   legacyArtemisMaxId?: number,
+  hasMultichainGovernor = true,
 ): boolean =>
   isMultichainHomeChain(proposal.chainId) ||
   isMultichainProposal(proposal.targets) ||
-  legacyArtemisMaxId === undefined ||
-  (legacyArtemisMaxId > 0 && proposal.proposalId > legacyArtemisMaxId);
+  (legacyArtemisMaxId === undefined && hasMultichainGovernor) ||
+  (legacyArtemisMaxId !== undefined &&
+    legacyArtemisMaxId > 0 &&
+    proposal.proposalId > legacyArtemisMaxId);
 
 /**
  * @deprecated Use `classifyProposalMultichain` — this variant misses hub-homed
@@ -330,9 +322,8 @@ const getLegacyArtemisMaxId = async (
  * the `options.crossChainQuorums?.get(...) ?? 0n` pattern.
  *
  * Read failures are routed through `onError` so Sentry-wired consumers see
- * them — matching `getProposalData` / `getCrossChainProposalData` /
- * `getExtendedProposalData`. The caller's `governanceEnvironment` carries
- * `onError` since we don't have one per foreign chain in scope.
+ * them — matching `getProposalsOnChainData`. The caller's `governanceEnvironment`
+ * carries `onError` since we don't have one per foreign chain in scope.
  */
 export const getEnvironmentByChainId = (
   chainId: number,
@@ -393,6 +384,15 @@ export const getProposalsOnChainData = async (
           : await governanceEnvironment.contracts.governor.read.getQuorum();
     } catch (error) {
       console.warn("Failed to fetch quorum:", error);
+      // Report so a swallowed quorum failure (which leaves quorum at 0n) is
+      // still observable to onError-wired consumers — the legacy Moonriver path
+      // surfaced this too. Uses a distinct `source` from the state/proposals
+      // reads (and from readCrossChainQuorums' "governance-cross-chain-quorum")
+      // so a local quorum-read failure is attributable on its own.
+      governanceEnvironment.onError?.(error, {
+        source: "governance-quorum",
+        chainId: governanceEnvironment.chainId,
+      });
     }
   }
 
@@ -420,10 +420,13 @@ export const getProposalsOnChainData = async (
       // (Ethereum multigov, no Artemis predecessor) classify as multichain
       // regardless of targets via classifyProposalMultichain. Computed once
       // here and returned on ProposalOnChainData so callers don't re-classify
-      // and drift (see getProposal/getProposals).
+      // and drift (see getProposal/getProposals). `hasMultichainGovernor` keeps
+      // the unknown-cutoff bias from misrouting legacy-only chains (Moonriver)
+      // to a nonexistent multichain governor when the Artemis count read fails.
       const isMultichain = classifyProposalMultichain(
         p,
         isLocal ? legacyArtemisMaxId : 0,
+        Boolean(homeEnv?.contracts.multichainGovernor),
       );
 
       if (!homeEnv) {
@@ -557,444 +560,3 @@ export const getProposalsOnChainData = async (
 
   return onChainDataList;
 };
-
-/**
- * Get proposal data from on-chain (Ponder-based, for Moonriver)
- */
-export const getProposalData = async (params: {
-  environment: Environment;
-  id?: number;
-}) => {
-  try {
-    if (params.environment.contracts.governor) {
-      let count = 0n;
-      let quorum = 0n;
-
-      if (params.environment.chainId === moonriver.id) {
-        [count, quorum] = await Promise.all([
-          params.environment.contracts.governor.read.proposalCount(),
-          params.environment.contracts.governor.read.getQuorum(),
-        ]);
-      } else {
-        [count, quorum] = await Promise.all([
-          params.environment.contracts.governor.read.proposalCount(),
-          params.environment.contracts.governor.read.quorumVotes(),
-        ]);
-      }
-
-      if (params.id) {
-        if (BigInt(params.id) > count) {
-          return [];
-        }
-      }
-
-      const ids = params.id
-        ? [BigInt(params.id)]
-        : Array.from({ length: Number(count) }, (_, i) => count - BigInt(i));
-
-      const proposalDataCall = Promise.all(
-        ids.map((id) =>
-          params.environment.contracts.governor?.read.proposals([id]),
-        ),
-      );
-
-      const proposalStateCall = Promise.all(
-        ids.map((id) =>
-          params.environment.contracts.governor?.read.state([id]),
-        ),
-      );
-
-      const [proposalsData, proposalsState] = await Promise.all([
-        proposalDataCall,
-        proposalStateCall,
-      ]);
-
-      const proposals = proposalsData?.map((item, index: number) => {
-        const state = proposalsState?.[index]!;
-
-        const [
-          id,
-          proposer,
-          eta,
-          startTimestamp,
-          endTimestamp,
-          startBlock,
-          forVotes,
-          againstVotes,
-          abstainVotes,
-          totalVotes,
-          canceled,
-          executed,
-        ] = item!;
-
-        const proposal: Proposal = {
-          chainId: params.environment.chainId,
-          id: Number(id),
-          proposalId: Number(id),
-          proposer,
-          eta: Number(eta),
-          startTimestamp: Number(startTimestamp),
-          endTimestamp: Number(endTimestamp),
-          startBlock: Number(startBlock),
-          forVotes: new Amount(forVotes, 18),
-          againstVotes: new Amount(againstVotes, 18),
-          abstainVotes: new Amount(abstainVotes, 18),
-          totalVotes: new Amount(totalVotes, 18),
-          canceled,
-          executed,
-          quorum: new Amount(quorum, 18),
-          state,
-        };
-
-        return proposal;
-      });
-
-      return proposals;
-    } else {
-      return [];
-    }
-  } catch (error) {
-    console.warn(
-      `[getProposalData] RPC failed for chain ${params.environment.chainId}:`,
-      error,
-    );
-    params.environment.onError?.(error, {
-      source: "governance-proposals",
-      chainId: params.environment.chainId,
-    });
-    return [];
-  }
-};
-
-/**
- * Get cross-chain proposal data (Ponder-based, for Moonriver)
- */
-export const getCrossChainProposalData = async (params: {
-  environment: Environment;
-  id?: number;
-}) => {
-  try {
-    if (params.environment.contracts.governor) {
-      const xcGovernanceSettings = params.environment.custom.governance;
-      if (
-        params.environment.contracts.multichainGovernor &&
-        xcGovernanceSettings &&
-        xcGovernanceSettings.chainIds.length > 0
-      ) {
-        const xcEnvironments = xcGovernanceSettings.chainIds
-          .map((chainId) =>
-            (Object.values(publicEnvironments) as Environment[]).find(
-              (env) => env.chainId === chainId,
-            ),
-          )
-          .filter((xcEnvironment) => !!xcEnvironment)
-          .filter(
-            (xcEnvironment) =>
-              xcEnvironment!.custom?.wormhole?.chainId &&
-              xcEnvironment!.contracts.voteCollector,
-          );
-
-        const [xcCount, xcQuorum] = await Promise.all([
-          params.environment.contracts.multichainGovernor.read.proposalCount(),
-          params.environment.contracts.multichainGovernor.read.quorum(),
-        ]);
-
-        if (params.id) {
-          params.id =
-            Number(params.id) -
-            (params.environment.custom?.governance?.proposalIdOffset || 0);
-
-          if (params.id < 0) return [];
-          if (BigInt(params.id) > xcCount) return [];
-        }
-
-        const ids = params.id
-          ? [BigInt(params.id)]
-          : Array.from(
-              { length: Number(xcCount) },
-              (_, i) => xcCount - BigInt(i),
-            );
-
-        const xcProposalsDataCall = Promise.all(
-          ids.map((id) =>
-            params.environment.contracts.multichainGovernor?.read.proposals([
-              id,
-            ]),
-          ),
-        );
-
-        const xcProposalsStateCall = Promise.all(
-          ids.map((id) =>
-            params.environment.contracts.multichainGovernor?.read.state([id]),
-          ),
-        );
-
-        const xcVotesCall = Promise.all(
-          xcEnvironments.map((xcEnvironment) =>
-            Promise.all(
-              ids.map((id) =>
-                params.environment.contracts.multichainGovernor?.read.chainVoteCollectorVotes(
-                  [(xcEnvironment!.custom as any).wormhole.chainId, id],
-                ),
-              ),
-            ),
-          ),
-        );
-
-        const [xcProposalsData, xcProposalsState, xcVotes] = await Promise.all([
-          xcProposalsDataCall,
-          xcProposalsStateCall,
-          xcVotesCall,
-        ]);
-
-        const proposals = ids.map((xcId, proposalIndex: number) => {
-          const state = xcProposalsState?.[proposalIndex]!;
-          const id =
-            Number(xcId) +
-            (params.environment.custom?.governance?.proposalIdOffset || 0);
-
-          const votesCollected = false;
-
-          const votes = xcVotes.reduce(
-            (prevVotes, currVotes) => {
-              const voteData = currVotes[proposalIndex];
-              if (!voteData) {
-                return prevVotes;
-              }
-
-              // chainVoteCollectorVotes returns [forVotes, againstVotes, abstainVotes]
-              const forVotes = voteData[0] || 0n;
-              const againstVotes = voteData[1] || 0n;
-              const abstainVotes = voteData[2] || 0n;
-              const totalVotes = forVotes + againstVotes + abstainVotes;
-
-              return {
-                totalVotes: prevVotes.totalVotes + totalVotes,
-                forVotes: prevVotes.forVotes + forVotes,
-                againstVotes: prevVotes.againstVotes + againstVotes,
-                abstainVotes: prevVotes.abstainVotes + abstainVotes,
-              };
-            },
-            {
-              totalVotes: 0n,
-              forVotes: 0n,
-              againstVotes: 0n,
-              abstainVotes: 0n,
-            },
-          );
-
-          const proposalData = xcProposalsData?.[proposalIndex];
-          if (!proposalData) {
-            throw new Error(
-              `Proposal data not found for index ${proposalIndex}`,
-            );
-          }
-
-          const [
-            proposer,
-            _voteSnapshotTimestamp,
-            votingStartTime,
-            votingEndTime,
-            crossChainVoteCollectionEndTimestamp,
-            voteSnapshotBlock,
-            proposalForVotes,
-            proposalAgainstVotes,
-            proposalAbstainVotes,
-            proposalTotalVotes,
-            canceled,
-            executed,
-          ] = proposalData;
-
-          const multichainState = (
-            MultichainProposalStateMapping as { [key: number]: ProposalState }
-          )[state]!;
-
-          const proposal: Proposal = {
-            chainId: params.environment.chainId,
-            id,
-            proposalId: Number(xcId),
-            proposer,
-            eta: Number(crossChainVoteCollectionEndTimestamp),
-            startTimestamp: Number(votingStartTime),
-            endTimestamp: Number(votingEndTime),
-            startBlock: Number(voteSnapshotBlock),
-            forVotes: new Amount(proposalForVotes + votes.forVotes, 18),
-            againstVotes: new Amount(
-              proposalAgainstVotes + votes.againstVotes,
-              18,
-            ),
-            abstainVotes: new Amount(
-              proposalAbstainVotes + votes.abstainVotes,
-              18,
-            ),
-            totalVotes: new Amount(proposalTotalVotes + votes.totalVotes, 18),
-            canceled,
-            executed,
-            quorum: new Amount(xcQuorum, 18),
-            state: multichainState,
-            multichain: {
-              id: Number(xcId),
-              votesCollected,
-            },
-          };
-
-          return proposal;
-        });
-
-        return proposals;
-      } else {
-        return [];
-      }
-    } else {
-      return [];
-    }
-  } catch (error) {
-    console.warn(
-      `[getCrossChainProposalData] RPC failed for chain ${params.environment.chainId}:`,
-      error,
-    );
-    params.environment.onError?.(error, {
-      source: "governance-proposals",
-      chainId: params.environment.chainId,
-    });
-    return [];
-  }
-};
-
-export const appendProposalExtendedData = (
-  proposals: Proposal[],
-  extendedDatas: PonderExtendedProposalData[],
-) => {
-  proposals.forEach((proposal) => {
-    const extendedData = extendedDatas.find(
-      (item) => item.id === proposal.proposalId,
-    );
-
-    if (extendedData) {
-      proposal.title = extendedData.title;
-      proposal.calldatas = extendedData.calldatas;
-      proposal.description = extendedData.description;
-      proposal.signatures = extendedData.signatures;
-      proposal.stateChanges = extendedData.stateChanges.map((change) => ({
-        blockNumber: change.blockNumber,
-        transactionHash: change.transactionHash,
-        state: change.state,
-        chainId: proposal.chainId,
-      }));
-      proposal.subtitle = extendedData.subtitle;
-      proposal.targets = extendedData.targets;
-    }
-  });
-};
-
-export const getExtendedProposalData = async (params: {
-  environment: Environment;
-  id?: number;
-}): Promise<PonderExtendedProposalData[]> => {
-  const result: PonderExtendedProposalData[] = [];
-  let lastId = -1;
-  let shouldContinue = true;
-  const MAX_PAGES = 100;
-  let page = 0;
-
-  try {
-    while (shouldContinue && page < MAX_PAGES) {
-      page++;
-      const response = await postWithRetry<{
-        data: {
-          proposals: {
-            items: {
-              proposalId: number;
-              description: string;
-              targets: string[];
-              calldatas: string[];
-              signatures: string[];
-              stateChanges: {
-                items: {
-                  txnHash: string;
-                  blockNumber: number;
-                  newState: string;
-                }[];
-              };
-            }[];
-          };
-        };
-      }>("https://ponder-eu2.moonwell.fi", {
-        query: `
-            query {
-              proposals(
-                limit: 1000,
-                orderDirection: "desc",
-                orderBy: "proposalId",
-                where: {
-                  chainId: ${params.environment.chainId}
-                  ${params.id ? `, proposalId: ${params.id}` : lastId >= 0 ? `, proposalId_lt: ${lastId}` : ""}
-                }
-              ) {
-                items {
-                  id
-                  proposalId
-                  description
-                  targets
-                  calldatas
-                  signatures
-                  stateChanges(orderBy: "blockNumber") {
-                    items {
-                      txnHash
-                      blockNumber
-                      newState
-                    }
-                  }
-                }
-              }
-            }
-          `,
-      });
-
-      if (response.status === 200 && response.data?.data?.proposals) {
-        const proposals = response.data.data.proposals.items.map((item) => {
-          const extendedProposalData: PonderExtendedProposalData = {
-            id: item.proposalId,
-            title: `Proposal #${item.proposalId}`,
-            subtitle: extractProposalSubtitle(item.description),
-            description: item.description,
-            calldatas: item.calldatas,
-            signatures: item.signatures,
-            stateChanges: item.stateChanges.items.map((change) => {
-              return {
-                blockNumber: change.blockNumber,
-                state: change.newState,
-                transactionHash: change.txnHash,
-              };
-            }),
-            targets: item.targets,
-          };
-
-          return extendedProposalData;
-        });
-
-        if (proposals.length < 1000 || proposals.length === 0) {
-          shouldContinue = false;
-        } else {
-          lastId = last(proposals)!.id;
-        }
-
-        result.push(...proposals);
-      } else {
-        shouldContinue = false;
-      }
-    }
-  } catch (error) {
-    console.warn(
-      `[getExtendedProposalData] Ponder failed for chain ${params.environment.chainId}:`,
-      error,
-    );
-    params.environment.onError?.(error, {
-      source: "governance-proposals",
-      chainId: params.environment.chainId,
-    });
-    return result;
-  }
-
-  return result;
-};

package/actions/governance/proposals/getProposal.ts

@@ -6,17 +6,13 @@ import type { Chain, Environment } from "../../../environments/index.js";
 import { type Proposal, ProposalState } from "../../../types/proposal.js";
 import {
   type ApiProposal,
-  SUPPORTED_GOVERNOR_CHAIN_IDS,
+  MULTIGOV_PROPOSAL_FALLBACK_CHAIN_IDS,
   fetchProposal,
   isNotFoundError,
 } from "../governor-api-client.js";
 import { resolveIpfsDescriptions } from "../ipfs.js";
 import {
-  appendProposalExtendedData,
   formatApiProposalData,
-  getCrossChainProposalData,
-  getExtendedProposalData,
-  getProposalData,
   getProposalsOnChainData,
   readCrossChainQuorums,
 } from "./common.js";
@@ -28,7 +24,8 @@ export type GetProposalParameters<
   proposalId: number;
   /**
    * The chain the proposal lives on (1 = Ethereum multigov,
-   * 1284 = Moonbeam historical). When omitted, both are tried in turn.
+   * 1284 = Moonbeam historical, 1285 = Moonriver legacy). When omitted, the
+   * supported chains are tried in turn.
    */
   chainId?: number;
 };
@@ -51,7 +48,7 @@ export async function getProposal<
 
   // Ethereum-home multigov proposals are served by the same Governor API as
   // historical Moonbeam ones (the lunar indexer fans out both chainIds), so
-  // route them through `getMoonbeamProposal` using the Moonbeam env as the
+  // route them through `getGovernorApiProposal` using the Moonbeam env as the
   // indexer source. Without this, a caller resolving the env by `chainId: 1`
   // would bail out on the `!moonbeam && !moonriver` check below and the page
   // reload path returns undefined.
@@ -62,7 +59,7 @@ export async function getProposal<
     if (!moonbeamEnv) {
       return undefined;
     }
-    return getMoonbeamProposal(
+    return getGovernorApiProposal(
       moonbeamEnv,
       proposalId,
       args.chainId ?? mainnet.id,
@@ -77,25 +74,29 @@ export async function getProposal<
   }
 
   if (environment.chainId === moonbeam.id) {
-    return getMoonbeamProposal(environment, proposalId, args.chainId);
+    return getGovernorApiProposal(environment, proposalId, args.chainId);
   }
-  return getMoonriverProposal(environment, proposalId);
+  return getGovernorApiProposal(environment, proposalId, moonriver.id);
 }
 
 /**
- * Fetch a single proposal for Moonbeam using the Governor API.
+ * Fetch a single proposal from the Governor API (Moonbeam/Ethereum multigov or
+ * Moonriver legacy governor).
  *
  * When `chainId` is provided we hit only that chain. When omitted we try the
- * supported chains in order (Ethereum first since that's where active multigov
- * proposals live) and fall back on `NotFoundError`. Real outages (5xx, network
- * errors) propagate so callers can distinguish "missing" from "broken".
+ * multigov chains in order (Ethereum first since that's where active multigov
+ * proposals live) and fall back on `NotFoundError`. Moonriver (1285) is
+ * deliberately absent from the fallback — it has its own explicit route, and a
+ * bare lookup resolving to it through a non-Moonriver env would be degraded.
+ * Real outages (5xx, network errors) propagate so callers can distinguish
+ * "missing" from "broken".
  */
-async function getMoonbeamProposal(
+async function getGovernorApiProposal(
   governanceEnvironment: Environment,
   proposalId: number,
   chainId?: number,
 ): Promise<Proposal | undefined> {
-  const tryChains = chainId ? [chainId] : SUPPORTED_GOVERNOR_CHAIN_IDS;
+  const tryChains = chainId ? [chainId] : MULTIGOV_PROPOSAL_FALLBACK_CHAIN_IDS;
 
   let apiProposal: ApiProposal | undefined;
   for (const cid of tryChains) {
@@ -180,11 +181,18 @@ async function getMoonbeamProposal(
     description: apiProposal.description,
     targets: apiProposal.targets,
     calldatas: apiProposal.calldatas,
-    signatures: [],
+    // Legacy-governor proposals (Moonriver, early Moonbeam) carry the function
+    // signature separately from the selector-less calldata; pass it through so
+    // consumers can decode the call. Empty for multichain-governor proposals.
+    signatures: apiProposal.signatures ?? [],
     stateChanges: formattedData.stateChanges,
     environment: governanceEnvironment,
   };
 
+  if (apiProposal.snapshotBlocks) {
+    proposal.snapshotBlocks = apiProposal.snapshotBlocks;
+  }
+
   if (isMultichain) {
     proposal.multichain = {
       id: apiProposal.proposalId,
@@ -194,35 +202,3 @@ async function getMoonbeamProposal(
 
   return proposal;
 }
-
-/**
- * Fetch a single proposal for Moonriver using the old Ponder-based approach
- */
-async function getMoonriverProposal(
-  governanceEnvironment: Environment,
-  proposalId: number,
-): Promise<Proposal | undefined> {
-  const [_proposals, _xcProposals, _extendedDatas] = await Promise.all([
-    getProposalData({ environment: governanceEnvironment, id: proposalId }),
-    getCrossChainProposalData({
-      environment: governanceEnvironment,
-      id: proposalId,
-    }),
-    getExtendedProposalData({
-      environment: governanceEnvironment,
-      id: proposalId,
-    }),
-  ]);
-
-  const proposals = [..._proposals, ..._xcProposals];
-
-  proposals.forEach((proposal) => {
-    proposal.environment = governanceEnvironment;
-  });
-
-  appendProposalExtendedData(proposals, _extendedDatas);
-
-  return proposals.find(
-    (p) => p.proposalId === proposalId || p.id === proposalId,
-  );
-}