@moonwell-fi/moonwell-sdk 0.20.3 → 0.20.5

package/actions/governance/proposals/getProposals.ts

@@ -8,11 +8,7 @@ import { type Proposal, ProposalState } from "../../../types/proposal.js";
 import { type ApiProposal, fetchAllProposals } from "../governor-api-client.js";
 import { resolveIpfsDescriptions } from "../ipfs.js";
 import {
-  appendProposalExtendedData,
   formatApiProposalData,
-  getCrossChainProposalData,
-  getExtendedProposalData,
-  getProposalData,
   getProposalsOnChainData,
   readCrossChainQuorums,
 } from "./common.js";
@@ -49,10 +45,10 @@ export async function getProposals<
   const allProposals = await Promise.all(
     governanceEnvironments.map(async (governanceEnvironment) => {
       if (governanceEnvironment.chainId === moonbeam.id) {
-        // Moonbeam: Use new Governor API
+        // Moonbeam + Ethereum: Governor API (chainIds 1 and 1284)
         return getMoonbeamProposals(governanceEnvironment);
       } else {
-        // Moonriver: Use old Ponder approach
+        // Moonriver: Governor API, single legacy governor (chainId 1285)
         return getMoonriverProposals(governanceEnvironment);
       }
     }),
@@ -109,6 +105,53 @@ async function getMoonbeamProposals(
     }
   });
 
+  return buildProposals(apiProposals, governanceEnvironment);
+}
+
+/**
+ * Fetch proposals for Moonriver using the Governor API.
+ *
+ * Moonriver runs a single legacy standalone governor (no multichain governor),
+ * so we fetch only its chainId from the same lunar indexer and reuse the shared
+ * pipeline. `getProposalsOnChainData` classifies these as non-multichain and
+ * reads state/quorum from the legacy governor (via `getQuorum`).
+ */
+async function getMoonriverProposals(
+  governanceEnvironment: Environment,
+): Promise<Proposal[]> {
+  // Moonriver is a single chain, so there's no other chain to "continue with"
+  // like the Moonbeam fan-out — but a bare throw would reject the whole
+  // `Promise.all` in getProposals and drop Moonbeam/Ethereum results too. Mirror
+  // the per-chain handling getMoonbeamProposals uses: report the outage via
+  // onError and degrade to an empty Moonriver list instead of rejecting.
+  let apiProposals: ApiProposal[] = [];
+  try {
+    apiProposals = await fetchAllProposals(governanceEnvironment, {
+      chainId: moonriver.id,
+    });
+  } catch (reason) {
+    console.warn(
+      `[getProposals] Failed to fetch proposals for chainId=${moonriver.id}; continuing with an empty Moonriver list.`,
+      reason,
+    );
+    governanceEnvironment.onError?.(reason, {
+      source: "governance-proposals",
+      chainId: moonriver.id,
+    });
+  }
+  return buildProposals(apiProposals, governanceEnvironment);
+}
+
+/**
+ * Shared Governor-API pipeline: resolve IPFS descriptions + cross-chain quorums
+ * in parallel, read on-chain data, then map each ApiProposal to a Proposal.
+ * Used by both the Moonbeam/Ethereum and Moonriver paths so the mapping stays
+ * in one place.
+ */
+async function buildProposals(
+  apiProposals: ApiProposal[],
+  governanceEnvironment: Environment,
+): Promise<Proposal[]> {
   // IPFS resolution and cross-chain quorum reads are independent — run them in
   // parallel to save one network round-trip on the proposal list path.
   const [, crossChainQuorums] = await Promise.all([
@@ -180,11 +223,18 @@ async function getMoonbeamProposals(
       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,
@@ -197,26 +247,3 @@ async function getMoonbeamProposals(
 
   return proposals;
 }
-
-/**
- * Fetch proposals for Moonriver using the old Ponder-based approach
- */
-async function getMoonriverProposals(
-  governanceEnvironment: Environment,
-): Promise<Proposal[]> {
-  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;
-}

package/errors/version.ts

@@ -1 +1 @@
-export const version = '0.20.3'
+export const version = '0.20.5'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@moonwell-fi/moonwell-sdk",
   "description": "TypeScript Interface for Moonwell",
-  "version": "0.20.3",
+  "version": "0.20.5",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",

package/types/proposal.ts

@@ -23,6 +23,17 @@ export type Proposal = {
     id: number;
     votesCollected: boolean;
   };
+  /**
+   * Authoritative per-chain voting-power snapshot blocks resolved by the
+   * lunar-indexer, keyed by chain name (`mainnet` → 1, `base` → 8453,
+   * `optimism` → 10, `moonbeam` → 1284). Block numbers are decimal strings.
+   *
+   * Present on indexer-sourced multichain proposals; absent for older
+   * proposals indexed before the field existed and for on-chain (Moonriver)
+   * proposals. Consumers reading voting power should prefer these blocks over
+   * resolving the snapshot timestamp to a block client-side.
+   */
+  snapshotBlocks?: Record<string, string>;
   //proposal extended data
   title?: string;
   subtitle?: string;