@mezo-org/passport 0.4.0-dev.6 → 0.4.0-dev.60

package/src/hooks/useDropdownData.ts

@@ -1,130 +1,152 @@
-import { useBitcoinAccount } from "@mezo-org/orangekit"
+import { useBalance } from "wagmi"
 import { useGetCurrentAccount } from "."
 import {
   CryptoAssetKey,
   getCryptoAsset,
   isBitcoinLikeCryptoAsset,
-  isUsdLikeCryptoAsset,
+  mapCryptoAssetToDetails,
 } from "../utils/cryptoAssets"
 import { fromFixedPoint } from "../utils/numbers"
-import { useAssetsUsdConversion } from "./useAssetsUSDConversion"
+import { useAssetsConversionRates } from "./useAssetsConversionRates"
 import useWalletAccount from "./useWalletAccount"
-
-/**
- * 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
- */
-export function formatCryptoAsset(
-  type: CryptoAssetKey,
-  balance: bigint,
-  btcUsdConversionRate: number,
-) {
-  const { decimals } = getCryptoAsset(type)
-
-  const nativeBalance = fromFixedPoint(balance, decimals, 4)
-  let balanceInUsd = 0
-  if (isBitcoinLikeCryptoAsset(type)) {
-    balanceInUsd = nativeBalance * btcUsdConversionRate
-  }
-  if (isUsdLikeCryptoAsset(type)) {
-    balanceInUsd = nativeBalance
-  }
-
-  return {
-    type,
-    balance: nativeBalance,
-    balanceInUsd,
-    decimals,
-  }
-}
+import { useTokensBalances } from "./useTokensBalances"
+import { useBorrowData } from "./useBorrowData"
+import { CHAIN_ID } from "../constants"
+import { usePassportContext } from "./usePassportContext"
+import { useWatchTransferEventsForAllTokens } from "./useWatchTransferEvents"
+import { convertToUsd } from "../utils/currency"
 
 export type DropdownCryptoAsset<T = CryptoAssetKey> = {
   type: T
   balance: bigint
 }
 
-type DropdownDetailedCryptoAsset = ReturnType<typeof formatCryptoAsset>
-
-export type DropdownData = {
-  mezoId: string
-  address: string
-  walletType: "bitcoin" | "evm"
-  totalBalanceInUsd: number
-  formattedNativeAssets: DropdownDetailedCryptoAsset[]
-  matsnet: {
-    mats: number
-    formattedAssets: DropdownDetailedCryptoAsset[]
-  }
-}
-
-type UseDropdownDataOptions = {
-  // This is workaround. It should be read from contracts or fetched from API.
-  evmNativeAssets?: DropdownCryptoAsset[]
-  matsnetAssets?: DropdownCryptoAsset[]
+const DEFAULT_ASSET_DATA = {
+  rawBalance: 0n,
+  formattedBalance: "0.0000",
+  usdBalance: 0,
+  formattedUsdBalance: "$0.00",
 }
 
 /**
  * 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.
+ * @param {accountDataRefetchInterval: number, nativeBalanceRefetchInterval: number }
+ * Object containing refetch intervals time (in milliseconds) for account data
+ * (like mats or mezo id) and for native balance. After that time the specific
+ * value should be marked as stale and re-fetched. Default value for both is
+ * 90000 (90 secs).
  * @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()
-  const { address, networkFamily, isConnected } = useWalletAccount()
-  const { data: passportAccount } = useGetCurrentAccount()
-  const { data: assetsUsdConversion } = useAssetsUsdConversion()
-
-  if (!address || !isConnected || !passportAccount) {
-    return null
-  }
-
-  const mezoId = passportAccount.mezoId!
-
-  const nativeAssets: DropdownCryptoAsset[] =
-    networkFamily === "bitcoin"
-      ? [
-          {
-            type: "btc",
-            balance: BigInt(btcBalance?.total ?? 0),
-          },
-        ]
-      : evmNativeAssets
+export default function useDropdownData({
+  accountDataRefetchInterval = 90000,
+  nativeBalanceRefetchInterval = 90000,
+}) {
+  const {
+    walletAddress,
+    accountAddress,
+    networkFamily: walletType,
+  } = useWalletAccount()
+  const { environment = "mainnet" } = usePassportContext()
+  const { data: btcBalance } = useBalance({
+    address: accountAddress,
+    chainId: CHAIN_ID[environment],
+    query: {
+      staleTime: nativeBalanceRefetchInterval,
+      refetchInterval: nativeBalanceRefetchInterval,
+    },
+  })
+  const { data: passportAccount } = useGetCurrentAccount({
+    staleTime: accountDataRefetchInterval,
+    refetchInterval: accountDataRefetchInterval,
+    enabled: !!accountAddress,
+  })
+  const { data: assetsConversionRates } = useAssetsConversionRates()
+  const { data: tokensBalances } = useTokensBalances()
+  const { data: debt } = useBorrowData()
+
+  useWatchTransferEventsForAllTokens()
+
+  const mezoId = passportAccount?.mezoId
+
+  const detailedAssets = [
+    ["BTC", btcBalance?.value ?? 0n],
+    ...Object.entries(tokensBalances ?? {}),
+  ].map((asset) => {
+    const [type, balance] = asset as [CryptoAssetKey, bigint]
+
+    if (isBitcoinLikeCryptoAsset(type)) {
+      return mapCryptoAssetToDetails(
+        type,
+        balance,
+        assetsConversionRates.btc.price,
+        assetsConversionRates.btc.decimals,
+      )
+    }
+    if (type === "mT") {
+      return mapCryptoAssetToDetails(
+        type,
+        balance,
+        assetsConversionRates.t.price,
+        assetsConversionRates.t.decimals,
+      )
+    }
+
+    return mapCryptoAssetToDetails(type, balance, 1n, 0)
+  })
+
+  const btcData = detailedAssets.find(({ type }) => type === "BTC")!
+  const musdData = detailedAssets.find(({ type }) => type === "MUSD")!
+  const otherAssetsData = detailedAssets.filter(
+    ({ type }) => !["BTC", "MUSD"].includes(type),
+  )
 
-  const btcUsdConversionRate = Number(assetsUsdConversion?.btcUsd ?? 0)
+  const otherAssetsCount = otherAssetsData.filter(
+    (asset) => asset.rawBalance !== 0n,
+  ).length
 
-  const formattedNativeAssets = nativeAssets.map((asset) =>
-    formatCryptoAsset(asset.type, asset.balance, btcUsdConversionRate),
-  )
+  const assets = {
+    btc: btcData || {
+      type: "BTC",
+      ...DEFAULT_ASSET_DATA,
+    },
+    musd: musdData || {
+      type: "mUSD",
+      ...DEFAULT_ASSET_DATA,
+    },
+  }
 
-  const totalBalanceInUsd = formattedNativeAssets.reduce(
-    (sum, value) => sum + value.balanceInUsd,
+  const otherAssetsUsdTotal = otherAssetsData.reduce(
+    (sum, { usdBalance }) => sum + usdBalance,
     0,
   )
 
-  const matsBalance = passportAccount.mats.totalMats
+  const matsBalance = passportAccount?.mats.totalMats || 0
 
-  const matsnetFormattedAssets = matsnetAssets.map((asset) =>
-    formatCryptoAsset(asset.type, asset.balance, btcUsdConversionRate),
+  const usdCollateral = convertToUsd(
+    debt?.collateral ?? 0n,
+    getCryptoAsset("MUSD").decimals,
+    assetsConversionRates.btc.price,
+    assetsConversionRates.btc.decimals,
   )
 
+  const usdTroveDebt = fromFixedPoint(debt?.troveDebt ?? 0n, 18)
+
+  const usdTotalBalance =
+    detailedAssets.reduce((sum, { usdBalance }) => sum + usdBalance, 0) +
+    usdCollateral
+
   return {
     mezoId,
-    address,
-    walletType: networkFamily,
-    totalBalanceInUsd,
-    formattedNativeAssets,
-    matsnet: {
-      mats: matsBalance,
-      formattedAssets: matsnetFormattedAssets,
-    },
+    matsBalance,
+    accountAddress,
+    walletAddress,
+    walletType,
+    usdTotalBalance,
+    usdTroveDebt,
+    usdCollateral,
+    assets,
+    otherAssetsCount,
+    otherAssetsUsdTotal,
   }
 }

package/src/hooks/useRefreshPassport.ts

@@ -0,0 +1,56 @@
+import { useQueryClient } from "@tanstack/react-query"
+import { useCallback } from "react"
+import { useAccount, useBalance } from "wagmi"
+import { QUERY_KEYS } from "./constants"
+import { useInvalidateBorrowData } from "./useBorrowData"
+import { useInvalidateTokensBalances } from "./useTokensBalances"
+
+/**
+ * Hook to refresh the passport using query invalidation mechanism.
+ * By calling the refresh function, the latest data will be refetched as soon as possible.
+ *
+ * @example
+ * const { refreshCurrentAccount, refreshUsdConversion } = useRefreshPassport()
+ *
+ * // Call this function to refresh the current account
+ * const handlerefreshCurrentAccount = async () => {
+ *   await refreshCurrentAccount()
+ * }
+ */
+export function useRefreshPassport() {
+  const { address } = useAccount()
+  const queryClient = useQueryClient()
+  const { invalidateBorrowData } = useInvalidateBorrowData()
+  const { invalidateTokensBalances } = useInvalidateTokensBalances()
+  const { queryKey: nativeTokenQueryKey } = useBalance({ address })
+
+  const refreshCurrentAccount = useCallback(
+    () =>
+      queryClient.invalidateQueries({
+        queryKey: [QUERY_KEYS.ACCOUNT, QUERY_KEYS.CURRENT],
+      }),
+    [queryClient],
+  )
+
+  const refreshUsdConversion = useCallback(
+    () =>
+      queryClient.invalidateQueries({
+        queryKey: [QUERY_KEYS.ASSETS_USD_CONVERSION],
+      }),
+    [queryClient],
+  )
+
+  const refreshTokensBalances = useCallback(async () => {
+    await queryClient.invalidateQueries({
+      queryKey: nativeTokenQueryKey,
+    })
+    await invalidateTokensBalances()
+  }, [queryClient, nativeTokenQueryKey, invalidateTokensBalances])
+
+  return {
+    refreshCurrentAccount,
+    refreshUsdConversion,
+    refreshBorrowData: invalidateBorrowData,
+    refreshTokensBalances,
+  }
+}

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 {
+  mainnetTokenContracts,
+  testnetTokenContracts,
+  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" ? mainnetTokenContracts : testnetTokenContracts
+
+    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 invalidateTokensBalancesHandler = useCallback(
+    () => queryClient.invalidateQueries({ queryKey }),
+    [queryClient, queryKey],
+  )
+
+  return {
+    invalidateTokensBalances: invalidateTokensBalancesHandler,
+  }
+}
+
+/**
+ * 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

@@ -1,39 +1,53 @@
-import { useBitcoinAccount } from "@mezo-org/orangekit"
-import { useEffect, useMemo, useState } from "react"
+import { OrangeKitBitcoinProvider } from "@mezo-org/orangekit"
+import { useQuery } from "@tanstack/react-query"
+import { useMemo } from "react"
 import { Address } from "viem"
 import { Connector, useAccount } from "wagmi"
 
 type UseWalletAccountReturn = {
-  address?: string | Address
+  accountAddress?: Address
+  walletAddress?: string
   isConnected: boolean
   networkFamily: "bitcoin" | "evm"
   connector?: Connector
   chainId?: number
 }
 
+type OrangeKitConnector = {
+  getBitcoinProvider: () => OrangeKitBitcoinProvider
+}
+
 export default function useWalletAccount(): UseWalletAccountReturn {
   const { address: evmAddress, connector, chainId } = useAccount()
-  const { btcAddress } = useBitcoinAccount()
-  const [isConnected, setIsConnected] = useState(false)
-
-  useEffect(() => {
-    if (!connector) {
-      setIsConnected(false)
-      return
-    }
-
-    const isBitcoinFlow = connector.type === "orangekit"
-    setIsConnected(isBitcoinFlow ? !!btcAddress : !!evmAddress)
-  }, [btcAddress, connector, evmAddress])
 
   const networkFamily = useMemo(
-    () => (btcAddress ? "bitcoin" : "evm"),
-    [btcAddress],
+    () => (connector?.type !== "orangekit" ? "evm" : "bitcoin"),
+    [connector],
   )
 
+  const { data: btcData } = useQuery({
+    queryKey: [connector?.id],
+    queryFn: async () => {
+      const bitcoinProvider = (
+        connector as unknown as OrangeKitConnector
+      ).getBitcoinProvider()
+
+      const address = await bitcoinProvider.getAddress()
+      const balance = await bitcoinProvider.getBalance()
+
+      return {
+        address,
+        balance,
+      }
+    },
+  })
+
+  const { address: btcAddress } = btcData || {}
+
   return {
-    address: btcAddress || evmAddress,
-    isConnected,
+    accountAddress: evmAddress,
+    walletAddress: btcAddress ?? evmAddress,
+    isConnected: networkFamily === "bitcoin" ? !!btcAddress : !!evmAddress,
     networkFamily,
     connector,
     chainId,

package/src/hooks/useWatchTransferEvents.ts

@@ -0,0 +1,74 @@
+import { useMemo } from "react"
+import { useAccount, useWatchContractEvent } from "wagmi"
+import {
+  mainnetTokenContracts,
+  MezoChainToken,
+  testnetTokenContracts,
+} from "../lib/contracts"
+import { usePassportContext } from "./usePassportContext"
+import { CHAIN_ID } from "../constants"
+import { useRefreshPassport } from "./useRefreshPassport"
+import { simpleWssMezoConfig } from "../config"
+
+function useWatchTransferEvents(token: MezoChainToken) {
+  const { address: userAddress } = useAccount()
+  const { environment = "mainnet" } = usePassportContext()
+  const { refreshTokensBalances, refreshBorrowData } = useRefreshPassport()
+
+  const contract = useMemo(() => {
+    const contracts =
+      environment === "mainnet" ? mainnetTokenContracts : testnetTokenContracts
+
+    return contracts[token]
+  }, [environment, token])
+
+  useWatchContractEvent({
+    address: contract.address,
+    abi: contract.abi,
+    eventName: "Transfer",
+    args: {
+      from: userAddress,
+    },
+    chainId: CHAIN_ID[environment],
+    enabled: !!userAddress,
+    config: simpleWssMezoConfig,
+    onLogs() {
+      console.log(`[${token}] Transfer from: ${userAddress}`)
+      refreshTokensBalances()
+      refreshBorrowData()
+    },
+  })
+
+  useWatchContractEvent({
+    address: contract.address,
+    abi: contract.abi,
+    eventName: "Transfer",
+    args: {
+      to: userAddress,
+    },
+    chainId: CHAIN_ID[environment],
+    enabled: !!userAddress,
+    config: simpleWssMezoConfig,
+    onLogs() {
+      console.log(`[${token}] Transfer to: ${userAddress}`)
+      refreshTokensBalances()
+      refreshBorrowData()
+    },
+  })
+}
+
+function useWatchTransferEventsForAllTokens() {
+  useWatchTransferEvents("mcbBTC")
+  useWatchTransferEvents("mDAI")
+  useWatchTransferEvents("mFBTC")
+  useWatchTransferEvents("mSolvBTC")
+  useWatchTransferEvents("mswBTC")
+  useWatchTransferEvents("mT")
+  useWatchTransferEvents("mUSDC")
+  useWatchTransferEvents("mUSDe")
+  useWatchTransferEvents("mUSDT")
+  useWatchTransferEvents("mxSolvBTC")
+  useWatchTransferEvents("MUSD")
+}
+
+export { useWatchTransferEvents, useWatchTransferEventsForAllTokens }

package/src/index.ts

@@ -1,5 +1,15 @@
 export * from "./components"
-export * from "./config"
+export {
+  defaultConfig,
+  unisatWalletMezoMainnet,
+  unisatWalletMezoTestnet,
+  okxWalletMezoMainnet,
+  okxWalletMezoTestnet,
+  xverseWalletMezoMainnet,
+  xverseWalletMezoTestnet,
+  getDefaultWallets,
+  getConfig,
+} from "./config"
 export * from "./constants"
 export * from "./hooks"
 export * from "./provider"