@mezo-org/passport 0.4.0-dev.82 → 0.4.0-dev.84

package/src/utils/currency.ts

@@ -1,10 +1,5 @@
-import { fromFixedPoint } from "./numbers"
-
-const DEFAULT_FORMAT_OPTIONS: Intl.NumberFormatOptions = {
-  style: "currency",
-  minimumFractionDigits: 2,
-  maximumFractionDigits: 2,
-}
+import { formatUnits } from "viem"
+import { normalizePrecision } from "./numbers"
 
 /**
  * Formats a number as a currency
@@ -14,10 +9,12 @@ const DEFAULT_FORMAT_OPTIONS: Intl.NumberFormatOptions = {
  */
 export function formatCurrency(
   value: number,
-  options: Omit<Intl.NumberFormatOptions, "style"> = {},
+  options: Omit<Intl.NumberFormatOptions, "style">,
 ): string {
   const formatter = new Intl.NumberFormat("en-US", {
-    ...DEFAULT_FORMAT_OPTIONS,
+    style: "currency",
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
     ...options,
   })
 
@@ -29,8 +26,8 @@ export function formatCurrency(
  * @param value The value to format
  * @returns The formatted currency
  */
-export function formatUsd(value: number): string {
-  return formatCurrency(value, { currency: "USD" })
+export function formatUsd(value: number | string): string {
+  return formatCurrency(Number(value), { currency: "USD" })
 }
 
 /**
@@ -45,9 +42,17 @@ export function convertToUsd(
   assetDecimals: number,
   conversionRate: bigint,
   conversionRateDecimals: number,
-): number {
-  return fromFixedPoint(
-    (assetAmount * conversionRate) / 10n ** BigInt(conversionRateDecimals),
-    assetDecimals,
+) {
+  const value = normalizePrecision(
+    assetAmount * conversionRate,
+    assetDecimals + conversionRateDecimals,
+    conversionRateDecimals,
   )
+
+  const formatted = formatUnits(value, conversionRateDecimals)
+
+  return {
+    value,
+    formatted,
+  }
 }

package/src/utils/numbers.test.ts

@@ -1,10 +1,7 @@
 import {
   formatNumberToCompactString,
-  fromFixedPoint,
-  roundUpNumber,
-  formatNumberToLocaleString,
-  fromFixedPointToString,
   bigIntMax,
+  normalizePrecision,
 } from "./numbers"
 
 describe("formatNumberToCompactString", () => {
@@ -44,182 +41,6 @@ describe("formatNumberToCompactString", () => {
   })
 })
 
-describe("roundUpNumber", () => {
-  it("rounds up to 2 decimals", () => {
-    expect(roundUpNumber(1.234)).toBe(1.24)
-  })
-
-  it("rounds up to 3 decimals", () => {
-    expect(roundUpNumber(9.87654, 3)).toBe(9.877)
-  })
-
-  it("rounds up exact decimal", () => {
-    expect(roundUpNumber(2.5, 1)).toBe(2.5)
-  })
-})
-
-describe("fromFixedPoint", () => {
-  it("converts fixed point with 18 decimals to float", () => {
-    const raw = 1234567890000000000n // 1.23456789 ETH in 18 decimals
-    expect(fromFixedPoint(raw, 18)).toBe(1.2345)
-  })
-
-  it("converts with truncation to 2 decimals", () => {
-    const raw = 987654321000000000n // ~0.987654321 ETH
-    expect(fromFixedPoint(raw, 18, 2)).toBe(0.98)
-  })
-
-  it("handles large fixedPoint decimals", () => {
-    const raw = 1_000_000_000_000_000_000_000_000n // 1M with 6 decimals
-    expect(fromFixedPoint(raw, 6, 2)).toBe(1000000000000000000)
-  })
-})
-
-describe("formatNumberToLocaleString", () => {
-  it("formats zero with 0 decimals", () => {
-    expect(formatNumberToLocaleString(0, 0)).toBe("0")
-  })
-
-  it("formats zero with >0 decimals", () => {
-    expect(formatNumberToLocaleString(0, 2)).toBe("0.00")
-    expect(formatNumberToLocaleString(0, 4)).toBe("0.0000")
-  })
-
-  it("formats small decimal number", () => {
-    expect(formatNumberToLocaleString(0.123456, 2)).toBe("0.12")
-    expect(formatNumberToLocaleString(0.123456, 4)).toBe("0.1235")
-  })
-
-  it("formats number just above 1", () => {
-    expect(formatNumberToLocaleString(1.000001, 3)).toBe("1.000")
-    expect(formatNumberToLocaleString(1.234567, 2)).toBe("1.23")
-  })
-
-  it("formats whole number", () => {
-    expect(formatNumberToLocaleString(1234, 0)).toBe("1,234")
-    expect(formatNumberToLocaleString(1000, 2)).toBe("1,000.00")
-  })
-
-  it("formats number with trailing decimal zeroes", () => {
-    expect(formatNumberToLocaleString(10.1, 3)).toBe("10.100")
-    expect(formatNumberToLocaleString(5.0, 2)).toBe("5.00")
-  })
-
-  it("formats string input", () => {
-    expect(formatNumberToLocaleString("123.456", 2)).toBe("123.46")
-    expect(formatNumberToLocaleString("0.00123", 4)).toBe("0.0012")
-  })
-
-  it("formats negative number", () => {
-    expect(formatNumberToLocaleString(-123.456, 2)).toBe("-123.46")
-    expect(formatNumberToLocaleString("-0.00999", 3)).toBe("-0.010")
-  })
-
-  it("formats large number with commas", () => {
-    expect(formatNumberToLocaleString(12345678.9, 2)).toBe("12,345,678.90")
-  })
-
-  it("handles max decimals safely", () => {
-    expect(formatNumberToLocaleString(1.123456789, 8)).toBe("1.12345679")
-    expect(formatNumberToLocaleString("0.000000000000000001", 18)).toBe(
-      "0.000000000000000001",
-    )
-  })
-
-  it("defaults to 0 decimals if not passed", () => {
-    expect(formatNumberToLocaleString(1234.567)).toBe("1,235") // rounds up by default
-  })
-})
-
-describe("fromFixedPointToString", () => {
-  const toFixedPoint = (num: number) => BigInt(Math.round(num * 1e18))
-
-  const cases = [
-    { input: 2.0, expected: "2.000" },
-    { input: 2.009, expected: "2.009" },
-    { input: 2.01, expected: "2.010" },
-    { input: 2.015, expected: "2.016" },
-    { input: 2.05, expected: "2.050" },
-    { input: 2.09, expected: "2.090" },
-  ]
-
-  describe("withRoundUp: true", () => {
-    cases.forEach(({ input, expected }) => {
-      it(`formats ${input} → ${expected}`, () => {
-        const fixed = toFixedPoint(input)
-        expect(fromFixedPointToString(fixed, 18, 3, true)).toBe(expected)
-      })
-    })
-  })
-
-  describe("withRoundUp: false", () => {
-    const noRoundCases = [
-      { input: 2.0099, expected: "2.009" },
-      { input: 2.0159, expected: "2.015" },
-      { input: 2.0101, expected: "2.010" },
-      { input: 2.0199, expected: "2.019" },
-    ]
-
-    noRoundCases.forEach(({ input, expected }) => {
-      it(`formats ${input} → ${expected} (no rounding)`, () => {
-        const fixed = toFixedPoint(input)
-        expect(fromFixedPointToString(fixed, 18, 3, false)).toBe(expected)
-      })
-    })
-  })
-
-  describe("zero handling", () => {
-    it("formats 0 → 0.000 (3 decimals)", () => {
-      expect(fromFixedPointToString(0n, 18, 3)).toBe("0.000")
-    })
-
-    it("formats 0 → 0.0000 (4 decimals)", () => {
-      expect(fromFixedPointToString(0n, 18, 4)).toBe("0.0000")
-    })
-  })
-
-  describe("very small numbers below display threshold", () => {
-    it("returns <0.0001 for small number (3 decimals)", () => {
-      const small = BigInt(123) // ~1.23e-16
-      expect(fromFixedPointToString(small, 18, 4)).toBe("<0.0001")
-    })
-
-    it("returns <0.01 for small number with only 2 decimals", () => {
-      const tiny = BigInt(9999999999999) // <0.01
-      expect(fromFixedPointToString(tiny, 18, 2)).toBe("<0.01")
-    })
-  })
-
-  describe("input types", () => {
-    it("accepts bigint", () => {
-      const amount = 2100000000000000000n
-      expect(fromFixedPointToString(amount, 18, 3)).toBe("2.100")
-    })
-
-    it("accepts string", () => {
-      expect(fromFixedPointToString("2000000000000000000", 18, 3)).toBe("2.000")
-    })
-
-    it("accepts number", () => {
-      expect(fromFixedPointToString(Number("1000000000000000000"), 18, 3)).toBe(
-        "1.000",
-      )
-    })
-  })
-
-  describe("high values", () => {
-    it("formats 1_000_000.123456789 correctly", () => {
-      const big = toFixedPoint(1_000_000.123456789)
-      expect(fromFixedPointToString(big, 18, 6)).toBe("1,000,000.123456")
-    })
-
-    it("formats 1e12 ETH", () => {
-      const big = BigInt("1000000000000000000000000000000")
-      expect(fromFixedPointToString(big, 18, 2)).toBe("1,000,000,000,000.00")
-    })
-  })
-})
-
 describe("bigIntMax", () => {
   it("returns the maximum of positive bigint values", () => {
     expect(bigIntMax(1n, 2n, 3n)).toBe(3n)
@@ -245,3 +66,31 @@ describe("bigIntMax", () => {
     expect(bigIntMax(5n, 5n, 5n)).toBe(5n)
   })
 })
+
+describe("normalizePrecision", () => {
+  it("reduces precision correctly (scale down)", () => {
+    const result = normalizePrecision(1234500n, 6, 3)
+    expect(result).toBe(1234n)
+  })
+
+  it("increases precision correctly (scale up)", () => {
+    const result = normalizePrecision(1234n, 3, 6)
+    expect(result).toBe(1234000n)
+  })
+
+  it("returns the same value when precision is equal", () => {
+    const result = normalizePrecision(987654321n, 5, 5)
+    expect(result).toBe(987654321n)
+  })
+
+  it("handles zero value correctly", () => {
+    const result = normalizePrecision(0n, 4, 8)
+    expect(result).toBe(0n)
+  })
+
+  it("handles large numbers without precision loss", () => {
+    const value = 123456789012345678901234567890n
+    const result = normalizePrecision(value, 18, 20)
+    expect(result).toBe(value * 100n)
+  })
+})

package/src/utils/numbers.ts

@@ -1,6 +1,5 @@
-type DesiredDecimals = Intl.NumberFormatOptions &
+type CompactStringDecimals = Intl.NumberFormatOptions["minimumFractionDigits"] &
   BigIntToLocaleStringOptions["minimumFractionDigits"]
-
 /**
  * Formats a number or bigint into compact string with K, M, B, or T suffix.
  * @param value The number or bigint to format.
@@ -9,189 +8,41 @@ type DesiredDecimals = Intl.NumberFormatOptions &
  */
 export function formatNumberToCompactString(
   value: number | bigint,
-  decimals = 4,
+  decimals: CompactStringDecimals = 2,
 ): string {
   return value.toLocaleString("en-US", {
     notation: "compact",
     compactDisplay: "short",
-    maximumFractionDigits: decimals as DesiredDecimals,
+    maximumFractionDigits: decimals,
   })
 }
 
 /**
- * Formats a number or string into a locale-sensitive string with the desired number of decimals.
- * @param value The number or string to format.
- * @param desiredDecimals The number of decimal places to include.
- * @returns The formatted number as a string.
- * @see https://github.com/thesis/acre/blob/2078d339f4ddce79e69c78529c9d72910dd2640a/dapp/src/utils/numbersUtils.ts#L5-L19
- */
-export function formatNumberToLocaleString(
-  value: string | number,
-  desiredDecimals = 0,
-) {
-  const number = typeof value === "number" ? value : parseFloat(value)
-
-  if (number === 0 && desiredDecimals === 0) return "0"
-
-  if (number === 0) return `0.${"0".repeat(desiredDecimals)}`
-
-  return number.toLocaleString("en-US", {
-    minimumFractionDigits: desiredDecimals,
-    maximumFractionDigits: desiredDecimals,
-  })
-}
-
-/**
- * Returns a number rounded up to the desired number of decimals.
- * @param amount The number to round up.
- * @param desiredDecimals The number of decimals to round up to.
- * @returns The rounded up number.
- * @see https://github.com/thesis/acre/blob/2078d339f4ddce79e69c78529c9d72910dd2640a/dapp/src/utils/numbersUtils.ts#L1-L3
- */
-export function roundUpNumber(amount: number, desiredDecimals = 2): number {
-  return Math.ceil(amount * 10 ** desiredDecimals) / 10 ** desiredDecimals
-}
-
-/**
- * Convert a fixed point bigint with precision `fixedPointDecimals` to a
- * floating point number truncated to `desiredDecimals`.
- * @param fixedPoint The fixed point bigint to convert.
- * @param fixedPointDecimals The number of decimals in the fixed point bigint.
- * @param desiredDecimals The number of decimals in the output number.
- * @returns The floating point number truncated to `desiredDecimals`.
- * @see https://github.com/tahowallet/extension/blob/f6b26b7cb4a0a0278b1fccc6319626638f1a6dfa/background/lib/fixed-point.ts#L216-L239
+ * Normalizes a bigint value to a target precision.
+ * @param value The bigint value to normalize.
+ * @param currentPrecision The current precision of the value.
+ * @param targetPrecision The target precision to normalize to.
+ * @returns The normalized bigint value.
  */
-export function fromFixedPoint(
-  fixedPoint: bigint,
-  fixedPointDecimals: number,
-  desiredDecimals = 4,
-): number {
-  const fixedPointDesiredDecimalsAmount =
-    fixedPoint /
-    10n ** BigInt(Math.max(1, fixedPointDecimals - desiredDecimals))
-
-  const formattedAmount =
-    Number(fixedPointDesiredDecimalsAmount) /
-    10 ** Math.min(desiredDecimals, fixedPointDecimals)
-
-  return formattedAmount
-}
-
-/**
- * Display a token amount correctly with desired decimals.
- * The function returns a string with a language-sensitive representation of this number.
- * @param amount The fixed point number to convert.
- * @param decimals The number of decimals in the fixed point number.
- * @param desiredDecimals The number of decimals to display.
- * @param withRoundUp Whether to round up the number.
- * @returns The formatted number as a string.
- * @see https://github.com/thesis/acre/blob/2078d339f4ddce79e69c78529c9d72910dd2640a/dapp/src/utils/numbersUtils.ts#L57-L87
- */
-export const fromFixedPointToString = (
-  amount: number | string | bigint,
-  decimals = 18,
-  desiredDecimals = 4,
-  withRoundUp = false,
-) => {
-  const fixedPoint = BigInt(amount)
-
-  if (fixedPoint === 0n) {
-    return `0.${"0".repeat(desiredDecimals)}`
-  }
-
-  const formattedAmount = fromFixedPoint(
-    fixedPoint,
-    decimals,
-    // To round the amount up, let's increase the precision by one.
-    // The desired decimal numbers will be set later anyway.
-    withRoundUp ? desiredDecimals + 1 : desiredDecimals,
-  )
-
-  const minAmountToDisplay = 1 / 10 ** Math.min(desiredDecimals, decimals)
-
-  if (minAmountToDisplay > formattedAmount) {
-    return `<0.${"0".repeat(desiredDecimals - 1)}1`
-  }
-
-  const finalFormattedAmount = withRoundUp
-    ? Math.ceil(formattedAmount * 10 ** desiredDecimals) / 10 ** desiredDecimals
-    : formattedAmount
-  return formatNumberToLocaleString(finalFormattedAmount, desiredDecimals)
-}
-
-/**
- * Converts a floating-point number or string to a bigint representation
- * scaled by the specified number of decimal places (default: 18).
- *
- * This function avoids floating-point precision issues by manually
- * parsing and scaling the number.
- *
- * @param amount - A number or string containing a floating point number.
- * @param decimals - Number of decimals to scale to (default: 18).
- * @returns A bigint representation scaled to the given decimal places.
- * @see https://github.com/thesis/mezo-portal/blob/3bd4f39cb77c39948af2886a6ce7415a0c60307a/dapp/src/shared/utils/numbers.ts#L55
- */
-export const fromFloatToBigInt = (
-  amount: string | number,
-  decimals = 18,
+export const normalizePrecision = (
+  value: bigint,
+  currentPrecision: number,
+  targetPrecision = currentPrecision,
 ): bigint => {
-  const FLOATING_POINT_REGEX = /^-?\d{1,3}(,\d{3})*(\.\d+)?$|^-?\d+(\.\d+)?$/
-
-  const parseToFixedPointNumber = (
-    floatingPointString: string,
-  ): { amount: bigint; decimals: number } | undefined => {
-    if (!floatingPointString.match(FLOATING_POINT_REGEX)) {
-      return undefined
-    }
-
-    const [whole, decimalsPart, ...extra] = floatingPointString.split(".")
-
-    if (extra.length > 0) return undefined
-
-    const noThousandsSeparatorWhole = whole.replace(/,/g, "")
-    const setDecimals = decimalsPart ?? ""
-
-    try {
-      return {
-        amount: BigInt([noThousandsSeparatorWhole, setDecimals].join("")),
-        decimals: setDecimals.length,
-      }
-    } catch {
-      return undefined
-    }
-  }
-
-  const convertFixedPoint = (
-    fixedPoint: bigint,
-    fixedPointDecimals: number,
-    targetDecimals: number,
-  ): bigint => {
-    if (fixedPointDecimals >= targetDecimals) {
-      return fixedPoint / 10n ** BigInt(fixedPointDecimals - targetDecimals)
-    }
-
-    return fixedPoint * 10n ** BigInt(targetDecimals - fixedPointDecimals)
+  if (currentPrecision > targetPrecision) {
+    return value / 10n ** BigInt(currentPrecision - targetPrecision)
   }
-
-  const parsedAmount = amount.toString()
-  const fixedPointAmount = parseToFixedPointNumber(parsedAmount)
-
-  if (typeof fixedPointAmount === "undefined") {
-    return 0n
+  if (currentPrecision < targetPrecision) {
+    return value * 10n ** BigInt(targetPrecision - currentPrecision)
   }
-
-  return convertFixedPoint(
-    fixedPointAmount.amount,
-    fixedPointAmount.decimals,
-    decimals,
-  )
+  return value
 }
 
 /**
- * Utility function to find the maximum value from an array of bigint values.
- * @param values Array of bigint values to find the maximum from.
- * @returns The maximum value from the provided bigint values.
- * @dev Works exactly like `Math.max` but for bigint values.
+ * Utility function to find the maximum value from given `BigInt` values.
+ * @param values Array of BigInt values to find the maximum from.
+ * @returns The maximum value from the provided `BigInt` values.
+ * @dev Works exactly like `Math.max` but for `BigInt` values.
  */
-export const bigIntMax = (...values: bigint[]) =>
+export const bigIntMax = (...values: bigint[]): bigint =>
   values.reduce((max, value) => (value > max ? value : max))

package/dist/src/components/Dropdown/Root/AccountAssetItem.d.ts

@@ -1,11 +0,0 @@
-import React from "react";
-import { CryptoAssetKey } from "../../../utils/cryptoAssets";
-type AccountAssetItemProps = {
-    type: CryptoAssetKey;
-    amount: string;
-    subLabel: string;
-    subValue: string;
-};
-export default function AccountAssetItem(props: AccountAssetItemProps): React.JSX.Element;
-export {};
-//# sourceMappingURL=AccountAssetItem.d.ts.map

package/dist/src/components/Dropdown/Root/AccountAssetItem.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AccountAssetItem.d.ts","sourceRoot":"","sources":["../../../../../src/components/Dropdown/Root/AccountAssetItem.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,EAAE,cAAc,EAAkB,MAAM,6BAA6B,CAAA;AAG5E,KAAK,qBAAqB,GAAG;IAC3B,IAAI,EAAE,cAAc,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,qBAcpE"}

package/dist/src/components/Dropdown/Root/AccountAssetItem.js

@@ -1,9 +0,0 @@
-import React from "react";
-import { getCryptoAsset } from "../../../utils/cryptoAssets";
-import ListingItem from "../ListingItem";
-export default function AccountAssetItem(props) {
-    const { type, amount, subLabel, subValue } = props;
-    const { icon: Icon, name: label } = getCryptoAsset(type);
-    return (React.createElement(ListingItem, { icon: Icon, label: label, subLabel: subLabel, value: amount, subValue: subValue }));
-}
-//# sourceMappingURL=AccountAssetItem.js.map

package/dist/src/components/Dropdown/Root/AccountAssetItem.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AccountAssetItem.js","sourceRoot":"","sources":["../../../../../src/components/Dropdown/Root/AccountAssetItem.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,EAAkB,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAC5E,OAAO,WAAW,MAAM,gBAAgB,CAAA;AASxC,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,KAA4B;IACnE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAA;IAElD,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,cAAc,CAAC,IAAI,CAAC,CAAA;IAExD,OAAO,CACL,oBAAC,WAAW,IACV,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,QAAQ,GAClB,CACH,CAAA;AACH,CAAC"}

package/dist/src/hooks/useDropdownData.d.ts

@@ -1,47 +0,0 @@
-import { CryptoAssetKey } from "../utils/cryptoAssets";
-export type DropdownCryptoAsset<T = CryptoAssetKey> = {
-    type: T;
-    balance: bigint;
-};
-/**
- * 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, nativeBalanceRefetchInterval, }: {
-    accountDataRefetchInterval?: number | undefined;
-    nativeBalanceRefetchInterval?: number | undefined;
-}): {
-    mezoId: string | undefined;
-    matsBalance: number;
-    accountAddress: `0x${string}` | undefined;
-    walletAddress: string | undefined;
-    walletType: "bitcoin" | "evm";
-    usdTotalBalance: number;
-    usdTroveDebt: number;
-    usdCollateral: number;
-    assets: {
-        btc: {
-            type: CryptoAssetKey;
-            rawBalance: bigint;
-            formattedBalance: string;
-            usdBalance: number;
-            formattedUsdBalance: string;
-        };
-        musd: {
-            type: CryptoAssetKey;
-            rawBalance: bigint;
-            formattedBalance: string;
-            usdBalance: number;
-            formattedUsdBalance: string;
-        };
-    };
-    otherAssetsCount: number;
-    otherAssetsUsdTotal: number;
-};
-//# sourceMappingURL=useDropdownData.d.ts.map

package/dist/src/hooks/useDropdownData.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useDropdownData.d.ts","sourceRoot":"","sources":["../../../src/hooks/useDropdownData.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,cAAc,EAIf,MAAM,uBAAuB,CAAA;AAW9B,MAAM,MAAM,mBAAmB,CAAC,CAAC,GAAG,cAAc,IAAI;IACpD,IAAI,EAAE,CAAC,CAAA;IACP,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AASD;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,EACtC,0BAAkC,EAClC,4BAAoC,GACrC;;;CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4GA"}

package/dist/src/hooks/useDropdownData.js

@@ -1,97 +0,0 @@
-import { useBalance } from "wagmi";
-import { useGetCurrentAccount } from ".";
-import { getCryptoAsset, 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";
-import { convertToUsd } from "../utils/currency";
-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;
-        if (isBitcoinLikeCryptoAsset(type)) {
-            return mapCryptoAssetToDetails(type, balance, assetsConversionRates.btc.price, assetsConversionRates.btc.decimals);
-        }
-        if (type === "mT") {
-            return mapCryptoAssetToDetails(type, balance, assetsConversionRates.t.price, assetsConversionRates.t.decimals);
-        }
-        return mapCryptoAssetToDetails(type, balance, 1n, 0);
-    });
-    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 matsBalance = passportAccount?.mats.totalMats || 0;
-    const usdCollateral = convertToUsd(debt?.collateral ?? 0n, getCryptoAsset("MUSD").decimals, assetsConversionRates.btc.price, assetsConversionRates.btc.decimals);
-    const usdTroveDebt = fromFixedPoint(debt?.troveDebt ?? 0n, 18);
-    const usdTotalBalance = detailedAssets.reduce((sum, { usdBalance }) => sum + usdBalance, 0) +
-        usdCollateral;
-    return {
-        mezoId,
-        matsBalance,
-        accountAddress,
-        walletAddress,
-        walletType,
-        usdTotalBalance,
-        usdTroveDebt,
-        usdCollateral,
-        assets,
-        otherAssetsCount,
-        otherAssetsUsdTotal,
-    };
-}
-//# sourceMappingURL=useDropdownData.js.map