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

package/src/config.ts

@@ -1,7 +1,12 @@
-import { http } from "viem"
 import { Chain, getDefaultConfig, WalletList } from "@rainbow-me/rainbowkit"
-import { Config, CreateConfigParameters } from "wagmi"
-import { CHAIN_ID, mezoMatsnetTestnet, RPC_BY_NETWORK } from "./constants"
+import {
+  Config,
+  createConfig,
+  CreateConfigParameters,
+  http,
+  webSocket,
+} from "wagmi"
+import { CHAIN_ID, mezoMainnet, mezoTestnet, RPC_BY_NETWORK } from "./constants"
 import { getOKXWallet, getUnisatWallet, getXverseWallet } from "./wallet"
 
 type WagmiConfigParameters = Omit<
@@ -20,7 +25,8 @@ type GetDefaultConfigParameters = WagmiConfigParameters & {
 }
 
 const transports = {
-  [CHAIN_ID.testnet]: http(RPC_BY_NETWORK.testnet),
+  [CHAIN_ID.mainnet]: http(RPC_BY_NETWORK.mainnet.http),
+  [CHAIN_ID.testnet]: http(RPC_BY_NETWORK.testnet.http),
 } as Pick<CreateConfigParameters, "transports">
 
 export const defaultConfig: Required<
@@ -34,39 +40,90 @@ export const defaultConfig: Required<
 > = {
   transports,
   walletConnectProjectId: "",
-  chains: [mezoMatsnetTestnet],
+  chains: [mezoMainnet, mezoTestnet],
   multiInjectedProviderDiscovery: true,
 }
 
-const bitcoinWalletConfig = {
-  rpcUrl: RPC_BY_NETWORK.testnet,
+const bitcoinWalletTestnetConfig = {
+  rpcUrl: RPC_BY_NETWORK.testnet.http,
   chainId: CHAIN_ID.testnet,
 }
 
-export const unisatWallet = getUnisatWallet(bitcoinWalletConfig)
-export const okxWallet = getOKXWallet(bitcoinWalletConfig)
-export const xverseWallet = getXverseWallet(bitcoinWalletConfig)
+const bitcoinWalletMainnetConfig = {
+  rpcUrl: RPC_BY_NETWORK.mainnet.http,
+  chainId: CHAIN_ID.mainnet,
+}
+
+export const unisatWalletMezoTestnet = getUnisatWallet(
+  bitcoinWalletTestnetConfig,
+)
+export const okxWalletMezoTestnet = getOKXWallet(bitcoinWalletTestnetConfig)
+export const xverseWalletMezoTestnet = getXverseWallet(
+  bitcoinWalletTestnetConfig,
+)
 
-export function getDefaultWallets(): WalletList {
+export const unisatWalletMezoMainnet = getUnisatWallet(
+  bitcoinWalletMainnetConfig,
+)
+export const okxWalletMezoMainnet = getOKXWallet(bitcoinWalletMainnetConfig)
+export const xverseWalletMezoMainnet = getXverseWallet(
+  bitcoinWalletMainnetConfig,
+)
+
+export function getDefaultWallets(
+  network: "mainnet" | "testnet" = "mainnet",
+): WalletList {
   return [
     {
       groupName: "Bitcoin",
-      wallets: [unisatWallet, okxWallet, xverseWallet],
+      wallets:
+        network === "mainnet"
+          ? [
+              unisatWalletMezoMainnet,
+              okxWalletMezoMainnet,
+              xverseWalletMezoMainnet,
+            ]
+          : [
+              unisatWalletMezoTestnet,
+              okxWalletMezoTestnet,
+              xverseWalletMezoTestnet,
+            ],
     },
   ]
 }
 
-export function getConfig({
-  appName,
-  bitcoinWallets,
-  walletConnectProjectId,
-  ...restParameters
-}: GetDefaultConfigParameters): Config {
+export function getConfig(config: GetDefaultConfigParameters): Config {
+  const {
+    appName,
+    walletConnectProjectId = defaultConfig.walletConnectProjectId,
+    ...restParameters
+  } = config
+
+  // Wallets don't have to be differentiated by network. Viem will choose proper
+  // connector selectively based on the chainId, or by the chainId passed
+  // explicitly.
+  const wallets = config.bitcoinWallets ?? [
+    ...getDefaultWallets("mainnet"),
+    ...getDefaultWallets("testnet"),
+  ]
+
   return getDefaultConfig({
     ...defaultConfig,
     appName,
-    wallets: [...(bitcoinWallets ?? getDefaultWallets())],
-    projectId: walletConnectProjectId ?? defaultConfig.walletConnectProjectId,
+    wallets,
+    projectId: walletConnectProjectId,
     ...restParameters,
   })
 }
+
+/**
+ * This config is only used to listen for Transfer events on mezo chain.
+ * Should not be exported in index for public use.
+ */
+export const simpleWssMezoConfig = createConfig({
+  chains: [mezoMainnet, mezoTestnet],
+  transports: {
+    [mezoMainnet.id]: webSocket(RPC_BY_NETWORK.mainnet.webSocket),
+    [mezoTestnet.id]: webSocket(RPC_BY_NETWORK.testnet.webSocket),
+  },
+})

package/src/constants.ts

@@ -1,11 +1,19 @@
-import { mezoMatsnetTestnet } from "@mezo-org/orangekit"
+import { mezoMainnet, mezoTestnet } from "@mezo-org/orangekit"
 
-export { mezoMatsnetTestnet } from "@mezo-org/orangekit"
+export { mezoMainnet, mezoTestnet } from "@mezo-org/orangekit"
 
 export const CHAIN_ID = {
-  testnet: mezoMatsnetTestnet.id,
+  testnet: mezoTestnet.id,
+  mainnet: mezoMainnet.id,
 }
 
 export const RPC_BY_NETWORK = {
-  testnet: mezoMatsnetTestnet.rpcUrls.default.http[0],
+  mainnet: {
+    http: mezoMainnet.rpcUrls.default.http[0],
+    webSocket: mezoMainnet.rpcUrls.default.webSocket?.[0],
+  },
+  testnet: {
+    http: mezoTestnet.rpcUrls.default.http[0],
+    webSocket: mezoTestnet.rpcUrls.default.webSocket?.[0],
+  },
 }

package/src/hooks/index.ts

@@ -6,13 +6,19 @@ export {
   useSubscribeToConnectorEvent,
   useSubscribeToWalletNetworkDoesNotMatchProviderChain,
 } from "@mezo-org/orangekit"
+export { useInvalidateBorrowData, useResetBorrowData } from "./useBorrowData"
 export * from "./useGetAccountByAddress"
 export * from "./useGetAccountByMezoId"
 export * from "./useGetCurrentAccount"
 export * from "./useGetSession"
 export * from "./useLinkAccount"
+export * from "./useRefreshPassport"
 export * from "./useSignInWithDiscord"
 export * from "./useSignInWithWallet"
 export * from "./useSignOut"
 export * from "./useSignUpWithWallet"
+export {
+  useInvalidateTokensBalances,
+  useResetTokensBalances,
+} from "./useTokensBalances"
 export * from "./useUpdateMezoId"

package/src/hooks/useAssetsConversionRates.ts

@@ -0,0 +1,97 @@
+import { useQuery } from "@tanstack/react-query"
+import { useReadContract } from "wagmi"
+import { ONE_SECOND_MS } from "../utils/time"
+import { QUERY_KEYS } from "./constants"
+import { usePortalApiClient } from "./usePortalApiClient"
+import { priceOracleContract } from "../lib/contracts"
+import { fromFloatToBigInt } from "../utils/numbers"
+import { getCryptoAsset } from "../utils/cryptoAssets"
+import { CHAIN_ID } from "../constants"
+import { usePassportContext } from "./usePassportContext"
+
+const BTC_TARGET_DIGITS = getCryptoAsset("BTC").decimals
+const T_TARGET_DIGITS = getCryptoAsset("mT").decimals
+// If the oracle has not been updated in at least 60 seconds, it is stale.
+const MAX_PRICE_DELAY = 60 * ONE_SECOND_MS
+
+/**
+ * Scales the price by the number of digits.
+ * @dev Oracles returns prices with variable number of digits. This function
+ *      scales the price to a fixed number of digits ensuring consistency.
+ * @param price - The price to scale.
+ * @param priceDigits - The number of digits in the price.
+ * @returns The scaled price.
+ */
+function scalePriceByDigits(price: bigint, priceDigits: number): bigint {
+  if (priceDigits > BTC_TARGET_DIGITS) {
+    return price / 10n ** BigInt(priceDigits - BTC_TARGET_DIGITS)
+  }
+  if (priceDigits < BTC_TARGET_DIGITS) {
+    return price * 10n ** BigInt(BTC_TARGET_DIGITS - priceDigits)
+  }
+  return price
+}
+
+/**
+ * Hook to fetch assets conversion rates.
+ * @see https://github.com/mezo-org/musd/blob/f0b2030315f0d8b0fc11a9fc778856fe4673051f/solidity/contracts/PriceFeed.sol
+ * @returns {}.data.{}.price - The latest asset price.
+ * @returns {}.data.{}.digits - The latest asset price digits.
+ * @returns {}.isPending - Whether the request is pending.
+ * @returns {}.isError - Whether there was an error fetching the price.
+ */
+export function useAssetsConversionRates() {
+  const portalApiClient = usePortalApiClient()
+  const { environment = "mainnet" } = usePassportContext()
+
+  const btcPrice = useReadContract({
+    ...priceOracleContract,
+    functionName: "latestRoundData",
+    query: {
+      refetchInterval: ({ state }) => {
+        if (!state.data) return MAX_PRICE_DELAY
+
+        const [, , , updatedAt] = state.data ?? []
+        if (!updatedAt) return MAX_PRICE_DELAY
+
+        const age = Date.now() - Number(updatedAt) * 1000
+
+        return age > MAX_PRICE_DELAY
+          ? // If the data is stale, we want to refetch as soon as possible, but
+            // not faster than once per second, to avoid excessive requests.
+            // Math.max ensures the interval is at least 1 second.
+            Math.max(ONE_SECOND_MS, MAX_PRICE_DELAY - age)
+          : MAX_PRICE_DELAY - age
+      },
+      select: (data) => {
+        const [, answer] = data
+        return scalePriceByDigits(answer, BTC_TARGET_DIGITS)
+      },
+    },
+    chainId: CHAIN_ID[environment],
+  })
+
+  const tPrice = useQuery({
+    queryKey: [QUERY_KEYS.ASSETS_USD_CONVERSION],
+    queryFn: () => portalApiClient.getPortalStatistics(),
+    select: (data) =>
+      fromFloatToBigInt(data.currentUsdPerTToken, T_TARGET_DIGITS),
+    refetchInterval: MAX_PRICE_DELAY,
+    throwOnError: true,
+  })
+
+  return {
+    data: {
+      t: {
+        price: tPrice.data ?? 0n,
+        decimals: T_TARGET_DIGITS,
+      },
+      btc: {
+        price: btcPrice.data ?? 0n,
+        decimals: BTC_TARGET_DIGITS,
+      },
+    },
+    isPending: tPrice.isPending || btcPrice.isPending,
+    isError: tPrice.isError || btcPrice.isError,
+  }
+}

package/src/hooks/useAuthenticateWithWallet.ts

@@ -1,7 +1,5 @@
 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"
@@ -17,32 +15,31 @@ function useAuthenticateWithWallet(
     "mutationFn" | "mutationKey"
   > = {},
 ) {
-  const { address, chainId, connector, networkFamily } = useWalletAccount()
-  const { btcAddress } = useBitcoinAccount()
+  const { walletAddress, chainId, connector, networkFamily } =
+    useWalletAccount()
   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 },
+    {
+      enabled: false,
+      retry: false,
+    },
   )
 
   const { mutate, mutateAsync, ...signInMutationRestParameters } = useMutation({
     mutationFn: async () => {
-      if (!address) {
+      if (!walletAddress) {
         throw new Error("Sign in error: Wallet not connected!")
       }
 
       const nonce = await ensureNoSessionAndFetchNonce()
 
       const messageResult = createSignInWithWalletMessage(
-        btcAddress || address,
+        walletAddress,
         nonce,
         networkFamily,
         chainId,

package/src/hooks/useBorrowData.ts

@@ -0,0 +1,181 @@
+import { useAccount, useReadContracts } from "wagmi"
+import { useCallback, useMemo } from "react"
+import { useQueryClient } from "@tanstack/react-query"
+import { ONE_MINUTE_MS } from "../utils/time"
+import {
+  mainnetBorrowContracts,
+  testnetBorrowContracts,
+} from "../lib/contracts"
+import { usePassportContext } from "./usePassportContext"
+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 TROVE_MANAGER_ABI = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_borrower",
+        type: "address",
+      },
+    ],
+    name: "getEntireDebtAndColl",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "coll",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "principal",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "interest",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "pendingCollateral",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "pendingPrincipal",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "pendingInterest",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const
+
+const BORROWER_OPERATIONS_ABI = [
+  {
+    inputs: [],
+    name: "MUSD_GAS_COMPENSATION",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const
+
+/**
+ * Query hook for getting borrow data. Returns collateral and trove debt for the
+ * connected account, based on it's evm address.
+ * @param queryOptions Query options passed to the underlying `useQuery` hook.
+ */
+export function useBorrowData(queryOptions = {}) {
+  const { environment = "mainnet" } = usePassportContext()
+  const { address } = useAccount()
+
+  const contractAddress = useMemo(() => {
+    if (environment === "mainnet") {
+      return {
+        troveManager: mainnetBorrowContracts.TroveManager.address,
+        borrowerOperations: mainnetBorrowContracts.BorrowerOperations.address,
+      }
+    }
+    return {
+      troveManager: testnetBorrowContracts.TroveManager.address,
+      borrowerOperations: testnetBorrowContracts.BorrowerOperations.address,
+    }
+  }, [environment])
+
+  const chainId = CHAIN_ID[environment]
+
+  return useReadContracts({
+    contracts: [
+      {
+        abi: TROVE_MANAGER_ABI,
+        address: contractAddress.troveManager,
+        functionName: "getEntireDebtAndColl",
+        args: [address || "0x"],
+        chainId,
+      },
+      {
+        abi: BORROWER_OPERATIONS_ABI,
+        address: contractAddress.borrowerOperations,
+        functionName: "MUSD_GAS_COMPENSATION",
+        args: [],
+        chainId,
+      },
+    ],
+    query: {
+      enabled: !!address,
+      staleTime: 5 * ONE_MINUTE_MS,
+      retry: 1,
+      select: (data) => {
+        if (!data || data.some((item) => !item.result)) return undefined
+
+        const [collateral, principal, interest] = data[0].result!
+        const gasCompensation = data[1].result!
+
+        return {
+          collateral,
+          // Principal includes gas compensation value which is not
+          troveDebt: principal + interest - gasCompensation,
+        }
+      },
+      ...queryOptions,
+    },
+  })
+}
+
+/**
+ * Hook for for invalidating current user's borrow data. Can be used to
+ * invalidate borrow data manually, which forces the data to be re-fetched.
+ * @returns Function `invalidateBorrowData` for invalidating the borrow data
+ */
+export function useInvalidateBorrowData() {
+  const queryClient = useQueryClient()
+
+  const { queryKey } = useBorrowData()
+
+  const invalidateBorrowDataHandler = useCallback(
+    () => queryClient.invalidateQueries({ queryKey }),
+    [queryClient, queryKey],
+  )
+
+  return {
+    invalidateBorrowData: invalidateBorrowDataHandler,
+  }
+}
+
+/**
+ * Hook for for resetting current user's borrow data. Can be used to reset
+ * borrow data manually, which forces the data to be re-fetched.
+ * @returns Function `resetBorrowData` for resetting the borrow data
+ */
+export function useResetBorrowData() {
+  const queryClient = useQueryClient()
+
+  const { queryKey } = useBorrowData()
+
+  const resetBorrowDataHandler = useCallback(
+    () => queryClient.resetQueries({ queryKey }),
+    [queryClient, queryKey],
+  )
+
+  return {
+    resetBorrowData: resetBorrowDataHandler,
+  }
+}