@mezo-org/passport 0.4.0-dev.2 → 0.4.0-dev.21

package/src/hooks/useAuthenticateWithWallet.ts

@@ -0,0 +1,102 @@
+import { useSignMessage } from "wagmi"
+import { MutationOptions, useMutation } from "@tanstack/react-query"
+import { useCreateAccount } from "./useCreateAccount"
+import { useCreateSession } from "./useCreateSession"
+import { useEnsureNoSessionAndFetchNonce } from "./useEnsureNoSessionAndFetchNonce"
+import { createSignInWithWalletMessage } from "../utils/siww"
+import { useGetAccountByAddress } from "./useGetAccountByAddress"
+import type { Session } from "../api"
+import useWalletAccount from "./useWalletAccount"
+
+function useAuthenticateWithWallet(
+  shouldCreateAccount = false,
+  mutationOptions: Omit<
+    MutationOptions<Session>,
+    "mutationFn" | "mutationKey"
+  > = {},
+) {
+  const { walletAddress, chainId, connector, networkFamily } =
+    useWalletAccount()
+  const { ensureNoSessionAndFetchNonce } = useEnsureNoSessionAndFetchNonce()
+  const { createSessionAsync } = useCreateSession()
+  const { createAccountAsync } = useCreateAccount()
+  const { signMessageAsync } = useSignMessage()
+
+  const { refetch: getAccountByAddress } = useGetAccountByAddress(
+    walletAddress,
+    {
+      enabled: false,
+      retry: false,
+    },
+  )
+
+  const { mutate, mutateAsync, ...signInMutationRestParameters } = useMutation({
+    mutationFn: async () => {
+      if (!walletAddress) {
+        throw new Error("Sign in error: Wallet not connected!")
+      }
+
+      const nonce = await ensureNoSessionAndFetchNonce()
+
+      const messageResult = createSignInWithWalletMessage(
+        walletAddress,
+        nonce,
+        networkFamily,
+        chainId,
+      )
+      const signatureResult = await signMessageAsync({
+        message: messageResult,
+        connector,
+      })
+
+      if (shouldCreateAccount) {
+        const getAccountByAddressResult = await getAccountByAddress()
+
+        if (getAccountByAddressResult.data) {
+          throw new Error(
+            "Wallet authentication failed: Account creation failed. Account already exists.",
+          )
+        }
+
+        if (getAccountByAddressResult.error) {
+          throw new Error(
+            `Wallet authentication failed: Account creation failed. Could not verify if account already exists: ${getAccountByAddressResult.error}`,
+          )
+        }
+
+        // Fetch was successful, but no account was found
+        try {
+          const createAccountResult = await createAccountAsync({
+            type: "wallet",
+            message: messageResult,
+            signature: signatureResult,
+          })
+
+          if (!createAccountResult) {
+            throw new Error("Failed to create new account")
+          }
+        } catch (error) {
+          throw new Error(
+            `Wallet authentication failed: Account creation failed: ${error}`,
+          )
+        }
+      }
+
+      return (await createSessionAsync({
+        type: "wallet",
+        message: messageResult,
+        signature: signatureResult,
+      })) as Session
+      // ^ By passing type: "wallet" we know for sure the return type is Session
+    },
+    ...mutationOptions,
+  })
+
+  return {
+    authenticateWithWallet: mutate,
+    authenticateWithWalletAsync: mutateAsync,
+    ...signInMutationRestParameters,
+  }
+}
+
+export { useAuthenticateWithWallet }

package/src/hooks/useBorrowData.ts

@@ -0,0 +1,79 @@
+import { useAccount, useReadContract } from "wagmi"
+import { useCallback } from "react"
+import { useQueryClient } from "@tanstack/react-query"
+import { ONE_MINUTE_MS } from "../utils/time"
+import { troveManagerContract } from "../lib/contracts"
+import { usePassportContext } from "./usePassportContext"
+import { CHAIN_ID } from "../constants"
+
+/**
+ * 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()
+  return useReadContract({
+    abi: troveManagerContract.abi,
+    address: troveManagerContract.address[environment],
+    functionName: "getEntireDebtAndColl",
+    args: [address || "0x"],
+    query: {
+      enabled: !!address,
+      staleTime: 5 * ONE_MINUTE_MS,
+      retry: 1,
+      select: (data) => {
+        if (!data) return undefined
+
+        const [collateral, principal, interest] = data
+        return {
+          collateral,
+          troveDebt: principal + interest,
+        }
+      },
+      ...queryOptions,
+    },
+    chainId: CHAIN_ID[environment],
+  })
+}
+
+/**
+ * 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

@@ -1,26 +1,35 @@
-import { useQueryClient, useMutation } from "@tanstack/react-query"
+import {
+  useQueryClient,
+  useMutation,
+  MutationOptions,
+  DefaultError,
+} from "@tanstack/react-query"
 import { useAuthApiClient } from "./useAuthApiClient"
 import { QUERY_KEYS } from "./constants"
-import { CreateAccountRequest } from "../api/auth"
+import type { CreateAccountRequest, CreateAccountResponse } from "../api"
 
-export function useCreateAccount(useMutationOptions = {}) {
+export function useCreateAccount(
+  mutationOptions: Omit<
+    MutationOptions<CreateAccountResponse, DefaultError, CreateAccountRequest>,
+    "mutationFn" | "mutationKey"
+  > = {},
+) {
   const queryClient = useQueryClient()
   const authApiClient = useAuthApiClient()
 
+  const { onSuccess: customOnSuccess, ...restMutationOptions } = mutationOptions
+
   const { mutate, mutateAsync, ...rest } = useMutation({
     mutationFn: (createAccountRequest: CreateAccountRequest) =>
       authApiClient.createAccount(createAccountRequest),
-    onSuccess: () => {
-      queryClient.resetQueries({
-        queryKey: [QUERY_KEYS.ACCOUNT_BY_ADDRESS],
-        exact: false,
-      })
+    onSuccess: (data, variables, context) => {
       queryClient.resetQueries({
-        queryKey: [QUERY_KEYS.ACCOUNT_BY_MEZO_ID],
-        exact: false,
+        queryKey: [QUERY_KEYS.ACCOUNT],
       })
+
+      if (customOnSuccess) customOnSuccess(data, variables, context)
     },
-    ...useMutationOptions,
+    ...restMutationOptions,
   })
 
   return { createAccount: mutate, createAccountAsync: mutateAsync, ...rest }

package/src/hooks/useCreateSession.ts

@@ -1,37 +1,43 @@
-import { useQueryClient, useMutation } from "@tanstack/react-query"
+import {
+  useQueryClient,
+  useMutation,
+  MutationOptions,
+  DefaultError,
+} from "@tanstack/react-query"
 import { useAuthApiClient } from "./useAuthApiClient"
-import { CreateSessionRequest } from "../api/auth"
+import type { CreateSessionRequest, CreateSessionResponse } from "../api"
 import { QUERY_KEYS } from "./constants"
 
 /**
  * This hook is not exposed for external consumers. For creating session they
  * should use `useSignIn` hook related to the authentication method.
  */
-export function useCreateSession(useMutationOptions = {}) {
+export function useCreateSession(
+  mutationOptions: Omit<
+    MutationOptions<CreateSessionResponse, DefaultError, CreateSessionRequest>,
+    "mutationFn" | "mutationKey"
+  > = {},
+) {
   const queryClient = useQueryClient()
   const authApiClient = useAuthApiClient()
 
+  const { onSuccess: customOnSuccess, ...restMutationOptions } = mutationOptions
+
   const { mutate, mutateAsync, ...rest } = useMutation({
     mutationFn: (createSessionRequest: CreateSessionRequest) =>
       authApiClient.createSession(createSessionRequest),
-    onSuccess: (data) => {
-      // Since `getSession` query also has code in it's query keys we can't
-      // set query data for a specific query, because we don't know if the
-      // code was used or not. Because of that we just reset all getSession
-      // queries
+    onSuccess: (data, variables, context) => {
+      // Since `getSession` query also has code in its query keys we can't set
+      // query data for a specific query, because we don't know if the code was
+      // used or not. Because of that we just reset all getSession queries
+      queryClient.resetQueries({ queryKey: [QUERY_KEYS.SESSION] })
       queryClient.resetQueries({
-        queryKey: [QUERY_KEYS.SESSION],
-        exact: false,
+        queryKey: [QUERY_KEYS.ACCOUNT, QUERY_KEYS.CURRENT],
       })
-      if ("user" in data) {
-        queryClient.setQueryData([QUERY_KEYS.CURRENT_ACCOUNT], data.user)
-      } else {
-        queryClient.resetQueries({
-          queryKey: [QUERY_KEYS.CURRENT_ACCOUNT],
-        })
-      }
+
+      if (customOnSuccess) customOnSuccess(data, variables, context)
     },
-    ...useMutationOptions,
+    ...restMutationOptions,
   })
 
   return { createSession: mutate, createSessionAsync: mutateAsync, ...rest }

package/src/hooks/useDropdownData.ts

@@ -0,0 +1,101 @@
+import { useBalance } from "wagmi"
+import { useGetCurrentAccount } from "."
+import {
+  CryptoAssetKey,
+  isBitcoinLikeCryptoAsset,
+  mapCryptoAssetToDetails,
+} from "../utils/cryptoAssets"
+import { fromFixedPoint } from "../utils/numbers"
+import useAssetsConversionRates from "./useAssetsConversionRates"
+import useWalletAccount from "./useWalletAccount"
+import { useTokensBalances } from "./useTokensBalances"
+import { useBorrowData } from "./useBorrowData"
+
+export type DropdownCryptoAsset<T = CryptoAssetKey> = {
+  type: T
+  balance: bigint
+}
+
+/**
+ * Aggregates dropdown data for Dropdown component.
+ * @returns Dropdown data.
+ * @dev This hook is for internal use only.
+ */
+export default function useDropdownData() {
+  const { data: btcBalance } = useBalance()
+  const {
+    walletAddress,
+    accountAddress,
+    networkFamily: walletType,
+  } = useWalletAccount()
+  const { data: passportAccount } = useGetCurrentAccount()
+  const { data: assetsConversionRates } = useAssetsConversionRates()
+  const { data: tokensBalances } = useTokensBalances()
+  const { data: debt } = useBorrowData()
+  const mezoId = passportAccount?.mezoId
+
+  const detailedAssets = Object.fromEntries(
+    [
+      ["BTC", btcBalance?.value ?? 0n],
+      ...Object.entries(tokensBalances ?? {}),
+    ].map((asset) => {
+      const [type, balance] = asset as [CryptoAssetKey, bigint]
+
+      let usdConversionRate: number | undefined
+      if (isBitcoinLikeCryptoAsset(type))
+        usdConversionRate = assetsConversionRates?.usd.btc
+      if (type === "mT") {
+        usdConversionRate = assetsConversionRates?.usd.t
+      }
+
+      return [
+        type,
+        mapCryptoAssetToDetails(type, balance, usdConversionRate || 1),
+      ]
+    }),
+  ) as Record<CryptoAssetKey, ReturnType<typeof mapCryptoAssetToDetails>>
+
+  const assets = {
+    btc: detailedAssets.BTC,
+    musd: detailedAssets.MUSD,
+  }
+
+  const otherAssetsData = Object.values(detailedAssets).filter(
+    (asset) => !["BTC", "MUSD"].includes(asset.type),
+  )
+
+  const otherAssetsCount = otherAssetsData.length
+
+  const otherAssetsUsdTotal = otherAssetsData.reduce(
+    (sum, { usdBalance }) => sum + usdBalance,
+    0,
+  )
+
+  const usdTotalBalance = Object.values(detailedAssets).reduce(
+    (sum, { usdBalance }) => sum + usdBalance,
+    0,
+  )
+
+  const matsBalance = passportAccount?.mats.totalMats || 0
+
+  const usdCollateral = fromFixedPoint(
+    (debt?.collateral ?? 0n) * BigInt(assetsConversionRates?.usd.btc ?? 0),
+    18,
+  )
+
+  const usdTroveDebt = fromFixedPoint(debt?.troveDebt ?? 0n, 18)
+
+  return {
+    mezoId,
+    matsBalance,
+    accountAddress,
+    walletAddress,
+    walletType,
+    usdTotalBalance,
+    usdTroveDebt,
+    usdCollateral,
+    assets,
+    otherAssetsCount,
+    otherAssetsUsdTotal,
+  }
+}

package/src/hooks/useEnsureNoSessionAndFetchNonce.ts

@@ -0,0 +1,46 @@
+import { useCallback } from "react"
+import { useGetSession } from "./useGetSession"
+import { useSignOut } from "./useSignOut"
+
+function useEnsureNoSessionAndFetchNonce() {
+  const { refetch: getSession } = useGetSession(undefined, {
+    enabled: false,
+    retry: false,
+  })
+  const { signOutAsync } = useSignOut()
+
+  const getAndValidateSession = useCallback(async () => {
+    const getSessionResult = await getSession()
+
+    // TODO: We should create a separate endpoint that will always return nonce
+    if (getSessionResult.error) {
+      throw new Error(
+        `Sign in error: Failed to fetch the current session: ${getSessionResult.error}`,
+      )
+    }
+    if (!getSessionResult.data) {
+      throw new Error(
+        "Sign in error: Failed to fetch the current session; no data returned.",
+      )
+    }
+
+    return getSessionResult.data
+  }, [getSession])
+
+  const ensureNoSessionAndFetchNonce = useCallback(async () => {
+    let getSessionResult = await getAndValidateSession()
+
+    if (!("nonce" in getSessionResult)) {
+      // If there is active session we are terminating it
+      await signOutAsync()
+      // Because we've signed out we can assume nonce will be returned here
+      getSessionResult = (await getAndValidateSession()) as { nonce: string }
+    }
+
+    return getSessionResult.nonce
+  }, [getAndValidateSession, signOutAsync])
+
+  return { ensureNoSessionAndFetchNonce }
+}
+
+export { useEnsureNoSessionAndFetchNonce }

package/src/hooks/useGetAccountByAddress.ts

@@ -1,19 +1,25 @@
-import { useQuery, skipToken } from "@tanstack/react-query"
+import { useQuery, skipToken, UseBaseQueryOptions } from "@tanstack/react-query"
 import { useAuthApiClient } from "./useAuthApiClient"
 import { QUERY_KEYS } from "./constants"
 import { ONE_MINUTE_MS } from "../utils/time"
+import type { GetAccountByMezoIdOrAddressResponse } from "../api"
 
-export function useGetAccountByAddress(address?: string, useQueryOptions = {}) {
+export function useGetAccountByAddress(
+  address?: string,
+  queryOptions: Omit<
+    UseBaseQueryOptions<GetAccountByMezoIdOrAddressResponse | null>,
+    "queryKey" | "queryFn"
+  > = {},
+) {
   const authApiClient = useAuthApiClient()
 
   return useQuery({
-    queryKey: [QUERY_KEYS.ACCOUNT_BY_ADDRESS, address],
+    queryKey: [QUERY_KEYS.ACCOUNT, address],
     queryFn: address
       ? () => authApiClient.getAccountByMezoIdOrAddress(address)
       : skipToken,
     staleTime: ONE_MINUTE_MS,
     retry: 1,
-    enabled: !!address,
-    ...useQueryOptions,
+    ...queryOptions,
   })
 }

package/src/hooks/useGetAccountByMezoId.ts

@@ -1,19 +1,25 @@
-import { useQuery, skipToken } from "@tanstack/react-query"
+import { useQuery, skipToken, UseBaseQueryOptions } from "@tanstack/react-query"
 import { useAuthApiClient } from "./useAuthApiClient"
 import { QUERY_KEYS } from "./constants"
 import { ONE_MINUTE_MS } from "../utils/time"
+import type { GetAccountByMezoIdOrAddressResponse } from "../api"
 
-export function useGetAccountByMezoId(mezoId?: string, useQueryOptions = {}) {
+export function useGetAccountByMezoId(
+  mezoId?: string,
+  queryOptions: Omit<
+    UseBaseQueryOptions<GetAccountByMezoIdOrAddressResponse | null>,
+    "queryKey" | "queryFn"
+  > = {},
+) {
   const authApiClient = useAuthApiClient()
 
   return useQuery({
-    queryKey: [QUERY_KEYS.ACCOUNT_BY_MEZO_ID, mezoId],
+    queryKey: [QUERY_KEYS.ACCOUNT, mezoId],
     queryFn: mezoId
       ? () => authApiClient.getAccountByMezoIdOrAddress(mezoId)
       : skipToken,
     staleTime: ONE_MINUTE_MS,
     retry: 1,
-    enabled: !!mezoId,
-    ...useQueryOptions,
+    ...queryOptions,
   })
 }

package/src/hooks/useGetCurrentAccount.ts

@@ -1,16 +1,62 @@
-import { useQuery } from "@tanstack/react-query"
-import { useAuthApiClient } from "./useAuthApiClient"
-import { QUERY_KEYS } from "./constants"
+import { UseBaseQueryOptions, useQuery } from "@tanstack/react-query"
 import { ONE_MINUTE_MS } from "../utils/time"
+import { QUERY_KEYS } from "./constants"
+import { useAuthApiClient } from "./useAuthApiClient"
+import { usePortalApiClient } from "./usePortalApiClient"
+import type { GetCurrentAccountResponse } from "../api"
 
-export function useGetCurrentAccount(useQueryOptions = {}) {
+type GetCurrentAccountResponseWithMats = GetCurrentAccountResponse & {
+  mats: {
+    totalMats: number
+  }
+}
+
+export function useGetCurrentAccount(
+  queryOptions: Omit<
+    UseBaseQueryOptions<GetCurrentAccountResponseWithMats>,
+    "queryKey" | "queryFn"
+  > = {},
+) {
   const authApiClient = useAuthApiClient()
+  const portalApiClient = usePortalApiClient()
 
   return useQuery({
-    queryKey: [QUERY_KEYS.CURRENT_ACCOUNT],
-    queryFn: () => authApiClient.getCurrentAccount(),
+    queryKey: [QUERY_KEYS.ACCOUNT, QUERY_KEYS.CURRENT],
+    queryFn: async () => {
+      const currentAccount = await authApiClient.getCurrentAccount()
+      const linkedWallets = currentAccount?.linkedAccounts?.filter(
+        (account) => account.type === "wallet",
+      )
+      if (!linkedWallets || linkedWallets.length === 0) {
+        return {
+          ...currentAccount,
+          mats: {
+            totalMats: 0,
+          },
+        }
+      }
+
+      const addresses = linkedWallets.map(
+        (account) => account.btcAddress || account.evmAddress,
+      )
+      const mats = await Promise.all(
+        addresses.map((address) => portalApiClient.getPortalMats(address)),
+      )
+
+      const totalMats = mats.reduce(
+        (sumMats, currentMats) => sumMats + currentMats.totalMats,
+        0,
+      )
+
+      return {
+        ...currentAccount,
+        mats: {
+          totalMats,
+        },
+      }
+    },
     staleTime: ONE_MINUTE_MS,
     retry: 1,
-    ...useQueryOptions,
+    ...queryOptions,
   })
 }

package/src/hooks/useGetSession.ts

@@ -1,15 +1,22 @@
-import { useQuery } from "@tanstack/react-query"
+import { useQuery, UseBaseQueryOptions } from "@tanstack/react-query"
 import { useAuthApiClient } from "./useAuthApiClient"
 import { QUERY_KEYS } from "./constants"
 import { ONE_MINUTE_MS } from "../utils/time"
+import type { GetSessionResponse } from "../api"
 
-export function useGetSession(code?: string, useQueryOptions = {}) {
+export function useGetSession(
+  code?: string,
+  queryOptions: Omit<
+    UseBaseQueryOptions<GetSessionResponse>,
+    "queryKey" | "queryFn"
+  > = {},
+) {
   const authApiClient = useAuthApiClient()
   return useQuery({
     queryKey: [QUERY_KEYS.SESSION, code],
     queryFn: () => authApiClient.getSession(code),
     staleTime: ONE_MINUTE_MS,
     retry: 1,
-    ...useQueryOptions,
+    ...queryOptions,
   })
 }

package/src/hooks/useLinkAccount.ts

@@ -1,44 +1,32 @@
-import { useQueryClient, useMutation } from "@tanstack/react-query"
+import {
+  useQueryClient,
+  useMutation,
+  MutationOptions,
+  DefaultError,
+} from "@tanstack/react-query"
 import { useAuthApiClient } from "./useAuthApiClient"
-import { LinkAccountRequest } from "../api/auth"
+import type { LinkAccountRequest, LinkAccountResponse } from "../api"
 import { QUERY_KEYS } from "./constants"
 
-export function useLinkAccount(useMutationOptions = {}) {
+export function useLinkAccount(
+  mutationOptions: Omit<
+    MutationOptions<LinkAccountResponse, DefaultError, LinkAccountRequest>,
+    "mutationFn" | "mutationKey"
+  > = {},
+) {
   const queryClient = useQueryClient()
   const authApiClient = useAuthApiClient()
 
+  const { onSuccess: customOnSuccess, ...restMutationOptions } = mutationOptions
+
   const { mutate, mutateAsync, ...rest } = useMutation({
     mutationFn: (linkAccountRequest: LinkAccountRequest) =>
       authApiClient.linkAccount(linkAccountRequest),
-    onSuccess: (data) => {
-      if ("user_metadata" in data) {
-        if (data.user_metadata.mezoId) {
-          queryClient.setQueryData(
-            [QUERY_KEYS.ACCOUNT_BY_MEZO_ID, data.user_metadata.mezoId],
-            data,
-          )
-        }
-
-        queryClient.setQueryData(
-          [QUERY_KEYS.ACCOUNT_BY_ADDRESS, data.user_metadata.btcAddress],
-          data,
-        )
-        queryClient.setQueryData(
-          [QUERY_KEYS.ACCOUNT_BY_ADDRESS, data.user_metadata.evmAddress],
-          data,
-        )
-      } else {
-        queryClient.resetQueries({
-          queryKey: [QUERY_KEYS.ACCOUNT_BY_MEZO_ID],
-          exact: false,
-        })
-        queryClient.resetQueries({
-          queryKey: [QUERY_KEYS.ACCOUNT_BY_ADDRESS],
-          exact: false,
-        })
-      }
+    onSuccess: (data, variables, context) => {
+      queryClient.resetQueries({ queryKey: [QUERY_KEYS.ACCOUNT] })
+      if (customOnSuccess) customOnSuccess(data, variables, context)
     },
-    ...useMutationOptions,
+    ...restMutationOptions,
   })
 
   return { linkAccount: mutate, linkAccountAsync: mutateAsync, ...rest }

package/src/hooks/usePortalApiClient.ts

@@ -0,0 +1,6 @@
+import { usePassportContext } from "./usePassportContext"
+
+export function usePortalApiClient() {
+  const { portalApiClient } = usePassportContext()
+  return portalApiClient
+}