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

package/src/hooks/useBorrowData.ts

@@ -0,0 +1,246 @@
+import { useReadContracts } from "wagmi"
+import { useCallback, useMemo } from "react"
+import { useQueryClient } from "@tanstack/react-query"
+import { formatUnits } from "viem"
+import { ONE_MINUTE_MS } from "../utils/time"
+import {
+  mainnetBorrowContracts,
+  testnetBorrowContracts,
+} from "../lib/contracts"
+import { usePassportContext } from "./usePassportContext"
+import { CHAIN_ID } from "../constants"
+import { bigIntMax, normalizePrecision } from "../utils/numbers"
+import useWalletAccount from "./useWalletAccount"
+import { getAsset } from "../utils/assets"
+import { convertToUsd } from "../utils/currency"
+
+const DEBT_AND_COLL_PRECISION = 18
+
+// 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
+
+const PRICE_FEED_ABI = [
+  {
+    inputs: [],
+    name: "fetchPrice",
+    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 walletAccount = useWalletAccount()
+
+  const contractAddress = useMemo(() => {
+    if (environment === "mainnet") {
+      return {
+        troveManager: mainnetBorrowContracts.TroveManager.address,
+        borrowerOperations: mainnetBorrowContracts.BorrowerOperations.address,
+        priceFeed: mainnetBorrowContracts.PriceFeed.address,
+      }
+    }
+    return {
+      troveManager: testnetBorrowContracts.TroveManager.address,
+      borrowerOperations: testnetBorrowContracts.BorrowerOperations.address,
+      priceFeed: testnetBorrowContracts.PriceFeed.address,
+    }
+  }, [environment])
+
+  const chainId = CHAIN_ID[environment]
+
+  return useReadContracts({
+    contracts: [
+      {
+        abi: TROVE_MANAGER_ABI,
+        address: contractAddress.troveManager,
+        functionName: "getEntireDebtAndColl",
+        args: walletAccount.accountAddress
+          ? [walletAccount.accountAddress]
+          : ["0x" as `0x${string}}`],
+        chainId,
+      },
+      {
+        abi: BORROWER_OPERATIONS_ABI,
+        address: contractAddress.borrowerOperations,
+        functionName: "MUSD_GAS_COMPENSATION",
+        chainId,
+      },
+      {
+        abi: PRICE_FEED_ABI,
+        address: contractAddress.priceFeed,
+        functionName: "fetchPrice",
+        chainId,
+      },
+    ],
+    query: {
+      enabled: !!walletAccount.accountAddress,
+      staleTime: 5 * ONE_MINUTE_MS,
+      retry: 1,
+      select: (data) => {
+        if (!data || data.some((item) => !item.result))
+          throw new Error("No borrow data available")
+
+        const [rawCollateral, principal, interest] = data[0].result!
+        const gasCompensation = data[1].result!
+        const collateralPrice = data[2].result!
+
+        const btcDetails = getAsset("BTC")
+
+        const collateral = {
+          value: rawCollateral,
+          decimals: btcDetails.decimals,
+          symbol: btcDetails.symbol,
+          formatted: formatUnits(rawCollateral, DEBT_AND_COLL_PRECISION),
+          usd: convertToUsd(
+            rawCollateral,
+            DEBT_AND_COLL_PRECISION,
+            collateralPrice,
+            DEBT_AND_COLL_PRECISION,
+          ),
+        }
+
+        const debtInUsdValue = bigIntMax(
+          normalizePrecision(
+            principal + interest - gasCompensation,
+            DEBT_AND_COLL_PRECISION,
+          ),
+          0n, // Ensure that debt is not negative
+        )
+        const formattedDebtInUsd = formatUnits(
+          debtInUsdValue,
+          DEBT_AND_COLL_PRECISION,
+        )
+
+        const debtInUsd = {
+          value: debtInUsdValue,
+          formatted: formattedDebtInUsd,
+        }
+
+        return {
+          collateral,
+          debtInUsd,
+        }
+      },
+      ...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,37 @@ export function useCreateAccount(
 ) {
   const queryClient = useQueryClient()
   const authApiClient = useAuthApiClient()
+  const walletAccount = 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 (!walletAccount?.connector) {
+          throw new Error("Connector not defined.")
+        }
+
+        const bitcoinPublicKey = await getBitcoinPublicKeyFromConnector(
+          walletAccount.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/useGetCurrentAccount.ts

@@ -24,16 +24,15 @@ export function useGetCurrentAccount(
     queryKey: [QUERY_KEYS.ACCOUNT, QUERY_KEYS.CURRENT],
     queryFn: async () => {
       const currentAccount = await authApiClient.getCurrentAccount()
+      if (!currentAccount) {
+        throw new Error("No current account found")
+      }
+
       const linkedWallets = currentAccount?.linkedAccounts?.filter(
         (account) => account.type === "wallet",
       )
       if (!linkedWallets || linkedWallets.length === 0) {
-        return {
-          ...currentAccount,
-          mats: {
-            totalMats: 0,
-          },
-        }
+        throw new Error("No linked wallets found for the current account")
       }
 
       const addresses = linkedWallets.map(
@@ -42,7 +41,6 @@ export function useGetCurrentAccount(
       const mats = await Promise.all(
         addresses.map((address) => portalApiClient.getPortalMats(address)),
       )
-
       const totalMats = mats.reduce(
         (sumMats, currentMats) => sumMats + currentMats.totalMats,
         0,

package/src/hooks/useLinkAccount.ts

@@ -5,23 +5,56 @@ 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 walletAccount = 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 (!walletAccount?.connector) {
+          throw new Error("Connector not defined.")
+        }
+
+        const bitcoinPublicKey = await getBitcoinPublicKeyFromConnector(
+          walletAccount.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"
   > = {},
 ) {