Develop

apps/marginfi-v2-trading/src/pages/_app.tsx

@@ -96,7 +96,7 @@ export default function MrgnApp({ Component, pageProps, path, bank }: AppProps &
         </ConnectionProvider>
       )}
       <Tutorial />
-      {process.env.NEXT_PUBLIC_ANALYTICS === "true" && (
+      {process.env.NEXT_PUBLIC_ANALYTICS === "true" && ready && (
         <>
           <GoogleAnalytics gaId="G-T5B2WRLKL9" />
           <GoogleTagManager gtmId="GTM-WFBC4RZ7" />

apps/marginfi-v2-ui/src/components/common/Navbar/Navbar.tsx

@@ -1,4 +1,4 @@
-import { FC } from "react";
+import React, { FC } from "react";
 
 import Link from "next/link";
 import Image from "next/image";
@@ -45,16 +45,27 @@ export const Navbar: FC = () => {
     state.fetchMrgnlendState,
   ]);
 
-  const { isOraclesStale, priorityType, broadcastType, priorityFees, maxCap, maxCapType, setTransactionSettings } =
-    useUiStore((state) => ({
-      isOraclesStale: state.isOraclesStale,
-      priorityType: state.priorityType,
-      broadcastType: state.broadcastType,
-      priorityFees: state.priorityFees,
-      maxCap: state.maxCap,
-      maxCapType: state.maxCapType,
-      setTransactionSettings: state.setTransactionSettings,
-    }));
+  const {
+    isOraclesStale,
+    priorityType,
+    broadcastType,
+    priorityFees,
+    maxCap,
+    maxCapType,
+    setTransactionSettings,
+    accountLabels,
+    fetchAccountLabels,
+  } = useUiStore((state) => ({
+    isOraclesStale: state.isOraclesStale,
+    priorityType: state.priorityType,
+    broadcastType: state.broadcastType,
+    priorityFees: state.priorityFees,
+    maxCap: state.maxCap,
+    maxCapType: state.maxCapType,
+    setTransactionSettings: state.setTransactionSettings,
+    accountLabels: state.accountLabels,
+    fetchAccountLabels: state.fetchAccountLabels,
+  }));
 
   const [userPointsData] = useUserProfileStore((state) => [state.userPointsData]);
 
@@ -200,6 +211,8 @@ export const Navbar: FC = () => {
                   ...priorityFees,
                   broadcastType,
                 }}
+                accountLabels={accountLabels}
+                fetchAccountLabels={fetchAccountLabels}
               />
             </div>
           )}

apps/marginfi-v2-ui/src/components/common/Portfolio/components/move-position/move-position-dialog.tsx

@@ -162,7 +162,16 @@ export const MovePositionDialog = ({
     } finally {
       setIsExecutionLoading(false);
     }
-  }, [marginfiClient, accountToMoveTo, actionTxns, broadcastType, priorityFees, fetchMrgnlendState, setIsOpen]);
+  }, [
+    marginfiClient,
+    accountToMoveTo,
+    actionTxns,
+    broadcastType,
+    priorityFees,
+    selectedAccount?.address,
+    fetchMrgnlendState,
+    setIsOpen,
+  ]);
 
   React.useEffect(() => {
     if (!accountToMoveTo) return;

apps/marginfi-v2-ui/src/components/common/Portfolio/components/rewards/rewards-dialog.tsx

@@ -6,9 +6,9 @@ import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription } f
 import { Button } from "~/components/ui/button";
 import { IconLoader } from "~/components/ui/icons";
 
-import { rewardsType } from "../../types";
+import { RewardsType } from "../../types";
 interface RewardsDialogProps extends DialogProps {
-  availableRewards: rewardsType | null;
+  availableRewards: RewardsType;
   onClose: () => void;
   onCollect: () => void;
   isLoading: boolean;

apps/marginfi-v2-ui/src/components/common/Portfolio/hooks/use-reward-simulation.tsx

@@ -3,50 +3,90 @@ import React from "react";
 import { PublicKey, VersionedTransaction } from "@solana/web3.js";
 
 import { MarginfiAccountWrapper, MarginfiClient } from "@mrgnlabs/marginfi-client-v2";
-import { ActionMessageType, captureSentryException, TOKEN_2022_MINTS } from "@mrgnlabs/mrgn-utils";
+import {
+  ActionMessageType,
+  captureSentryException,
+  EMISSION_MINT_INFO_MAP,
+  TOKEN_2022_MINTS,
+} from "@mrgnlabs/mrgn-utils";
 import { ExtendedBankInfo } from "@mrgnlabs/marginfi-v2-ui-state";
 import {
   AccountLayout,
   getAssociatedTokenAddressSync,
   nativeToUi,
   numeralFormatter,
+  SolanaTransaction,
   TOKEN_2022_PROGRAM_ID,
   TOKEN_PROGRAM_ID,
 } from "@mrgnlabs/mrgn-common";
 
-import { rewardsType } from "../types";
+import { RewardsType } from "../types";
 
 type RewardSimulationProps = {
-  simulationResult: rewardsType | null;
-  actionTxn: VersionedTransaction | null;
+  simulationResult: RewardsType | null;
   marginfiClient: MarginfiClient | null;
   selectedAccount: MarginfiAccountWrapper | null;
   extendedBankInfos: ExtendedBankInfo[];
 
-  setSimulationResult: (result: rewardsType | null) => void;
-  setActionTxn: (actionTxn: VersionedTransaction | null) => void;
+  setSimulationResult: (result: RewardsType) => void;
+  setActionTxn: (actionTxn: SolanaTransaction) => void;
   setErrorMessage: (error: ActionMessageType | null) => void;
 };
 
 export const useRewardSimulation = ({
-  actionTxn,
   marginfiClient,
   selectedAccount,
   extendedBankInfos,
   setSimulationResult,
   setActionTxn,
 }: RewardSimulationProps) => {
-  const bankAddressesWithEmissions: PublicKey[] = React.useMemo(() => {
-    if (!extendedBankInfos) return [];
-    return extendedBankInfos.filter((bank) => bank.info.state.emissionsRate > 0).map((bank) => bank.meta.address);
-  }, [extendedBankInfos]);
+  const generateTxn = async (
+    banksWithEmissions: ExtendedBankInfo[],
+    selectedAccount: MarginfiAccountWrapper
+  ): Promise<SolanaTransaction | undefined> => {
+    try {
+      const bankAddressesWithEmissions = banksWithEmissions.map((bank) => bank.meta.address);
+      const tx = await selectedAccount?.makeWithdrawEmissionsTx(bankAddressesWithEmissions);
+      if (!tx) return;
+      return tx;
+    } catch (error) {
+      console.error("Error generating emissions transaction", error);
+    }
+  };
 
   const handleSimulation = React.useCallback(async () => {
     try {
-      if (!actionTxn || !marginfiClient || !selectedAccount) {
+      if (!marginfiClient || !selectedAccount) {
         setSimulationResult({
+          state: "ERROR",
+          tooltipContent: "Error fetching rewards",
           rewards: [],
-          totalReward: 0,
+          totalRewardAmount: 0,
+        });
+        return;
+      }
+
+      const banksWithEmissions = extendedBankInfos.filter((bank) => bank.info.state.emissionsRate > 0);
+      if (!banksWithEmissions.length) {
+        setSimulationResult({
+          state: "NO_REWARDS",
+          tooltipContent: "There are currently no banks that are outputting rewards.",
+          rewards: [],
+          totalRewardAmount: 0,
+        });
+        return;
+      }
+
+      const txns = await generateTxn(banksWithEmissions, selectedAccount);
+
+      if (!txns) {
+        setSimulationResult({
+          state: "NO_REWARDS",
+          tooltipContent: `You do not have any outstanding rewards. Deposit into a bank with emissions to earn additional rewards on top of yield. Banks with emissions: ${[
+            ...banksWithEmissions.map((bank) => bank.meta.tokenSymbol),
+          ].join(", ")}`,
+          rewards: [],
+          totalRewardAmount: 0,
         });
         return;
       }
@@ -56,13 +96,12 @@ export const useRewardSimulation = ({
 
       const atas: PublicKey[] = [];
 
-      for (let bankAddress of bankAddressesWithEmissions) {
-        const bank = marginfiClient.getBankByPk(bankAddress);
+      for (let bank of banksWithEmissions) {
         if (!bank) continue;
 
-        const tokenMint = bank.emissionsMint;
-        const tokenSymbol = bank.tokenSymbol ?? "";
-        const mintDecimals = bank.mintDecimals;
+        const tokenMint = bank.info.rawBank.emissionsMint;
+        const tokenSymbol = bank.info.rawBank.tokenSymbol ?? "";
+        const mintDecimals = bank.info.rawBank.mintDecimals;
         if (!tokenMint) continue;
 
         const programId = TOKEN_2022_MINTS.includes(tokenMint.toString()) ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
@@ -71,28 +110,32 @@ export const useRewardSimulation = ({
         atas.push(ata);
 
         const originData = await marginfiClient.provider.connection.getAccountInfo(ata);
-        if (!originData) continue;
+        let beforeAmount = "0";
+        if (originData) {
+          beforeAmount = AccountLayout.decode(originData.data).amount.toString();
+        }
 
-        const beforeAmount = AccountLayout.decode(originData.data).amount.toString();
-        beforeAmounts.set(bankAddress, { amount: beforeAmount, tokenSymbol, mintDecimals });
+        beforeAmounts.set(bank.meta.address, { amount: beforeAmount, tokenSymbol, mintDecimals });
       }
 
       if (beforeAmounts.size === 0) {
         setSimulationResult({
-          totalReward: 0,
+          state: "NO_REWARDS",
+          tooltipContent: "",
           rewards: [],
+          totalRewardAmount: 0,
         });
         return;
       }
 
-      const previewAtas = await marginfiClient.simulateTransactions([actionTxn], atas);
+      const previewAtas = await marginfiClient.simulateTransactions([txns], atas);
       if (!previewAtas[0]) return;
 
       previewAtas.forEach((ata, index) => {
         if (!ata) return;
 
         const afterAmount = AccountLayout.decode(ata).amount.toString();
-        const bankAddress = bankAddressesWithEmissions[index];
+        const bankAddress = banksWithEmissions[index].meta.address;
         const beforeData = beforeAmounts.get(bankAddress);
 
         if (beforeData) {
@@ -104,9 +147,11 @@ export const useRewardSimulation = ({
         }
       });
 
-      let rewards: rewardsType = {
-        totalReward: 0,
+      let rewards: RewardsType = {
+        state: "REWARDS_FETCHED",
+        tooltipContent: "",
         rewards: [],
+        totalRewardAmount: 0,
       };
 
       beforeAmounts.forEach((beforeData, bankAddress) => {
@@ -122,45 +167,29 @@ export const useRewardSimulation = ({
               bank: beforeData.tokenSymbol,
               amount: rewardAmount < 0.01 ? "<0.01" : numeralFormatter(rewardAmount),
             });
-            rewards.totalReward += rewardAmount;
+            rewards.totalRewardAmount += rewardAmount;
           }
         }
       });
 
       setSimulationResult(rewards);
+      setActionTxn(txns);
     } catch (error) {
       console.error("Error simulating emissions transactions", error);
       captureSentryException(error, "Error simulating emissions transactions", {
         action: "rewardSimulation",
         walletAddress: selectedAccount?.address.toBase58(),
       });
       setSimulationResult({
-        totalReward: 0,
+        state: "NO_REWARDS",
+        tooltipContent: "",
         rewards: [],
+        totalRewardAmount: 0,
       });
     }
-  }, [actionTxn, bankAddressesWithEmissions, marginfiClient, selectedAccount, setSimulationResult]);
-
-  const generateTxn = React.useCallback(async () => {
-    try {
-      if (!bankAddressesWithEmissions.length) return;
-      const tx = await selectedAccount?.makeWithdrawEmissionsTx(bankAddressesWithEmissions);
-      if (!tx) return;
-      setActionTxn(tx);
-    } catch (error) {
-      setActionTxn(null);
-    }
-  }, [bankAddressesWithEmissions, selectedAccount, setActionTxn]);
-
-  React.useEffect(() => {
-    if (bankAddressesWithEmissions.length) {
-      generateTxn();
-    }
-  }, [bankAddressesWithEmissions, generateTxn]);
+  }, [extendedBankInfos, marginfiClient, selectedAccount, setActionTxn, setSimulationResult]);
 
   return {
     handleSimulation,
-    generateTxn,
-    bankAddressesWithEmissions,
   };
 };