@mezo-org/passport 0.4.0-dev.9 → 0.5.0

package/src/hooks/useAssetsConversionRates.ts

@@ -0,0 +1,79 @@
+import { useQuery } from "@tanstack/react-query"
+import { useConfig } from "wagmi"
+import { readContract } from "wagmi/actions"
+import { parseUnits } from "viem"
+import { ONE_SECOND_MS } from "../utils/time"
+import { usePortalApiClient } from "./usePortalApiClient"
+import { priceOracleContract } from "../lib/contracts"
+import { CHAIN_ID } from "../constants"
+import { usePassportContext } from "./usePassportContext"
+import { normalizePrecision } from "../utils/numbers"
+
+export const CONVERSION_RATE_DECIMALS = 18
+
+// If the oracle has not been updated in at least 60 seconds, it is stale.
+const MAX_PRICE_DELAY = 60 * ONE_SECOND_MS
+
+export const QUERY_KEY = "passport.assetsConversionRates"
+
+/**
+ * Hook to fetch assets conversion rates.
+ * @see https://github.com/mezo-org/musd/blob/f0b2030315f0d8b0fc11a9fc778856fe4673051f/solidity/contracts/PriceFeed.sol
+ * @returns {}.data.{}.price - The latest asset price.
+ * @returns {}.data.{}.digits - The latest asset price digits.
+ * @returns {}.isPending - Whether the request is pending.
+ * @returns {}.isError - Whether there was an error fetching the price.
+ */
+export function useAssetsConversionRates() {
+  const portalApiClient = usePortalApiClient()
+  const { environment = "mainnet" } = usePassportContext()
+  const config = useConfig()
+
+  return useQuery({
+    queryKey: [QUERY_KEY],
+    queryFn: async () =>
+      Promise.all([
+        portalApiClient.getPortalStatistics(),
+        readContract(config, {
+          ...priceOracleContract,
+          functionName: "latestRoundData",
+          chainId: CHAIN_ID[environment],
+        }),
+      ]),
+    select: ([portalStatistics, btcPriceData]) => {
+      const tTokenConversionRate = portalStatistics.currentUsdPerTToken
+      const [, btcConversionRate] = btcPriceData
+
+      const tPrice = parseUnits(tTokenConversionRate, CONVERSION_RATE_DECIMALS)
+      const btcPrice = normalizePrecision(
+        btcConversionRate,
+        CONVERSION_RATE_DECIMALS,
+      )
+
+      return {
+        rates: {
+          mT: tPrice,
+          BTC: btcPrice,
+        },
+        decimals: CONVERSION_RATE_DECIMALS,
+      }
+    },
+    refetchInterval: ({ state }) => {
+      if (!state.data) return MAX_PRICE_DELAY
+
+      const [, btcPriceData] = state.data
+      const [, , , updatedAt] = btcPriceData
+
+      if (!updatedAt) return MAX_PRICE_DELAY
+
+      const age = Date.now() - Number(updatedAt) * 1000
+
+      return age > MAX_PRICE_DELAY
+        ? // If the data is stale, we want to refetch as soon as possible, but
+          // not faster than once per second, to avoid excessive requests.
+          // Math.max ensures the interval is at least 1 second.
+          Math.max(ONE_SECOND_MS, MAX_PRICE_DELAY - age)
+        : MAX_PRICE_DELAY - age
+    },
+  })
+}

package/src/hooks/useAuthenticateWithWallet.ts

@@ -1,9 +1,16 @@
 import { useSignMessage } from "wagmi"
-import { MutationOptions, useMutation } from "@tanstack/react-query"
+import {
+  DefaultError,
+  MutationOptions,
+  useMutation,
+} from "@tanstack/react-query"
 import { useCreateAccount } from "./useCreateAccount"
 import { useCreateSession } from "./useCreateSession"
 import { useEnsureNoSessionAndFetchNonce } from "./useEnsureNoSessionAndFetchNonce"
-import { createSignInWithWalletMessage } from "../utils/siww"
+import {
+  createSignInWithWalletMessage,
+  verifyDomainInSignInWithWalletMessage,
+} from "../utils/siww"
 import { useGetAccountByAddress } from "./useGetAccountByAddress"
 import type { Session } from "../api"
 import useWalletAccount from "./useWalletAccount"
@@ -11,40 +18,49 @@ import useWalletAccount from "./useWalletAccount"
 function useAuthenticateWithWallet(
   shouldCreateAccount = false,
   mutationOptions: Omit<
-    MutationOptions<Session>,
+    MutationOptions<Session, DefaultError, number | void>,
     "mutationFn" | "mutationKey"
   > = {},
 ) {
-  const { address, chainId, connector, networkFamily } = useWalletAccount()
+  const walletAccount = useWalletAccount()
   const { ensureNoSessionAndFetchNonce } = useEnsureNoSessionAndFetchNonce()
   const { createSessionAsync } = useCreateSession()
   const { createAccountAsync } = useCreateAccount()
   const { signMessageAsync } = useSignMessage()
 
-  const { refetch: getAccountByAddress } = useGetAccountByAddress(address, {
-    enabled: false,
-    retry: false,
-  })
+  const { refetch: getAccountByAddress } = useGetAccountByAddress(
+    walletAccount.walletAddress,
+    {
+      enabled: false,
+      retry: false,
+    },
+  )
 
   const { mutate, mutateAsync, ...signInMutationRestParameters } = useMutation({
-    mutationFn: async () => {
-      if (!address) {
+    mutationFn: async (chainId?: number | void) => {
+      if (!walletAccount.walletAddress) {
         throw new Error("Sign in error: Wallet not connected!")
       }
 
       const nonce = await ensureNoSessionAndFetchNonce()
 
       const messageResult = createSignInWithWalletMessage(
-        address,
+        walletAccount.walletAddress,
         nonce,
-        networkFamily,
-        chainId,
+        walletAccount.networkFamily!,
+        chainId ?? walletAccount.chainId,
       )
       const signatureResult = await signMessageAsync({
         message: messageResult,
-        connector,
+        connector: walletAccount.connector,
       })
 
+      await verifyDomainInSignInWithWalletMessage(
+        messageResult,
+        signatureResult,
+        nonce,
+      )
+
       if (shouldCreateAccount) {
         const getAccountByAddressResult = await getAccountByAddress()
 

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"
   > = {},
 ) {