@mezo-org/passport 0.4.0-dev.1 → 0.4.0-dev.10

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

package/src/hooks/useSignInWithDiscord.ts

@@ -1,42 +1,33 @@
-import { useAccount } from "wagmi"
-import { useMutation } from "@tanstack/react-query"
-import { useGetSession } from "./useGetSession"
+import { MutationOptions, useMutation } from "@tanstack/react-query"
 import { useCreateSession } from "./useCreateSession"
+import { useEnsureNoSessionAndFetchNonce } from "./useEnsureNoSessionAndFetchNonce"
+import type { AuthenticationProviderRedirectResponse } from "../api"
 
-function useSignInWithDiscord() {
-  const { address } = useAccount()
-  const { refetch: getSession } = useGetSession(undefined, {
-    enabled: false,
-  })
+function useSignInWithDiscord(
+  mutationOptions: Omit<
+    MutationOptions<AuthenticationProviderRedirectResponse>,
+    "mutationFn" | "mutationKey"
+  > = {},
+) {
+  const { ensureNoSessionAndFetchNonce } = useEnsureNoSessionAndFetchNonce()
   const { createSessionAsync } = useCreateSession()
 
   const { mutate, mutateAsync, ...signInMutationRestParameters } = useMutation({
-    mutationFn: async () => {
-      if (!address) {
-        throw new Error("Sign in error: User not connected!")
-      }
-
-      const getSessionResult = await getSession()
-
-      // TODO: We should create a separate endpoint that will always return nonce
-      if (!getSessionResult.data || !("nonce" in getSessionResult.data)) {
-        if (getSessionResult.error) {
-          throw new Error(`Sign in error: ${getSessionResult.error}`)
-        }
-        throw new Error(
-          "Sign in error: Nonce not available! Remove the session first.",
-        )
-      }
+    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 {
-    signIn: mutate,
-    signInAsync: mutateAsync,
+    signInWithDiscord: mutate,
+    signInWithDiscordAsync: mutateAsync,
     ...signInMutationRestParameters,
   }
 }

package/src/hooks/useSignInWithWallet.ts

@@ -1,60 +1,20 @@
-import { useAccount, useSignMessage } from "wagmi"
-import { useBitcoinAccount } from "@mezo-org/orangekit"
-import { useMutation } from "@tanstack/react-query"
-import { useGetSession } from "./useGetSession"
-import { useCreateSession } from "./useCreateSession"
-import { createSignInWithWalletMessage } from "../utils/siww"
+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 { refetch: getSession } = useGetSession(undefined, {
-    enabled: false,
-  })
-  const { createSessionAsync } = useCreateSession()
-  const { signMessageAsync } = useSignMessage()
-
-  const { mutate, mutateAsync, ...signInMutationRestParameters } = useMutation({
-    mutationFn: async () => {
-      if (!address) {
-        throw new Error("Sign in error: User not connected!")
-      }
-
-      const getSessionResult = await getSession()
-
-      // TODO: We should create a separate endpoint that will always return nonce
-      if (!getSessionResult.data || !("nonce" in getSessionResult.data)) {
-        if (getSessionResult.error) {
-          throw new Error(`Sign in error: ${getSessionResult.error}`)
-        }
-        throw new Error(
-          "Sign in error: Nonce not available! Remove the session first.",
-        )
-      }
-
-      const networkFamily = btcAddress ? "bitcoin" : "evm"
-      const messageResult = createSignInWithWalletMessage(
-        btcAddress ? btcAddress! : address!,
-        getSessionResult.data.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 {
-    signIn: mutate,
-    signInAsync: mutateAsync,
-    ...signInMutationRestParameters,
+    signInWithWallet: authenticateWithWallet,
+    signInWithWalletAsync: authenticateWithWalletAsync,
+    ...rest,
   }
 }
 

package/src/hooks/useSignOut.ts

@@ -1,18 +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: () => {
-      queryClient.resetQueries({ queryKey: [QUERY_KEYS.SESSION], exact: false })
-      queryClient.resetQueries({ queryKey: [QUERY_KEYS.CURRENT_ACCOUNT] })
+    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 }

package/src/hooks/useUpdateMezoId.ts

@@ -1,24 +1,32 @@
-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 type { UpdateMezoIdResponse } from "../api"
 
-export function useUpdateMezoId(useMutationOptions = {}) {
+export function useUpdateMezoId(
+  mutationOptions: Omit<
+    MutationOptions<UpdateMezoIdResponse, DefaultError, string>,
+    "mutationFn" | "mutationKey"
+  > = {},
+) {
   const queryClient = useQueryClient()
   const authApiClient = useAuthApiClient()
 
+  const { onSuccess: customOnSuccess, ...restMutationOptions } = mutationOptions
+
   const { mutate, mutateAsync, ...rest } = useMutation({
     mutationFn: (newMezoId: string) => authApiClient.updateMezoId(newMezoId),
-    onSuccess: () => {
-      queryClient.resetQueries({
-        queryKey: [QUERY_KEYS.ACCOUNT_BY_ADDRESS],
-        exact: false,
-      })
-      queryClient.resetQueries({
-        queryKey: [QUERY_KEYS.ACCOUNT_BY_MEZO_ID],
-        exact: false,
-      })
+    onSuccess: (data, variables, context) => {
+      queryClient.resetQueries({ queryKey: [QUERY_KEYS.ACCOUNT] })
+
+      if (customOnSuccess) customOnSuccess(data, variables, context)
     },
-    ...useMutationOptions,
+    ...restMutationOptions,
   })
 
   return { updateMezoId: mutate, updateMezoIdAsync: mutateAsync, ...rest }

package/src/hooks/useWalletAccount.ts

@@ -0,0 +1,53 @@
+import { OrangeKitBitcoinProvider } from "@mezo-org/orangekit"
+import { useQuery } from "@tanstack/react-query"
+import { useMemo } from "react"
+import { Address } from "viem"
+import { Connector, useAccount } from "wagmi"
+
+type UseWalletAccountReturn = {
+  address?: string | Address
+  isConnected: boolean
+  networkFamily: "bitcoin" | "evm"
+  connector?: Connector
+  chainId?: number
+}
+
+type OrangeKitConnector = {
+  getBitcoinProvider: () => OrangeKitBitcoinProvider
+}
+
+export default function useWalletAccount(): UseWalletAccountReturn {
+  const { address: evmAddress, connector, chainId } = useAccount()
+
+  const networkFamily = useMemo(
+    () => (connector?.type !== "orangekit" ? "evm" : "bitcoin"),
+    [connector],
+  )
+
+  const { data: btcData } = useQuery({
+    queryKey: [connector?.id],
+    queryFn: async () => {
+      const bitcoinProvider = (
+        connector as unknown as OrangeKitConnector
+      ).getBitcoinProvider()
+
+      const address = await bitcoinProvider.getAddress()
+      const balance = await bitcoinProvider.getBalance()
+
+      return {
+        address,
+        balance,
+      }
+    },
+  })
+
+  const { address: btcAddress } = btcData || {}
+
+  return {
+    address: networkFamily === "bitcoin" ? btcAddress : evmAddress,
+    isConnected: networkFamily === "bitcoin" ? !!btcAddress : !!evmAddress,
+    networkFamily,
+    connector,
+    chainId,
+  } as const
+}

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from "./components"
 export * from "./config"
 export * from "./constants"
 export * from "./hooks"

package/src/provider.ts

@@ -1,56 +1,49 @@
-import { createContext, createElement, useMemo } from "react"
-import { API_ENDPOINTS_BY_ENV, AuthApiClient } from "./api/auth"
+import { createContext, createElement } from "react"
+import { AuthApiClient, PortalApiClient } from "./api"
 
 export interface PassportContextValue {
   authApiClient: AuthApiClient
+  portalApiClient: PortalApiClient
+  environment?: Environment
 }
 
 export const PassportContext = createContext<PassportContextValue | undefined>(
   undefined,
 )
 
-interface PassportProviderProps {
-  // eslint-disable-next-line react/require-default-props
-  options: {
-    environment?: keyof typeof API_ENDPOINTS_BY_ENV
-    apiUrl?: string
-  } & (
-    | {
-        environment: keyof typeof API_ENDPOINTS_BY_ENV
-      }
-    | {
-        apiUrl: string
-      }
-  )
+type Environment = "mainnet" | "testnet"
+
+type PassportProviderProps = {
   children: React.ReactNode
+  // eslint-disable-next-line react/require-default-props
+  environment?: Environment
+  // eslint-disable-next-line react/require-default-props
+  authApiUrl?: string
+  // eslint-disable-next-line react/require-default-props
+  portalApiUrl?: string
 }
 
-export function PassportProvider({ options, children }: PassportProviderProps) {
-  const { environment, apiUrl } = options
-
-  const finalApiUrl = useMemo(() => {
-    if (!environment && !apiUrl) {
-      throw new Error(
-        "Neither apiUrl or environment are specified in Passport Provider",
-      )
-    }
-    if (apiUrl) return apiUrl
-
-    if (!(environment! in API_ENDPOINTS_BY_ENV)) {
-      throw new Error("Wrong environment passed to PassportProvider.")
-    }
-
-    return API_ENDPOINTS_BY_ENV[environment!]
-  }, [environment, apiUrl])
+export function PassportProvider({
+  environment,
+  authApiUrl,
+  portalApiUrl,
+  children,
+}: PassportProviderProps) {
+  if (environment && !["mainnet", "testnet"].includes(environment)) {
+    throw new Error("Wrong environment passed to PassportProvider.")
+  }
 
   return createElement(
     PassportContext.Provider,
     {
-      value: finalApiUrl
-        ? {
-            authApiClient: new AuthApiClient(finalApiUrl),
-          }
-        : undefined,
+      value: {
+        authApiClient: new AuthApiClient(environment ?? "mainnet", authApiUrl),
+        portalApiClient: new PortalApiClient(
+          environment ?? "mainnet",
+          portalApiUrl,
+        ),
+        environment,
+      },
     },
     children,
   )

package/src/utils/address.test.ts

@@ -0,0 +1,38 @@
+import { getAddressExplorerUrl, trimAddress } from "./address"
+
+describe("trimAddress", () => {
+  it("returns full address if length is less than 11", () => {
+    expect(trimAddress("0x12345")).toBe("0x12345")
+  })
+
+  it("returns trimmed address if length is 11 or more", () => {
+    const input = "0x123456789abcdef"
+    const expected = "0x123...bcdef"
+    expect(trimAddress(input)).toBe(expected)
+  })
+})
+
+describe("getAddressExplorerUrl", () => {
+  const btcAddress = "bc1qxyz123"
+  const evmAddress = "0x1234567890abcdef"
+
+  it("returns correct mainnet Bitcoin explorer URL", () => {
+    const url = getAddressExplorerUrl(btcAddress, "bitcoin", false)
+    expect(url).toBe(`https://mempool.space/address/${btcAddress}`)
+  })
+
+  it("returns correct testnet Bitcoin explorer URL", () => {
+    const url = getAddressExplorerUrl(btcAddress, "bitcoin", true)
+    expect(url).toBe(`https://mempool.space/testnet/address/${btcAddress}`)
+  })
+
+  it("returns correct mainnet EVM explorer URL", () => {
+    const url = getAddressExplorerUrl(evmAddress, "evm", false)
+    expect(url).toBe(`https://etherscan.io/address/${evmAddress}`)
+  })
+
+  it("returns correct testnet EVM explorer URL", () => {
+    const url = getAddressExplorerUrl(evmAddress, "evm", true)
+    expect(url).toBe(`https://sepolia.etherscan.io/address/${evmAddress}`)
+  })
+})

package/src/utils/address.ts

@@ -0,0 +1,43 @@
+/**
+ * Trims the address to the first 5 and last 5 characters.
+ * @param address The address to trim.
+ * @returns The trimmed address.
+ */
+export function trimAddress(address: string): string {
+  if (address.length < 11) return address
+
+  const trimmedAddress = `${address.slice(0, 5)}...${address.slice(-5)}`
+
+  return trimmedAddress
+}
+
+const MAINNET_EXPLORER_URLS: Record<"bitcoin" | "evm", string> = {
+  bitcoin: "https://mempool.space",
+  evm: "https://etherscan.io",
+}
+
+const TESTNET_EXPLORER_URLS: Record<"bitcoin" | "evm", string> = {
+  bitcoin: "https://mempool.space/testnet",
+  evm: "https://sepolia.etherscan.io",
+}
+
+/**
+ * Get the URL of the block explorer page for an address.
+ * @param address - The address to link to.
+ * @param chainType - The chain type of the address.
+ * @param isTestnet - Whether the address is on testnet.
+ * @returns The URL of the block explorer page for the address.
+ */
+export function getAddressExplorerUrl(
+  address: string,
+  chainType: "bitcoin" | "evm",
+  isTestnet: boolean,
+) {
+  const EXPLORER_URLS = isTestnet
+    ? TESTNET_EXPLORER_URLS
+    : MAINNET_EXPLORER_URLS
+  const baseUrl = EXPLORER_URLS[chainType]
+  const endpoint = `address/${address}`
+
+  return `${baseUrl}/${endpoint}`
+}