@mezo-org/passport 0.5.2 → 0.5.4-dev.0

package/src/hooks/useBorrowData.ts

@@ -13,6 +13,7 @@ import { bigIntMax, normalizePrecision } from "../utils/numbers"
 import useWalletAccount from "./useWalletAccount"
 import { getAsset } from "../utils/assets"
 import { convertToUsd } from "../utils/currency"
+import { useCollateralPrice } from "./useCollateralPrice"
 
 const DEBT_AND_COLL_PRECISION = 18
 
@@ -85,22 +86,6 @@ const BORROWER_OPERATIONS_ABI = [
   },
 ] as const
 
-const PRICE_FEED_ABI = [
-  {
-    inputs: [],
-    name: "fetchPrice",
-    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.
@@ -110,18 +95,20 @@ export function useBorrowData(queryOptions = {}) {
   const { environment = "mainnet" } = usePassportContext()
   const walletAccount = useWalletAccount()
 
+  const { data: collateralPriceData } = useCollateralPrice()
+
+  const collateralPrice = collateralPriceData?.toString()
+
   const contractAddress = useMemo(() => {
     if (environment === "mainnet") {
       return {
         troveManager: mainnetBorrowContracts.TroveManager.address,
         borrowerOperations: mainnetBorrowContracts.BorrowerOperations.address,
-        priceFeed: mainnetBorrowContracts.PriceFeed.address,
       }
     }
     return {
       troveManager: testnetBorrowContracts.TroveManager.address,
       borrowerOperations: testnetBorrowContracts.BorrowerOperations.address,
-      priceFeed: testnetBorrowContracts.PriceFeed.address,
     }
   }, [environment])
 
@@ -144,24 +131,19 @@ export function useBorrowData(queryOptions = {}) {
         functionName: "MUSD_GAS_COMPENSATION",
         chainId,
       },
-      {
-        abi: PRICE_FEED_ABI,
-        address: contractAddress.priceFeed,
-        functionName: "fetchPrice",
-        chainId,
-      },
     ],
     query: {
-      enabled: !!walletAccount.accountAddress,
+      enabled: !!walletAccount.accountAddress && !!collateralPrice,
       staleTime: 5 * ONE_MINUTE_MS,
       retry: 1,
       select: (data) => {
         if (!data || data.some((item) => !item.result))
           throw new Error("No borrow data available")
 
+        if (!collateralPrice) throw new Error("Collateral price not available")
+
         const [rawCollateral, principal, interest] = data[0].result!
         const gasCompensation = data[1].result!
-        const collateralPrice = data[2].result!
 
         const btcDetails = getAsset("BTC")
 
@@ -173,7 +155,7 @@ export function useBorrowData(queryOptions = {}) {
           usd: convertToUsd(
             rawCollateral,
             DEBT_AND_COLL_PRECISION,
-            collateralPrice,
+            BigInt(collateralPrice),
             DEBT_AND_COLL_PRECISION,
           ),
         }

package/src/hooks/useCollateralPrice.ts

@@ -0,0 +1,62 @@
+import { useReadContract } from "wagmi"
+import { useMemo } from "react"
+import {
+  mainnetBorrowContracts,
+  testnetBorrowContracts,
+} from "../lib/contracts"
+import { usePassportContext } from "./usePassportContext"
+import { CHAIN_ID } from "../constants"
+import useWalletAccount from "./useWalletAccount"
+
+// 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 PRICE_FEED_ABI = [
+  {
+    inputs: [],
+    name: "fetchPrice",
+    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 useCollateralPrice(queryOptions = {}) {
+  const { environment = "mainnet" } = usePassportContext()
+  const walletAccount = useWalletAccount()
+
+  const priceFeedContractAddress = useMemo(() => {
+    if (environment === "mainnet") {
+      return mainnetBorrowContracts.PriceFeed.address
+    }
+    return testnetBorrowContracts.PriceFeed.address
+  }, [environment])
+
+  const chainId = CHAIN_ID[environment]
+
+  return useReadContract({
+    abi: PRICE_FEED_ABI,
+    address: priceFeedContractAddress,
+    functionName: "fetchPrice",
+    chainId,
+    query: {
+      enabled: !!walletAccount.accountAddress,
+      retry: 1,
+      ...queryOptions,
+    },
+  })
+}

package/src/hooks/useTokensBalances.ts

@@ -124,6 +124,9 @@ export function useTokensBalances<T extends MezoChainToken[]>(
       walletAccount?.accountAddress,
       options.tokens,
       chainId,
+      conversionRatesData?.decimals,
+      conversionRatesData?.rates.BTC,
+      conversionRatesData?.rates.mT,
     ],
     enabled: !!walletAccount?.accountAddress && !!conversionRatesData,
     queryFn: async () => {

package/src/lib/contracts/index.ts

@@ -95,5 +95,3 @@ export const testnetBorrowContracts = {
   BorrowerOperations: borrowerOperationsTestnet,
   PriceFeed: priceFeedTestnet,
 } as unknown as ContractsMap<MezoBorrowContract>
-
-export { default as priceOracleContract } from "./priceOracle"

package/src/utils/number2.test.ts

@@ -0,0 +1,309 @@
+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")
+  })
+})