@moonwell-fi/moonwell-sdk 0.21.0 → 0.22.0

package/actions/governance/proposals/getProposals.ts

@@ -1,16 +1,20 @@
-import { moonbeam, moonriver } from "viem/chains";
 import type { MoonwellClient } from "../../../client/createMoonwellClient.js";
-import { Amount, getEnvironmentsFromArgs } from "../../../common/index.js";
+import { getEnvironmentsFromArgs } from "../../../common/index.js";
 import type { OptionalNetworkParameterType } from "../../../common/types.js";
 import type { Chain, Environment } from "../../../environments/index.js";
 import * as logger from "../../../logger/console.js";
-import { type Proposal, ProposalState } from "../../../types/proposal.js";
-import { type ApiProposal, fetchAllProposals } from "../governor-api-client.js";
+import type { Proposal } from "../../../types/proposal.js";
+import {
+  type ApiProposal,
+  SUPPORTED_GOVERNOR_CHAIN_IDS,
+  fetchAllProposals,
+} from "../governor-api-client.js";
 import { resolveIpfsDescriptions } from "../ipfs.js";
 import {
-  formatApiProposalData,
   getProposalsOnChainData,
+  mapApiProposalToProposal,
   readCrossChainQuorums,
+  resolveGovernanceEnvironment,
 } from "./common.js";
 
 export type GetProposalsParameters<
@@ -31,30 +35,14 @@ export async function getProposals<
 
   const environments = getEnvironmentsFromArgs(client, args);
 
-  const governanceEnvironments = environments.filter(
-    (environment) =>
-      environment.chainId === moonbeam.id ||
-      environment.chainId === moonriver.id,
-  );
+  const governanceEnvironment = resolveGovernanceEnvironment(environments);
 
-  if (governanceEnvironments.length === 0) {
+  if (!governanceEnvironment) {
     logger.end(logId);
     return [];
   }
 
-  const allProposals = await Promise.all(
-    governanceEnvironments.map(async (governanceEnvironment) => {
-      if (governanceEnvironment.chainId === moonbeam.id) {
-        // Moonbeam + Ethereum: Governor API (chainIds 1 and 1284)
-        return getMoonbeamProposals(governanceEnvironment);
-      } else {
-        // Moonriver: Governor API, single legacy governor (chainId 1285)
-        return getMoonriverProposals(governanceEnvironment);
-      }
-    }),
-  );
-
-  const proposals = allProposals.flat();
+  const proposals = await fetchGovernorProposals(governanceEnvironment);
   // Newer multigov-ethereum proposals (chainId=1) and historical Moonbeam
   // proposals (chainId=1284) restart their proposalId counters from 1, so IDs
   // may collide across chains. Sort by proposalId desc with chainId as a
@@ -70,27 +58,34 @@ export async function getProposals<
 }
 
 /**
- * Fetch proposals for Moonbeam using the Governor API.
+ * Fetch every proposal the Governor API serves, across all governance chains.
  *
- * The same indexer DO serves two chains:
- *   - chainId=1 (Ethereum) — the active multigov contract
- *   - chainId=1284 (Moonbeam) — historical proposals
+ * One indexer DO serves them all:
+ *   - chainId=1    (Ethereum)  — the active multigov contract
+ *   - chainId=1284 (Moonbeam)  — historical archive, chain halted
+ *   - chainId=1285 (Moonriver) — legacy Apollo governor, chain halted
  *
- * Uses `Promise.allSettled` so a transient outage on one chain doesn't take
- * down the other — partial results are preferred over a hard failure.
+ * The sunset chains keep appearing here on purpose: the indexer still has their
+ * proposals even though no RPC exists for them any more, so the governance
+ * record stays readable (MOO-551). What they lose is the on-chain half —
+ * `getProposalsOnChainData` finds no environment for 1284/1285 and derives their
+ * state from indexer events, leaving quorum and eta unset.
+ *
+ * `Promise.allSettled` so one chain's outage degrades to a missing slice rather
+ * than an empty list.
  */
-async function getMoonbeamProposals(
+async function fetchGovernorProposals(
   governanceEnvironment: Environment,
 ): Promise<Proposal[]> {
-  const results = await Promise.allSettled([
-    fetchAllProposals(governanceEnvironment, { chainId: 1 }),
-    fetchAllProposals(governanceEnvironment, { chainId: 1284 }),
-  ]);
+  const results = await Promise.allSettled(
+    SUPPORTED_GOVERNOR_CHAIN_IDS.map((chainId) =>
+      fetchAllProposals(governanceEnvironment, { chainId }),
+    ),
+  );
 
-  const chainsAttempted: ReadonlyArray<1 | 1284> = [1, 1284];
   const apiProposals: ApiProposal[] = [];
   results.forEach((result, index) => {
-    const chainId = chainsAttempted[index];
+    const chainId = SUPPORTED_GOVERNOR_CHAIN_IDS[index];
     if (result.status === "fulfilled") {
       apiProposals.push(...result.value);
     } else if (chainId !== undefined) {
@@ -109,44 +104,13 @@ async function getMoonbeamProposals(
 }
 
 /**
- * Fetch proposals for Moonriver using the Governor API.
+ * Governor-API pipeline: resolve IPFS descriptions + cross-chain quorums in
+ * parallel, read on-chain data, then map each ApiProposal to a Proposal.
  *
- * 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.
+ * Single caller (`fetchGovernorProposals`) since the sunset removed the separate
+ * `getMoonbeamProposals` / `getMoonriverProposals` entry points (MOO-551) —
+ * kept as its own function because it is the list-shaped counterpart to
+ * `getProposal`'s single-proposal pipeline, and the two are read together.
  */
 async function buildProposals(
   apiProposals: ApiProposal[],
@@ -164,85 +128,20 @@ async function buildProposals(
     { crossChainQuorums },
   );
 
-  const proposals: Proposal[] = apiProposals.map((apiProposal, index) => {
-    const onChainData = onChainDataList[index]!;
-    const formattedData = formatApiProposalData(apiProposal);
-    // Single source of truth — see getProposal.ts. getProposalsOnChainData
-    // classified with the Artemis cutoff and routed the reads accordingly;
-    // re-classifying here without the cutoff would drift and drop `multichain`.
-    const isMultichain = onChainData.isMultichain;
-
-    const now = Math.floor(Date.now() / 1000);
-    let proposalState = onChainData.state;
-
-    if (
-      proposalState === ProposalState.Pending &&
-      now >= apiProposal.votingStartTime &&
-      now <= apiProposal.votingEndTime
-    ) {
-      proposalState = ProposalState.Active;
-    }
-
-    if (formattedData.executed) {
-      proposalState = ProposalState.Executed;
-    } else if (
-      isMultichain &&
-      onChainData.votesCollected &&
-      now > apiProposal.votingEndTime &&
-      proposalState === ProposalState.Succeeded
-    ) {
-      // Succeeded with collection done means "awaiting execution" — surface
-      // as Queued so the frontend renders the "Ready to Execute" timeline
-      // step. Defeated/Canceled/Executed must NOT be promoted: under the new
-      // state-machine-based votesCollected, those terminal states also
-      // satisfy `votesCollected: true`, so a `< Queued` gate would mislabel
-      // them.
-      proposalState = ProposalState.Queued;
-    }
-
-    const proposal: Proposal = {
-      id: apiProposal.proposalId,
-      chainId: apiProposal.chainId,
-      proposalId: apiProposal.proposalId,
-      proposer: apiProposal.proposer as `0x${string}`,
-      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,
-      // 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,
-        votesCollected: onChainData.votesCollected,
-      };
-    }
-
-    return proposal;
+  // `getProposalsOnChainData` maps 1:1 over its input, so every index resolves —
+  // guard rather than assert, so the invariant is enforced instead of asserted
+  // away if that ever stops holding.
+  const proposals: Proposal[] = apiProposals.flatMap((apiProposal, index) => {
+    const onChainData = onChainDataList[index];
+    return onChainData
+      ? [
+          mapApiProposalToProposal(
+            apiProposal,
+            onChainData,
+            governanceEnvironment,
+          ),
+        ]
+      : [];
   });
 
   return proposals;

package/client/createMoonwellClient.ts

@@ -5,8 +5,6 @@ import {
   type BaseEnvironment,
   type Environment,
   type EthereumEnvironment,
-  type MoonbeamEnvironment,
-  type MoonriverEnvironment,
   type OptimismEnvironment,
   type PolygonEnvironment,
   type SupportedChains,
@@ -15,10 +13,9 @@ import {
   base,
   createEnvironment,
   ethereum,
-  moonbeam,
-  moonriver,
   optimism,
   polygon,
+  supportedChains,
 } from "../environments/index.js";
 import { actions } from "./createActions.js";
 
@@ -33,16 +30,6 @@ export type MoonwellClient<
         name,
         "optimism"
       >]: OptimismEnvironment;
-    } & {
-      [name in keyof environments as Extract<
-        name,
-        "moonbeam"
-      >]: MoonbeamEnvironment;
-    } & {
-      [name in keyof environments as Extract<
-        name,
-        "moonriver"
-      >]: MoonriverEnvironment;
     } & {
       [name in keyof environments as Extract<
         name,
@@ -86,25 +73,40 @@ export const createMoonwellClient = <const networks>(config: {
     config.networks as NetworksConfig<SupportedChains>,
   ).reduce((prev, [curr, networkConfig]) => {
     if (!networkConfig) return prev;
+
+    // Every supported key gets its own branch and unknown keys throw. The old
+    // shape ended in a bare `: polygon` fallthrough, so a key TypeScript would
+    // have rejected — `moonbeam`/`moonriver` after the sunset (MOO-551), or any
+    // typo from a JS consumer — silently built a *Polygon* environment stored
+    // under that key, wired with Polygon addresses over the caller's RPC. Fail
+    // loudly instead, matching `createEnvironment`'s "Unsupported chainId".
+    const chain =
+      curr === "base"
+        ? base
+        : curr === "optimism"
+          ? optimism
+          : curr === "ethereum"
+            ? ethereum
+            : curr === "avalanche"
+              ? avalanche
+              : curr === "arbitrum"
+                ? arbitrum
+                : curr === "polygon"
+                  ? polygon
+                  : undefined;
+
+    if (!chain) {
+      throw new Error(
+        `Unsupported network "${curr}". Supported networks: ${Object.keys(
+          supportedChains,
+        ).join(", ")}.`,
+      );
+    }
+
     return {
       ...prev,
       [curr]: createEnvironment({
-        chain:
-          curr === "base"
-            ? base
-            : curr === "optimism"
-              ? optimism
-              : curr === "moonbeam"
-                ? moonbeam
-                : curr === "moonriver"
-                  ? moonriver
-                  : curr === "ethereum"
-                    ? ethereum
-                    : curr === "avalanche"
-                      ? avalanche
-                      : curr === "arbitrum"
-                        ? arbitrum
-                        : polygon,
+        chain,
         rpcUrls: networkConfig.rpcUrls,
       }),
     };
@@ -116,16 +118,6 @@ export const createMoonwellClient = <const networks>(config: {
         name,
         "optimism"
       >]: OptimismEnvironment;
-    } & {
-      [name in keyof networks as Extract<
-        name,
-        "moonbeam"
-      >]: MoonbeamEnvironment;
-    } & {
-      [name in keyof networks as Extract<
-        name,
-        "moonriver"
-      >]: MoonriverEnvironment;
     } & {
       [name in keyof networks as Extract<
         name,

package/common/index.ts

@@ -136,6 +136,17 @@ export const getEnvironmentFromArgs = (
   return undefined;
 };
 
+/**
+ * Resolve the environments an action should run against.
+ *
+ * A `chainId`/`network` that matches no registered environment yields an EMPTY
+ * array, not `[undefined]`. The single-element-holding-undefined shape used to
+ * leak out of here and every caller dereferences what it gets back, so an
+ * unmatched selector crashed with an opaque `Cannot read properties of
+ * undefined` instead of hitting the caller's own "nothing to do" guard. That
+ * became reachable on ordinary input once Moonbeam/Moonriver stopped being
+ * registrable (MOO-551) while `getProposal` still teaches callers to pass 1284.
+ */
 export const getEnvironmentsFromArgs = (
   client: MoonwellClient,
   args?: { chainId?: number; network?: any },
@@ -150,15 +161,15 @@ export const getEnvironmentsFromArgs = (
     };
 
     if (Number.isInteger(chainId)) {
-      return [
-        Object.values(client.environments).find(
-          (env) => env.chainId === chainId,
-        ),
-      ] as Environment[];
+      const matched = Object.values(client.environments).find(
+        (env) => env.chainId === chainId,
+      );
+      return matched ? [matched] : [];
     }
 
     if (network) {
-      return [client.environments[network]] as Environment[];
+      const matched = client.environments[network];
+      return matched ? [matched] : [];
     }
   }
   return Object.values(client.environments as Environment[]).filter((r) =>

package/environments/definitions/governance.ts

@@ -1,4 +1,4 @@
-import { base, mainnet, moonbeam, moonriver, optimism } from "viem/chains";
+import { base, mainnet, optimism } from "viem/chains";
 
 export interface GovernanceTokenInfo {
   id: string;
@@ -23,14 +23,10 @@ export const GovernanceTokensConfig = createGovernanceTokensConfig({
     id: "WELL",
     symbol: "WELL",
     name: "WELL",
-    chainIds: [moonbeam.id, base.id, optimism.id, mainnet.id] as number[],
-    testnet: false,
-  },
-  MFAM: {
-    id: "MFAM",
-    symbol: "MFAM",
-    name: "MFAM",
-    chainIds: [moonriver.id] as number[],
+    // Moonbeam (1284) dropped with the sunset (MOO-551): the chain is halted, so
+    // it can no longer serve voting-power reads. MFAM/Moonriver is gone for the
+    // same reason — Apollo governance ended with the chain.
+    chainIds: [base.id, optimism.id, mainnet.id] as number[],
     testnet: false,
   },
 });

package/environments/index.ts

@@ -15,18 +15,6 @@ import {
   createEnvironment as createBaseEnvironment,
 } from "./definitions/base/environment.js";
 
-import {
-  createEnvironment as createMoonbeamEnvironment,
-  type markets as moonbeamMarkets,
-  type tokens as moonbeamTokens,
-} from "./definitions/moonbeam/environment.js";
-
-import {
-  createEnvironment as createMoonriverEnvironment,
-  type markets as moonriverMarkets,
-  type tokens as moonriverTokens,
-} from "./definitions/moonriver/environment.js";
-
 import {
   createEnvironment as createOptimismEnvironment,
   type markets as optimismMarkets,
@@ -60,7 +48,7 @@ import {
   type tokens as polygonTokens,
 } from "./definitions/polygon/environment.js";
 
-import { moonbeam, moonriver, optimism } from "viem/chains";
+import { optimism } from "viem/chains";
 import type { Environment, TokenConfig } from "./types/config.js";
 
 export {
@@ -69,8 +57,6 @@ export {
   base,
   ethereum,
   GovernanceTokensConfig,
-  moonbeam,
-  moonriver,
   optimism,
   polygon,
   supportedChains,
@@ -92,8 +78,6 @@ export type {
 const supportedChainsIds: { [id: number]: keyof typeof supportedChains } = {
   [base.id]: "base",
   [optimism.id]: "optimism",
-  [moonriver.id]: "moonriver",
-  [moonbeam.id]: "moonbeam",
   [ethereum.id]: "ethereum",
   [avalanche.id]: "avalanche",
   [arbitrum.id]: "arbitrum",
@@ -103,8 +87,6 @@ const supportedChainsIds: { [id: number]: keyof typeof supportedChains } = {
 const supportedChains = {
   base: base,
   optimism: optimism,
-  moonriver: moonriver,
-  moonbeam: moonbeam,
   ethereum: ethereum,
   avalanche: avalanche,
   arbitrum: arbitrum,
@@ -115,10 +97,6 @@ type SupportedChains = Prettify<keyof typeof supportedChains>;
 type SupportedChainsIds = Prettify<keyof typeof supportedChainsIds>;
 
 export type BaseEnvironment = ReturnType<typeof createBaseEnvironment>;
-export type MoonbeamEnvironment = ReturnType<typeof createMoonbeamEnvironment>;
-export type MoonriverEnvironment = ReturnType<
-  typeof createMoonriverEnvironment
->;
 export type OptimismEnvironment = ReturnType<typeof createOptimismEnvironment>;
 export type EthereumEnvironment = ReturnType<typeof createEthereumEnvironment>;
 export type AvalancheEnvironment = ReturnType<
@@ -129,21 +107,17 @@ export type PolygonEnvironment = ReturnType<typeof createPolygonEnvironment>;
 
 export type GetEnvironment<chain> = chain extends typeof base
   ? BaseEnvironment
-  : chain extends typeof moonbeam
-    ? MoonbeamEnvironment
-    : chain extends typeof moonriver
-      ? MoonriverEnvironment
-      : chain extends typeof optimism
-        ? OptimismEnvironment
-        : chain extends typeof ethereum
-          ? EthereumEnvironment
-          : chain extends typeof avalanche
-            ? AvalancheEnvironment
-            : chain extends typeof arbitrum
-              ? ArbitrumEnvironment
-              : chain extends typeof polygon
-                ? PolygonEnvironment
-                : undefined;
+  : chain extends typeof optimism
+    ? OptimismEnvironment
+    : chain extends typeof ethereum
+      ? EthereumEnvironment
+      : chain extends typeof avalanche
+        ? AvalancheEnvironment
+        : chain extends typeof arbitrum
+          ? ArbitrumEnvironment
+          : chain extends typeof polygon
+            ? PolygonEnvironment
+            : undefined;
 
 export const createEnvironment = <const chain extends Chain>(config: {
   chain: chain;
@@ -152,12 +126,6 @@ export const createEnvironment = <const chain extends Chain>(config: {
   switch (config.chain.id) {
     case base.id:
       return createBaseEnvironment(config.rpcUrls) as GetEnvironment<chain>;
-    case moonbeam.id:
-      return createMoonbeamEnvironment(config.rpcUrls) as GetEnvironment<chain>;
-    case moonriver.id:
-      return createMoonriverEnvironment(
-        config.rpcUrls,
-      ) as GetEnvironment<chain>;
     case optimism.id:
       return createOptimismEnvironment(config.rpcUrls) as GetEnvironment<chain>;
     case ethereum.id:
@@ -177,8 +145,6 @@ export const createEnvironment = <const chain extends Chain>(config: {
 
 export const publicEnvironments = {
   base: createBaseEnvironment(),
-  moonbeam: createMoonbeamEnvironment(),
-  moonriver: createMoonriverEnvironment(),
   optimism: createOptimismEnvironment(),
   ethereum: createEthereumEnvironment(),
   avalanche: createAvalancheEnvironment(),
@@ -188,33 +154,25 @@ export const publicEnvironments = {
 
 export type TokensType<environment> = environment extends BaseEnvironment
   ? typeof baseTokens
-  : environment extends MoonbeamEnvironment
-    ? typeof moonbeamTokens
-    : environment extends MoonriverEnvironment
-      ? typeof moonriverTokens
-      : environment extends OptimismEnvironment
-        ? typeof optimismTokens
-        : environment extends EthereumEnvironment
-          ? typeof ethereumTokens
-          : environment extends AvalancheEnvironment
-            ? typeof avalancheTokens
-            : environment extends ArbitrumEnvironment
-              ? typeof arbitrumTokens
-              : environment extends PolygonEnvironment
-                ? typeof polygonTokens
-                : undefined;
+  : environment extends OptimismEnvironment
+    ? typeof optimismTokens
+    : environment extends EthereumEnvironment
+      ? typeof ethereumTokens
+      : environment extends AvalancheEnvironment
+        ? typeof avalancheTokens
+        : environment extends ArbitrumEnvironment
+          ? typeof arbitrumTokens
+          : environment extends PolygonEnvironment
+            ? typeof polygonTokens
+            : undefined;
 
 export type MarketsType<environment> = environment extends BaseEnvironment
   ? typeof baseMarkets
-  : environment extends MoonbeamEnvironment
-    ? typeof moonbeamMarkets
-    : environment extends MoonriverEnvironment
-      ? typeof moonriverMarkets
-      : environment extends OptimismEnvironment
-        ? typeof optimismMarkets
-        : environment extends EthereumEnvironment
-          ? typeof ethereumMarkets
-          : undefined;
+  : environment extends OptimismEnvironment
+    ? typeof optimismMarkets
+    : environment extends EthereumEnvironment
+      ? typeof ethereumMarkets
+      : undefined;
 
 export type VaultsType<environment> = environment extends BaseEnvironment
   ? typeof baseVaults

package/environments/types/config.ts

@@ -175,6 +175,20 @@ export type CustomConfigType = {
   };
   governance?: {
     token: GovernanceToken;
+    /**
+     * Satellite chains this environment acts as the governance home for.
+     *
+     * Consumed as a `homeEnvironment` membership test — a satellite prices its
+     * native-token rewards through whichever environment claims its chainId.
+     * Only Moonbeam ever claimed any, so since the sunset (MOO-551) every
+     * surviving environment ships `[]` and each chain resolves to itself via
+     * the call sites' `|| environment` fallback. The
+     * `ethereum/environment.test.ts` invariant keeps it that way.
+     *
+     * Kept as an extension point for a future hub that genuinely fronts other
+     * chains; collapsing the lookups and retiring the field is a separate
+     * cleanup, since it would change `Environment["custom"]`.
+     */
     chainIds: number[];
     proposalIdOffset?: number;
     snapshotEnsName?: string;

package/errors/version.ts

@@ -1 +1 @@
-export const version = '0.21.0'
+export const version = '0.22.0'

package/package.json

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

package/_cjs/environments/definitions/moonbeam/contracts.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.contracts = void 0;
-const config_js_1 = require("../../types/config.js");
-const tokens_js_1 = require("./tokens.js");
-exports.contracts = (0, config_js_1.createContractsConfig)({
-    tokens: tokens_js_1.tokens,
-    contracts: {
-        governanceToken: "WELL",
-        stakingToken: "stkWELL",
-        wrappedNativeToken: "WGLMR",
-        tokenSale: "0x933fCDf708481c57E9FD82f6BAA084f42e98B60e",
-        comptroller: "0x8E00D5e02E65A19337Cdba98bbA9F84d4186a180",
-        maximillion: "0xe5Ef9310cC7E3437bAD83466675f24FD62A380c3",
-        views: "0xe76C8B8706faC85a8Fbdcac3C42e3E7823c73994",
-        oracle: "0xED301cd3EB27217BDB05C4E9B820a8A3c8B665f9",
-        governor: "0xfc4DFB17101A12C5CEc5eeDd8E92B5b16557666d",
-        multichainGovernor: "0x9A8464C4C11CeA17e191653Deb7CdC1bE30F1Af4",
-        voteCollector: "0xB8A798a50a7274A13449B7f2Dd6Df22faF2d40E5",
-    },
-});
-//# sourceMappingURL=contracts.js.map

package/_cjs/environments/definitions/moonbeam/contracts.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"contracts.js","sourceRoot":"","sources":["../../../../environments/definitions/moonbeam/contracts.ts"],"names":[],"mappings":";;;AAAA,qDAA8D;AAC9D,2CAAqC;AAExB,QAAA,SAAS,GAAG,IAAA,iCAAqB,EAAC;IAC7C,MAAM,EAAN,kBAAM;IACN,SAAS,EAAE;QACT,eAAe,EAAE,MAAM;QACvB,YAAY,EAAE,SAAS;QACvB,kBAAkB,EAAE,OAAO;QAC3B,SAAS,EAAE,4CAA4C;QACvD,WAAW,EAAE,4CAA4C;QACzD,WAAW,EAAE,4CAA4C;QACzD,KAAK,EAAE,4CAA4C;QACnD,MAAM,EAAE,4CAA4C;QACpD,QAAQ,EAAE,4CAA4C;QACtD,kBAAkB,EAAE,4CAA4C;QAChE,aAAa,EAAE,4CAA4C;KAC5D;CACF,CAAC,CAAC"}