@mezo-org/passport 0.4.0-dev.5 → 0.4.0-dev.51

package/src/hooks/useAssetsConversionRates.ts

@@ -0,0 +1,96 @@
+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 { CHAIN_ID } from "../constants"
+import { usePassportContext } from "./usePassportContext"
+
+const BTC_TARGET_DIGITS = 18
+const T_TARGET_DIGITS = 10
+// 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,43 +1,45 @@
-import { useAccount, useSignMessage } from "wagmi"
-import { useBitcoinAccount } from "@mezo-org/orangekit"
-import { useMutation } from "@tanstack/react-query"
-import { useMemo } from "react"
+import { useSignMessage } from "wagmi"
+import { MutationOptions, useMutation } from "@tanstack/react-query"
 import { useCreateAccount } from "./useCreateAccount"
 import { useCreateSession } from "./useCreateSession"
 import { useEnsureNoSessionAndFetchNonce } from "./useEnsureNoSessionAndFetchNonce"
 import { createSignInWithWalletMessage } from "../utils/siww"
 import { useGetAccountByAddress } from "./useGetAccountByAddress"
+import type { Session } from "../api"
+import useWalletAccount from "./useWalletAccount"
 
-function useAuthenticateWithWallet({
-  signUp = false,
-}: { signUp?: boolean } = {}) {
-  const { chainId, address, connector } = useAccount()
-  const { btcAddress } = useBitcoinAccount()
+function useAuthenticateWithWallet(
+  shouldCreateAccount = false,
+  mutationOptions: Omit<
+    MutationOptions<Session>,
+    "mutationFn" | "mutationKey"
+  > = {},
+) {
+  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 networkFamily = btcAddress ? "bitcoin" : "evm"
       const messageResult = createSignInWithWalletMessage(
-        btcAddress ? btcAddress! : address!,
+        walletAddress,
         nonce,
         networkFamily,
         chainId,
@@ -47,10 +49,23 @@ function useAuthenticateWithWallet({
         connector,
       })
 
-      if (signUp) {
-        const getAcountByAddressResult = await getAccountByAddress()
+      if (shouldCreateAccount) {
+        const getAccountByAddressResult = await getAccountByAddress()
+
+        if (getAccountByAddressResult.data) {
+          throw new Error(
+            "Wallet authentication failed: Account creation failed. Account already exists.",
+          )
+        }
 
-        if (!getAcountByAddressResult.data) {
+        if (getAccountByAddressResult.error) {
+          throw new Error(
+            `Wallet authentication failed: Account creation failed. Could not verify if account already exists: ${getAccountByAddressResult.error}`,
+          )
+        }
+
+        // Fetch was successful, but no account was found
+        try {
           const createAccountResult = await createAccountAsync({
             type: "wallet",
             message: messageResult,
@@ -58,17 +73,23 @@ function useAuthenticateWithWallet({
           })
 
           if (!createAccountResult) {
-            throw new Error("Sign in error: Failed to create new account")
+            throw new Error("Failed to create new account")
           }
+        } catch (error) {
+          throw new Error(
+            `Wallet authentication failed: Account creation failed: ${error}`,
+          )
         }
       }
 
-      return createSessionAsync({
+      return (await createSessionAsync({
         type: "wallet",
         message: messageResult,
         signature: signatureResult,
-      })
+      })) as Session
+      // ^ By passing type: "wallet" we know for sure the return type is Session
     },
+    ...mutationOptions,
   })
 
   return {

package/src/hooks/useBorrowData.ts

@@ -0,0 +1,143 @@
+import { useAccount, useReadContract } 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
+
+/**
+ * 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 mainnetBorrowContracts.TroveManager.address
+    }
+    return testnetBorrowContracts.TroveManager.address
+  }, [environment])
+
+  return useReadContract({
+    abi: TROVE_MANAGER_ABI,
+    address: contractAddress,
+    functionName: "getEntireDebtAndColl",
+    args: [address || "0x"],
+    query: {
+      enabled: !!address,
+      staleTime: 5 * ONE_MINUTE_MS,
+      retry: 1,
+      select: (data) => {
+        if (!data) return undefined
+
+        const [collateral, principal, interest] = data
+        return {
+          collateral,
+          troveDebt: principal + interest,
+        }
+      },
+      ...queryOptions,
+    },
+    chainId: CHAIN_ID[environment],
+  })
+}
+
+/**
+ * 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

@@ -1,21 +1,35 @@
-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 { CreateAccountRequest } from "../api/auth"
+import type { CreateAccountRequest, CreateAccountResponse } from "../api"
 
-export function useCreateAccount(useMutationOptions = {}) {
+export function useCreateAccount(
+  mutationOptions: Omit<
+    MutationOptions<CreateAccountResponse, DefaultError, CreateAccountRequest>,
+    "mutationFn" | "mutationKey"
+  > = {},
+) {
   const queryClient = useQueryClient()
   const authApiClient = useAuthApiClient()
 
+  const { onSuccess: customOnSuccess, ...restMutationOptions } = mutationOptions
+
   const { mutate, mutateAsync, ...rest } = useMutation({
     mutationFn: (createAccountRequest: CreateAccountRequest) =>
       authApiClient.createAccount(createAccountRequest),
-    onSuccess: () => {
+    onSuccess: (data, variables, context) => {
       queryClient.resetQueries({
         queryKey: [QUERY_KEYS.ACCOUNT],
       })
+
+      if (customOnSuccess) customOnSuccess(data, variables, context)
     },
-    ...useMutationOptions,
+    ...restMutationOptions,
   })
 
   return { createAccount: mutate, createAccountAsync: mutateAsync, ...rest }

package/src/hooks/useCreateSession.ts

@@ -1,30 +1,43 @@
-import { useQueryClient, useMutation } from "@tanstack/react-query"
+import {
+  useQueryClient,
+  useMutation,
+  MutationOptions,
+  DefaultError,
+} from "@tanstack/react-query"
 import { useAuthApiClient } from "./useAuthApiClient"
-import { CreateSessionRequest } from "../api/auth"
+import type { CreateSessionRequest, CreateSessionResponse } from "../api"
 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 = {}) {
+export function useCreateSession(
+  mutationOptions: Omit<
+    MutationOptions<CreateSessionResponse, DefaultError, CreateSessionRequest>,
+    "mutationFn" | "mutationKey"
+  > = {},
+) {
   const queryClient = useQueryClient()
   const authApiClient = useAuthApiClient()
 
+  const { onSuccess: customOnSuccess, ...restMutationOptions } = mutationOptions
+
   const { mutate, mutateAsync, ...rest } = useMutation({
     mutationFn: (createSessionRequest: CreateSessionRequest) =>
       authApiClient.createSession(createSessionRequest),
-    onSuccess: () => {
-      // 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
+    onSuccess: (data, variables, context) => {
+      // Since `getSession` query also has code in its 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] })
       queryClient.resetQueries({
         queryKey: [QUERY_KEYS.ACCOUNT, QUERY_KEYS.CURRENT],
       })
+
+      if (customOnSuccess) customOnSuccess(data, variables, context)
     },
-    ...useMutationOptions,
+    ...restMutationOptions,
   })
 
   return { createSession: mutate, createSessionAsync: mutateAsync, ...rest }

package/src/hooks/useDropdownData.ts

@@ -0,0 +1,149 @@
+import { useBalance } from "wagmi"
+import { useGetCurrentAccount } from "."
+import {
+  CryptoAssetKey,
+  isBitcoinLikeCryptoAsset,
+  mapCryptoAssetToDetails,
+} from "../utils/cryptoAssets"
+import { fromFixedPoint } from "../utils/numbers"
+import { useAssetsConversionRates } from "./useAssetsConversionRates"
+import useWalletAccount from "./useWalletAccount"
+import { useTokensBalances } from "./useTokensBalances"
+import { useBorrowData } from "./useBorrowData"
+import { CHAIN_ID } from "../constants"
+import { usePassportContext } from "./usePassportContext"
+import { useWatchTransferEventsForAllTokens } from "./useWatchTransferEvents"
+
+export type DropdownCryptoAsset<T = CryptoAssetKey> = {
+  type: T
+  balance: bigint
+}
+
+const DEFAULT_ASSET_DATA = {
+  rawBalance: 0n,
+  formattedBalance: "0.0000",
+  usdBalance: 0,
+  formattedUsdBalance: "$0.00",
+}
+
+/**
+ * Aggregates dropdown data for Dropdown component.
+ * @param {accountDataRefetchInterval: number, nativeBalanceRefetchInterval: number }
+ * Object containing refetch intervals time (in milliseconds) for account data
+ * (like mats or mezo id) and for native balance. After that time the specific
+ * value should be marked as stale and re-fetched. Default value for both is
+ * 90000 (90 secs).
+ * @returns Dropdown data.
+ * @dev This hook is for internal use only.
+ */
+export default function useDropdownData({
+  accountDataRefetchInterval = 90000,
+  nativeBalanceRefetchInterval = 90000,
+}) {
+  const {
+    walletAddress,
+    accountAddress,
+    networkFamily: walletType,
+  } = useWalletAccount()
+  const { environment = "mainnet" } = usePassportContext()
+  const { data: btcBalance } = useBalance({
+    address: accountAddress,
+    chainId: CHAIN_ID[environment],
+    query: {
+      staleTime: nativeBalanceRefetchInterval,
+      refetchInterval: nativeBalanceRefetchInterval,
+    },
+  })
+  const { data: passportAccount } = useGetCurrentAccount({
+    staleTime: accountDataRefetchInterval,
+    refetchInterval: accountDataRefetchInterval,
+    enabled: !!accountAddress,
+  })
+  const { data: assetsConversionRates } = useAssetsConversionRates()
+  const { data: tokensBalances } = useTokensBalances()
+  const { data: debt } = useBorrowData()
+
+  useWatchTransferEventsForAllTokens()
+
+  const mezoId = passportAccount?.mezoId
+
+  const detailedAssets = [
+    ["BTC", btcBalance?.value ?? 0n],
+    ...Object.entries(tokensBalances ?? {}),
+  ].map((asset) => {
+    const [type, balance] = asset as [CryptoAssetKey, bigint]
+
+    let conversionRate: bigint | undefined
+    let conversionRateDecimals: number | undefined
+
+    if (isBitcoinLikeCryptoAsset(type)) {
+      conversionRate = assetsConversionRates.btc.price
+      conversionRateDecimals = assetsConversionRates.btc.decimals
+    }
+    if (type === "mT") {
+      conversionRate = assetsConversionRates.t.price
+      conversionRateDecimals = assetsConversionRates.t.decimals
+    }
+
+    return mapCryptoAssetToDetails(
+      type,
+      balance,
+      conversionRate,
+      conversionRateDecimals,
+    )
+  })
+
+  const btcData = detailedAssets.find(({ type }) => type === "BTC")!
+  const musdData = detailedAssets.find(({ type }) => type === "MUSD")!
+  const otherAssetsData = detailedAssets.filter(
+    ({ type }) => !["BTC", "MUSD"].includes(type),
+  )
+
+  const otherAssetsCount = otherAssetsData.filter(
+    (asset) => asset.rawBalance !== 0n,
+  ).length
+
+  const assets = {
+    btc: btcData || {
+      type: "BTC",
+      ...DEFAULT_ASSET_DATA,
+    },
+    musd: musdData || {
+      type: "mUSD",
+      ...DEFAULT_ASSET_DATA,
+    },
+  }
+
+  const otherAssetsUsdTotal = otherAssetsData.reduce(
+    (sum, { usdBalance }) => sum + usdBalance,
+    0,
+  )
+
+  const usdTotalBalance = detailedAssets.reduce(
+    (sum, { usdBalance }) => sum + usdBalance,
+    0,
+  )
+
+  const matsBalance = passportAccount?.mats.totalMats || 0
+
+  const usdCollateral = fromFixedPoint(
+    (debt?.collateral ?? 0n) * assetsConversionRates.btc.price,
+    18,
+  )
+
+  const usdTroveDebt = fromFixedPoint(debt?.troveDebt ?? 0n, 18)
+
+  return {
+    mezoId,
+    matsBalance,
+    accountAddress,
+    walletAddress,
+    walletType,
+    usdTotalBalance,
+    usdTroveDebt,
+    usdCollateral,
+    assets,
+    otherAssetsCount,
+    otherAssetsUsdTotal,
+  }
+}

package/src/hooks/useGetAccountByAddress.ts

@@ -2,12 +2,12 @@ import { useQuery, skipToken, UseBaseQueryOptions } from "@tanstack/react-query"
 import { useAuthApiClient } from "./useAuthApiClient"
 import { QUERY_KEYS } from "./constants"
 import { ONE_MINUTE_MS } from "../utils/time"
-import { GetAccountByMezoIdOrAddressResponse } from "../api/auth"
+import type { GetAccountByMezoIdOrAddressResponse } from "../api"
 
 export function useGetAccountByAddress(
   address?: string,
   queryOptions: Omit<
-    UseBaseQueryOptions<GetAccountByMezoIdOrAddressResponse>,
+    UseBaseQueryOptions<GetAccountByMezoIdOrAddressResponse | null>,
     "queryKey" | "queryFn"
   > = {},
 ) {

package/src/hooks/useGetAccountByMezoId.ts

@@ -2,12 +2,12 @@ import { useQuery, skipToken, UseBaseQueryOptions } from "@tanstack/react-query"
 import { useAuthApiClient } from "./useAuthApiClient"
 import { QUERY_KEYS } from "./constants"
 import { ONE_MINUTE_MS } from "../utils/time"
-import { GetAccountByMezoIdOrAddressResponse } from "../api/auth"
+import type { GetAccountByMezoIdOrAddressResponse } from "../api"
 
 export function useGetAccountByMezoId(
   mezoId?: string,
   queryOptions: Omit<
-    UseBaseQueryOptions<GetAccountByMezoIdOrAddressResponse>,
+    UseBaseQueryOptions<GetAccountByMezoIdOrAddressResponse | null>,
     "queryKey" | "queryFn"
   > = {},
 ) {