@mezo-org/passport 0.4.0-dev.9 → 0.5.1-dev.0

package/src/hooks/useTokensBalances.ts

@@ -0,0 +1,265 @@
+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,
+  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
+// 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
+
+export 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 extends MezoChainToken[]> = {
+  tokens?: T
+  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
+ *          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.
+ * @example
+ * const mezoTokensBalance = useTokensBalances({
+ *   tokens: ["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 { tokens = BALANCE_TOKENS, ...restQueryOptions } = options
+
+  const walletAccount = useWalletAccount()
+
+  const config = useConfig()
+
+  const { data: conversionRatesData } = useAssetsConversionRates()
+
+  return useQuery({
+    queryKey: [
+      TOKEN_BALANCES_QUERY_KEY,
+      walletAccount?.accountAddress,
+      options.tokens,
+    ],
+    enabled: !!walletAccount?.accountAddress && !!conversionRatesData,
+    queryFn: async () => {
+      const isMainnet = config.state.chainId === CHAIN_ID.mainnet
+      const contractsMap = isMainnet
+        ? mainnetTokenContracts
+        : testnetTokenContracts
+
+      const accountAddress = walletAccount?.accountAddress
+
+      if (!accountAddress) {
+        throw new Error("Account address is not available.")
+      }
+
+      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 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.")
+      }
+
+      const parsedBtcBalance = {
+        ...btcBalance,
+        symbol: getAsset("BTC").symbol,
+        usd: convertToUsd(
+          btcBalance.value,
+          btcBalance.decimals,
+          conversionRatesData.rates.BTC,
+          conversionRatesData.decimals,
+        ),
+      }
+
+      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 ${walletAccount?.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.
+ * @returns Function `invalidateTokenBalances` that invalidates token balances
+ * @example
+ * const { invalidateTokenBalances } = useInvalidateTokensBalances()
+ * (...)
+ * await invalidateTokenBalances()
+ */
+export function useInvalidateTokensBalances() {
+  const queryClient = useQueryClient()
+
+  const invalidateTokensBalancesHandler = () =>
+    queryClient.invalidateQueries({ queryKey: [TOKEN_BALANCES_QUERY_KEY] })
+
+  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.
+ * @returns Function `resetTokenBalances` that invalidates token balances
+ * @example
+ * const { resetTokenBalances } = useResetTokensBalances()
+ * (...)
+ * await resetTokenBalances()
+ */
+export function useResetTokensBalances() {
+  const queryClient = useQueryClient()
+
+  const resetTokenBalancesHandler = () =>
+    queryClient.resetQueries({ queryKey: [TOKEN_BALANCES_QUERY_KEY] })
+
+  return {
+    resetTokenBalances: resetTokenBalancesHandler,
+  }
+}

package/src/hooks/useValidateMezoId.ts

@@ -0,0 +1,31 @@
+import { UseQueryResult } from "@tanstack/react-query"
+import { validateMezoId, MezoId } from "../utils/mezoId"
+import { useGetAccountByMezoId } from "./useGetAccountByMezoId"
+
+export function useValidateMezoId(mezoId: MezoId) {
+  const validationErrors = validateMezoId(mezoId)
+
+  return useGetAccountByMezoId(mezoId, {
+    placeholderData: {
+      // @ts-expect-error TODO: Couldn't fix type for placeholderData which for
+      // some reason should return the same data as the data returned in
+      // queryFn.
+      isValid: validationErrors.length === 0,
+      isAvailable: validationErrors.length === 0,
+      errors: validationErrors,
+    },
+    enabled: validationErrors.length === 0,
+    // @ts-expect-error TODO: Couldn't fix type for select which for some reason
+    // should return the same data as the data returned in queryFn.
+    select: (data) => {
+      const isValid = validationErrors.length === 0
+      const isAvailable = isValid ? !data : false
+
+      return { isValid, isAvailable, errors: validationErrors }
+    },
+  }) as UseQueryResult<{
+    isValid: boolean
+    isAvailable: boolean
+    errors: string[]
+  }>
+}

package/src/hooks/useWalletAccount.ts

@@ -1,41 +1,53 @@
-import { useBitcoinAccount } from "@mezo-org/orangekit"
-import { useEffect, useMemo, useState } from "react"
+import { OrangeKitConnector } 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
 }
 
+// TODO: Invesitgate race conditions and refactor
+
 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,
-  } as const
+  }
 }

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,6 +1,17 @@
 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"
 export * from "./wallet"
+export { DISALLOWED_MEZO_ID_PATTERNS } from "./utils/mezoId"

package/src/lib/contracts/index.ts

@@ -0,0 +1,99 @@
+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 musdMainnet from "@mezo-org/musd-contracts/deployments/mainnet/MUSD.json"
+import troveManagerMainnet from "@mezo-org/musd-contracts/deployments/mainnet/TroveManager.json"
+import borrowerOperationsMainnet from "@mezo-org/musd-contracts/deployments/mainnet/BorrowerOperations.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 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"
+
+export type MezoChainToken =
+  | "mcbBTC"
+  | "mDAI"
+  | "mFBTC"
+  | "mSolvBTC"
+  | "mswBTC"
+  | "mT"
+  | "mUSDC"
+  | "mUSDe"
+  | "mUSDT"
+  | "mxSolvBTC"
+  | "MUSD"
+
+export type MezoBorrowContract =
+  | "TroveManager"
+  | "BorrowerOperations"
+  | "PriceFeed"
+
+type ContractsMap<K extends string> = Record<
+  K,
+  {
+    address: Address
+    abi: Abi
+  }
+>
+
+export const testnetTokenContracts = {
+  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<MezoChainToken>
+
+export const mainnetTokenContracts = {
+  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<MezoChainToken>
+
+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/lib/contracts/priceOracle.ts

@@ -0,0 +1,53 @@
+import { Address } from "viem"
+
+export default {
+  address: "0x7b7c000000000000000000000000000000000015" as Address,
+  abi: [
+    {
+      inputs: [],
+      name: "decimals",
+      outputs: [
+        {
+          internalType: "uint8",
+          name: "",
+          type: "uint8",
+        },
+      ],
+      stateMutability: "view",
+      type: "function",
+    },
+    {
+      inputs: [],
+      name: "latestRoundData",
+      outputs: [
+        {
+          internalType: "uint80",
+          name: "roundId",
+          type: "uint80",
+        },
+        {
+          internalType: "int256",
+          name: "answer",
+          type: "int256",
+        },
+        {
+          internalType: "uint256",
+          name: "startedAt",
+          type: "uint256",
+        },
+        {
+          internalType: "uint256",
+          name: "updatedAt",
+          type: "uint256",
+        },
+        {
+          internalType: "uint80",
+          name: "answeredInRound",
+          type: "uint80",
+        },
+      ],
+      stateMutability: "view",
+      type: "function",
+    },
+  ] as const,
+}

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/stores/dropdownStore.ts

@@ -0,0 +1,20 @@
+import { create } from "zustand"
+
+export enum DropdownView {
+  ROOT = "ROOT",
+  RECEIVE = "RECEIVE",
+}
+
+interface DropdownStore {
+  view: DropdownView
+  setView: (view: DropdownView) => void
+  isNestedView: () => boolean
+}
+
+const useDropdownStore = create<DropdownStore>((set, get) => ({
+  view: DropdownView.ROOT,
+  setView: (view: DropdownView) => set({ view }),
+  isNestedView: () => get().view !== DropdownView.ROOT,
+}))
+
+export default useDropdownStore