@mezo-org/passport 0.4.0-dev.4 → 0.4.0-dev.41

package/src/hooks/useCreateSession.ts

@@ -1,30 +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: () => {
-      // 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.ACCOUNT, QUERY_KEYS.CURRENT],
       })
+
+      if (customOnSuccess) customOnSuccess(data, variables, context)
     },
-    ...useMutationOptions,
+    ...restMutationOptions,
   })
 
   return { createSession: mutate, createSessionAsync: mutateAsync, ...rest }

package/src/hooks/useDropdownData.ts

@@ -0,0 +1,139 @@
+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"
+import { CHAIN_ID } from "../constants"
+import { usePassportContext } from "./usePassportContext"
+import { useWatchTransferEventsForAllTokens } from "./useWatchTransferEvents"
+
+export type DropdownCryptoAsset<T = CryptoAssetKey> = {
+  type: T
+  balance: bigint
+}
+
+const DEFAULT_ASSET_DATA = {
+  rawBalance: 0n,
+  formattedBalance: "0.0000",
+  usdBalance: 0,
+  formattedUsdBalance: "$0.00",
+}
+
+/**
+ * Aggregates dropdown data for Dropdown component.
+ * @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({
+  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]
+
+    let usdConversionRate: number | undefined
+    if (isBitcoinLikeCryptoAsset(type))
+      usdConversionRate = assetsConversionRates?.usd.btc
+    if (type === "mT") {
+      usdConversionRate = assetsConversionRates?.usd.t
+    }
+
+    return mapCryptoAssetToDetails(type, balance, usdConversionRate || 1)
+  })
+
+  const btcData = detailedAssets.find(({ type }) => type === "BTC")!
+  const musdData = detailedAssets.find(({ type }) => type === "MUSD")!
+  const otherAssetsData = detailedAssets.filter(
+    ({ type }) => !["BTC", "MUSD"].includes(type),
+  )
+
+  const otherAssetsCount = otherAssetsData.filter(
+    (asset) => asset.rawBalance !== 0n,
+  ).length
+
+  const assets = {
+    btc: btcData || {
+      type: "BTC",
+      ...DEFAULT_ASSET_DATA,
+    },
+    musd: musdData || {
+      type: "mUSD",
+      ...DEFAULT_ASSET_DATA,
+    },
+  }
+
+  const otherAssetsUsdTotal = otherAssetsData.reduce(
+    (sum, { usdBalance }) => sum + usdBalance,
+    0,
+  )
+
+  const usdTotalBalance = 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

@@ -5,6 +5,7 @@ import { useSignOut } from "./useSignOut"
 function useEnsureNoSessionAndFetchNonce() {
   const { refetch: getSession } = useGetSession(undefined, {
     enabled: false,
+    retry: false,
   })
   const { signOutAsync } = useSignOut()
 

package/src/hooks/useGetAccountByAddress.ts

@@ -2,12 +2,12 @@ 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 { GetAccountByMezoIdOrAddressResponse } from "../api/auth"
+import type { GetAccountByMezoIdOrAddressResponse } from "../api"
 
 export function useGetAccountByAddress(
   address?: string,
   queryOptions: Omit<
-    UseBaseQueryOptions<GetAccountByMezoIdOrAddressResponse>,
+    UseBaseQueryOptions<GetAccountByMezoIdOrAddressResponse | null>,
     "queryKey" | "queryFn"
   > = {},
 ) {

package/src/hooks/useGetAccountByMezoId.ts

@@ -2,12 +2,12 @@ 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 { GetAccountByMezoIdOrAddressResponse } from "../api/auth"
+import type { GetAccountByMezoIdOrAddressResponse } from "../api"
 
 export function useGetAccountByMezoId(
   mezoId?: string,
   queryOptions: Omit<
-    UseBaseQueryOptions<GetAccountByMezoIdOrAddressResponse>,
+    UseBaseQueryOptions<GetAccountByMezoIdOrAddressResponse | null>,
     "queryKey" | "queryFn"
   > = {},
 ) {

package/src/hooks/useGetCurrentAccount.ts

@@ -1,20 +1,60 @@
-import { useQuery, UseBaseQueryOptions } 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 { GetCurrentAccountResponse } from "../api/auth"
+import { QUERY_KEYS } from "./constants"
+import { useAuthApiClient } from "./useAuthApiClient"
+import { usePortalApiClient } from "./usePortalApiClient"
+import type { GetCurrentAccountResponse } from "../api"
+
+type GetCurrentAccountResponseWithMats = GetCurrentAccountResponse & {
+  mats: {
+    totalMats: number
+  }
+}
 
 export function useGetCurrentAccount(
   queryOptions: Omit<
-    UseBaseQueryOptions<GetCurrentAccountResponse>,
+    UseBaseQueryOptions<GetCurrentAccountResponseWithMats>,
     "queryKey" | "queryFn"
   > = {},
 ) {
   const authApiClient = useAuthApiClient()
+  const portalApiClient = usePortalApiClient()
 
   return useQuery({
     queryKey: [QUERY_KEYS.ACCOUNT, QUERY_KEYS.CURRENT],
-    queryFn: () => authApiClient.getCurrentAccount(),
+    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,
     ...queryOptions,

package/src/hooks/useGetSession.ts

@@ -2,7 +2,7 @@ import { useQuery, UseBaseQueryOptions } from "@tanstack/react-query"
 import { useAuthApiClient } from "./useAuthApiClient"
 import { QUERY_KEYS } from "./constants"
 import { ONE_MINUTE_MS } from "../utils/time"
-import { GetSessionResponse } from "../api/auth"
+import type { GetSessionResponse } from "../api"
 
 export function useGetSession(
   code?: string,

package/src/hooks/useLinkAccount.ts

@@ -1,19 +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: () => {
+    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
+}

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

@@ -1,19 +1,28 @@
-import { useMutation } from "@tanstack/react-query"
+import { MutationOptions, useMutation } from "@tanstack/react-query"
 import { useCreateSession } from "./useCreateSession"
 import { useEnsureNoSessionAndFetchNonce } from "./useEnsureNoSessionAndFetchNonce"
+import type { AuthenticationProviderRedirectResponse } from "../api"
 
-function useSignInWithDiscord() {
+function useSignInWithDiscord(
+  mutationOptions: Omit<
+    MutationOptions<AuthenticationProviderRedirectResponse>,
+    "mutationFn" | "mutationKey"
+  > = {},
+) {
   const { ensureNoSessionAndFetchNonce } = useEnsureNoSessionAndFetchNonce()
   const { createSessionAsync } = useCreateSession()
 
   const { mutate, mutateAsync, ...signInMutationRestParameters } = useMutation({
-    mutationFn: async () => {
+    mutationFn: async (): Promise<AuthenticationProviderRedirectResponse> => {
       await ensureNoSessionAndFetchNonce()
 
-      return createSessionAsync({
+      return (await createSessionAsync({
         type: "discord",
-      })
+      })) as AuthenticationProviderRedirectResponse
+      // ^ By passing type: "discord" we know for sure the return type is
+      // AuthenticationProviderRedirectResponse
     },
+    ...mutationOptions,
   })
 
   return {

package/src/hooks/useSignInWithWallet.ts

@@ -1,48 +1,20 @@
-import { useAccount, useSignMessage } from "wagmi"
-import { useBitcoinAccount } from "@mezo-org/orangekit"
-import { useMutation } from "@tanstack/react-query"
-import { useCreateSession } from "./useCreateSession"
-import { createSignInWithWalletMessage } from "../utils/siww"
-import { useEnsureNoSessionAndFetchNonce } from "./useEnsureNoSessionAndFetchNonce"
+import { MutationOptions } from "@tanstack/react-query"
+import { useAuthenticateWithWallet } from "./useAuthenticateWithWallet"
+import type { Session } from "../api"
 
-function useSignInWithWallet() {
-  const { chainId, address, connector } = useAccount()
-  const { btcAddress } = useBitcoinAccount()
-  const { ensureNoSessionAndFetchNonce } = useEnsureNoSessionAndFetchNonce()
-  const { createSessionAsync } = useCreateSession()
-  const { signMessageAsync } = useSignMessage()
-
-  const { mutate, mutateAsync, ...signInMutationRestParameters } = useMutation({
-    mutationFn: async () => {
-      if (!address) {
-        throw new Error("Sign in error: Wallet not connected!")
-      }
-
-      const nonce = await ensureNoSessionAndFetchNonce()
-
-      const networkFamily = btcAddress ? "bitcoin" : "evm"
-      const messageResult = createSignInWithWalletMessage(
-        btcAddress ? btcAddress! : address!,
-        nonce,
-        networkFamily,
-        chainId,
-      )
-      const signatureResult = await signMessageAsync({
-        message: messageResult,
-        connector,
-      })
-      return createSessionAsync({
-        type: "wallet",
-        message: messageResult,
-        signature: signatureResult,
-      })
-    },
-  })
+function useSignInWithWallet(
+  mutationOptions: Omit<
+    MutationOptions<Session>,
+    "mutationFn" | "mutationKey"
+  > = {},
+) {
+  const { authenticateWithWallet, authenticateWithWalletAsync, ...rest } =
+    useAuthenticateWithWallet(false, mutationOptions)
 
   return {
-    signInWithWallet: mutate,
-    signInWithWalletAsync: mutateAsync,
-    ...signInMutationRestParameters,
+    signInWithWallet: authenticateWithWallet,
+    signInWithWalletAsync: authenticateWithWalletAsync,
+    ...rest,
   }
 }
 

package/src/hooks/useSignOut.ts

@@ -1,20 +1,34 @@
-import { useMutation, useQueryClient } from "@tanstack/react-query"
+import {
+  MutationOptions,
+  useMutation,
+  useQueryClient,
+} from "@tanstack/react-query"
 import { useAuthApiClient } from "./useAuthApiClient"
 import { QUERY_KEYS } from "./constants"
+import type { DeleteSessionResponse } from "../api"
 
-export function useSignOut(useMutationOptions = {}) {
+export function useSignOut(
+  mutationOptions: Omit<
+    MutationOptions<DeleteSessionResponse>,
+    "mutationFn" | "mutationKey"
+  > = {},
+) {
   const queryClient = useQueryClient()
   const authApiClient = useAuthApiClient()
 
+  const { onSuccess: customOnSuccess, ...restMutationOptions } = mutationOptions
+
   const { mutate, mutateAsync, ...rest } = useMutation({
     mutationFn: () => authApiClient.deleteSession(),
-    onSuccess: () => {
+    onSuccess: (data, variables, context) => {
       queryClient.resetQueries({ queryKey: [QUERY_KEYS.SESSION] })
       queryClient.resetQueries({
         queryKey: [QUERY_KEYS.ACCOUNT, QUERY_KEYS.CURRENT],
       })
+
+      if (customOnSuccess) customOnSuccess(data, variables, context)
     },
-    ...useMutationOptions,
+    ...restMutationOptions,
   })
 
   return { signOut: mutate, signOutAsync: mutateAsync, ...rest }

package/src/hooks/useSignUpWithWallet.ts

@@ -0,0 +1,21 @@
+import { MutationOptions } from "@tanstack/react-query"
+import { useAuthenticateWithWallet } from "./useAuthenticateWithWallet"
+import type { Session } from "../api"
+
+function useSignUpWithWallet(
+  mutationOptions: Omit<
+    MutationOptions<Session>,
+    "mutationFn" | "mutationKey"
+  > = {},
+) {
+  const { authenticateWithWallet, authenticateWithWalletAsync, ...rest } =
+    useAuthenticateWithWallet(true, mutationOptions)
+
+  return {
+    signUpWithWallet: authenticateWithWallet,
+    signUpWithWalletAsync: authenticateWithWalletAsync,
+    ...rest,
+  }
+}
+
+export { useSignUpWithWallet }