@moonwell-fi/moonwell-sdk 0.21.0 → 0.23.0

package/actions/core/markets/common.ts

@@ -459,6 +459,29 @@ async function getMarketsFromMTokenFallback(
   return markets;
 }
 
+/**
+ * Parse a numeric field from a Lunar record, rejecting `NaN`.
+ *
+ * `Number()` wrapping is defensive — Lunar may return numeric fields as strings
+ * — but a missing or non-numeric field yields `NaN`, and only the fields that go
+ * on to reach `BigInt()` fail loudly. The rest (USD totals, prices, caps, APYs)
+ * flowed into `Market` as `NaN` and silently poisoned every downstream
+ * aggregate: a single bad `totalSupplyUsd` turns a chain's summed TVL into
+ * `NaN`. Throwing puts both field classes on the same record-level guard, so a
+ * dropped field costs its record and is reported, instead of returning a market
+ * with holes in it. Names the field, which `BigInt()`'s bare "NaN cannot be
+ * converted to a BigInt" never did.
+ */
+const toLunarNumber = (value: unknown, field: string): number => {
+  const parsed = Number(value);
+  if (Number.isNaN(parsed)) {
+    throw new Error(
+      `Lunar field "${field}" is not a number (received ${JSON.stringify(value)})`,
+    );
+  }
+  return parsed;
+};
+
 /**
  * Fetch markets data from Lunar Indexer (hybrid approach)
  *
@@ -525,6 +548,8 @@ async function fetchMarketsFromLunar(
   }
 
   const markets: Market[] = [];
+  let malformedCount = 0;
+  let malformedIncentiveCount = 0;
 
   for (const lunarMarket of lunarMarkets) {
     const marketFound = findMarketByAddress(
@@ -539,196 +564,312 @@ async function fetchMarketsFromLunar(
     const { marketConfig, marketToken, underlyingToken, marketKey } =
       marketFound;
 
-    // Transform Lunar decimal numbers to SDK Amount types
-    // Note: Number() wrapping is defensive — the Lunar API may return numeric
-    // fields as strings, which would break BigInt conversion via Math.floor.
-    const totalSupply = new Amount(
-      BigInt(
-        Math.floor(
-          Number(lunarMarket.totalSupply) * 10 ** underlyingToken.decimals,
+    // A malformed record must not reject the whole chain's market list:
+    // `BigInt()` throws a RangeError on NaN (a missing numeric field), and one
+    // bad record previously took down every market on the chain — observed
+    // chain-wide on the sunset Moonbeam deployment after the indexer stopped
+    // backfilling it (MOONWELL-FRONTEND-12J). Skip the record instead; the
+    // all-malformed case still throws below so `getMarketsData` keeps its
+    // on-chain fallback. `toLunarNumber` routes the fields that never reach
+    // `BigInt()` into this same guard, so a dropped field can't leave `NaN` in a
+    // returned market either.
+    try {
+      // Transform Lunar decimal numbers to SDK Amount types. `toLunarNumber`
+      // absorbs the string-encoded numbers Lunar may return, and rejects the
+      // `NaN` a dropped field produces — see its docblock for why the fields
+      // that never reach `BigInt()` need the same guard.
+      const totalSupply = new Amount(
+        BigInt(
+          Math.floor(
+            toLunarNumber(lunarMarket.totalSupply, "totalSupply") *
+              10 ** underlyingToken.decimals,
+          ),
         ),
-      ),
-      underlyingToken.decimals,
-    );
+        underlyingToken.decimals,
+      );
 
-    const totalBorrows = new Amount(
-      BigInt(
-        Math.floor(
-          Number(lunarMarket.totalBorrows) * 10 ** underlyingToken.decimals,
+      const totalBorrows = new Amount(
+        BigInt(
+          Math.floor(
+            toLunarNumber(lunarMarket.totalBorrows, "totalBorrows") *
+              10 ** underlyingToken.decimals,
+          ),
         ),
-      ),
-      underlyingToken.decimals,
-    );
+        underlyingToken.decimals,
+      );
 
-    const totalReserves = new Amount(
-      BigInt(
-        Math.floor(
-          Number(lunarMarket.totalReserves) * 10 ** underlyingToken.decimals,
+      const totalReserves = new Amount(
+        BigInt(
+          Math.floor(
+            toLunarNumber(lunarMarket.totalReserves, "totalReserves") *
+              10 ** underlyingToken.decimals,
+          ),
         ),
-      ),
-      underlyingToken.decimals,
-    );
+        underlyingToken.decimals,
+      );
 
-    const cash = new Amount(
-      BigInt(
-        Math.floor(Number(lunarMarket.cash) * 10 ** underlyingToken.decimals),
-      ),
-      underlyingToken.decimals,
-    );
+      const cash = new Amount(
+        BigInt(
+          Math.floor(
+            toLunarNumber(lunarMarket.cash, "cash") *
+              10 ** underlyingToken.decimals,
+          ),
+        ),
+        underlyingToken.decimals,
+      );
 
-    const badDebt = new Amount(
-      BigInt(
-        Math.floor(
-          Number(lunarMarket.badDebt) * 10 ** underlyingToken.decimals,
+      const badDebt = new Amount(
+        BigInt(
+          Math.floor(
+            toLunarNumber(lunarMarket.badDebt, "badDebt") *
+              10 ** underlyingToken.decimals,
+          ),
         ),
-      ),
-      underlyingToken.decimals,
-    );
+        underlyingToken.decimals,
+      );
 
-    const supplyCaps = new Amount(
-      BigInt(
-        Math.floor(
-          Number(lunarMarket.supplyCap) * 10 ** underlyingToken.decimals,
+      const supplyCaps = new Amount(
+        BigInt(
+          Math.floor(
+            toLunarNumber(lunarMarket.supplyCap, "supplyCap") *
+              10 ** underlyingToken.decimals,
+          ),
         ),
-      ),
-      underlyingToken.decimals,
-    );
+        underlyingToken.decimals,
+      );
 
-    const borrowCaps = new Amount(
-      BigInt(
-        Math.floor(
-          Number(lunarMarket.borrowCap) * 10 ** underlyingToken.decimals,
+      const borrowCaps = new Amount(
+        BigInt(
+          Math.floor(
+            toLunarNumber(lunarMarket.borrowCap, "borrowCap") *
+              10 ** underlyingToken.decimals,
+          ),
         ),
-      ),
-      underlyingToken.decimals,
-    );
+        underlyingToken.decimals,
+      );
 
-    // Lunar provides reserveFactor as wei string, convert to decimal
-    const reserveFactor = new Amount(BigInt(lunarMarket.reserveFactor), 18)
-      .value;
+      // Lunar provides reserveFactor as wei string, convert to decimal
+      const reserveFactor = new Amount(BigInt(lunarMarket.reserveFactor), 18)
+        .value;
 
-    const market: Market = {
-      marketKey,
-      chainId: environment.chainId,
-      seizePaused: lunarMarket.seizePaused,
-      transferPaused: lunarMarket.transferPaused,
-      mintPaused: lunarMarket.mintPaused,
-      borrowPaused: lunarMarket.borrowPaused,
-      deprecated: marketConfig.deprecated === true,
-      borrowCaps,
-      borrowCapsUsd:
-        Number(lunarMarket.borrowCap) * Number(lunarMarket.priceUsd),
-      cash,
-      collateralFactor: Number(lunarMarket.collateralFactor),
-      exchangeRate: Number(lunarMarket.exchangeRate),
-      marketToken,
-      reserveFactor,
-      supplyCaps,
-      supplyCapsUsd:
-        Number(lunarMarket.supplyCap) * Number(lunarMarket.priceUsd),
-      badDebt,
-      badDebtUsd: Number(lunarMarket.badDebtUsd),
-      totalBorrows,
-      totalBorrowsUsd: Number(lunarMarket.totalBorrowsUsd),
-      totalReserves,
-      totalReservesUsd: Number(lunarMarket.totalReservesUsd),
-      totalSupply,
-      totalSupplyUsd: Number(lunarMarket.totalSupplyUsd),
-      underlyingPrice: Number(lunarMarket.priceUsd),
-      underlyingToken,
-      baseBorrowApy: Number(lunarMarket.baseBorrowApy),
-      baseSupplyApy: Number(lunarMarket.baseSupplyApy),
-      totalBorrowApr: 0,
-      totalSupplyApr: 0,
-      rewards: [],
-    };
+      const market: Market = {
+        marketKey,
+        chainId: environment.chainId,
+        seizePaused: lunarMarket.seizePaused,
+        transferPaused: lunarMarket.transferPaused,
+        mintPaused: lunarMarket.mintPaused,
+        borrowPaused: lunarMarket.borrowPaused,
+        deprecated: marketConfig.deprecated === true,
+        borrowCaps,
+        borrowCapsUsd:
+          toLunarNumber(lunarMarket.borrowCap, "borrowCap") *
+          toLunarNumber(lunarMarket.priceUsd, "priceUsd"),
+        cash,
+        collateralFactor: toLunarNumber(
+          lunarMarket.collateralFactor,
+          "collateralFactor",
+        ),
+        exchangeRate: toLunarNumber(lunarMarket.exchangeRate, "exchangeRate"),
+        marketToken,
+        reserveFactor,
+        supplyCaps,
+        supplyCapsUsd:
+          toLunarNumber(lunarMarket.supplyCap, "supplyCap") *
+          toLunarNumber(lunarMarket.priceUsd, "priceUsd"),
+        badDebt,
+        badDebtUsd: toLunarNumber(lunarMarket.badDebtUsd, "badDebtUsd"),
+        totalBorrows,
+        totalBorrowsUsd: toLunarNumber(
+          lunarMarket.totalBorrowsUsd,
+          "totalBorrowsUsd",
+        ),
+        totalReserves,
+        totalReservesUsd: toLunarNumber(
+          lunarMarket.totalReservesUsd,
+          "totalReservesUsd",
+        ),
+        totalSupply,
+        totalSupplyUsd: toLunarNumber(
+          lunarMarket.totalSupplyUsd,
+          "totalSupplyUsd",
+        ),
+        underlyingPrice: toLunarNumber(lunarMarket.priceUsd, "priceUsd"),
+        underlyingToken,
+        baseBorrowApy: toLunarNumber(
+          lunarMarket.baseBorrowApy,
+          "baseBorrowApy",
+        ),
+        baseSupplyApy: toLunarNumber(
+          lunarMarket.baseSupplyApy,
+          "baseSupplyApy",
+        ),
+        totalBorrowApr: 0,
+        totalSupplyApr: 0,
+        rewards: [],
+      };
 
-    for (const incentive of lunarMarket.incentives) {
-      const token = findTokenByAddress(
-        environment,
-        incentive.token as `0x${string}`,
-      );
-      if (!token) {
-        continue;
-      }
+      for (const incentive of lunarMarket.incentives) {
+        // A malformed incentive costs its own reward entry, not the market.
+        // `BigInt()` runs on three reward fields below, so a rewards-only
+        // indexer incident would otherwise throw out to the record-level catch
+        // and drop an otherwise-valid market — the same blast radius this fix
+        // set out to shrink, one level down. Matches the loop's existing
+        // skip-the-unusable-entry idiom (`if (!token) continue`).
+        try {
+          const token = findTokenByAddress(
+            environment,
+            incentive.token as `0x${string}`,
+          );
+          if (!token) {
+            continue;
+          }
 
-      let supplyApr: number;
-      let borrowApr: number;
-
-      // On-chain contracts use borrowIncentivesPerSec=1 (1 wei) as a
-      // placeholder when there are no active borrow incentives, because
-      // setting it to 0 triggers a known smart contract bug. Treat as zero.
-      const isBorrowPlaceholder =
-        BigInt(incentive.borrowIncentivesPerSec) === 1n;
-
-      if (
-        incentive.priceUsd !== null &&
-        incentive.supplyApr !== null &&
-        incentive.borrowApr !== null
-      ) {
-        supplyApr = Number(incentive.supplyApr);
-        borrowApr = isBorrowPlaceholder ? 0 : -Number(incentive.borrowApr);
-      } else {
-        const isGovernanceToken =
-          token.symbol === environment.custom?.governance?.token;
-        const isNativeToken = token.address === zeroAddress;
-
-        const price = isNativeToken
-          ? nativeTokenPrice?.value
-          : isGovernanceToken
-            ? governanceTokenPrice?.value
-            : undefined;
-
-        if (!price) {
-          continue;
-        }
+          let supplyApr: number;
+          let borrowApr: number;
+
+          // On-chain contracts use borrowIncentivesPerSec=1 (1 wei) as a
+          // placeholder when there are no active borrow incentives, because
+          // setting it to 0 triggers a known smart contract bug. Treat as zero.
+          const isBorrowPlaceholder =
+            BigInt(incentive.borrowIncentivesPerSec) === 1n;
+
+          if (
+            incentive.priceUsd !== null &&
+            incentive.supplyApr !== null &&
+            incentive.borrowApr !== null
+          ) {
+            supplyApr = toLunarNumber(
+              incentive.supplyApr,
+              "incentive.supplyApr",
+            );
+            borrowApr = isBorrowPlaceholder
+              ? 0
+              : -toLunarNumber(incentive.borrowApr, "incentive.borrowApr");
+          } else {
+            const isGovernanceToken =
+              token.symbol === environment.custom?.governance?.token;
+            const isNativeToken = token.address === zeroAddress;
+
+            const price = isNativeToken
+              ? nativeTokenPrice?.value
+              : isGovernanceToken
+                ? governanceTokenPrice?.value
+                : undefined;
+
+            if (!price) {
+              continue;
+            }
+
+            const borrowIncentivesPerSec = isBorrowPlaceholder
+              ? 0n
+              : BigInt(incentive.borrowIncentivesPerSec);
+            const supplyIncentivesPerSec = BigInt(
+              incentive.supplyIncentivesPerSec,
+            );
 
-        const borrowIncentivesPerSec = isBorrowPlaceholder
-          ? 0n
-          : BigInt(incentive.borrowIncentivesPerSec);
-        const supplyIncentivesPerSec = BigInt(incentive.supplyIncentivesPerSec);
-
-        const supplyRewardsPerDayUsd =
-          perDay(new Amount(supplyIncentivesPerSec, token.decimals).value) *
-          price;
-        const borrowRewardsPerDayUsd =
-          perDay(new Amount(borrowIncentivesPerSec, token.decimals).value) *
-          price;
-
-        supplyApr =
-          Number(lunarMarket.totalSupplyUsd) === 0
-            ? 0
-            : (supplyRewardsPerDayUsd / Number(lunarMarket.totalSupplyUsd)) *
-              DAYS_PER_YEAR *
-              100;
-        // Negative: borrow reward APR reduces the effective borrowing cost
-        borrowApr =
-          Number(lunarMarket.totalBorrowsUsd) === 0
-            ? 0
-            : (borrowRewardsPerDayUsd / Number(lunarMarket.totalBorrowsUsd)) *
-              DAYS_PER_YEAR *
-              100 *
-              -1;
+            const supplyRewardsPerDayUsd =
+              perDay(new Amount(supplyIncentivesPerSec, token.decimals).value) *
+              price;
+            const borrowRewardsPerDayUsd =
+              perDay(new Amount(borrowIncentivesPerSec, token.decimals).value) *
+              price;
+
+            supplyApr =
+              toLunarNumber(lunarMarket.totalSupplyUsd, "totalSupplyUsd") === 0
+                ? 0
+                : (supplyRewardsPerDayUsd /
+                    toLunarNumber(
+                      lunarMarket.totalSupplyUsd,
+                      "totalSupplyUsd",
+                    )) *
+                  DAYS_PER_YEAR *
+                  100;
+            // Negative: borrow reward APR reduces the effective borrowing cost
+            borrowApr =
+              toLunarNumber(lunarMarket.totalBorrowsUsd, "totalBorrowsUsd") ===
+              0
+                ? 0
+                : (borrowRewardsPerDayUsd /
+                    toLunarNumber(
+                      lunarMarket.totalBorrowsUsd,
+                      "totalBorrowsUsd",
+                    )) *
+                  DAYS_PER_YEAR *
+                  100 *
+                  -1;
+          }
+
+          market.rewards.push({
+            liquidStakingApr: 0,
+            borrowApr,
+            supplyApr,
+            token,
+          });
+        } catch (error) {
+          malformedIncentiveCount++;
+          console.warn(
+            `[fetchMarketsFromLunar] Skipping malformed incentive ${incentive.token} on market ${lunarMarket.address} (chain ${environment.chainId}):`,
+            error,
+          );
+        }
       }
 
-      market.rewards.push({
-        liquidStakingApr: 0,
-        borrowApr,
-        supplyApr,
-        token,
-      });
+      market.totalSupplyApr = market.rewards.reduce(
+        (prev, curr) => prev + curr.supplyApr,
+        market.baseSupplyApy,
+      );
+      market.totalBorrowApr = market.rewards.reduce(
+        (prev, curr) => prev + curr.borrowApr,
+        market.baseBorrowApy,
+      );
+
+      markets.push(market);
+    } catch (error) {
+      malformedCount++;
+      console.warn(
+        `[fetchMarketsFromLunar] Skipping malformed market ${lunarMarket.address} on chain ${environment.chainId}:`,
+        error,
+      );
     }
+  }
 
-    market.totalSupplyApr = market.rewards.reduce(
-      (prev, curr) => prev + curr.supplyApr,
-      market.baseSupplyApy,
+  // Every matched record was malformed — the indexer's data for this chain is
+  // unusable, so surface it to the caller's catch (one meaningful onError +
+  // on-chain fallback) instead of silently returning an empty market list.
+  if (malformedCount > 0 && markets.length === 0) {
+    throw new Error(
+      `Lunar Indexer returned only malformed market records for chain ${environment.chainId} (${malformedCount} skipped)`,
     );
-    market.totalBorrowApr = market.rewards.reduce(
-      (prev, curr) => prev + curr.borrowApr,
-      market.baseBorrowApy,
+  }
+
+  // A partial incident is the likeliest shape, and it is the one that returns
+  // successfully — without this, markets vanishing from the response would
+  // leave nothing behind but a console line, making the incident class this fix
+  // exists for (MOONWELL-FRONTEND-12J) invisible rather than visible. Distinct
+  // `source` values so a degraded result is attributable separately from the
+  // total failure that routes through `getMarketsData`'s own "markets" source.
+  if (malformedCount > 0) {
+    environment.onError?.(
+      new Error(
+        `Lunar Indexer returned ${malformedCount} malformed market record(s) for chain ${environment.chainId}; those markets were skipped (${markets.length} returned)`,
+      ),
+      {
+        source: "markets-malformed-records",
+        chainId: environment.chainId,
+      },
     );
+  }
 
-    markets.push(market);
+  if (malformedIncentiveCount > 0) {
+    environment.onError?.(
+      new Error(
+        `Lunar Indexer returned ${malformedIncentiveCount} malformed incentive record(s) for chain ${environment.chainId}; those rewards were skipped`,
+      ),
+      {
+        source: "markets-malformed-incentives",
+        chainId: environment.chainId,
+      },
+    );
   }
 
   return markets;

package/actions/governance/getDelegates.ts

@@ -1,5 +1,5 @@
 import { isAddress } from "viem";
-import { base, mainnet, moonbeam, optimism } from "viem/chains";
+import { base, mainnet, optimism } from "viem/chains";
 import type { MoonwellClient } from "../../client/createMoonwellClient.js";
 import {
   type Environment,
@@ -23,17 +23,17 @@ export async function getDelegates(
 ): GetDelegatesReturnType {
   const logId = logger.start("getDelegates", "Starting to get delegates...");
 
-  const governanceEnvironment = publicEnvironments.moonbeam;
+  // Any environment resolves the same `governanceIndexerUrl`; the Ethereum hub
+  // replaces Moonbeam here now that the sunset chain is gone (MOO-551).
+  const governanceEnvironment = publicEnvironments.ethereum;
 
   const apiVoters = await fetchAllVoters(governanceEnvironment);
   const forumProfiles = await getForumProfiles();
 
-  const targetChainIds = [
-    moonbeam.id,
-    base.id,
-    optimism.id,
-    mainnet.id,
-  ] as const;
+  // Moonbeam dropped with the sunset: the chain is halted, so it can no longer
+  // serve `getUserVotingPower`. Delegate totals therefore no longer include any
+  // WELL that remained on Moonbeam.
+  const targetChainIds = [base.id, optimism.id, mainnet.id] as const;
   const envs = Object.values(client.environments as Environment[]).filter(
     (env) =>
       env.contracts.views !== undefined &&

package/actions/governance/getGovernanceTokenInfo.ts

@@ -19,6 +19,8 @@ export type GetGovernanceTokenInfoReturnType = Promise<
 
 export async function getGovernanceTokenInfo(
   _client: MoonwellClient,
+  // Retained for API compatibility, but WELL is the only governance token left
+  // now that MFAM went with Moonriver (MOO-551), so there is nothing to branch on.
   args: GetGovernanceTokenInfoParameters,
 ): GetGovernanceTokenInfoReturnType {
   const logId = logger.start(
@@ -26,22 +28,28 @@ export async function getGovernanceTokenInfo(
     "Starting to get governance token info...",
   );
 
-  if (args.governanceToken === "WELL") {
-    const totalSupply =
-      await publicEnvironments.moonbeam.contracts.governanceToken.read.totalSupply();
-
+  // TypeScript already narrows `GovernanceToken` to "WELL", but a JS consumer
+  // still passing "MFAM" would otherwise receive WELL's supply as a normal
+  // success — silently wrong data where TS consumers get a compile error.
+  // Reject it rather than let the removed token look like it still resolves.
+  if (args.governanceToken !== undefined && args.governanceToken !== "WELL") {
     logger.end(logId);
+    throw new Error(
+      `Unsupported governance token "${args.governanceToken}". MFAM was removed with the Moonriver sunset (MOO-551); WELL is the only governance token.`,
+    );
+  }
 
-    return {
-      totalSupply: new Amount(totalSupply || 0n, 18),
-    };
-  } else {
-    const totalSupply =
-      await publicEnvironments.moonriver.contracts.governanceToken.read.totalSupply();
+  // WELL supply used to be read from Moonbeam, the original mint. That chain is
+  // halted (MOO-551), so the read now targets the Ethereum multigov hub — the
+  // home of live governance. Note this reports the hub's xWELL supply rather
+  // than Moonbeam's historical total, so the number can differ from pre-sunset
+  // releases. MFAM is gone entirely: Apollo governance ended with Moonriver.
+  const totalSupply =
+    await publicEnvironments.ethereum.contracts.governanceToken.read.totalSupply();
 
-    logger.end(logId);
-    return {
-      totalSupply: new Amount(totalSupply || 0n, 18),
-    };
-  }
+  logger.end(logId);
+
+  return {
+    totalSupply: new Amount(totalSupply || 0n, 18),
+  };
 }

package/actions/governance/getUserVoteReceipt.ts

@@ -1,7 +1,8 @@
 import type { Address, Chain } from "viem";
 import type { MoonwellClient } from "../../client/createMoonwellClient.js";
-import { Amount, getEnvironmentFromArgs } from "../../common/index.js";
+import { Amount } from "../../common/index.js";
 import type { NetworkParameterType } from "../../common/types.js";
+import type { Environment } from "../../environments/index.js";
 import type { VoteReceipt } from "../../types/voteReceipt.js";
 import {
   type ApiVoteReceipt,
@@ -10,6 +11,7 @@ import {
   fetchUserVoteReceipt,
   isNotFoundError,
 } from "./governor-api-client.js";
+import { resolveGovernanceEnvironment } from "./proposals/common.js";
 
 export type GetUserVoteReceiptParameters<
   environments,
@@ -50,8 +52,17 @@ export async function getUserVoteReceipt<
 ): GetUserVoteReceiptReturnType {
   const { proposalId, userAddress, chainId } = args;
 
-  const environment = getEnvironmentFromArgs(client, args);
-  if (!environment) {
+  // `args.chainId` identifies the chain the PROPOSAL lives on, not the
+  // environment we read through — the same distinction `getProposal` draws
+  // (MOO-551). Resolving the environment from it meant an archive lookup
+  // (1284/1285) matched no registered environment post-sunset and returned `[]`,
+  // a third shape callers don't handle: every historical vote read as "didn't
+  // vote". Resolve the indexer source independently and pass `chainId` through
+  // untouched.
+  const governanceEnvironment = resolveGovernanceEnvironment(
+    Object.values(client.environments as Record<string, Environment>),
+  );
+  if (!governanceEnvironment) {
     return [];
   }
 
@@ -64,7 +75,7 @@ export async function getUserVoteReceipt<
   for (const cid of tryChains) {
     try {
       const apiVoteReceipts = await fetchUserVoteReceipt(
-        environment,
+        governanceEnvironment,
         cid,
         proposalId,
         userAddress,
@@ -87,7 +98,10 @@ export async function getUserVoteReceipt<
   if (collected.length === 0) {
     return [
       {
-        chainId: environment.chainId,
+        // An explicit request names the chain the stub is about; a bare lookup
+        // queried every supported chain, so the source we read through is the
+        // only chain it can honestly claim.
+        chainId: chainId ?? governanceEnvironment.chainId,
         proposalId,
         account: userAddress,
         voted: false,