@mezo-org/passport 0.4.0-dev.8 → 0.4.0-dev.81

package/src/hooks/useBorrowData.ts

@@ -0,0 +1,187 @@
+import { useAccount, useReadContracts } from "wagmi"
+import { useCallback, useMemo } from "react"
+import { useQueryClient } from "@tanstack/react-query"
+import { ONE_MINUTE_MS } from "../utils/time"
+import {
+  mainnetBorrowContracts,
+  testnetBorrowContracts,
+} from "../lib/contracts"
+import { usePassportContext } from "./usePassportContext"
+import { CHAIN_ID } from "../constants"
+import { bigIntMax } 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
+
+const TROVE_MANAGER_ABI = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_borrower",
+        type: "address",
+      },
+    ],
+    name: "getEntireDebtAndColl",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "coll",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "principal",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "interest",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "pendingCollateral",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "pendingPrincipal",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "pendingInterest",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const
+
+const BORROWER_OPERATIONS_ABI = [
+  {
+    inputs: [],
+    name: "MUSD_GAS_COMPENSATION",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const
+
+/**
+ * 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()
+
+  const contractAddress = useMemo(() => {
+    if (environment === "mainnet") {
+      return {
+        troveManager: mainnetBorrowContracts.TroveManager.address,
+        borrowerOperations: mainnetBorrowContracts.BorrowerOperations.address,
+      }
+    }
+    return {
+      troveManager: testnetBorrowContracts.TroveManager.address,
+      borrowerOperations: testnetBorrowContracts.BorrowerOperations.address,
+    }
+  }, [environment])
+
+  const chainId = CHAIN_ID[environment]
+
+  return useReadContracts({
+    contracts: [
+      {
+        abi: TROVE_MANAGER_ABI,
+        address: contractAddress.troveManager,
+        functionName: "getEntireDebtAndColl",
+        args: [address || "0x"],
+        chainId,
+      },
+      {
+        abi: BORROWER_OPERATIONS_ABI,
+        address: contractAddress.borrowerOperations,
+        functionName: "MUSD_GAS_COMPENSATION",
+        args: [],
+        chainId,
+      },
+    ],
+    query: {
+      enabled: !!address,
+      staleTime: 5 * ONE_MINUTE_MS,
+      retry: 1,
+      select: (data) => {
+        if (!data || data.some((item) => !item.result)) return undefined
+
+        const [collateral, principal, interest] = data[0].result!
+        const gasCompensation = data[1].result!
+
+        const troveDebt = bigIntMax(
+          principal + interest - gasCompensation,
+          0n, // Ensure that debt is not negative
+        )
+
+        return {
+          collateral,
+          // Principal includes gas compensation value which is not
+          troveDebt,
+        }
+      },
+      ...queryOptions,
+    },
+  })
+}
+
+/**
+ * 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/useCreateAccount.ts

@@ -7,6 +7,8 @@ import {
 import { useAuthApiClient } from "./useAuthApiClient"
 import { QUERY_KEYS } from "./constants"
 import type { CreateAccountRequest, CreateAccountResponse } from "../api"
+import useWalletAccount from "./useWalletAccount"
+import { getBitcoinPublicKeyFromConnector } from "../utils/wagmi"
 
 export function useCreateAccount(
   mutationOptions: Omit<
@@ -16,12 +18,36 @@ export function useCreateAccount(
 ) {
   const queryClient = useQueryClient()
   const authApiClient = useAuthApiClient()
+  const { connector } = useWalletAccount()
 
   const { onSuccess: customOnSuccess, ...restMutationOptions } = mutationOptions
 
   const { mutate, mutateAsync, ...rest } = useMutation({
-    mutationFn: (createAccountRequest: CreateAccountRequest) =>
-      authApiClient.createAccount(createAccountRequest),
+    mutationFn: async (
+      createAccountMutationFnParameters: CreateAccountRequest,
+    ) => {
+      if (createAccountMutationFnParameters.type === "wallet") {
+        if (!connector) {
+          throw new Error("Connector not defined.")
+        }
+
+        const bitcoinPublicKey =
+          await getBitcoinPublicKeyFromConnector(connector)
+
+        // Creating bitcoin mezo account
+        if (bitcoinPublicKey) {
+          return authApiClient.createAccount({
+            ...createAccountMutationFnParameters,
+            bitcoinPublicKey,
+          })
+        }
+      }
+
+      // Creating evm mezo account
+      return authApiClient.createAccount({
+        ...createAccountMutationFnParameters,
+      })
+    },
     onSuccess: (data, variables, context) => {
       queryClient.resetQueries({
         queryKey: [QUERY_KEYS.ACCOUNT],

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/useLinkAccount.ts

@@ -5,23 +5,55 @@ import {
   DefaultError,
 } from "@tanstack/react-query"
 import { useAuthApiClient } from "./useAuthApiClient"
-import type { LinkAccountRequest, LinkAccountResponse } from "../api"
+import type { LinkAccountResponse, SignatureData } from "../api"
 import { QUERY_KEYS } from "./constants"
+import useWalletAccount from "./useWalletAccount"
+import { getBitcoinPublicKeyFromConnector } from "../utils/wagmi"
+
+type LinkAccountMutationFnParameters =
+  | ({ type: "wallet" } & SignatureData)
+  | { type: "discord" }
 
 export function useLinkAccount(
   mutationOptions: Omit<
-    MutationOptions<LinkAccountResponse, DefaultError, LinkAccountRequest>,
+    MutationOptions<
+      LinkAccountResponse,
+      DefaultError,
+      LinkAccountMutationFnParameters
+    >,
     "mutationFn" | "mutationKey"
   > = {},
 ) {
   const queryClient = useQueryClient()
   const authApiClient = useAuthApiClient()
+  const { connector } = useWalletAccount()
 
   const { onSuccess: customOnSuccess, ...restMutationOptions } = mutationOptions
 
   const { mutate, mutateAsync, ...rest } = useMutation({
-    mutationFn: (linkAccountRequest: LinkAccountRequest) =>
-      authApiClient.linkAccount(linkAccountRequest),
+    mutationFn: async (
+      linkAccountMutationFnParameters: LinkAccountMutationFnParameters,
+    ) => {
+      if (linkAccountMutationFnParameters.type === "wallet") {
+        if (!connector) {
+          throw new Error("Connector not defined.")
+        }
+
+        const bitcoinPublicKey =
+          await getBitcoinPublicKeyFromConnector(connector)
+
+        // Linking bitcoin account
+        if (bitcoinPublicKey) {
+          return authApiClient.linkAccount({
+            ...linkAccountMutationFnParameters,
+            bitcoinPublicKey,
+          })
+        }
+      }
+
+      // Linking any other account like wallet evm address account or discord
+      return authApiClient.linkAccount(linkAccountMutationFnParameters)
+    },
     onSuccess: (data, variables, context) => {
       queryClient.resetQueries({ queryKey: [QUERY_KEYS.ACCOUNT] })
       if (customOnSuccess) customOnSuccess(data, variables, context)

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/useSignInWithWallet.ts

@@ -1,10 +1,10 @@
-import { MutationOptions } from "@tanstack/react-query"
+import { DefaultError, MutationOptions } from "@tanstack/react-query"
 import { useAuthenticateWithWallet } from "./useAuthenticateWithWallet"
 import type { Session } from "../api"
 
 function useSignInWithWallet(
   mutationOptions: Omit<
-    MutationOptions<Session>,
+    MutationOptions<Session, DefaultError, number | void>,
     "mutationFn" | "mutationKey"
   > = {},
 ) {

package/src/hooks/useSignUpWithWallet.ts

@@ -1,10 +1,10 @@
-import { MutationOptions } from "@tanstack/react-query"
+import { DefaultError, MutationOptions } from "@tanstack/react-query"
 import { useAuthenticateWithWallet } from "./useAuthenticateWithWallet"
 import type { Session } from "../api"
 
 function useSignUpWithWallet(
   mutationOptions: Omit<
-    MutationOptions<Session>,
+    MutationOptions<Session, DefaultError, number | void>,
     "mutationFn" | "mutationKey"
   > = {},
 ) {