@mezo-org/passport 0.4.0-dev.7 → 0.4.0-dev.70

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,20 @@ 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"
+export * from "./useValidateMezoId"

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,11 +1,12 @@
 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"
-import { createSignInWithWalletMessage } from "../utils/siww"
+import {
+  createSignInWithWalletMessage,
+  verifyDomainInSignInWithWalletMessage,
+} from "../utils/siww"
 import { useGetAccountByAddress } from "./useGetAccountByAddress"
 import type { Session } from "../api"
 import useWalletAccount from "./useWalletAccount"
@@ -17,32 +18,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,
@@ -52,6 +52,12 @@ function useAuthenticateWithWallet(
         connector,
       })
 
+      await verifyDomainInSignInWithWalletMessage(
+        messageResult,
+        signatureResult,
+        nonce,
+      )
+
       if (shouldCreateAccount) {
         const getAccountByAddressResult = await getAccountByAddress()
 

package/src/hooks/useBorrowData.ts

@@ -0,0 +1,187 @@
+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"
+import { bigIntMax } from "../utils/numbers"
+
+// 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!
+
+        const troveDebt = bigIntMax(
+          principal + interest - gasCompensation,
+          0n, // Ensure that debt is not negative
+        )
+
+        return {
+          collateral,
+          // Principal includes gas compensation value which is not
+          troveDebt,
+        }
+      },
+      ...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,
+  }
+}

package/src/hooks/useCreateAccount.ts

@@ -7,6 +7,8 @@ import {
 import { useAuthApiClient } from "./useAuthApiClient"
 import { QUERY_KEYS } from "./constants"
 import type { CreateAccountRequest, CreateAccountResponse } from "../api"
+import useWalletAccount from "./useWalletAccount"
+import { getBitcoinPublicKeyFromConnector } from "../utils/wagmi"
 
 export function useCreateAccount(
   mutationOptions: Omit<
@@ -16,12 +18,36 @@ export function useCreateAccount(
 ) {
   const queryClient = useQueryClient()
   const authApiClient = useAuthApiClient()
+  const { connector } = useWalletAccount()
 
   const { onSuccess: customOnSuccess, ...restMutationOptions } = mutationOptions
 
   const { mutate, mutateAsync, ...rest } = useMutation({
-    mutationFn: (createAccountRequest: CreateAccountRequest) =>
-      authApiClient.createAccount(createAccountRequest),
+    mutationFn: async (
+      createAccountMutationFnParameters: CreateAccountRequest,
+    ) => {
+      if (createAccountMutationFnParameters.type === "wallet") {
+        if (!connector) {
+          throw new Error("Connector not defined.")
+        }
+
+        const bitcoinPublicKey =
+          await getBitcoinPublicKeyFromConnector(connector)
+
+        // Creating bitcoin mezo account
+        if (bitcoinPublicKey) {
+          return authApiClient.createAccount({
+            ...createAccountMutationFnParameters,
+            bitcoinPublicKey,
+          })
+        }
+      }
+
+      // Creating evm mezo account
+      return authApiClient.createAccount({
+        ...createAccountMutationFnParameters,
+      })
+    },
     onSuccess: (data, variables, context) => {
       queryClient.resetQueries({
         queryKey: [QUERY_KEYS.ACCOUNT],