@mezo-org/passport 0.5.4-dev.2 → 0.5.4-dev.21

package/src/hooks/index.ts

@@ -18,6 +18,7 @@ export * from "./useSignInWithWallet"
 export * from "./useSignOut"
 export * from "./useSignUpWithWallet"
 export {
+  useTokensBalances,
   useInvalidateTokensBalances,
   useResetTokensBalances,
 } from "./useTokensBalances"

package/src/hooks/useAssetsConversionRates.ts

@@ -3,6 +3,7 @@ import { parseUnits } from "viem"
 import { ONE_SECOND_MS } from "../utils/time"
 import { usePortalApiClient } from "./usePortalApiClient"
 import { useCollateralPrice } from "./useCollateralPrice"
+import { PortalStatistics } from "../api"
 
 export const CONVERSION_RATE_DECIMALS = 18
 
@@ -27,9 +28,22 @@ export function useAssetsConversionRates() {
 
   return useQuery({
     queryKey: [QUERY_KEY, collateralPrice],
-    queryFn: async () => Promise.all([portalApiClient.getPortalStatistics()]),
+    queryFn: () => {
+      if (!collateralPriceData) {
+        throw new Error("Collateral price is not available.")
+      }
+
+      return Promise.all([
+        new Promise((resolve) => {
+          resolve(portalApiClient.getPortalStatistics())
+        }) as Promise<PortalStatistics>,
+        new Promise((resolve) => {
+          resolve(collateralPriceData)
+        }) as Promise<typeof collateralPriceData>,
+      ])
+    },
     enabled: !!collateralPrice,
-    select: ([portalStatistics]) => {
+    select: ([portalStatistics, btcPrice]) => {
       const tTokenConversionRate = portalStatistics.tTokenPrice
 
       const tPrice = parseUnits(
@@ -40,7 +54,7 @@ export function useAssetsConversionRates() {
       return {
         rates: {
           mT: tPrice,
-          BTC: BigInt(collateralPrice!),
+          BTC: btcPrice,
         },
         decimals: CONVERSION_RATE_DECIMALS,
       }

package/src/hooks/useBorrowData.ts

@@ -2,7 +2,6 @@ import { useReadContracts } from "wagmi"
 import { useCallback, useMemo } from "react"
 import { useQueryClient } from "@tanstack/react-query"
 import { formatUnits } from "viem"
-import { ONE_MINUTE_MS } from "../utils/time"
 import {
   mainnetBorrowContracts,
   testnetBorrowContracts,
@@ -92,12 +91,11 @@ const BORROWER_OPERATIONS_ABI = [
  * @param queryOptions Query options passed to the underlying `useQuery` hook.
  */
 export function useBorrowData(queryOptions = {}) {
-  const { environment = "mainnet" } = usePassportContext()
+  const { environment = "mainnet", borrowDataRefetchInterval } =
+    usePassportContext()
   const walletAccount = useWalletAccount()
 
-  const { data: collateralPriceData } = useCollateralPrice()
-
-  const collateralPrice = collateralPriceData?.toString()
+  const { data: collateralPrice } = useCollateralPrice()
 
   const contractAddress = useMemo(() => {
     if (environment === "mainnet") {
@@ -134,7 +132,6 @@ export function useBorrowData(queryOptions = {}) {
     ],
     query: {
       enabled: !!walletAccount.accountAddress && !!collateralPrice,
-      staleTime: 5 * ONE_MINUTE_MS,
       retry: 1,
       select: (data) => {
         if (!data || data.some((item) => !item.result))
@@ -155,7 +152,7 @@ export function useBorrowData(queryOptions = {}) {
           usd: convertToUsd(
             rawCollateral,
             DEBT_AND_COLL_PRECISION,
-            BigInt(collateralPrice),
+            collateralPrice,
             DEBT_AND_COLL_PRECISION,
           ),
         }
@@ -182,6 +179,8 @@ export function useBorrowData(queryOptions = {}) {
           debtInUsd,
         }
       },
+      staleTime: borrowDataRefetchInterval,
+      refetchInterval: borrowDataRefetchInterval,
       ...queryOptions,
     },
   })

package/src/hooks/useCollateralPrice.ts

@@ -36,7 +36,8 @@ const PRICE_FEED_ABI = [
  * @param queryOptions Query options passed to the underlying `useQuery` hook.
  */
 export function useCollateralPrice(queryOptions = {}) {
-  const { environment = "mainnet" } = usePassportContext()
+  const { environment = "mainnet", borrowDataRefetchInterval } =
+    usePassportContext()
   const walletAccount = useWalletAccount()
 
   const priceFeedContractAddress = useMemo(() => {
@@ -55,6 +56,8 @@ export function useCollateralPrice(queryOptions = {}) {
     chainId,
     query: {
       enabled: !!walletAccount.accountAddress,
+      staleTime: borrowDataRefetchInterval,
+      refetchInterval: borrowDataRefetchInterval,
       retry: 1,
       ...queryOptions,
     },

package/src/hooks/useTokensBalances.ts

@@ -1,6 +1,7 @@
 import { useConfig } from "wagmi"
 import { Abi, formatUnits } from "viem"
 import {
+  keepPreviousData,
   useQuery,
   useQueryClient,
   UseQueryOptions,
@@ -124,20 +125,16 @@ export function useTokensBalances<T extends MezoChainToken[]>(
       walletAccount?.accountAddress,
       options.tokens,
       chainId,
-      conversionRatesData?.decimals,
-      conversionRatesData?.rates.BTC.toString(),
-      conversionRatesData?.rates.mT.toString(),
     ],
     enabled: !!walletAccount?.accountAddress && !!conversionRatesData,
+    placeholderData: keepPreviousData,
     queryFn: async () => {
       const isMainnet = chainId === CHAIN_ID.mainnet
       const contractsMap = isMainnet
         ? mainnetTokenContracts
         : testnetTokenContracts
 
-      const accountAddress = walletAccount?.accountAddress
-
-      if (!accountAddress) {
+      if (!walletAccount?.accountAddress) {
         throw new Error("Account address is not available.")
       }
 
@@ -147,7 +144,7 @@ export function useTokensBalances<T extends MezoChainToken[]>(
           address,
           abi: BALANCE_OF_ABI,
           functionName: "balanceOf" as const,
-          args: [accountAddress],
+          args: [walletAccount?.accountAddress],
           chainId,
         }
       })
@@ -157,7 +154,7 @@ export function useTokensBalances<T extends MezoChainToken[]>(
       }
 
       return Promise.all([
-        getBalance(config, { address: accountAddress }),
+        getBalance(config, { address: walletAccount?.accountAddress, chainId }),
         readContracts(config, {
           contracts: tokenContracts,
         }),
@@ -167,7 +164,7 @@ export function useTokensBalances<T extends MezoChainToken[]>(
       ])
     },
     select: (data) => {
-      const [btcBalance, tokensBalancesData, conversions] = data
+      const [btcBalance, tokensBalancesData, conversion] = data
 
       const parsedBtcBalance = {
         ...btcBalance,
@@ -175,8 +172,8 @@ export function useTokensBalances<T extends MezoChainToken[]>(
         usd: convertToUsd(
           btcBalance.value,
           btcBalance.decimals,
-          conversions.rates.BTC,
-          conversions.decimals,
+          conversion.rates.BTC,
+          conversion.decimals,
         ),
       }
 
@@ -201,7 +198,7 @@ export function useTokensBalances<T extends MezoChainToken[]>(
           value: normalizePrecision(
             tokenBalance.value,
             tokenBalance.decimals,
-            conversions.decimals,
+            conversion.decimals,
           ),
           formatted: formatUnits(tokenBalance.value, tokenBalance.decimals),
         }
@@ -209,16 +206,16 @@ export function useTokensBalances<T extends MezoChainToken[]>(
           usd = convertToUsd(
             tokenBalance.value,
             tokenBalance.decimals,
-            conversions.rates.BTC,
-            conversions.decimals,
+            conversion.rates.BTC,
+            conversion.decimals,
           )
         }
         if (isTTokenCryptoAsset(tokenBalance.symbol)) {
           usd = convertToUsd(
             tokenBalance.value,
             tokenBalance.decimals,
-            conversions.rates.mT,
-            conversions.decimals,
+            conversion.rates.mT,
+            conversion.decimals,
           )
         }
 

package/src/provider.ts

@@ -8,6 +8,8 @@ export interface PassportContextValue {
   environment?: Environment
   accountDataRefetchInterval: number
   nativeBalanceRefetchInterval: number
+  nativePriceRefetchInterval: number
+  borrowDataRefetchInterval: number
 }
 
 export const PassportContext = createContext<PassportContextValue | undefined>(
@@ -21,10 +23,19 @@ type PassportProviderProps = {
   environment?: Environment
   authApiUrl?: string
   portalApiUrl?: string
-  /** Time in milliseconds after which account data (like mats or mezo id) in dropdown should be re-fetched. Default is 90000 (90 secs) */
+  /** Time in milliseconds after which account data (like mats or mezo id) in
+   * dropdown should be re-fetched. Default is 60000 (60 secs) */
   accountDataRefetchInterval?: number
-  /** Time in milliseconds after which native balance in dropdown should be re-fetched. Default is 90000 (90 secs) */
+  /** Time in milliseconds after which native token balance in dropdown should
+   * be re-fetched. Default is 60000 (60 secs). */
   nativeBalanceRefetchInterval?: number
+  /** Time in milliseconds after which native token price in dropdown should be
+   * re-fetched. Default is 60000 (60 secs). */
+  nativePriceRefetchInterval?: number
+  /** Time in milliseconds after which borrow data in dropdown should be
+   * re-fetched. Default is 60000 (60 secs)
+   * price. */
+  borrowDataRefetchInterval?: number
 }
 
 export function PassportProvider({
@@ -32,8 +43,10 @@ export function PassportProvider({
   authApiUrl,
   portalApiUrl,
   children,
-  accountDataRefetchInterval = 90 * ONE_SECOND_MS,
-  nativeBalanceRefetchInterval = 90 * ONE_SECOND_MS,
+  accountDataRefetchInterval = 60 * ONE_SECOND_MS,
+  nativeBalanceRefetchInterval = 60 * ONE_SECOND_MS,
+  nativePriceRefetchInterval = 60 * ONE_SECOND_MS,
+  borrowDataRefetchInterval = 60 * ONE_SECOND_MS,
 }: PassportProviderProps) {
   if (environment && !["mainnet", "testnet"].includes(environment)) {
     throw new Error("Wrong environment passed to PassportProvider.")
@@ -51,6 +64,8 @@ export function PassportProvider({
         environment,
         accountDataRefetchInterval,
         nativeBalanceRefetchInterval,
+        nativePriceRefetchInterval,
+        borrowDataRefetchInterval,
       },
     },
     children,

package/dist/src/utils/number2.d.ts

@@ -1,106 +0,0 @@
-export declare const FLOATING_POINT_REGEX: RegExp;
-/** PUBLIC HELPER FUNCTIONS for calculations */
-/**
- * Multiplies a bigint with a decimal number, taking into account the decimal places.
- *
- * @param bigint - The bigint value to multiply.
- * @param number - The decimal number to multiply with.
- * @returns The result of the multiplication as a bigint.
- */
-export declare const multiplyBigIntWithDecimal: (bigint: bigint, number: number) => bigint;
-/**
- * Converts a fixed-point number to another fixed-point number with a different decimal precision.
- * @param args The arguments for the conversion.
- *  - amount: required, the fixed-point number to convert.
- *  - decimals: required, the current decimal precision of the number.
- *  - targetDecimals: required, the target decimal precision for the conversion.
- * @returns The converted fixed-point number.
- */
-export declare const convertDecimals: ({ amount, decimals, targetDecimals, }: {
-    amount: bigint;
-    decimals: number;
-    targetDecimals: number;
-}) => bigint;
-/** Helper functions for input components */
-/**
- * Trims decimal places to a specified precision - NO ROUNDING!
- * @param value The value to trim
- * @param precision The number of decimal places to keep
- * @returns The trimmed value
- */
-export declare const trimDecimals: (value: string, precision: number) => string;
-/**
- * Trims integer part to a specified length - NO ROUNDING!
- * @param value The value to trim
- * @param precision The number of integer places to keep
- * @returns The trimmed value
- * @deprecated just compare the value to the max allowed value in the input component
- */
-export declare const trimBeforeDecimals: (value: string, precision: number) => string;
-/**
- * Normalizes a decimal number input by removing invalid characters and preventing multiple dots.
- * @param value The value to normalize
- * @returns The normalized value
- */
-export declare const normalizeDecimalNumber: (value: string) => string;
-/**
- * CONVERSION FUNCTIONS
- * These functions convert between floating-point numbers and big integers as well as
- * provide human-readable formats.
- *
- * They are used to ensure that numbers are correctly formatted for display and calculations
- * and should be used in the UI and business logic to ensure correct number formatting.
- */
-/** Basic conversion bigint <-> float  */
-/**
- * Converts a floating-point number to a big integer representation.
- * @param args The arguments for the conversion.
- *   - amount: required, the floating-point number to convert.
- *   - decimals: optional, the number of decimal places to consider.
- * @returns The big integer representation of the floating-point number.
- */
-export declare const floatToBigInt: ({ amount, decimals, }: {
-    amount: string | number;
-    decimals?: number;
-}) => bigint;
-/**
- * Converts a big integer representation to a floating-point number.
- * @param args The arguments for the conversion.
- *   - amount: required, the big integer representation to convert.
- *   - decimals: optional, the number of decimal places to consider.
- *   - desiredDecimals: optional, the desired number of decimal places for the output.
- * @returns The floating-point representation of the big integer.
- */
-export declare const bigIntToFloat: ({ amount, decimals, desiredDecimals, }: {
-    amount: bigint;
-    decimals?: number;
-    desiredDecimals?: number;
-}) => string;
-/**  Human-readable formats */
-type AmountAsHumanReadableArguments<T extends number | string | bigint> = {
-    amount: T;
-    desiredDecimals?: number;
-    minDecimals?: number;
-    decimals?: number;
-};
-/**
- * Helpers for setting correct arguments and getting unified human-readable
- * formats across the app with _toHumanReadableFormat functions.
- */
-export declare const amountAsUSD: <T extends number | string | bigint>(args: AmountAsHumanReadableArguments<T>) => AmountAsHumanReadableArguments<T>;
-export declare const amountAsToken: <T extends number | string | bigint>(args: AmountAsHumanReadableArguments<T>) => AmountAsHumanReadableArguments<T>;
-export declare const amountAsMusd: <T extends number | string | bigint>(args: AmountAsHumanReadableArguments<T>) => AmountAsHumanReadableArguments<T>;
-export declare const amountAsMats: <T extends number | string | bigint>(args: AmountAsHumanReadableArguments<T>) => AmountAsHumanReadableArguments<T>;
-/**
- * Converts a floating-point number to a human-readable format - with thousands
- * separators and specified decimal places.
- * @param args The arguments for the conversion.
- *   - amount: required, the floating-point number to convert.
- *   - desiredDecimals: optional, the desired number of decimal places for the output.
- *   - minDecimals: optional, the minimum number of decimal places.
- * @returns The human-readable format of the floating-point number.
- */
-export declare const floatToHumanReadableFormat: ({ amount, desiredDecimals, minDecimals, }: AmountAsHumanReadableArguments<number | string>) => string;
-export declare const bigIntToHumanReadableFormat: ({ amount, decimals, desiredDecimals, minDecimals, }: AmountAsHumanReadableArguments<bigint>) => string;
-export {};
-//# sourceMappingURL=number2.d.ts.map

package/dist/src/utils/number2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"number2.d.ts","sourceRoot":"","sources":["../../../src/utils/number2.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,oBAAoB,QAAsC,CAAA;AAuFvE,+CAA+C;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,GACpC,QAAQ,MAAM,EACd,QAAQ,MAAM,KACb,MAqBF,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,uCAI7B;IACD,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,EAAE,MAAM,CAAA;CACvB,KAAG,MAMH,CAAA;AAED,4CAA4C;AAE5C;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,EAAE,WAAW,MAAM,KAAG,MAK/D,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,MAAM,EACb,WAAW,MAAM,KAChB,MAMF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GAAI,OAAO,MAAM,WACM,CAAA;AAE1D;;;;;;;GAOG;AAEH,yCAAyC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAI,uBAG3B;IACD,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,KAAG,MAeH,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GAAI,wCAI3B;IACD,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,KAAG,MAqEH,CAAA;AAED,8BAA8B;AAE9B,KAAK,8BAA8B,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,IAAI;IACxE,MAAM,EAAE,CAAC,CAAA;IACT,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;GAGG;AAEH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAC5D,MAAM,8BAA8B,CAAC,CAAC,CAAC,KACtC,8BAA8B,CAAC,CAAC,CAIjC,CAAA;AAEF,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAC9D,MAAM,8BAA8B,CAAC,CAAC,CAAC,KACtC,8BAA8B,CAAC,CAAC,CAIjC,CAAA;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAC7D,MAAM,8BAA8B,CAAC,CAAC,CAAC,KACtC,8BAA8B,CAAC,CAAC,CAKjC,CAAA;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAC7D,MAAM,8BAA8B,CAAC,CAAC,CAAC,KACtC,8BAA8B,CAAC,CAAC,CAIjC,CAAA;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,GAAI,2CAIxC,8BAA8B,CAAC,MAAM,GAAG,MAAM,CAAC,KAAG,MACa,CAAA;AAElE,eAAO,MAAM,2BAA2B,GAAI,qDAKzC,8BAA8B,CAAC,MAAM,CAAC,KAAG,MAkC3C,CAAA"}

package/dist/src/utils/number2.js

@@ -1,289 +0,0 @@
-// Matches floating point numbers with optional thousands separators
-export const FLOATING_POINT_REGEX = /^[^0-9]*([0-9,]+)(?:\.([0-9]*))?$/;
-const FRIENDLY_DECIMALS_AMOUNT = 6;
-/**
- * HELPER FUNCTIONS
- * These functions are used to convert between floating-point numbers and fixed-point numbers.
- * They handle parsing, conversion, and formatting of numbers with specific decimal places.
- * They shouldn't be used directly in the UI or business logic.
- */
-/**
- * Parses a floating-point string into a fixed-point number representation.
- * @param floatingPointString The floating-point string to parse.
- * @returns The fixed-point number representation or undefined if parsing fails.
- */
-const parseToFixedPointNumber = (floatingPointString) => {
-    if (!floatingPointString.match(FLOATING_POINT_REGEX)) {
-        return undefined;
-    }
-    const [whole, decimals, ...extra] = floatingPointString.split(".");
-    // Only one `.` supported.
-    if (extra.length > 0) {
-        return undefined;
-    }
-    const noThousandsSeparatorWhole = whole.replace(",", "");
-    const setDecimals = decimals ?? "";
-    try {
-        return {
-            amount: BigInt([noThousandsSeparatorWhole, setDecimals].join("")),
-            decimals: setDecimals.length,
-        };
-    }
-    catch (error) {
-        return undefined;
-    }
-};
-/**
- * Separates thousands in a number with commas.
- * @param value The value to format.
- * @param minDecimals The minimum number of decimal places.
- * @param maxDecimals The maximum number of decimal places.
- * @returns The formatted value with thousands separators.
- */
-const separateThousandsWithComma = (value, minDecimals = 0, maxDecimals = 2) => {
-    let adjustedValue = value;
-    let adjustedMaxDecimals = maxDecimals;
-    // If passed value is not numeric we should return 0
-    if (Number.isNaN(+value.toString())) {
-        adjustedValue = 0;
-    }
-    if (typeof adjustedValue === "string") {
-        adjustedValue = +adjustedValue;
-    }
-    if (minDecimals > maxDecimals) {
-        adjustedMaxDecimals = minDecimals;
-    }
-    // Ensure maximumFractionDigits is within allowed range [0, 20]
-    const safeMaxDecimals = Math.max(0, Math.min(adjustedMaxDecimals, 20));
-    // @ts-expect-error - `maximumFractionDigits` wants to get number less than 21,
-    // but as the tokens have 18 decimals have, we can safely pass a parameter
-    return adjustedValue.toLocaleString("en-US", {
-        minimumFractionDigits: minDecimals,
-        maximumFractionDigits: safeMaxDecimals,
-        roundingMode: "halfExpand",
-    });
-};
-/** PUBLIC HELPER FUNCTIONS for calculations */
-/**
- * Multiplies a bigint with a decimal number, taking into account the decimal places.
- *
- * @param bigint - The bigint value to multiply.
- * @param number - The decimal number to multiply with.
- * @returns The result of the multiplication as a bigint.
- */
-export const multiplyBigIntWithDecimal = (bigint, number) => {
-    const numberString = number.toString();
-    const scientificMatch = /^1e-(\d+)$/.exec(numberString);
-    // Ensure we can correctly deal with scientific number expression
-    if (scientificMatch) {
-        const exponent = parseInt(scientificMatch[1], 10);
-        const scale = BigInt(10 ** exponent);
-        return (bigint * 1n) / scale;
-    }
-    const decimalsPart = number.toString().split(".")[1];
-    const decimalsCount = decimalsPart ? decimalsPart.length : 0;
-    if (!decimalsCount)
-        return bigint * BigInt(number);
-    const scale = BigInt(10 ** decimalsCount);
-    const scaledNumber = BigInt(Math.round(number * Number(scale)));
-    return (bigint * scaledNumber) / scale;
-};
-/**
- * Converts a fixed-point number to another fixed-point number with a different decimal precision.
- * @param args The arguments for the conversion.
- *  - amount: required, the fixed-point number to convert.
- *  - decimals: required, the current decimal precision of the number.
- *  - targetDecimals: required, the target decimal precision for the conversion.
- * @returns The converted fixed-point number.
- */
-export const convertDecimals = ({ amount, decimals, targetDecimals, }) => {
-    if (decimals >= targetDecimals) {
-        return amount / 10n ** BigInt(decimals - targetDecimals);
-    }
-    return amount * 10n ** BigInt(targetDecimals - decimals);
-};
-/** Helper functions for input components */
-/**
- * Trims decimal places to a specified precision - NO ROUNDING!
- * @param value The value to trim
- * @param precision The number of decimal places to keep
- * @returns The trimmed value
- */
-export const trimDecimals = (value, precision) => {
-    const [integerPart, decimalPart = ""] = value.split(".");
-    return decimalPart.length > precision
-        ? `${integerPart}.${decimalPart.slice(0, precision)}`
-        : value;
-};
-/**
- * Trims integer part to a specified length - NO ROUNDING!
- * @param value The value to trim
- * @param precision The number of integer places to keep
- * @returns The trimmed value
- * @deprecated just compare the value to the max allowed value in the input component
- */
-export const trimBeforeDecimals = (value, precision) => {
-    const [integerPart, decimalPart = ""] = value.split(".");
-    return integerPart.length > precision
-        ? `${integerPart.slice(0, precision)}.${decimalPart}`
-        : value;
-};
-/**
- * Normalizes a decimal number input by removing invalid characters and preventing multiple dots.
- * @param value The value to normalize
- * @returns The normalized value
- */
-export const normalizeDecimalNumber = (value) => value.replace(/[^0-9.]/g, "").replace(/\.(?=.*\.)/g, ""); // Remove all dots except the first one
-/**
- * CONVERSION FUNCTIONS
- * These functions convert between floating-point numbers and big integers as well as
- * provide human-readable formats.
- *
- * They are used to ensure that numbers are correctly formatted for display and calculations
- * and should be used in the UI and business logic to ensure correct number formatting.
- */
-/** Basic conversion bigint <-> float  */
-/**
- * Converts a floating-point number to a big integer representation.
- * @param args The arguments for the conversion.
- *   - amount: required, the floating-point number to convert.
- *   - decimals: optional, the number of decimal places to consider.
- * @returns The big integer representation of the floating-point number.
- */
-export const floatToBigInt = ({ amount, decimals = 18, }) => {
-    const parsedAmount = amount.toString();
-    const fixedPointAmount = parseToFixedPointNumber(parsedAmount);
-    if (typeof fixedPointAmount === "undefined") {
-        return 0n;
-    }
-    const bigIntAmount = convertDecimals({
-        amount: fixedPointAmount.amount,
-        decimals: fixedPointAmount.decimals,
-        targetDecimals: decimals,
-    });
-    return bigIntAmount;
-};
-/**
- * Converts a big integer representation to a floating-point number.
- * @param args The arguments for the conversion.
- *   - amount: required, the big integer representation to convert.
- *   - decimals: optional, the number of decimal places to consider.
- *   - desiredDecimals: optional, the desired number of decimal places for the output.
- * @returns The floating-point representation of the big integer.
- */
-export const bigIntToFloat = ({ amount, decimals = 18, desiredDecimals = decimals, }) => {
-    let isNegative = false;
-    let normalizedAmount = amount;
-    if (amount < 0n) {
-        normalizedAmount = -amount;
-        isNegative = true;
-    }
-    const desiredDecimalsAmount = normalizedAmount / 10n ** BigInt(Math.max(0, decimals - desiredDecimals));
-    // Desired decimals amount with additional decimal to check if number
-    // should be rounded up
-    const desiredDecimalsAmountWithAdditionalDecimal = normalizedAmount /
-        10n ** BigInt(Math.max(0, decimals - desiredDecimals - 1));
-    // We are getting the first value that has been cut off
-    const firstDecimalAfterCutOff = desiredDecimalsAmountWithAdditionalDecimal
-        .toString()
-        .at(-1);
-    // Padding amount when its length is smaller than desired
-    const parsedDesiredAmount = desiredDecimalsAmount
-        .toString()
-        .padStart(desiredDecimals + 1, "0");
-    const integersPart = parsedDesiredAmount.slice(0, -desiredDecimals);
-    const decimalsPart = parsedDesiredAmount.slice(-desiredDecimals);
-    // If number is above or equal to 5 we should round up the number
-    const shouldIncreaseDecimalsPart = Number(firstDecimalAfterCutOff) >= 5 && desiredDecimals !== decimals;
-    // If above is true we add 1 to the decimals value and convert it back to string
-    const adjustedDecimalsPart = shouldIncreaseDecimalsPart
-        ? (Number(decimalsPart) + 1).toString().padStart(desiredDecimals, "0")
-        : decimalsPart;
-    // Determining whether integer part needs to be increased due to rounding up
-    const shouldIncreaseIntegerPart = (decimalsPart === "0" && adjustedDecimalsPart !== decimalsPart) ||
-        adjustedDecimalsPart.length > decimalsPart.length;
-    // If above is true we add 1 to the integers value and convert it back to string
-    // and set first value of decimals part to 0
-    const adjustedIntegersPart = shouldIncreaseIntegerPart
-        ? (Number(integersPart) + 1).toString()
-        : integersPart;
-    const decimalsPartAfterIntegersAdjustments = shouldIncreaseIntegerPart
-        ? `0${adjustedDecimalsPart.slice(1)}`
-        : adjustedDecimalsPart;
-    // Inserting "." to separate integers part from decimal part
-    const desiredAmount = [
-        ...adjustedIntegersPart,
-        ".",
-        ...decimalsPartAfterIntegersAdjustments,
-    ].join("");
-    // Remove trailing zeros and the trailing decimal point (if exists)
-    const trimmedDesiredAmount = desiredAmount.replace(/(?:\.0*|(\.\d+?)0+)$/, "$1");
-    return isNegative ? `-${trimmedDesiredAmount}` : trimmedDesiredAmount;
-};
-/**
- * Helpers for setting correct arguments and getting unified human-readable
- * formats across the app with _toHumanReadableFormat functions.
- */
-export const amountAsUSD = (args) => ({
-    desiredDecimals: 2,
-    minDecimals: 2,
-    ...args,
-});
-export const amountAsToken = (args) => ({
-    desiredDecimals: FRIENDLY_DECIMALS_AMOUNT,
-    minDecimals: 0,
-    ...args,
-});
-export const amountAsMusd = (args) => ({
-    desiredDecimals: 2,
-    minDecimals: 2,
-    decimals: 18, // MUSD has 18 decimals
-    ...args,
-});
-export const amountAsMats = (args) => ({
-    desiredDecimals: 0,
-    minDecimals: 0,
-    ...args,
-});
-/**
- * Converts a floating-point number to a human-readable format - with thousands
- * separators and specified decimal places.
- * @param args The arguments for the conversion.
- *   - amount: required, the floating-point number to convert.
- *   - desiredDecimals: optional, the desired number of decimal places for the output.
- *   - minDecimals: optional, the minimum number of decimal places.
- * @returns The human-readable format of the floating-point number.
- */
-export const floatToHumanReadableFormat = ({ amount, desiredDecimals = 2, // treat is as an USD amount by default
-minDecimals = 0, }) => separateThousandsWithComma(amount, minDecimals, desiredDecimals);
-export const bigIntToHumanReadableFormat = ({ amount, decimals = 18, desiredDecimals = FRIENDLY_DECIMALS_AMOUNT, // treat is as a token by default
-minDecimals = 0, }) => {
-    let isNegative = false;
-    let normalizedAmount = amount;
-    let adjustedDesiredDecimals = desiredDecimals;
-    if (minDecimals > desiredDecimals) {
-        adjustedDesiredDecimals = minDecimals;
-    }
-    if (normalizedAmount < 0n) {
-        normalizedAmount = -normalizedAmount;
-        isNegative = true;
-    }
-    const trimmedDesiredAmount = bigIntToFloat({
-        amount: normalizedAmount,
-        decimals,
-        desiredDecimals: adjustedDesiredDecimals,
-    });
-    if (trimmedDesiredAmount === "0" && normalizedAmount !== 0n) {
-        const decimalsString = "1".padStart(adjustedDesiredDecimals, "0");
-        return `<0.${decimalsString}`;
-    }
-    const desiredValue = isNegative
-        ? `-${trimmedDesiredAmount}`
-        : trimmedDesiredAmount;
-    return floatToHumanReadableFormat({
-        amount: desiredValue,
-        desiredDecimals: adjustedDesiredDecimals,
-        minDecimals,
-    });
-};
-//# sourceMappingURL=number2.js.map