Moonwell lending

NEXT_PUBLIC_DYNAMIC_ENV_ID=your-environment-id-here
NEXT_PUBLIC_BASE_RPC_URL=https://your-provider.example/base-mainnet

export const CHAIN_ID = 8453; // Base

export const MARKETS_API = "https://api.moonwell.fi/v1/markets?chainId=8453";

/** Native USDC on Base (6 decimals). */
export const USDC_ADDRESS =
  "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as const;

/** Moonwell mToken for the native USDC market (8 decimals). */
export const MUSDC_ADDRESS =
  "0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22" as const;

export const USDC_DECIMALS = 6;

export const BASE_RPC_URL = process.env.NEXT_PUBLIC_BASE_RPC_URL!;

import { createDynamicClient, initializeClient } from "@dynamic-labs-sdk/client";
import { addEvmExtension } from "@dynamic-labs-sdk/evm";
import { BASE_RPC_URL, CHAIN_ID } from "@/lib/constants";

export const dynamicClient = createDynamicClient({
  autoInitialize: false,
  environmentId: process.env.NEXT_PUBLIC_DYNAMIC_ENV_ID!,
  metadata: { name: "Moonwell Lending" },
  transformers: {
    networksData: (networksData) =>
      networksData
        .filter(
          (network) =>
            network.chain !== "EVM" || Number(network.networkId) === CHAIN_ID,
        )
        .map((network) => {
          if (Number(network.networkId) !== CHAIN_ID) return network;
          return {
            ...network,
            rpcUrls: {
              ...network.rpcUrls,
              http: [BASE_RPC_URL, ...network.rpcUrls.http],
            },
          };
        }),
  },
});

// "use client" modules still execute during server rendering, where there is
// no wallet environment to initialize.
if (typeof window !== "undefined") {
  addEvmExtension();
  initializeClient().catch((error) => {
    console.error("Dynamic client failed to initialize", error);
  });
}

"use client";

import { createContext, useContext, type ReactNode } from "react";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import {
  DynamicProvider,
  useOnEvent,
  useUser,
  useGetWalletAccounts,
} from "@dynamic-labs-sdk/react-hooks";
import {
  createWaasWalletAccounts,
  getChainsMissingWaasWalletAccounts,
  isWaasWalletAccount,
} from "@dynamic-labs-sdk/client/waas";
import type { WalletAccount } from "@dynamic-labs-sdk/client";
import { isEvmWalletAccount, type EvmWalletAccount } from "@dynamic-labs-sdk/evm";
import { dynamicClient } from "@/lib/dynamic";

interface WalletContextValue {
  evmAccount: EvmWalletAccount | null;
  loggedIn: boolean;
}

const WalletContext = createContext<WalletContextValue>({
  evmAccount: null,
  loggedIn: false,
});

export function useWallet() {
  return useContext(WalletContext);
}

const queryClient = new QueryClient({
  defaultOptions: { queries: { staleTime: 1000 * 5 } },
});

function WaasBootstrap() {
  useOnEvent({
    event: "userChanged",
    listener: async (user) => {
      if (!user) return;
      const missingChains = getChainsMissingWaasWalletAccounts();
      if (missingChains.length === 0) return;
      try {
        await createWaasWalletAccounts({ chains: missingChains });
      } catch (error) {
        // Nothing awaits an event listener, so an uncaught rejection is silent
        // and the UI waits forever for a wallet that never arrives.
        console.error("Embedded wallet creation failed", error);
      }
    },
  });
  return null;
}

function WalletContextProvider({ children }: { children: ReactNode }) {
  const { data: user } = useUser();
  const { data: accounts = [] } = useGetWalletAccounts();
  const evmAccounts = (accounts as WalletAccount[]).filter(isEvmWalletAccount);

  const evmAccount =
    evmAccounts.find((walletAccount) => isWaasWalletAccount({ walletAccount })) ??
    null;

  return (
    <WalletContext.Provider value={{ evmAccount, loggedIn: !!user }}>
      {children}
    </WalletContext.Provider>
  );
}

export default function Providers({ children }: { children: ReactNode }) {
  return (
    <QueryClientProvider client={queryClient}>
      <DynamicProvider client={dynamicClient}>
        <WaasBootstrap />
        <WalletContextProvider>{children}</WalletContextProvider>
      </DynamicProvider>
    </QueryClientProvider>
  );
}

"use client";

import { useQuery } from "@tanstack/react-query";
import { createPublicClient, http } from "viem";
import { base } from "viem/chains";
import { ERC20_ABI, MTOKEN_ABI } from "@/lib/ABIs";
import { BASE_RPC_URL, MUSDC_ADDRESS, USDC_ADDRESS } from "@/lib/constants";

export const publicClient = createPublicClient({
  chain: base,
  transport: http(BASE_RPC_URL),
});

export const balancesQueryKey = (address?: string) =>
  ["moonwell", "balances", address ?? "anonymous"] as const;

export function useBalances(address?: string) {
  return useQuery({
    queryKey: balancesQueryKey(address),
    enabled: !!address,
    refetchInterval: 5_000,
    queryFn: async () => {
      const owner = address as `0x${string}`;
      const [walletUsdc, mTokenBalance, exchangeRate, allowance] =
        await Promise.all([
          publicClient.readContract({
            address: USDC_ADDRESS,
            abi: ERC20_ABI,
            functionName: "balanceOf",
            args: [owner],
          }),
          publicClient.readContract({
            address: MUSDC_ADDRESS,
            abi: MTOKEN_ABI,
            functionName: "balanceOf",
            args: [owner],
          }),
          publicClient.readContract({
            address: MUSDC_ADDRESS,
            abi: MTOKEN_ABI,
            functionName: "exchangeRateStored",
          }),
          publicClient.readContract({
            address: USDC_ADDRESS,
            abi: ERC20_ABI,
            functionName: "allowance",
            args: [owner, MUSDC_ADDRESS],
          }),
        ]);

      return {
        walletUsdc,
        mTokenBalance,
        suppliedUsdc: (mTokenBalance * exchangeRate) / 10n ** 18n,
        allowance,
      };
    },
  });
}

import {
  getActiveNetworkId,
  isProgrammaticNetworkSwitchAvailable,
  switchActiveNetwork,
} from "@dynamic-labs-sdk/client";
import { createWalletClientForWalletAccount } from "@dynamic-labs-sdk/evm/viem";
import type { EvmWalletAccount } from "@dynamic-labs-sdk/evm";
import { CHAIN_ID } from "@/lib/constants";

export async function getWalletClient(evmAccount: EvmWalletAccount) {
  const { networkId } = await getActiveNetworkId({ walletAccount: evmAccount });

  if (Number(networkId) !== CHAIN_ID) {
    if (!isProgrammaticNetworkSwitchAvailable({ walletAccount: evmAccount })) {
      throw new Error(
        `This wallet is on chain ${networkId} and cannot switch networks programmatically. Switch to Base in your wallet, then try again.`,
      );
    }
    await switchActiveNetwork({
      networkId: String(CHAIN_ID),
      walletAccount: evmAccount,
    });
  }

  const walletClient = await createWalletClientForWalletAccount({
    walletAccount: evmAccount,
  });

  // Re-check the chain: signing against the wrong chain's contracts is the
  // failure a silent switch would cause.
  if (walletClient.chain?.id !== CHAIN_ID) {
    throw new Error(`Wallet is still on chain ${walletClient.chain?.id}.`);
  }

  // An embedded wallet signs locally, which viem models as a `local` account.
  // A `json-rpc` account means the transaction would be forwarded to an RPC
  // that holds no keys.
  if (walletClient.account?.type !== "local") {
    throw new Error(
      `Selected wallet cannot sign locally (account type "${walletClient.account?.type}").`,
    );
  }

  return walletClient;
}

import type { Account, SimulateContractReturnType } from "viem";
import type { EvmWalletAccount } from "@dynamic-labs-sdk/evm";
import { ERC20_ABI, MTOKEN_ABI } from "@/lib/ABIs";
import { MUSDC_ADDRESS, USDC_ADDRESS } from "@/lib/constants";
import { publicClient } from "@/lib/hooks/useBalances";
import { getWalletClient } from "@/lib/wallet";

/**
 * Compound v2 markets answer some failures with a nonzero return code instead
 * of reverting, so a transaction can succeed on-chain while doing nothing.
 * Simulating first exposes that code.
 */
function assertNoErrorCode(result: unknown, action: string) {
  if (typeof result === "bigint" && result !== 0n) {
    throw new Error(`Moonwell rejected the ${action} with error code ${result}.`);
  }
}

async function run(
  evmAccount: EvmWalletAccount,
  action: string,
  simulate: (account: Account) => Promise<SimulateContractReturnType>,
) {
  const walletClient = await getWalletClient(evmAccount);

  // Pass the wallet's account object, not its address. `writeContract` prefers
  // the account carried on the simulated request, and an address string parses
  // into a `json-rpc` account, which sends `eth_sendTransaction` to the RPC
  // instead of signing locally.
  const { request, result } = await simulate(walletClient.account);
  assertNoErrorCode(result, action);

  const hash = await walletClient.writeContract(request);
  const receipt = await publicClient.waitForTransactionReceipt({ hash });
  if (receipt.status !== "success") {
    throw new Error(`${action} transaction reverted`);
  }
  return hash;
}

/** Approves the mToken to spend exactly `amount` USDC. */
export const approve = (evmAccount: EvmWalletAccount, amount: bigint) =>
  run(evmAccount, "approval", (account) =>
    publicClient.simulateContract({
      address: USDC_ADDRESS,
      abi: ERC20_ABI,
      functionName: "approve",
      args: [MUSDC_ADDRESS, amount],
      account,
    }),
  );

/** Supplies USDC and receives mUSDC. */
export const supply = (evmAccount: EvmWalletAccount, amount: bigint) =>
  run(evmAccount, "supply", (account) =>
    publicClient.simulateContract({
      address: MUSDC_ADDRESS,
      abi: MTOKEN_ABI,
      functionName: "mint",
      args: [amount],
      account,
    }),
  );

/** Withdraws an exact USDC amount. */
export const withdraw = (evmAccount: EvmWalletAccount, amount: bigint) =>
  run(evmAccount, "withdrawal", (account) =>
    publicClient.simulateContract({
      address: MUSDC_ADDRESS,
      abi: MTOKEN_ABI,
      functionName: "redeemUnderlying",
      args: [amount],
      account,
    }),
  );

/** Withdraws everything by redeeming the whole mToken balance. */
export const withdrawMax = (
  evmAccount: EvmWalletAccount,
  mTokenBalance: bigint,
) =>
  run(evmAccount, "withdrawal", (account) =>
    publicClient.simulateContract({
      address: MUSDC_ADDRESS,
      abi: MTOKEN_ABI,
      functionName: "redeem",
      args: [mTokenBalance],
      account,
    }),
  );