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

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 {
+  mainnetTokenContracts,
+  testnetTokenContracts,
+  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" ? mainnetTokenContracts : testnetTokenContracts
+
+    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 invalidateTokensBalancesHandler = useCallback(
+    () => queryClient.invalidateQueries({ queryKey }),
+    [queryClient, queryKey],
+  )
+
+  return {
+    invalidateTokensBalances: invalidateTokensBalancesHandler,
+  }
+}
+
+/**
+ * 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,17 +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: () => {
+    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?: Address
+  walletAddress?: string
+  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/hooks/useWatchTransferEvents.ts

@@ -0,0 +1,74 @@
+import { useMemo } from "react"
+import { useAccount, useWatchContractEvent } from "wagmi"
+import {
+  mainnetTokenContracts,
+  MezoChainToken,
+  testnetTokenContracts,
+} from "../lib/contracts"
+import { usePassportContext } from "./usePassportContext"
+import { CHAIN_ID } from "../constants"
+import { useRefreshPassport } from "./useRefreshPassport"
+import { simpleWssMezoConfig } from "../config"
+
+function useWatchTransferEvents(token: MezoChainToken) {
+  const { address: userAddress } = useAccount()
+  const { environment = "mainnet" } = usePassportContext()
+  const { refreshTokensBalances, refreshBorrowData } = useRefreshPassport()
+
+  const contract = useMemo(() => {
+    const contracts =
+      environment === "mainnet" ? mainnetTokenContracts : testnetTokenContracts
+
+    return contracts[token]
+  }, [environment, token])
+
+  useWatchContractEvent({
+    address: contract.address,
+    abi: contract.abi,
+    eventName: "Transfer",
+    args: {
+      from: userAddress,
+    },
+    chainId: CHAIN_ID[environment],
+    enabled: !!userAddress,
+    config: simpleWssMezoConfig,
+    onLogs() {
+      console.log(`[${token}] Transfer from: ${userAddress}`)
+      refreshTokensBalances()
+      refreshBorrowData()
+    },
+  })
+
+  useWatchContractEvent({
+    address: contract.address,
+    abi: contract.abi,
+    eventName: "Transfer",
+    args: {
+      to: userAddress,
+    },
+    chainId: CHAIN_ID[environment],
+    enabled: !!userAddress,
+    config: simpleWssMezoConfig,
+    onLogs() {
+      console.log(`[${token}] Transfer to: ${userAddress}`)
+      refreshTokensBalances()
+      refreshBorrowData()
+    },
+  })
+}
+
+function useWatchTransferEventsForAllTokens() {
+  useWatchTransferEvents("mcbBTC")
+  useWatchTransferEvents("mDAI")
+  useWatchTransferEvents("mFBTC")
+  useWatchTransferEvents("mSolvBTC")
+  useWatchTransferEvents("mswBTC")
+  useWatchTransferEvents("mT")
+  useWatchTransferEvents("mUSDC")
+  useWatchTransferEvents("mUSDe")
+  useWatchTransferEvents("mUSDT")
+  useWatchTransferEvents("mxSolvBTC")
+  useWatchTransferEvents("MUSD")
+}
+
+export { useWatchTransferEvents, useWatchTransferEventsForAllTokens }

package/src/index.ts

@@ -1,4 +1,12 @@
-export * from "./config"
+export * from "./components"
+export {
+  defaultConfig,
+  unisatWallet,
+  okxWallet,
+  xverseWallet,
+  getDefaultWallets,
+  getConfig,
+} from "./config"
 export * from "./constants"
 export * from "./hooks"
 export * from "./provider"

package/src/lib/contracts/index.ts

@@ -0,0 +1,88 @@
+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 musdMainnet from "@mezo-org/musd-contracts/deployments/mainnet/MUSD.json"
+
+import troveManagerMainnet from "@mezo-org/musd-contracts/deployments/mainnet/TroveManager.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 musdTestnet from "@mezo-org/musd-contracts/deployments/matsnet/MUSD.json"
+
+import troveManagerTestnet from "@mezo-org/musd-contracts/deployments/matsnet/TroveManager.json"
+
+import { Abi, Address } from "viem"
+
+export type MezoChainToken =
+  | "mcbBTC"
+  | "mDAI"
+  | "mFBTC"
+  | "mSolvBTC"
+  | "mswBTC"
+  | "mT"
+  | "mUSDC"
+  | "mUSDe"
+  | "mUSDT"
+  | "mxSolvBTC"
+  | "MUSD"
+
+export type MezoBorrowContract = "TroveManager"
+
+type ContractsMap<K extends string> = Record<
+  K,
+  {
+    address: Address
+    abi: Abi
+  }
+>
+
+export const testnetTokenContracts = {
+  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<MezoChainToken>
+
+export const mainnetTokenContracts = {
+  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<MezoChainToken>
+
+export const mainnetBorrowContracts = {
+  TroveManager: troveManagerMainnet,
+} as unknown as ContractsMap<MezoBorrowContract>
+
+export const testnetBorrowContracts = {
+  TroveManager: troveManagerTestnet,
+} as unknown as ContractsMap<MezoBorrowContract>

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/stores/dropdownStore.ts

@@ -0,0 +1,20 @@
+import { create } from "zustand"
+
+export enum DropdownView {
+  ROOT = "ROOT",
+  RECEIVE = "RECEIVE",
+}
+
+interface DropdownStore {
+  view: DropdownView
+  setView: (view: DropdownView) => void
+  isNestedView: () => boolean
+}
+
+const useDropdownStore = create<DropdownStore>((set, get) => ({
+  view: DropdownView.ROOT,
+  setView: (view: DropdownView) => set({ view }),
+  isNestedView: () => get().view !== DropdownView.ROOT,
+}))
+
+export default useDropdownStore

package/src/utils/address.test.ts

@@ -0,0 +1,48 @@
+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}`)
+  })
+
+  it("returns correct mainnet Mezo explorer URL", () => {
+    const url = getAddressExplorerUrl(evmAddress, "mezo", false)
+    expect(url).toBe(`https://explorer.mezo.org/address/${evmAddress}`)
+  })
+
+  it("returns correct testnet Mezo explorer URL", () => {
+    const url = getAddressExplorerUrl(evmAddress, "mezo", true)
+    expect(url).toBe(`https://explorer.test.mezo.org/address/${evmAddress}`)
+  })
+})

package/src/utils/address.ts

@@ -0,0 +1,45 @@
+/**
+ * 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" | "mezo", string> = {
+  bitcoin: "https://mempool.space",
+  evm: "https://etherscan.io",
+  mezo: "https://explorer.mezo.org",
+}
+
+const TESTNET_EXPLORER_URLS: Record<"bitcoin" | "evm" | "mezo", string> = {
+  bitcoin: "https://mempool.space/testnet",
+  evm: "https://sepolia.etherscan.io",
+  mezo: "https://explorer.test.mezo.org",
+}
+
+/**
+ * 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" | "mezo",
+  isTestnet: boolean,
+) {
+  const EXPLORER_URLS = isTestnet
+    ? TESTNET_EXPLORER_URLS
+    : MAINNET_EXPLORER_URLS
+  const baseUrl = EXPLORER_URLS[chainType]
+  const endpoint = `address/${address}`
+
+  return `${baseUrl}/${endpoint}`
+}