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

package/src/hooks/useRefreshPassport.ts

@@ -0,0 +1,40 @@
+import { useQueryClient } from "@tanstack/react-query"
+import { useCallback } from "react"
+import { QUERY_KEYS } from "./constants"
+
+/**
+ * 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 queryClient = useQueryClient()
+
+  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],
+  )
+
+  return {
+    refreshCurrentAccount,
+    refreshUsdConversion,
+  }
+}

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,61 +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() {
-  console.log("use sign int with wallet broooo")
-  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/useTokensBalances.ts

@@ -0,0 +1,187 @@
+import { useReadContracts } from "wagmi"
+import { useCallback, useMemo } from "react"
+import { Abi } from "viem"
+import { useQueryClient } from "@tanstack/react-query"
+import { usePassportContext } from "./usePassportContext"
+import {
+  mainnetContracts,
+  testnetContracts,
+  MezoChainToken,
+} from "../lib/contracts"
+import useWalletAccount from "./useWalletAccount"
+import { CHAIN_ID } from "../constants"
+
+// Wagmi handles typesafety with ABI const assertions. TypeScript doesn't
+// support importing JSON as const yet so types cannot be inferred from the
+// imported contract. As a workaround there is minimal ABI definition that can
+// be asserted types from.
+// Ref: https://wagmi.sh/core/typescript#const-assert-abis-typed-data
+
+const BALANCE_OF_ABI = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+    ],
+    name: "balanceOf",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const satisfies Abi
+
+const BALANCE_TOKENS: MezoChainToken[] = [
+  "mcbBTC",
+  "mDAI",
+  "mFBTC",
+  "mSolvBTC",
+  "mswBTC",
+  "mT",
+  "mUSDC",
+  "mUSDe",
+  "mUSDT",
+  "mxSolvBTC",
+  "MUSD",
+]
+
+type UseMezoChainTokensBalancesOptions<T> = {
+  tokens?: T
+  queryOptions?: object
+}
+
+/**
+ * Hook to get the balance of a list of tokens for the current account
+ * @param   options.tokens The list of tokens to get the balance for. It will
+ *          fallback to all tokens if not provided.
+ * @param   options.queryOptions The query options to pass to the
+ *          `useReadContracts`
+ * @returns Tanstack's `useQuery` returnings with balance of tokens for the
+ *          current account in form of typesafe object with token names as keys
+ *          and balances as values.
+ * @dev     In case of error data fallbacks to `0n`. To determine if an error
+ *          occurred, check the `isError` property.
+ * @example
+ * const mezoTokensBalance = useTokensBalances({
+ *   tokens: ["mT", "mxSolvBTC"],
+ * })
+ * console.log(mezoTokensBalance?.data.mT) // Eg. 0n
+ * console.log(Object.keys(mezoTokensBalance?.data)) // ["mT", "mxSolvBTC"]
+ */
+export function useTokensBalances<T extends MezoChainToken[]>(
+  options: UseMezoChainTokensBalancesOptions<T> = {},
+) {
+  const { environment = "mainnet" } = usePassportContext()
+
+  const { accountAddress } = useWalletAccount()
+
+  const contractsMap = useMemo(() => {
+    const contracts =
+      environment === "mainnet" ? mainnetContracts : testnetContracts
+
+    const tokenContracts = Object.fromEntries(
+      Object.entries(contracts).filter(([key]) =>
+        BALANCE_TOKENS.includes(key as MezoChainToken),
+      ),
+    ) as typeof contracts
+
+    return tokenContracts
+  }, [environment])
+
+  const { tokens = Object.keys(contractsMap) as T, queryOptions = {} } = options
+
+  const contracts = useMemo(() => {
+    if (!accountAddress) return []
+
+    return tokens.map((token) => {
+      const { address } = contractsMap[token]
+
+      return {
+        address,
+        abi: BALANCE_OF_ABI,
+        functionName: "balanceOf",
+        args: [accountAddress],
+        chainId: CHAIN_ID[environment],
+      }
+    })
+  }, [accountAddress, tokens, contractsMap, environment])
+
+  return useReadContracts({
+    contracts,
+    query: {
+      select: (data) =>
+        data.reduce(
+          (acc, item) => {
+            const token = tokens[data.indexOf(item)]
+
+            return {
+              ...acc,
+              [token]: item.result ?? 0n,
+            }
+          },
+          {} as Record<T[number], bigint>,
+        ),
+      ...queryOptions,
+    },
+  })
+}
+
+/**
+ * Hook for invalidating current user's token balances. Can be used to
+ * invalidate the balances manually, which forces the data to be re-fetched.
+ * @param tokens The list of tokens (as string arrays) for which we want to
+ * invalidate query for.
+ * @returns Function `invalidateTokenBalances` that invalidates token balances
+ * @example
+ * const { invalidateTokenBalances } = useInvalidateTokensBalances(["mT", "mUSD"])
+ * (...)
+ * await invalidateTokenBalances()
+ */
+export function useInvalidateTokensBalances(tokens?: MezoChainToken[]) {
+  const queryClient = useQueryClient()
+
+  const { queryKey } = useTokensBalances({ tokens })
+
+  const invalidateTokenBalancesHandler = useCallback(
+    () => queryClient.invalidateQueries({ queryKey }),
+    [queryClient, queryKey],
+  )
+
+  return {
+    invalidateTokenBalances: invalidateTokenBalancesHandler,
+  }
+}
+
+/**
+ * Hook for resetting current user's token balances. Can be used to reset the
+ * balances manually, which forces the data to be re-fetched.
+ * @param tokens The list of tokens (as string arrays) for which we want to
+ * reset query for.
+ * @returns Function `resetTokenBalances` that invalidates token balances
+ * @example
+ * const { resetTokenBalances } = useResetTokensBalances(["mT", "mUSD"])
+ * (...)
+ * await resetTokenBalances()
+ */
+export function useResetTokensBalances(tokens?: MezoChainToken[]) {
+  const queryClient = useQueryClient()
+
+  const { queryKey } = useTokensBalances({ tokens })
+
+  const resetTokenBalancesHandler = useCallback(
+    () => queryClient.resetQueries({ queryKey }),
+    [queryClient, queryKey],
+  )
+
+  return {
+    resetTokenBalances: resetTokenBalancesHandler,
+  }
+}

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,55 @@
+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 = {
+  accountAddress?: string | Address
+  walletAddress?: 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 {
+    accountAddress: evmAddress,
+    walletAddress: 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/lib/contracts/index.ts

@@ -0,0 +1,75 @@
+import cbbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mcbBTC.json"
+import daiMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mDAI.json"
+import fbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mFBTC.json"
+import solvbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mSolvBTC.json"
+import swbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mswBTC.json"
+import tMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mT.json"
+import usdcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mUSDC.json"
+import usdeMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mUSDe.json"
+import usdtMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mUSDT.json"
+import xsolvbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mxSolvBTC.json"
+
+import cbbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mcbBTC.json"
+import daiTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mDAI.json"
+import fbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mFBTC.json"
+import solvbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mSolvBTC.json"
+import swbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mswBTC.json"
+import tTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mT.json"
+import usdcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mUSDC.json"
+import usdeTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mUSDe.json"
+import usdtTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mUSDT.json"
+import xsolvbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mxSolvBTC.json"
+
+import { Abi, Address } from "viem"
+import { musdTestnet, musdMainnet } from "./musd"
+
+export { default as troveManagerContract } from "./troveManager"
+
+export type MezoChainToken =
+  | "mcbBTC"
+  | "mDAI"
+  | "mFBTC"
+  | "mSolvBTC"
+  | "mswBTC"
+  | "mT"
+  | "mUSDC"
+  | "mUSDe"
+  | "mUSDT"
+  | "mxSolvBTC"
+  | "MUSD"
+
+type ContractsMap = Record<
+  MezoChainToken,
+  {
+    address: Address
+    abi: Abi
+  }
+>
+
+export const testnetContracts = {
+  mcbBTC: cbbtcTestnet,
+  mDAI: daiTestnet,
+  mFBTC: fbtcTestnet,
+  mSolvBTC: solvbtcTestnet,
+  mswBTC: swbtcTestnet,
+  mT: tTestnet,
+  mUSDC: usdcTestnet,
+  mUSDe: usdeTestnet,
+  mUSDT: usdtTestnet,
+  mxSolvBTC: xsolvbtcTestnet,
+  MUSD: musdTestnet,
+} as unknown as ContractsMap
+
+export const mainnetContracts = {
+  mcbBTC: cbbtcMainnet,
+  mDAI: daiMainnet,
+  mFBTC: fbtcMainnet,
+  mSolvBTC: solvbtcMainnet,
+  mswBTC: swbtcMainnet,
+  mT: tMainnet,
+  mUSDC: usdcMainnet,
+  mUSDe: usdeMainnet,
+  mUSDT: usdtMainnet,
+  mxSolvBTC: xsolvbtcMainnet,
+  MUSD: musdMainnet,
+} as unknown as ContractsMap