@mezo-org/passport 0.4.0-dev.82 → 0.4.0-dev.84

package/src/hooks/useTokensBalances.ts

@@ -1,15 +1,26 @@
-import { useReadContracts } from "wagmi"
-import { useCallback, useMemo } from "react"
-import { Abi } from "viem"
-import { useQueryClient } from "@tanstack/react-query"
-import { usePassportContext } from "./usePassportContext"
+import { useConfig } from "wagmi"
+import { Abi, formatUnits } from "viem"
+import {
+  useQuery,
+  useQueryClient,
+  UseQueryOptions,
+} from "@tanstack/react-query"
+import { getBalance, readContracts } from "wagmi/actions"
 import {
   mainnetTokenContracts,
-  testnetTokenContracts,
   MezoChainToken,
+  testnetTokenContracts,
 } from "../lib/contracts"
 import useWalletAccount from "./useWalletAccount"
+import {
+  getAsset,
+  isBitcoinLikeCryptoAsset,
+  isTTokenCryptoAsset,
+} from "../utils/assets"
+import { convertToUsd } from "../utils/currency"
 import { CHAIN_ID } from "../constants"
+import { useAssetsConversionRates } from "./useAssetsConversionRates"
+import { normalizePrecision } from "../utils/numbers"
 
 // Wagmi handles typesafety with ABI const assertions. TypeScript doesn't
 // support importing JSON as const yet so types cannot be inferred from the
@@ -17,7 +28,7 @@ import { CHAIN_ID } from "../constants"
 // be asserted types from.
 // Ref: https://wagmi.sh/core/typescript#const-assert-abis-typed-data
 
-const BALANCE_OF_ABI = [
+export const BALANCE_OF_ABI = [
   {
     inputs: [
       {
@@ -53,11 +64,27 @@ const BALANCE_TOKENS: MezoChainToken[] = [
   "MUSD",
 ]
 
-type UseMezoChainTokensBalancesOptions<T> = {
+type UseMezoChainTokensBalancesOptions<T extends MezoChainToken[]> = {
   tokens?: T
-  queryOptions?: object
+  queryOptions?: Omit<
+    UseQueryOptions<Record<T[number], TokenBalance>>,
+    "queryKey" | "queryFn" | "select" | "enabled"
+  >
 }
 
+export type TokenBalance = {
+  decimals: number
+  formatted: string
+  symbol: string
+  value: bigint
+  usd: {
+    value: bigint
+    formatted: string
+  }
+}
+
+const TOKEN_BALANCES_QUERY_KEY = "passport.tokenBalances"
+
 /**
  * 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
@@ -67,93 +94,150 @@ type UseMezoChainTokensBalancesOptions<T> = {
  * @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"]
+ * // Assuming the status is "success"
+ * console.log(mezoTokensBalance.data.mT) // Eg. { value: 0n ... }
+ * console.log(Object.keys(mezoTokensBalance.data)) // ["mT", "mxSolvBTC"]
  */
 export function useTokensBalances<T extends MezoChainToken[]>(
   options: UseMezoChainTokensBalancesOptions<T> = {},
 ) {
-  const { environment = "mainnet" } = usePassportContext()
+  const { tokens = BALANCE_TOKENS, ...restQueryOptions } = options
 
-  const { accountAddress } = useWalletAccount()
+  const { data: walletAccountData } = useWalletAccount()
 
-  const contractsMap = useMemo(() => {
-    const contracts =
-      environment === "mainnet" ? mainnetTokenContracts : testnetTokenContracts
+  const config = useConfig()
 
-    const tokenContracts = Object.fromEntries(
-      Object.entries(contracts).filter(([key]) =>
-        BALANCE_TOKENS.includes(key as MezoChainToken),
-      ),
-    ) as typeof contracts
+  const { data: conversionRatesData } = useAssetsConversionRates()
 
-    return tokenContracts
-  }, [environment])
+  return useQuery({
+    queryKey: [
+      TOKEN_BALANCES_QUERY_KEY,
+      walletAccountData?.accountAddress,
+      options.tokens,
+    ],
+    enabled: !!walletAccountData?.accountAddress && !!conversionRatesData,
+    queryFn: async () => {
+      const isMainnet = config.state.chainId === CHAIN_ID.mainnet
+      const contractsMap = isMainnet
+        ? mainnetTokenContracts
+        : testnetTokenContracts
 
-  const { tokens = Object.keys(contractsMap) as T, queryOptions = {} } = options
+      const accountAddress = walletAccountData?.accountAddress
 
-  const contracts = useMemo(() => {
-    if (!accountAddress) return []
+      if (!accountAddress) {
+        throw new Error("Account address is not available.")
+      }
 
-    return tokens.map((token) => {
-      const { address } = contractsMap[token]
+      const tokenContracts = tokens.map((token) => {
+        const { address } = contractsMap[token]
+        return {
+          address,
+          abi: BALANCE_OF_ABI,
+          functionName: "balanceOf" as const,
+          args: [accountAddress],
+          chainId: config.state.chainId,
+        }
+      })
 
-      return {
-        address,
-        abi: BALANCE_OF_ABI,
-        functionName: "balanceOf",
-        args: [accountAddress],
-        chainId: CHAIN_ID[environment],
+      return Promise.all([
+        getBalance(config, { address: accountAddress }),
+        readContracts(config, {
+          contracts: tokenContracts,
+        }),
+      ])
+    },
+    select: (data) => {
+      const [btcBalance, tokensBalancesData] = data
+      if (!conversionRatesData) {
+        throw new Error("Conversion rates data is not available.")
       }
-    })
-  }, [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>,
+
+      const parsedBtcBalance = {
+        ...btcBalance,
+        symbol: getAsset("BTC").symbol,
+        usd: convertToUsd(
+          btcBalance.value,
+          btcBalance.decimals,
+          conversionRatesData.rates.BTC,
+          conversionRatesData.decimals,
         ),
-      ...queryOptions,
+      }
+
+      const parsedTokensBalances = tokensBalancesData.map((item, index) => {
+        const token = tokens[index]
+        const { decimals, symbol } = getAsset(token)
+
+        if (item.status === "failure") {
+          throw new Error(
+            `Failed to fetch balance of ${token} for ${walletAccountData?.accountAddress}.`,
+          )
+        }
+
+        const tokenBalance: Omit<TokenBalance, "usd"> = {
+          value: item.result,
+          decimals,
+          symbol,
+          formatted: formatUnits(item.result, decimals),
+        }
+
+        let usd = {
+          value: normalizePrecision(
+            tokenBalance.value,
+            tokenBalance.decimals,
+            conversionRatesData.decimals,
+          ),
+          formatted: formatUnits(tokenBalance.value, tokenBalance.decimals),
+        }
+        if (isBitcoinLikeCryptoAsset(tokenBalance.symbol)) {
+          usd = convertToUsd(
+            tokenBalance.value,
+            tokenBalance.decimals,
+            conversionRatesData.rates.BTC,
+            conversionRatesData.decimals,
+          )
+        }
+        if (isTTokenCryptoAsset(tokenBalance.symbol)) {
+          usd = convertToUsd(
+            tokenBalance.value,
+            tokenBalance.decimals,
+            conversionRatesData.rates.mT,
+            conversionRatesData.decimals,
+          )
+        }
+
+        return { ...tokenBalance, usd }
+      })
+
+      return [parsedBtcBalance, ...parsedTokensBalances].reduce(
+        (acc, token) => ({
+          ...acc,
+          [token.symbol]: token,
+        }),
+        {} as Record<T[number] | "BTC", TokenBalance>,
+      )
     },
+    ...restQueryOptions,
   })
 }
 
 /**
  * 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"])
+ * const { invalidateTokenBalances } = useInvalidateTokensBalances()
  * (...)
  * await invalidateTokenBalances()
  */
-export function useInvalidateTokensBalances(tokens?: MezoChainToken[]) {
+export function useInvalidateTokensBalances() {
   const queryClient = useQueryClient()
 
-  const { queryKey } = useTokensBalances({ tokens })
-
-  const invalidateTokensBalancesHandler = useCallback(
-    () => queryClient.invalidateQueries({ queryKey }),
-    [queryClient, queryKey],
-  )
+  const invalidateTokensBalancesHandler = () =>
+    queryClient.invalidateQueries({ queryKey: [TOKEN_BALANCES_QUERY_KEY] })
 
   return {
     invalidateTokensBalances: invalidateTokensBalancesHandler,
@@ -163,23 +247,17 @@ export function useInvalidateTokensBalances(tokens?: MezoChainToken[]) {
 /**
  * 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"])
+ * const { resetTokenBalances } = useResetTokensBalances()
  * (...)
  * await resetTokenBalances()
  */
-export function useResetTokensBalances(tokens?: MezoChainToken[]) {
+export function useResetTokensBalances() {
   const queryClient = useQueryClient()
 
-  const { queryKey } = useTokensBalances({ tokens })
-
-  const resetTokenBalancesHandler = useCallback(
-    () => queryClient.resetQueries({ queryKey }),
-    [queryClient, queryKey],
-  )
+  const resetTokenBalancesHandler = () =>
+    queryClient.resetQueries({ queryKey: [TOKEN_BALANCES_QUERY_KEY] })
 
   return {
     resetTokenBalances: resetTokenBalancesHandler,

package/src/hooks/useWalletAccount.ts

@@ -5,14 +5,18 @@ import { Address } from "viem"
 import { Connector, useAccount } from "wagmi"
 
 type UseWalletAccountReturn = {
-  accountAddress?: Address
-  walletAddress?: string
-  isConnected: boolean
-  networkFamily: "bitcoin" | "evm"
-  connector?: Connector
-  chainId?: number
+  data: {
+    accountAddress?: Address
+    walletAddress?: string
+    isConnected: boolean
+    networkFamily: "bitcoin" | "evm"
+    connector?: Connector
+    chainId?: number
+  }
 }
 
+// TODO: Invesitgate race conditions and refactor
+
 export default function useWalletAccount(): UseWalletAccountReturn {
   const { address: evmAddress, connector, chainId } = useAccount()
 
@@ -41,11 +45,13 @@ export default function useWalletAccount(): UseWalletAccountReturn {
   const { address: btcAddress } = btcData || {}
 
   return {
-    accountAddress: evmAddress,
-    walletAddress: btcAddress ?? evmAddress,
-    isConnected: networkFamily === "bitcoin" ? !!btcAddress : !!evmAddress,
-    networkFamily,
-    connector,
-    chainId,
-  } as const
+    data: {
+      accountAddress: evmAddress,
+      walletAddress: btcAddress ?? evmAddress,
+      isConnected: networkFamily === "bitcoin" ? !!btcAddress : !!evmAddress,
+      networkFamily,
+      connector,
+      chainId,
+    },
+  }
 }

package/src/lib/contracts/index.ts

@@ -25,6 +25,8 @@ import xsolvbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mxSol
 import musdTestnet from "@mezo-org/musd-contracts/deployments/matsnet/MUSD.json"
 import troveManagerTestnet from "@mezo-org/musd-contracts/deployments/matsnet/TroveManager.json"
 import borrowerOperationsTestnet from "@mezo-org/musd-contracts/deployments/matsnet/BorrowerOperations.json"
+import priceFeed from "@mezo-org/musd-contracts/deployments/mainnet/PriceFeed.json"
+import priceFeedTestnet from "@mezo-org/musd-contracts/deployments/matsnet/PriceFeed.json"
 
 import { Abi, Address } from "viem"
 
@@ -41,7 +43,10 @@ export type MezoChainToken =
   | "mxSolvBTC"
   | "MUSD"
 
-export type MezoBorrowContract = "TroveManager" | "BorrowerOperations"
+export type MezoBorrowContract =
+  | "TroveManager"
+  | "BorrowerOperations"
+  | "PriceFeed"
 
 type ContractsMap<K extends string> = Record<
   K,
@@ -82,11 +87,13 @@ export const mainnetTokenContracts = {
 export const mainnetBorrowContracts = {
   TroveManager: troveManagerMainnet,
   BorrowerOperations: borrowerOperationsMainnet,
+  PriceFeed: priceFeed,
 } as unknown as ContractsMap<MezoBorrowContract>
 
 export const testnetBorrowContracts = {
   TroveManager: troveManagerTestnet,
   BorrowerOperations: borrowerOperationsTestnet,
+  PriceFeed: priceFeedTestnet,
 } as unknown as ContractsMap<MezoBorrowContract>
 
 export { default as priceOracleContract } from "./priceOracle"

package/src/provider.ts

@@ -1,10 +1,13 @@
 import { createContext, createElement } from "react"
 import { AuthApiClient, PortalApiClient } from "./api"
+import { ONE_SECOND_MS } from "./utils/time"
 
 export interface PassportContextValue {
   authApiClient: AuthApiClient
   portalApiClient: PortalApiClient
   environment?: Environment
+  accountDataRefetchInterval: number
+  nativeBalanceRefetchInterval: number
 }
 
 export const PassportContext = createContext<PassportContextValue | undefined>(
@@ -15,12 +18,13 @@ type Environment = "mainnet" | "testnet"
 
 type PassportProviderProps = {
   children: React.ReactNode
-  // eslint-disable-next-line react/require-default-props
   environment?: Environment
-  // eslint-disable-next-line react/require-default-props
   authApiUrl?: string
-  // eslint-disable-next-line react/require-default-props
   portalApiUrl?: string
+  /** Time in milliseconds after which account data (like mats or mezo id) in dropdown should be re-fetched. Default is 90000 (90 secs) */
+  accountDataRefetchInterval?: number
+  /** Time in milliseconds after which native balance in dropdown should be re-fetched. Default is 90000 (90 secs) */
+  nativeBalanceRefetchInterval?: number
 }
 
 export function PassportProvider({
@@ -28,6 +32,8 @@ export function PassportProvider({
   authApiUrl,
   portalApiUrl,
   children,
+  accountDataRefetchInterval = 90 * ONE_SECOND_MS,
+  nativeBalanceRefetchInterval = 90 * ONE_SECOND_MS,
 }: PassportProviderProps) {
   if (environment && !["mainnet", "testnet"].includes(environment)) {
     throw new Error("Wrong environment passed to PassportProvider.")
@@ -43,6 +49,8 @@ export function PassportProvider({
           portalApiUrl,
         ),
         environment,
+        accountDataRefetchInterval,
+        nativeBalanceRefetchInterval,
       },
     },
     children,

package/src/utils/assets.test.ts

@@ -0,0 +1,57 @@
+import {
+  getAsset,
+  isBitcoinLikeCryptoAsset,
+  isUsdLikeCryptoAsset,
+  isTTokenCryptoAsset,
+} from "./assets"
+
+describe("getAsset", () => {
+  it("should return correct asset data", () => {
+    const asset = getAsset("BTC")
+    expect(asset).toEqual({
+      name: "Bitcoin",
+      symbol: "BTC",
+      decimals: 18,
+    })
+  })
+})
+
+describe("isBitcoinLikeCryptoAsset", () => {
+  it('should return true for keys containing "btc"', () => {
+    expect(isBitcoinLikeCryptoAsset("BTC")).toBe(true)
+    expect(isBitcoinLikeCryptoAsset("mFBTC")).toBe(true)
+    expect(isBitcoinLikeCryptoAsset("mcbBTC")).toBe(true)
+    expect(isBitcoinLikeCryptoAsset("mxSolvBTC")).toBe(true)
+  })
+
+  it("should return false for non-Bitcoin assets", () => {
+    expect(isBitcoinLikeCryptoAsset("ETH")).toBe(false)
+    expect(isBitcoinLikeCryptoAsset("mUSDC")).toBe(false)
+  })
+})
+
+describe("isUsdLikeCryptoAsset", () => {
+  it('should return true for keys containing "usd" or "dai"', () => {
+    expect(isUsdLikeCryptoAsset("mUSDC")).toBe(true)
+    expect(isUsdLikeCryptoAsset("mUSDT")).toBe(true)
+    expect(isUsdLikeCryptoAsset("mUSDe")).toBe(true)
+    expect(isUsdLikeCryptoAsset("mDAI")).toBe(true)
+  })
+
+  it("should return false for other tokens", () => {
+    expect(isUsdLikeCryptoAsset("BTC")).toBe(false)
+    expect(isUsdLikeCryptoAsset("mT")).toBe(false)
+  })
+})
+
+describe("isTTokenCryptoAsset", () => {
+  it('should return true for keys like "mT" or "t"', () => {
+    expect(isTTokenCryptoAsset("mT")).toBe(true)
+    expect(isTTokenCryptoAsset("T")).toBe(true)
+  })
+
+  it("should return false for other tokens", () => {
+    expect(isTTokenCryptoAsset("BTC")).toBe(false)
+    expect(isTTokenCryptoAsset("mUSDT")).toBe(false)
+  })
+})

package/src/utils/assets.ts

@@ -0,0 +1,103 @@
+const ASSETS = {
+  BTC: {
+    name: "Bitcoin",
+    symbol: "BTC",
+    decimals: 18,
+  },
+  ETH: {
+    name: "Ethereum",
+    symbol: "ETH",
+    decimals: 18,
+  },
+  MUSD: {
+    name: "MUSD",
+    symbol: "MUSD",
+    decimals: 18,
+  },
+  mDAI: {
+    name: "Mezo Dai Stablecoin",
+    symbol: "mDAI",
+    decimals: 18,
+  },
+  mFBTC: {
+    name: "Mezo Fire Bitcoin",
+    symbol: "mFBTC",
+    decimals: 8,
+  },
+  mcbBTC: {
+    name: "Mezo Coinbase Wrapped BTC",
+    symbol: "mcbBTC",
+    decimals: 8,
+  },
+  mSolvBTC: {
+    name: "Mezo SolvBTC",
+    symbol: "mSolvBTC",
+    decimals: 18,
+  },
+  mswBTC: {
+    name: "Mezo swBTC",
+    symbol: "mswBTC",
+    decimals: 8,
+  },
+  mT: {
+    name: "Mezo Threshold Network Token",
+    symbol: "mT",
+    decimals: 18,
+  },
+  mUSDC: {
+    name: "Mezo Circle USDC",
+    symbol: "mUSDC",
+    decimals: 6,
+  },
+  mUSDe: {
+    name: "Mezo Ethena USDe",
+    symbol: "mUSDe",
+    decimals: 18,
+  },
+  mUSDT: {
+    name: "Mezo Tether USDe",
+    symbol: "mUSDT",
+    decimals: 6,
+  },
+  mxSolvBTC: {
+    name: "Mezo xSolvBTC",
+    symbol: "mxSolvBTC",
+    decimals: 18,
+  },
+}
+
+/**
+ * Gets details of given crypto asset
+ * @param key The key of crypto asset
+ * @returns The crypto asset details
+ */
+export function getAsset(key: keyof typeof ASSETS) {
+  return ASSETS[key]
+}
+
+/**
+ * Checks if given crypto asset is Bitcoin-like
+ * @param key The key of crypto asset
+ * @returns True if crypto asset is Bitcoin-like
+ */
+export function isBitcoinLikeCryptoAsset(key: string) {
+  return /(btc)/i.test(key)
+}
+
+/**
+ * Checks if given crypto asset is USD-like
+ * @param key The key of crypto asset
+ * @returns True if crypto asset is USD-like
+ */
+export function isUsdLikeCryptoAsset(key: string) {
+  return /(usd|dai)/i.test(key)
+}
+
+/**
+ * Checks if given crypto asset is T token
+ * @param key The key of crypto asset
+ * @returns True if crypto asset is T token
+ */
+export function isTTokenCryptoAsset(key: string) {
+  return /^(mt|t)$/i.test(key)
+}

package/src/utils/currency.test.ts

@@ -1,4 +1,4 @@
-import { formatCurrency, formatUsd } from "./currency"
+import { convertToUsd, formatCurrency, formatUsd } from "./currency"
 
 describe("formatCurrency", () => {
   it("formats a number as currency with default options", () => {
@@ -37,4 +37,78 @@ describe("formatUsd", () => {
   })
 })
 
-// TODO: Add tests for convertToUsd function
+describe("convertToUsd", () => {
+  it("converts 1 BTC (8 decimals) with $30,000 rate (6 decimals)", () => {
+    const assetAmount = 1_00000000n // 1 BTC
+    const assetDecimals = 8
+    const conversionRate = 30_000_000000n // $30,000 in 6 decimals
+    const conversionRateDecimals = 6
+
+    const result = convertToUsd(
+      assetAmount,
+      assetDecimals,
+      conversionRate,
+      conversionRateDecimals,
+    )
+
+    expect(result.value).toBe(30_000_000000n)
+    expect(result.formatted).toBe("30000")
+  })
+
+  it("converts 0.5 BTC correctly", () => {
+    const assetAmount = 50_000000n // 0.5 BTC
+    const assetDecimals = 8
+    const conversionRate = 40_000_000000n // $40,000
+    const conversionRateDecimals = 6
+
+    const result = convertToUsd(
+      assetAmount,
+      assetDecimals,
+      conversionRate,
+      conversionRateDecimals,
+    )
+
+    expect(result.value).toBe(20_000_000000n)
+    expect(result.formatted).toBe("20000")
+  })
+
+  it("converts 1 ETH (18 decimals) with $2,000 rate (6 decimals)", () => {
+    const assetAmount = 1_000000000000000000n // 1 ETH
+    const assetDecimals = 18
+    const conversionRate = 2_000_000000n
+    const conversionRateDecimals = 6
+
+    const result = convertToUsd(
+      assetAmount,
+      assetDecimals,
+      conversionRate,
+      conversionRateDecimals,
+    )
+
+    expect(result.value).toBe(2_000_000000n)
+    expect(result.formatted).toBe("2000")
+  })
+
+  it("handles zero amount correctly", () => {
+    const result = convertToUsd(0n, 18, 999_999999n, 6)
+    expect(result.value).toBe(0n)
+    expect(result.formatted).toBe("0")
+  })
+
+  it("handles assets with fewer decimals than conversion rate", () => {
+    const assetAmount = 100n
+    const assetDecimals = 2
+    const conversionRate = 1_500_000000n // $1500
+    const conversionRateDecimals = 6
+
+    const result = convertToUsd(
+      assetAmount,
+      assetDecimals,
+      conversionRate,
+      conversionRateDecimals,
+    )
+
+    expect(result.value).toBe(1_500_000000n)
+    expect(result.formatted).toBe("1500")
+  })
+})