@mezo-org/passport 0.5.2-dev.3 → 0.5.2-dev.4

package/src/hooks/useTokensBalances copy.ts

@@ -1,289 +0,0 @@
-import { useConfig } from "wagmi"
-import { Abi } from "viem"
-import {
-  useQuery,
-  useQueryClient,
-  UseQueryOptions,
-} from "@tanstack/react-query"
-import { getBalance, readContracts } from "wagmi/actions"
-import {
-  mainnetTokenContracts,
-  MezoChainToken,
-  testnetTokenContracts,
-} from "../lib/contracts"
-import useWalletAccount from "./useWalletAccount"
-import {
-  getAsset,
-  isBitcoinLikeCryptoAsset,
-  isTTokenCryptoAsset,
-} from "../utils/assets"
-import { convertToUsd } from "../utils/currency"
-import { CHAIN_ID } from "../constants"
-import { useAssetsConversionRates } from "./useAssetsConversionRates"
-import { isMezoChain } from "../utils/chain"
-import {
-  amountAsUSD,
-  bigIntToFloat,
-  floatToHumanReadableFormat,
-} from "../utils/number2"
-import { useBorrowData } from "./useBorrowData"
-
-// 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
-
-export 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 extends MezoChainToken[]> = {
-  tokens?: T
-  queryOptions?: Omit<
-    UseQueryOptions<Record<T[number], TokenBalance>>,
-    "queryKey" | "queryFn" | "select" | "enabled"
-  >
-}
-
-export type TokenBalance = {
-  decimals: number
-  symbol: string
-  value: bigint
-  usd: {
-    value: number
-    formatted: string
-  }
-}
-
-const TOKEN_BALANCES_QUERY_KEY = "passport.tokenBalances"
-
-/**
- * Hook to get the balance of a list of Mezo 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.
- * @example
- * const mezoTokensBalance = useTokensBalances({
- *   tokens: ["mT", "mxSolvBTC"],
- * })
- * // Assuming the status is "success"
- * console.log(mezoTokensBalance.data.mT) // Eg. { value: 0n ... }
- * console.log(Object.keys(mezoTokensBalance.data)) // ["mT", "mxSolvBTC"]
- */
-export function useTokensBalances<T extends MezoChainToken[]>(
-  options: UseMezoChainTokensBalancesOptions<T> = {},
-) {
-  const { tokens = BALANCE_TOKENS, ...restQueryOptions } = options
-
-  const walletAccount = useWalletAccount()
-
-  const config = useConfig()
-
-  const { data: conversionRatesData } = useAssetsConversionRates()
-
-  const isMezoChainId = isMezoChain(config.state.chainId)
-
-  const { data: borrowData } = useBorrowData()
-
-  return useQuery({
-    queryKey: [
-      TOKEN_BALANCES_QUERY_KEY,
-      walletAccount?.accountAddress,
-      options.tokens,
-      config.state.chainId,
-      borrowData?.collateral.value.toString(),
-    ],
-    enabled:
-      !!walletAccount?.accountAddress &&
-      !!conversionRatesData &&
-      isMezoChainId &&
-      !!borrowData?.collateral.value,
-    queryFn: async () => {
-      const { chainId } = config.state
-      const isMainnet = chainId === CHAIN_ID.mainnet
-      const contractsMap = isMainnet
-        ? mainnetTokenContracts
-        : testnetTokenContracts
-
-      const accountAddress = walletAccount?.accountAddress
-
-      if (!accountAddress) {
-        throw new Error("Account address is not available.")
-      }
-
-      const tokenContracts = tokens.map((token) => {
-        const { address } = contractsMap[token]
-        return {
-          address,
-          abi: BALANCE_OF_ABI,
-          functionName: "balanceOf" as const,
-          args: [accountAddress],
-          chainId,
-        }
-      })
-
-      return Promise.all([
-        getBalance(config, { address: accountAddress }),
-        readContracts(config, {
-          contracts: tokenContracts,
-        }),
-      ])
-    },
-    select: (data) => {
-      const [btcBalance, tokensBalancesData] = data
-      if (!conversionRatesData) {
-        throw new Error("Conversion rates data is not available.")
-      }
-
-      const parsedBtcBalance = {
-        ...btcBalance,
-        symbol: getAsset("BTC").symbol,
-        usd: convertToUsd(
-          btcBalance.value,
-          btcBalance.decimals,
-          BigInt(conversionRatesData.rates.BTC),
-          conversionRatesData.decimals,
-        ),
-      }
-
-      const parsedTokensBalances = tokensBalancesData.map((item, index) => {
-        const token = tokens[index]
-        const { decimals, symbol } = getAsset(token)
-
-        if (item.status === "failure") {
-          throw new Error(
-            `Failed to fetch balance of ${token} for ${walletAccount?.accountAddress}.`,
-          )
-        }
-
-        const floatAmount = bigIntToFloat({
-          amount: item.result,
-          decimals,
-        })
-
-        // const formatted =
-        //   Number(floatAmount) * getTokenUsdPrice(token as SupportedTokenName)
-
-        const tokenBalance: Omit<TokenBalance, "usd"> = {
-          value: item.result,
-          decimals,
-          symbol,
-        }
-
-        let value = Number(item.result)
-        let usd = {
-          value,
-          formatted: floatToHumanReadableFormat(amountAsUSD({ amount: value })),
-        }
-        if (isBitcoinLikeCryptoAsset(tokenBalance.symbol)) {
-          // TODO: had to add number for rates to avoid red underline
-          value = Number(floatAmount) * Number(conversionRatesData.rates.BTC)
-          usd = {
-            value,
-            formatted: floatToHumanReadableFormat(
-              amountAsUSD({ amount: value }),
-            ),
-          }
-        }
-        if (isTTokenCryptoAsset(tokenBalance.symbol)) {
-          // TODO: had to add number for rates to avoid red underline
-          value = Number(floatAmount) * Number(conversionRatesData.rates.mT)
-          usd = {
-            value,
-            formatted: floatToHumanReadableFormat(
-              amountAsUSD({ amount: value }),
-            ),
-          }
-        }
-
-        return { ...tokenBalance, usd }
-      })
-
-      return [parsedBtcBalance, ...parsedTokensBalances].reduce(
-        (acc, token) => ({
-          ...acc,
-          [token.symbol]: token,
-        }),
-        {} as Record<T[number] | "BTC", TokenBalance>,
-      )
-    },
-    ...restQueryOptions,
-  })
-}
-
-/**
- * Hook for invalidating current user's token balances. Can be used to
- * invalidate the balances manually, which forces the data to be re-fetched.
- * @returns Function `invalidateTokenBalances` that invalidates token balances
- * @example
- * const { invalidateTokenBalances } = useInvalidateTokensBalances()
- * (...)
- * await invalidateTokenBalances()
- */
-export function useInvalidateTokensBalances() {
-  const queryClient = useQueryClient()
-
-  const invalidateTokensBalancesHandler = () =>
-    queryClient.invalidateQueries({ queryKey: [TOKEN_BALANCES_QUERY_KEY] })
-
-  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.
- * @returns Function `resetTokenBalances` that invalidates token balances
- * @example
- * const { resetTokenBalances } = useResetTokensBalances()
- * (...)
- * await resetTokenBalances()
- */
-export function useResetTokensBalances() {
-  const queryClient = useQueryClient()
-
-  const resetTokenBalancesHandler = () =>
-    queryClient.resetQueries({ queryKey: [TOKEN_BALANCES_QUERY_KEY] })
-
-  return {
-    resetTokenBalances: resetTokenBalancesHandler,
-  }
-}

package/src/lib/contracts/priceOracle.ts

@@ -1,53 +0,0 @@
-import { Address } from "viem"
-
-export default {
-  address: "0x7b7c000000000000000000000000000000000015" as Address,
-  abi: [
-    {
-      inputs: [],
-      name: "decimals",
-      outputs: [
-        {
-          internalType: "uint8",
-          name: "",
-          type: "uint8",
-        },
-      ],
-      stateMutability: "view",
-      type: "function",
-    },
-    {
-      inputs: [],
-      name: "latestRoundData",
-      outputs: [
-        {
-          internalType: "uint80",
-          name: "roundId",
-          type: "uint80",
-        },
-        {
-          internalType: "int256",
-          name: "answer",
-          type: "int256",
-        },
-        {
-          internalType: "uint256",
-          name: "startedAt",
-          type: "uint256",
-        },
-        {
-          internalType: "uint256",
-          name: "updatedAt",
-          type: "uint256",
-        },
-        {
-          internalType: "uint80",
-          name: "answeredInRound",
-          type: "uint80",
-        },
-      ],
-      stateMutability: "view",
-      type: "function",
-    },
-  ] as const,
-}

package/src/utils/chain.ts

@@ -1,5 +0,0 @@
-import { mezoMainnet, mezoTestnet } from "@mezo-org/orangekit"
-
-export function isMezoChain(chainId: number) {
-  return chainId === mezoMainnet.id || chainId === mezoTestnet.id
-}

package/src/utils/number2.test.ts

@@ -1,309 +0,0 @@
-import {
-  bigIntToFloat,
-  bigIntToHumanReadableFormat,
-  floatToBigInt,
-  floatToHumanReadableFormat,
-  multiplyBigIntWithDecimal,
-  normalizeDecimalNumber,
-  trimBeforeDecimals,
-  trimDecimals,
-} from "./number2"
-
-describe("floatToBigInt", () => {
-  it("should convert integer string to bigint with default decimals", () => {
-    expect(floatToBigInt({ amount: "1" })).toBe(1_000_000_000_000_000_000n)
-  })
-
-  it("should convert float string to bigint with default decimals", () => {
-    expect(floatToBigInt({ amount: "1.23" })).toBe(1_230_000_000_000_000_000n)
-  })
-
-  it("should convert float string to bigint with custom decimals", () => {
-    expect(floatToBigInt({ amount: "1.23", decimals: 2 })).toBe(123n)
-    expect(floatToBigInt({ amount: "1.2345", decimals: 2 })).toBe(123n)
-    expect(floatToBigInt({ amount: "1.2345", decimals: 6 })).toBe(1234500n)
-  })
-
-  it("should handle numbers as input", () => {
-    expect(floatToBigInt({ amount: 2.5 })).toBe(2_500_000_000_000_000_000n)
-  })
-
-  it("should handle zero", () => {
-    expect(floatToBigInt({ amount: "0" })).toBe(0n)
-    expect(floatToBigInt({ amount: 0 })).toBe(0n)
-  })
-
-  it("should handle negative numbers", () => {
-    expect(floatToBigInt({ amount: "-1.5" })).toBe(-1_500_000_000_000_000_000n)
-  })
-
-  it("should handle numbers with thousands separator", () => {
-    expect(floatToBigInt({ amount: "1,234.56" })).toBe(
-      1_234_560_000_000_000_000_000n,
-    )
-  })
-
-  it("should return 0n for invalid input", () => {
-    expect(floatToBigInt({ amount: "abc" })).toBe(0n)
-    expect(floatToBigInt({ amount: "1.2.3" })).toBe(0n)
-    expect(floatToBigInt({ amount: "" })).toBe(0n)
-  })
-})
-
-describe("bigIntToFloat", () => {
-  it("should convert bigint to float string with default decimals", () => {
-    expect(bigIntToFloat({ amount: 1_000_000_000_000_000_000n })).toBe("1")
-    expect(bigIntToFloat({ amount: 1_230_000_000_000_000_000n })).toBe("1.23")
-  })
-
-  it("should convert bigint to float string with custom decimals", () => {
-    expect(bigIntToFloat({ amount: 123n, decimals: 2 })).toBe("1.23")
-    expect(bigIntToFloat({ amount: 1234500n, decimals: 6 })).toBe("1.2345")
-  })
-
-  it("should handle desiredDecimals less than decimals", () => {
-    expect(
-      bigIntToFloat({
-        amount: 1_234_567_890_000_000_000n,
-        decimals: 18,
-        desiredDecimals: 2,
-      }),
-    ).toBe("1.23")
-    expect(
-      bigIntToFloat({
-        amount: 1_234_567_890_000_000_000n,
-        decimals: 18,
-        desiredDecimals: 6,
-      }),
-    ).toBe("1.234568")
-  })
-
-  it("should handle zero", () => {
-    expect(bigIntToFloat({ amount: 0n })).toBe("0")
-  })
-
-  it("should handle negative numbers", () => {
-    expect(bigIntToFloat({ amount: -1_500_000_000_000_000_000n })).toBe("-1.5")
-  })
-
-  it("should handle rounding up", () => {
-    expect(
-      bigIntToFloat({
-        amount: 1_249_999_999_999_999_999n,
-        decimals: 18,
-        desiredDecimals: 2,
-      }),
-    ).toBe("1.25")
-    expect(
-      bigIntToFloat({
-        amount: 1_234_567_890_000_000_000n,
-        decimals: 18,
-        desiredDecimals: 4,
-      }),
-    ).toBe("1.2346")
-  })
-
-  it("should handle large numbers", () => {
-    expect(
-      bigIntToFloat({
-        amount: 123_456_789_012_345_678_901_234_567_890n,
-        decimals: 18,
-        desiredDecimals: 2,
-      }),
-    ).toBe("123456789012.35")
-  })
-})
-
-describe("floatToHumanReadableFormat", () => {
-  it("should format number with thousands separator and default decimals", () => {
-    expect(floatToHumanReadableFormat({ amount: 1234567.891 })).toBe(
-      "1,234,567.89",
-    )
-    expect(floatToHumanReadableFormat({ amount: "1234567.891" })).toBe(
-      "1,234,567.89",
-    )
-  })
-
-  it("should format with custom decimals", () => {
-    expect(
-      floatToHumanReadableFormat({ amount: 1234567.891, desiredDecimals: 3 }),
-    ).toBe("1,234,567.891")
-    expect(
-      floatToHumanReadableFormat({ amount: 1234567.8, desiredDecimals: 0 }),
-    ).toBe("1,234,568")
-  })
-
-  it("should format with minDecimals", () => {
-    expect(
-      floatToHumanReadableFormat({
-        amount: 1234.5,
-        desiredDecimals: 2,
-        minDecimals: 1,
-      }),
-    ).toBe("1,234.5")
-    expect(
-      floatToHumanReadableFormat({
-        amount: 1234.5,
-        desiredDecimals: 2,
-        minDecimals: 2,
-      }),
-    ).toBe("1,234.50")
-    expect(
-      floatToHumanReadableFormat({
-        amount: 1234.5,
-        desiredDecimals: 2,
-        minDecimals: 4,
-      }),
-    ).toBe("1,234.5000")
-  })
-
-  it("should return '0' for invalid input", () => {
-    expect(floatToHumanReadableFormat({ amount: "abc" })).toBe("0")
-  })
-})
-
-describe("bigIntToHumanReadableFormat", () => {
-  it("should format bigint to human readable string", () => {
-    expect(
-      bigIntToHumanReadableFormat({
-        amount: 1_234_567_890_000_000_000n,
-        decimals: 18,
-        desiredDecimals: 2,
-      }),
-    ).toBe("1.23")
-    expect(
-      bigIntToHumanReadableFormat({
-        amount: 1_234_567_890_000_000_000n,
-        decimals: 18,
-        desiredDecimals: 6,
-      }),
-    ).toBe("1.234568")
-  })
-
-  it("should handle negative values", () => {
-    expect(
-      bigIntToHumanReadableFormat({
-        amount: -1_234_567_890_000_000_000n,
-        decimals: 18,
-        desiredDecimals: 2,
-      }),
-    ).toBe("-1.23")
-  })
-
-  it("should show <0.01 for very small nonzero values", () => {
-    expect(
-      bigIntToHumanReadableFormat({
-        amount: 1n,
-        decimals: 18,
-        desiredDecimals: 2,
-      }),
-    ).toBe("<0.01")
-    expect(
-      bigIntToHumanReadableFormat({
-        amount: -1n,
-        decimals: 18,
-        desiredDecimals: 2,
-      }),
-    ).toBe("<0.01")
-  })
-
-  it("should format with minDecimals", () => {
-    expect(
-      bigIntToHumanReadableFormat({
-        amount: 1_234_000_000_000_000_000n,
-        decimals: 18,
-        desiredDecimals: 2,
-        minDecimals: 3,
-      }),
-    ).toBe("1.234")
-    expect(
-      bigIntToHumanReadableFormat({
-        amount: 1_234_000_000_000_000_000n,
-        decimals: 18,
-        desiredDecimals: 3,
-        minDecimals: 2,
-      }),
-    ).toBe("1.234")
-    expect(
-      bigIntToHumanReadableFormat({
-        amount: 1_234_000_000_000_000_000n,
-        decimals: 18,
-        desiredDecimals: 2,
-        minDecimals: 4,
-      }),
-    ).toBe("1.2340")
-  })
-})
-
-describe("multiplyBigIntWithDecimal", () => {
-  it("should multiply bigint by integer", () => {
-    expect(multiplyBigIntWithDecimal(10n, 2)).toBe(20n)
-  })
-
-  it("should multiply bigint by decimal", () => {
-    expect(multiplyBigIntWithDecimal(100n, 0.5)).toBe(50n)
-    expect(multiplyBigIntWithDecimal(100n, 1.25)).toBe(125n)
-  })
-
-  it("should handle scientific notation", () => {
-    expect(multiplyBigIntWithDecimal(100n, 1e-2)).toBe(1n)
-  })
-
-  it("should handle zero", () => {
-    expect(multiplyBigIntWithDecimal(0n, 1.5)).toBe(0n)
-  })
-})
-
-describe("trimDecimals", () => {
-  it("should trim decimals to specified precision", () => {
-    expect(trimDecimals("1.23456", 2)).toBe("1.23")
-    expect(trimDecimals("1.2", 4)).toBe("1.2")
-    expect(trimDecimals("1", 2)).toBe("1")
-  })
-})
-
-describe("trimBeforeDecimals", () => {
-  it("should trim integer part to specified length", () => {
-    expect(trimBeforeDecimals("12345.67", 3)).toBe("123.67")
-    expect(trimBeforeDecimals("12.34", 5)).toBe("12.34")
-    expect(trimBeforeDecimals("123456", 2)).toBe("12.")
-  })
-})
-
-describe("normalizeDecimalNumber", () => {
-  it("should remove invalid characters", () => {
-    expect(normalizeDecimalNumber("12a3.4b5")).toBe("123.45")
-  })
-
-  it("should prevent multiple dots", () => {
-    expect(normalizeDecimalNumber("1.2.3")).toBe("12.3")
-    expect(normalizeDecimalNumber("1..1.2")).toBe("11.2")
-  })
-
-  it("should allow only digits and one dot", () => {
-    expect(normalizeDecimalNumber("abc")).toBe("")
-    expect(normalizeDecimalNumber("123")).toBe("123")
-  })
-
-  it("should handle leading and trailing spaces", () => {
-    expect(normalizeDecimalNumber("  1.23  ")).toBe("1.23")
-    expect(normalizeDecimalNumber("  1.2.3  ")).toBe("12.3")
-  })
-
-  it("should handle empty input", () => {
-    expect(normalizeDecimalNumber("")).toBe("")
-    expect(normalizeDecimalNumber("   ")).toBe("")
-  })
-
-  it("should handle numbers with thousands separator", () => {
-    expect(normalizeDecimalNumber("1,234.56")).toBe("1234.56")
-    expect(normalizeDecimalNumber("1,234,567.89")).toBe("1234567.89")
-  })
-
-  it("should handle scientific notation", () => {
-    // This function does not support scientific notation as our input is expected
-    // to accept only decimal numbers
-    expect(normalizeDecimalNumber("1e3")).toBe("13")
-    expect(normalizeDecimalNumber("1.23e2")).toBe("1.232")
-  })
-})