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

package/src/hooks/useAuthenticateWithWallet.ts

@@ -0,0 +1,105 @@
+import { useSignMessage } from "wagmi"
+import { useBitcoinAccount } from "@mezo-org/orangekit"
+import { MutationOptions, useMutation } from "@tanstack/react-query"
+import { useMemo } from "react"
+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 { address, chainId, connector, networkFamily } = useWalletAccount()
+  const { btcAddress } = useBitcoinAccount()
+  const { ensureNoSessionAndFetchNonce } = useEnsureNoSessionAndFetchNonce()
+  const { createSessionAsync } = useCreateSession()
+  const { createAccountAsync } = useCreateAccount()
+  const { signMessageAsync } = useSignMessage()
+  const walletAddress = useMemo(
+    () => (connector?.type === "orangekit" ? btcAddress : address),
+    [btcAddress, address, connector],
+  )
+
+  const { refetch: getAccountByAddress } = useGetAccountByAddress(
+    walletAddress,
+    { enabled: false, retry: false },
+  )
+
+  const { mutate, mutateAsync, ...signInMutationRestParameters } = useMutation({
+    mutationFn: async () => {
+      if (!address) {
+        throw new Error("Sign in error: Wallet not connected!")
+      }
+
+      const nonce = await ensureNoSessionAndFetchNonce()
+
+      const messageResult = createSignInWithWalletMessage(
+        btcAddress || address,
+        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/useCreateAccount.ts

@@ -1,21 +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: () => {
+    onSuccess: (data, variables, context) => {
       queryClient.resetQueries({
         queryKey: [QUERY_KEYS.ACCOUNT],
       })
+
+      if (customOnSuccess) customOnSuccess(data, variables, context)
     },
-    ...useMutationOptions,
+    ...restMutationOptions,
   })
 
   return { createAccount: mutate, createAccountAsync: mutateAsync, ...rest }

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,130 @@
+import { useBitcoinAccount } from "@mezo-org/orangekit"
+import { useGetCurrentAccount } from "."
+import {
+  CryptoAssetKey,
+  getCryptoAsset,
+  isBitcoinLikeCryptoAsset,
+  isUsdLikeCryptoAsset,
+} from "../utils/cryptoAssets"
+import { fromFixedPoint } from "../utils/numbers"
+import { useAssetsUsdConversion } from "./useAssetsUSDConversion"
+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,
+  }
+}
+
+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[]
+}
+
+/**
+ * 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.
+ * @returns Dropdown data.
+ */
+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
+
+  const btcUsdConversionRate = Number(assetsUsdConversion?.btcUsd ?? 0)
+
+  const formattedNativeAssets = nativeAssets.map((asset) =>
+    formatCryptoAsset(asset.type, asset.balance, btcUsdConversionRate),
+  )
+
+  const totalBalanceInUsd = formattedNativeAssets.reduce(
+    (sum, value) => sum + value.balanceInUsd,
+    0,
+  )
+
+  const matsBalance = passportAccount.mats.totalMats
+
+  const matsnetFormattedAssets = matsnetAssets.map((asset) =>
+    formatCryptoAsset(asset.type, asset.balance, btcUsdConversionRate),
+  )
+
+  return {
+    mezoId,
+    address,
+    walletType: networkFamily,
+    totalBalanceInUsd,
+    formattedNativeAssets,
+    matsnet: {
+      mats: matsBalance,
+      formattedAssets: matsnetFormattedAssets,
+    },
+  }
+}

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/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 }