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

package/src/hooks/useCreateSession.ts

@@ -0,0 +1,38 @@
+import { useQueryClient, useMutation } from "@tanstack/react-query"
+import { useAuthApiClient } from "./useAuthApiClient"
+import { CreateSessionRequest } from "../api/auth"
+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 = {}) {
+  const queryClient = useQueryClient()
+  const authApiClient = useAuthApiClient()
+
+  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
+      queryClient.resetQueries({
+        queryKey: [QUERY_KEYS.SESSION],
+        exact: false,
+      })
+      if ("user" in data) {
+        queryClient.setQueryData([QUERY_KEYS.CURRENT_ACCOUNT], data.user)
+      } else {
+        queryClient.resetQueries({
+          queryKey: [QUERY_KEYS.CURRENT_ACCOUNT],
+        })
+      }
+    },
+    ...useMutationOptions,
+  })
+
+  return { createSession: mutate, createSessionAsync: mutateAsync, ...rest }
+}

package/src/hooks/useGetAccountByAddress.ts

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

package/src/hooks/useGetAccountByMezoId.ts

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

package/src/hooks/useGetCurrentAccount.ts

@@ -0,0 +1,16 @@
+import { useQuery } from "@tanstack/react-query"
+import { useAuthApiClient } from "./useAuthApiClient"
+import { QUERY_KEYS } from "./constants"
+import { ONE_MINUTE_MS } from "../utils/time"
+
+export function useGetCurrentAccount(useQueryOptions = {}) {
+  const authApiClient = useAuthApiClient()
+
+  return useQuery({
+    queryKey: [QUERY_KEYS.CURRENT_ACCOUNT],
+    queryFn: () => authApiClient.getCurrentAccount(),
+    staleTime: ONE_MINUTE_MS,
+    retry: 1,
+    ...useQueryOptions,
+  })
+}

package/src/hooks/useGetSession.ts

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

package/src/hooks/useLinkAccount.ts

@@ -0,0 +1,45 @@
+import { useQueryClient, useMutation } from "@tanstack/react-query"
+import { useAuthApiClient } from "./useAuthApiClient"
+import { LinkAccountRequest } from "../api/auth"
+import { QUERY_KEYS } from "./constants"
+
+export function useLinkAccount(useMutationOptions = {}) {
+  const queryClient = useQueryClient()
+  const authApiClient = useAuthApiClient()
+
+  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,
+        })
+      }
+    },
+    ...useMutationOptions,
+  })
+
+  return { linkAccount: mutate, linkAccountAsync: mutateAsync, ...rest }
+}

package/src/hooks/usePassportContext.ts

@@ -0,0 +1,11 @@
+import { useContext } from "react"
+import { PassportContext, PassportContextValue } from "../provider"
+
+export function usePassportContext(): PassportContextValue {
+  const passportContext = useContext(PassportContext)
+  if (!passportContext) {
+    throw new Error("usePassportContext must be used within PassportProvider!")
+  }
+
+  return passportContext
+}

package/src/hooks/useSignInWithDiscord.ts

@@ -0,0 +1,44 @@
+import { useAccount } from "wagmi"
+import { useMutation } from "@tanstack/react-query"
+import { useGetSession } from "./useGetSession"
+import { useCreateSession } from "./useCreateSession"
+
+function useSignInWithDiscord() {
+  const { address } = useAccount()
+  const { refetch: getSession } = useGetSession(undefined, {
+    enabled: false,
+  })
+  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.",
+        )
+      }
+
+      return createSessionAsync({
+        type: "discord",
+      })
+    },
+  })
+
+  return {
+    signIn: mutate,
+    signInAsync: mutateAsync,
+    ...signInMutationRestParameters,
+  }
+}
+
+export { useSignInWithDiscord }

package/src/hooks/useSignInWithWallet.ts

@@ -0,0 +1,61 @@
+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"
+
+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,
+      })
+    },
+  })
+
+  return {
+    signIn: mutate,
+    signInAsync: mutateAsync,
+    ...signInMutationRestParameters,
+  }
+}
+
+export { useSignInWithWallet }

package/src/hooks/useSignOut.ts

@@ -0,0 +1,19 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query"
+import { useAuthApiClient } from "./useAuthApiClient"
+import { QUERY_KEYS } from "./constants"
+
+export function useSignOut(useMutationOptions = {}) {
+  const queryClient = useQueryClient()
+  const authApiClient = useAuthApiClient()
+
+  const { mutate, mutateAsync, ...rest } = useMutation({
+    mutationFn: () => authApiClient.deleteSession(),
+    onSuccess: () => {
+      queryClient.resetQueries({ queryKey: [QUERY_KEYS.SESSION], exact: false })
+      queryClient.resetQueries({ queryKey: [QUERY_KEYS.CURRENT_ACCOUNT] })
+    },
+    ...useMutationOptions,
+  })
+
+  return { signOut: mutate, signOutAsync: mutateAsync, ...rest }
+}

package/src/hooks/useUpdateMezoId.ts

@@ -0,0 +1,25 @@
+import { useQueryClient, useMutation } from "@tanstack/react-query"
+import { useAuthApiClient } from "./useAuthApiClient"
+import { QUERY_KEYS } from "./constants"
+
+export function useUpdateMezoId(useMutationOptions = {}) {
+  const queryClient = useQueryClient()
+  const authApiClient = useAuthApiClient()
+
+  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,
+      })
+    },
+    ...useMutationOptions,
+  })
+
+  return { updateMezoId: mutate, updateMezoIdAsync: mutateAsync, ...rest }
+}

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from "./config"
 export * from "./constants"
 export * from "./hooks"
+export * from "./provider"
 export * from "./wallet"

package/src/provider.ts

@@ -0,0 +1,57 @@
+import { createContext, createElement, useMemo } from "react"
+import { API_ENDPOINTS_BY_ENV, AuthApiClient } from "./api/auth"
+
+export interface PassportContextValue {
+  authApiClient: AuthApiClient
+}
+
+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
+      }
+  )
+  children: React.ReactNode
+}
+
+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])
+
+  return createElement(
+    PassportContext.Provider,
+    {
+      value: finalApiUrl
+        ? {
+            authApiClient: new AuthApiClient(finalApiUrl),
+          }
+        : undefined,
+    },
+    children,
+  )
+}

package/src/utils/siww.ts

@@ -0,0 +1,31 @@
+import { SignInWithWalletMessage } from "@mezo-org/sign-in-with-wallet"
+import { ONE_DAY_MS } from "./time"
+
+const SESSION_EXPIRATION_DURATION_MS = 14 * ONE_DAY_MS
+
+type NetworkFamily = "evm" | "bitcoin"
+
+export function createSignInWithWalletMessage(
+  address: string,
+  nonce: string,
+  networkFamily: NetworkFamily,
+  chainId?: number,
+) {
+  const { host: domain, origin: uri } = window.location
+
+  const message = new SignInWithWalletMessage({
+    domain,
+    address, // if "bitcoin" this should be btc address, not underlaying eth address
+    uri,
+    nonce,
+    issuedAt: new Date().toISOString(),
+    expirationTime: new Date(
+      Date.now() + SESSION_EXPIRATION_DURATION_MS,
+    ).toISOString(),
+    version: "1",
+    chainId: networkFamily === "evm" ? chainId : undefined,
+    networkFamily,
+  })
+
+  return message.prepareMessage()
+}

package/src/utils/time.ts

@@ -0,0 +1,4 @@
+export const ONE_SECOND_MS = 1000
+export const ONE_MINUTE_MS = 60 * ONE_SECOND_MS
+export const ONE_HOUR_MS = 60 * ONE_MINUTE_MS
+export const ONE_DAY_MS = 24 * ONE_HOUR_MS