@moonwell-fi/moonwell-sdk 0.20.3 → 0.20.4

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,
-  );
-}

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.4'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@moonwell-fi/moonwell-sdk",
   "description": "TypeScript Interface for Moonwell",
-  "version": "0.20.3",
+  "version": "0.20.4",
   "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;