@mezo-org/passport 0.4.0-dev.20 → 0.4.0-dev.21

package/src/hooks/{useAssetsUSDConversion.ts → useAssetsConversionRates.ts}

@@ -4,11 +4,10 @@ import { QUERY_KEYS } from "./constants"
 import { usePortalApiClient } from "./usePortalApiClient"
 
 type AssetsUsdConversion = {
-  btcUsd: string
-  ethUsd: string
+  usd: Record<"btc" | "eth" | "t", number>
 }
 
-export function useAssetsUsdConversion(
+export default function useAssetsConversionRates(
   useQueryOptions: Partial<UseBaseQueryOptions<AssetsUsdConversion>> = {},
 ) {
   const portalApiClient = usePortalApiClient()
@@ -16,12 +15,14 @@ export function useAssetsUsdConversion(
   return useQuery({
     queryKey: [QUERY_KEYS.ASSETS_USD_CONVERSION],
     queryFn: async () => {
-      const { currentUsdPerBtc, currentUsdPerEth } =
+      const { currentUsdPerBtc, currentUsdPerEth, currentUsdPerTToken } =
         await portalApiClient.getPortalStatistics()
-
       return {
-        btcUsd: currentUsdPerBtc,
-        ethUsd: currentUsdPerEth,
+        usd: {
+          btc: Number(currentUsdPerBtc),
+          eth: Number(currentUsdPerEth),
+          t: Number(currentUsdPerTToken),
+        },
       }
     },
     staleTime: 30 * ONE_MINUTE_MS,

package/src/hooks/useAuthenticateWithWallet.ts

@@ -15,27 +15,31 @@ function useAuthenticateWithWallet(
     "mutationFn" | "mutationKey"
   > = {},
 ) {
-  const { address, chainId, connector, networkFamily } = useWalletAccount()
+  const { walletAddress, chainId, connector, networkFamily } =
+    useWalletAccount()
   const { ensureNoSessionAndFetchNonce } = useEnsureNoSessionAndFetchNonce()
   const { createSessionAsync } = useCreateSession()
   const { createAccountAsync } = useCreateAccount()
   const { signMessageAsync } = useSignMessage()
 
-  const { refetch: getAccountByAddress } = useGetAccountByAddress(address, {
-    enabled: false,
-    retry: false,
-  })
+  const { refetch: getAccountByAddress } = useGetAccountByAddress(
+    walletAddress,
+    {
+      enabled: false,
+      retry: false,
+    },
+  )
 
   const { mutate, mutateAsync, ...signInMutationRestParameters } = useMutation({
     mutationFn: async () => {
-      if (!address) {
+      if (!walletAddress) {
         throw new Error("Sign in error: Wallet not connected!")
       }
 
       const nonce = await ensureNoSessionAndFetchNonce()
 
       const messageResult = createSignInWithWalletMessage(
-        address,
+        walletAddress,
         nonce,
         networkFamily,
         chainId,

package/src/hooks/useBorrowData.ts

@@ -0,0 +1,79 @@
+import { useAccount, useReadContract } from "wagmi"
+import { useCallback } from "react"
+import { useQueryClient } from "@tanstack/react-query"
+import { ONE_MINUTE_MS } from "../utils/time"
+import { troveManagerContract } from "../lib/contracts"
+import { usePassportContext } from "./usePassportContext"
+import { CHAIN_ID } from "../constants"
+
+/**
+ * Query hook for getting borrow data. Returns collateral and trove debt for the
+ * connected account, based on it's evm address.
+ * @param queryOptions Query options passed to the underlying `useQuery` hook.
+ */
+export function useBorrowData(queryOptions = {}) {
+  const { environment = "mainnet" } = usePassportContext()
+  const { address } = useAccount()
+  return useReadContract({
+    abi: troveManagerContract.abi,
+    address: troveManagerContract.address[environment],
+    functionName: "getEntireDebtAndColl",
+    args: [address || "0x"],
+    query: {
+      enabled: !!address,
+      staleTime: 5 * ONE_MINUTE_MS,
+      retry: 1,
+      select: (data) => {
+        if (!data) return undefined
+
+        const [collateral, principal, interest] = data
+        return {
+          collateral,
+          troveDebt: principal + interest,
+        }
+      },
+      ...queryOptions,
+    },
+    chainId: CHAIN_ID[environment],
+  })
+}
+
+/**
+ * Hook for for invalidating current user's borrow data. Can be used to
+ * invalidate borrow data manually, which forces the data to be re-fetched.
+ * @returns Function `invalidateBorrowData` for invalidating the borrow data
+ */
+export function useInvalidateBorrowData() {
+  const queryClient = useQueryClient()
+
+  const { queryKey } = useBorrowData()
+
+  const invalidateBorrowDataHandler = useCallback(
+    () => queryClient.invalidateQueries({ queryKey }),
+    [queryClient, queryKey],
+  )
+
+  return {
+    invalidateBorrowData: invalidateBorrowDataHandler,
+  }
+}
+
+/**
+ * Hook for for resetting current user's borrow data. Can be used to reset
+ * borrow data manually, which forces the data to be re-fetched.
+ * @returns Function `resetBorrowData` for resetting the borrow data
+ */
+export function useResetBorrowData() {
+  const queryClient = useQueryClient()
+
+  const { queryKey } = useBorrowData()
+
+  const resetBorrowDataHandler = useCallback(
+    () => queryClient.resetQueries({ queryKey }),
+    [queryClient, queryKey],
+  )
+
+  return {
+    resetBorrowData: resetBorrowDataHandler,
+  }
+}

package/src/hooks/useDropdownData.ts

@@ -1,160 +1,101 @@
-import { useBitcoinAccount } from "@mezo-org/orangekit"
+import { useBalance } from "wagmi"
 import { useGetCurrentAccount } from "."
 import {
   CryptoAssetKey,
-  getCryptoAsset,
   isBitcoinLikeCryptoAsset,
-  isUsdLikeCryptoAsset,
+  mapCryptoAssetToDetails,
 } from "../utils/cryptoAssets"
-import {
-  formatNumberToCompactString,
-  fromFixedPoint,
-  fromFixedPointToString,
-} from "../utils/numbers"
-import { useAssetsUsdConversion } from "./useAssetsUSDConversion"
+import { fromFixedPoint } from "../utils/numbers"
+import useAssetsConversionRates from "./useAssetsConversionRates"
 import useWalletAccount from "./useWalletAccount"
-import { formatUsd } from "../utils/currency"
-
-/**
- * Formats crypto asset to balance details (balance in USD and decimals)
- * @param type The type of crypto asset
- * @param balance The balance of crypto asset
- * @param btcUsdConversionRate The USD conversion rate
- * @returns The balance details
- */
-function formatCryptoAsset(
-  type: CryptoAssetKey,
-  balance: bigint,
-  btcUsdConversionRate: number,
-) {
-  const { decimals } = getCryptoAsset(type)
-
-  const nativeBalance = fromFixedPoint(balance, decimals)
-  let balanceInUsd = 0
-  if (isBitcoinLikeCryptoAsset(type)) {
-    balanceInUsd = fromFixedPoint(
-      balance * BigInt(btcUsdConversionRate),
-      decimals,
-    )
-  }
-  if (isUsdLikeCryptoAsset(type)) {
-    balanceInUsd = nativeBalance
-  }
-
-  return {
-    type,
-    balance: fromFixedPointToString(
-      balance,
-      decimals,
-      isUsdLikeCryptoAsset(type) ? 2 : 4,
-    ),
-    balanceInUsd: formatUsd(balanceInUsd),
-  }
-}
+import { useTokensBalances } from "./useTokensBalances"
+import { useBorrowData } from "./useBorrowData"
 
 export type DropdownCryptoAsset<T = CryptoAssetKey> = {
   type: T
   balance: bigint
 }
 
-type DropdownDetailedCryptoAsset = ReturnType<typeof formatCryptoAsset>
-
-export type DropdownData = {
-  mezoId: string
-  accountAddress: string
-  walletAddress: string
-  walletType: "bitcoin" | "evm"
-  totalBalanceInUsd: string
-  formattedNativeAssets: DropdownDetailedCryptoAsset[]
-  matsnet: {
-    mats: string
-    formattedAssets: DropdownDetailedCryptoAsset[]
-  }
-}
-
-type UseDropdownDataOptions = {
-  // This is workaround. It should be read from contracts or fetched from API.
-  evmNativeAssets?: DropdownCryptoAsset[]
-  matsnetAssets?: DropdownCryptoAsset[]
-}
-
 /**
  * Aggregates dropdown data for Dropdown component.
- * @param options - Options for the dropdown data.
- * @param options.evmNativeAssets - Native assets for EVM wallet.
- * @param options.matsnetAssets - Matsnet tokens. Rendered as separate section.
  * @returns Dropdown data.
  * @dev This hook is for internal use only.
  */
-export default function useDropdownData(
-  options?: UseDropdownDataOptions,
-): DropdownData | null {
-  const { evmNativeAssets = [], matsnetAssets = [] } = options || {}
-
-  const { btcBalance } = useBitcoinAccount()
+export default function useDropdownData() {
+  const { data: btcBalance } = useBalance()
   const {
-    address: walletAddress,
-    networkFamily,
-    isConnected,
+    walletAddress,
+    accountAddress,
+    networkFamily: walletType,
   } = useWalletAccount()
   const { data: passportAccount } = useGetCurrentAccount()
-  const { data: assetsUsdConversion } = useAssetsUsdConversion()
-
-  const accountAddress = passportAccount?.linkedAccounts?.find(
-    (account) => account.type === "wallet",
-  )?.evmAddress
-
-  if (!walletAddress || !isConnected || !passportAccount || !accountAddress) {
-    return null
+  const { data: assetsConversionRates } = useAssetsConversionRates()
+  const { data: tokensBalances } = useTokensBalances()
+  const { data: debt } = useBorrowData()
+  const mezoId = passportAccount?.mezoId
+
+  const detailedAssets = Object.fromEntries(
+    [
+      ["BTC", btcBalance?.value ?? 0n],
+      ...Object.entries(tokensBalances ?? {}),
+    ].map((asset) => {
+      const [type, balance] = asset as [CryptoAssetKey, bigint]
+
+      let usdConversionRate: number | undefined
+      if (isBitcoinLikeCryptoAsset(type))
+        usdConversionRate = assetsConversionRates?.usd.btc
+      if (type === "mT") {
+        usdConversionRate = assetsConversionRates?.usd.t
+      }
+
+      return [
+        type,
+        mapCryptoAssetToDetails(type, balance, usdConversionRate || 1),
+      ]
+    }),
+  ) as Record<CryptoAssetKey, ReturnType<typeof mapCryptoAssetToDetails>>
+
+  const assets = {
+    btc: detailedAssets.BTC,
+    musd: detailedAssets.MUSD,
   }
 
-  const mezoId = passportAccount.mezoId!
-
-  const nativeAssets: DropdownCryptoAsset[] =
-    networkFamily === "bitcoin"
-      ? [
-          {
-            type: "btc",
-            balance: BigInt(btcBalance?.total ?? 0),
-          },
-        ]
-      : evmNativeAssets
+  const otherAssetsData = Object.values(detailedAssets).filter(
+    (asset) => !["BTC", "MUSD"].includes(asset.type),
+  )
 
-  const btcUsdConversionRate = Number(assetsUsdConversion?.btcUsd ?? 0)
+  const otherAssetsCount = otherAssetsData.length
 
-  const formattedNativeAssets = nativeAssets.map((asset) =>
-    formatCryptoAsset(asset.type, asset.balance, btcUsdConversionRate),
+  const otherAssetsUsdTotal = otherAssetsData.reduce(
+    (sum, { usdBalance }) => sum + usdBalance,
+    0,
   )
 
-  const totalBalanceInUsd = formatUsd(
-    nativeAssets.reduce((sum, value) => {
-      const { decimals } = getCryptoAsset(value.type)
-      return (
-        sum +
-        fromFixedPoint(value.balance * BigInt(btcUsdConversionRate), decimals)
-      )
-    }, 0),
+  const usdTotalBalance = Object.values(detailedAssets).reduce(
+    (sum, { usdBalance }) => sum + usdBalance,
+    0,
   )
 
-  const matsBalance = formatNumberToCompactString(
-    passportAccount.mats.totalMats,
-    2,
-  )
+  const matsBalance = passportAccount?.mats.totalMats || 0
 
-  const matsnetFormattedAssets = matsnetAssets.map((asset) =>
-    formatCryptoAsset(asset.type, asset.balance, btcUsdConversionRate),
+  const usdCollateral = fromFixedPoint(
+    (debt?.collateral ?? 0n) * BigInt(assetsConversionRates?.usd.btc ?? 0),
+    18,
   )
 
+  const usdTroveDebt = fromFixedPoint(debt?.troveDebt ?? 0n, 18)
+
   return {
     mezoId,
+    matsBalance,
     accountAddress,
     walletAddress,
-    walletType: networkFamily,
-    totalBalanceInUsd,
-    formattedNativeAssets,
-    matsnet: {
-      mats: matsBalance,
-      formattedAssets: matsnetFormattedAssets,
-    },
+    walletType,
+    usdTotalBalance,
+    usdTroveDebt,
+    usdCollateral,
+    assets,
+    otherAssetsCount,
+    otherAssetsUsdTotal,
   }
 }

package/src/hooks/useTokensBalances.ts

@@ -0,0 +1,187 @@
+import { useReadContracts } from "wagmi"
+import { useCallback, useMemo } from "react"
+import { Abi } from "viem"
+import { useQueryClient } from "@tanstack/react-query"
+import { usePassportContext } from "./usePassportContext"
+import {
+  mainnetContracts,
+  testnetContracts,
+  MezoChainToken,
+} from "../lib/contracts"
+import useWalletAccount from "./useWalletAccount"
+import { CHAIN_ID } from "../constants"
+
+// Wagmi handles typesafety with ABI const assertions. TypeScript doesn't
+// support importing JSON as const yet so types cannot be inferred from the
+// imported contract. As a workaround there is minimal ABI definition that can
+// be asserted types from.
+// Ref: https://wagmi.sh/core/typescript#const-assert-abis-typed-data
+
+const BALANCE_OF_ABI = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+    ],
+    name: "balanceOf",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const satisfies Abi
+
+const BALANCE_TOKENS: MezoChainToken[] = [
+  "mcbBTC",
+  "mDAI",
+  "mFBTC",
+  "mSolvBTC",
+  "mswBTC",
+  "mT",
+  "mUSDC",
+  "mUSDe",
+  "mUSDT",
+  "mxSolvBTC",
+  "MUSD",
+]
+
+type UseMezoChainTokensBalancesOptions<T> = {
+  tokens?: T
+  queryOptions?: object
+}
+
+/**
+ * Hook to get the balance of a list of tokens for the current account
+ * @param   options.tokens The list of tokens to get the balance for. It will
+ *          fallback to all tokens if not provided.
+ * @param   options.queryOptions The query options to pass to the
+ *          `useReadContracts`
+ * @returns Tanstack's `useQuery` returnings with balance of tokens for the
+ *          current account in form of typesafe object with token names as keys
+ *          and balances as values.
+ * @dev     In case of error data fallbacks to `0n`. To determine if an error
+ *          occurred, check the `isError` property.
+ * @example
+ * const mezoTokensBalance = useTokensBalances({
+ *   tokens: ["mT", "mxSolvBTC"],
+ * })
+ * console.log(mezoTokensBalance?.data.mT) // Eg. 0n
+ * console.log(Object.keys(mezoTokensBalance?.data)) // ["mT", "mxSolvBTC"]
+ */
+export function useTokensBalances<T extends MezoChainToken[]>(
+  options: UseMezoChainTokensBalancesOptions<T> = {},
+) {
+  const { environment = "mainnet" } = usePassportContext()
+
+  const { accountAddress } = useWalletAccount()
+
+  const contractsMap = useMemo(() => {
+    const contracts =
+      environment === "mainnet" ? mainnetContracts : testnetContracts
+
+    const tokenContracts = Object.fromEntries(
+      Object.entries(contracts).filter(([key]) =>
+        BALANCE_TOKENS.includes(key as MezoChainToken),
+      ),
+    ) as typeof contracts
+
+    return tokenContracts
+  }, [environment])
+
+  const { tokens = Object.keys(contractsMap) as T, queryOptions = {} } = options
+
+  const contracts = useMemo(() => {
+    if (!accountAddress) return []
+
+    return tokens.map((token) => {
+      const { address } = contractsMap[token]
+
+      return {
+        address,
+        abi: BALANCE_OF_ABI,
+        functionName: "balanceOf",
+        args: [accountAddress],
+        chainId: CHAIN_ID[environment],
+      }
+    })
+  }, [accountAddress, tokens, contractsMap, environment])
+
+  return useReadContracts({
+    contracts,
+    query: {
+      select: (data) =>
+        data.reduce(
+          (acc, item) => {
+            const token = tokens[data.indexOf(item)]
+
+            return {
+              ...acc,
+              [token]: item.result ?? 0n,
+            }
+          },
+          {} as Record<T[number], bigint>,
+        ),
+      ...queryOptions,
+    },
+  })
+}
+
+/**
+ * Hook for invalidating current user's token balances. Can be used to
+ * invalidate the balances manually, which forces the data to be re-fetched.
+ * @param tokens The list of tokens (as string arrays) for which we want to
+ * invalidate query for.
+ * @returns Function `invalidateTokenBalances` that invalidates token balances
+ * @example
+ * const { invalidateTokenBalances } = useInvalidateTokensBalances(["mT", "mUSD"])
+ * (...)
+ * await invalidateTokenBalances()
+ */
+export function useInvalidateTokensBalances(tokens?: MezoChainToken[]) {
+  const queryClient = useQueryClient()
+
+  const { queryKey } = useTokensBalances({ tokens })
+
+  const invalidateTokenBalancesHandler = useCallback(
+    () => queryClient.invalidateQueries({ queryKey }),
+    [queryClient, queryKey],
+  )
+
+  return {
+    invalidateTokenBalances: invalidateTokenBalancesHandler,
+  }
+}
+
+/**
+ * Hook for resetting current user's token balances. Can be used to reset the
+ * balances manually, which forces the data to be re-fetched.
+ * @param tokens The list of tokens (as string arrays) for which we want to
+ * reset query for.
+ * @returns Function `resetTokenBalances` that invalidates token balances
+ * @example
+ * const { resetTokenBalances } = useResetTokensBalances(["mT", "mUSD"])
+ * (...)
+ * await resetTokenBalances()
+ */
+export function useResetTokensBalances(tokens?: MezoChainToken[]) {
+  const queryClient = useQueryClient()
+
+  const { queryKey } = useTokensBalances({ tokens })
+
+  const resetTokenBalancesHandler = useCallback(
+    () => queryClient.resetQueries({ queryKey }),
+    [queryClient, queryKey],
+  )
+
+  return {
+    resetTokenBalances: resetTokenBalancesHandler,
+  }
+}

package/src/hooks/useWalletAccount.ts

@@ -5,7 +5,8 @@ import { Address } from "viem"
 import { Connector, useAccount } from "wagmi"
 
 type UseWalletAccountReturn = {
-  address?: string | Address
+  accountAddress?: string | Address
+  walletAddress?: string | Address
   isConnected: boolean
   networkFamily: "bitcoin" | "evm"
   connector?: Connector
@@ -44,7 +45,8 @@ export default function useWalletAccount(): UseWalletAccountReturn {
   const { address: btcAddress } = btcData || {}
 
   return {
-    address: networkFamily === "bitcoin" ? btcAddress : evmAddress,
+    accountAddress: evmAddress,
+    walletAddress: btcAddress ?? evmAddress,
     isConnected: networkFamily === "bitcoin" ? !!btcAddress : !!evmAddress,
     networkFamily,
     connector,

package/src/lib/contracts/index.ts

@@ -0,0 +1,75 @@
+import cbbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mcbBTC.json"
+import daiMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mDAI.json"
+import fbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mFBTC.json"
+import solvbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mSolvBTC.json"
+import swbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mswBTC.json"
+import tMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mT.json"
+import usdcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mUSDC.json"
+import usdeMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mUSDe.json"
+import usdtMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mUSDT.json"
+import xsolvbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mxSolvBTC.json"
+
+import cbbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mcbBTC.json"
+import daiTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mDAI.json"
+import fbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mFBTC.json"
+import solvbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mSolvBTC.json"
+import swbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mswBTC.json"
+import tTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mT.json"
+import usdcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mUSDC.json"
+import usdeTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mUSDe.json"
+import usdtTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mUSDT.json"
+import xsolvbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mxSolvBTC.json"
+
+import { Abi, Address } from "viem"
+import { musdTestnet, musdMainnet } from "./musd"
+
+export { default as troveManagerContract } from "./troveManager"
+
+export type MezoChainToken =
+  | "mcbBTC"
+  | "mDAI"
+  | "mFBTC"
+  | "mSolvBTC"
+  | "mswBTC"
+  | "mT"
+  | "mUSDC"
+  | "mUSDe"
+  | "mUSDT"
+  | "mxSolvBTC"
+  | "MUSD"
+
+type ContractsMap = Record<
+  MezoChainToken,
+  {
+    address: Address
+    abi: Abi
+  }
+>
+
+export const testnetContracts = {
+  mcbBTC: cbbtcTestnet,
+  mDAI: daiTestnet,
+  mFBTC: fbtcTestnet,
+  mSolvBTC: solvbtcTestnet,
+  mswBTC: swbtcTestnet,
+  mT: tTestnet,
+  mUSDC: usdcTestnet,
+  mUSDe: usdeTestnet,
+  mUSDT: usdtTestnet,
+  mxSolvBTC: xsolvbtcTestnet,
+  MUSD: musdTestnet,
+} as unknown as ContractsMap
+
+export const mainnetContracts = {
+  mcbBTC: cbbtcMainnet,
+  mDAI: daiMainnet,
+  mFBTC: fbtcMainnet,
+  mSolvBTC: solvbtcMainnet,
+  mswBTC: swbtcMainnet,
+  mT: tMainnet,
+  mUSDC: usdcMainnet,
+  mUSDe: usdeMainnet,
+  mUSDT: usdtMainnet,
+  mxSolvBTC: xsolvbtcMainnet,
+  MUSD: musdMainnet,
+} as unknown as ContractsMap