@multiversx/sdk-dapp-liquidity 0.2.0-alpha.1

package/reactjs/queries/useGetChains.query.mjs

@@ -0,0 +1,30 @@
+import { useQuery } from "@tanstack/react-query";
+import { getChains } from "../../api/getChains.mjs";
+import { getApiURL } from "../../helpers/getApiURL.mjs";
+const useGetChainsQuery = () => {
+  const queryFn = async () => {
+    try {
+      const { data } = await getChains({
+        url: getApiURL()
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  };
+  const retry = (_failureCount, error) => {
+    var _a;
+    return ((_a = error.response) == null ? void 0 : _a.status) === 404;
+  };
+  return useQuery({
+    queryKey: ["chains"],
+    queryFn,
+    retry,
+    refetchOnWindowFocus: false,
+    gcTime: 5 * 60 * 1e3,
+    staleTime: 0
+  });
+};
+export {
+  useGetChainsQuery
+};

package/reactjs/queries/useGetEvmTokensBalances.query.d.ts

@@ -0,0 +1,22 @@
+import { TokenType } from '../../types/token';
+import { AxiosError } from 'axios';
+
+export declare const useGetEvmTokensBalancesQuery: ({ tokens, chainId }: {
+    tokens: TokenType[];
+    chainId?: string;
+}) => import('@tanstack/react-query').UseQueryResult<{
+    balance: string;
+    chainId: number;
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    crosschain: boolean;
+    pngUrl: string;
+    svgUrl: string;
+    metadata: {
+        minBridgeAmount: string;
+        maxBridgeAmount: string;
+    };
+}[], AxiosError<unknown, any>>;
+export declare function invalidateEvmTokensBalances(): void;

package/reactjs/queries/useGetEvmTokensBalances.query.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../index-cvy2-uZ_.js");
+const react = require("../../react-CNXJSTCv.js");
+require("viem");
+require("viem/chains");
+const require$$0 = require("react");
+const reactQuery = require("@tanstack/react-query");
+const reactjs_context_queryClient = require("../context/queryClient.js");
+const reactjs_hooks_useBalances = require("../../useBalances-Bxtc4GNK.js");
+const useGetEvmTokensBalancesQuery = ({
+  tokens,
+  chainId
+}) => {
+  const { address } = react.useAppKitAccount();
+  const { fetchBalances } = reactjs_hooks_useBalances.useBalances();
+  const tokenIdentifiers = require$$0.useMemo(() => {
+    return tokens.filter((token) => token.chainId.toString() === (chainId == null ? void 0 : chainId.toString())).map(({ address: tokenId }) => tokenId);
+  }, [tokens, chainId]);
+  const queryFn = async () => {
+    try {
+      if (!address) {
+        throw new Error("User address is required");
+      }
+      if (!chainId) {
+        throw new Error("Chain ID is required");
+      }
+      const assets = await fetchBalances({
+        address,
+        chainId: chainId.toString(),
+        tokenIdentifiers
+      });
+      return assets.map((asset) => {
+        const foundToken = tokens.find(
+          (token) => token.address === asset.tokenId
+        );
+        if (!foundToken) {
+          throw new Error("Token not found");
+        }
+        return {
+          ...foundToken,
+          balance: asset.balance.toString()
+        };
+      });
+    } catch (error) {
+      throw error;
+    }
+  };
+  const retry = (_failureCount, error) => {
+    var _a;
+    return ((_a = error.response) == null ? void 0 : _a.status) === 404;
+  };
+  return reactQuery.useQuery({
+    queryKey: [
+      "evm-tokens-balances",
+      address,
+      chainId,
+      tokenIdentifiers.sort()
+    ],
+    queryFn,
+    retry,
+    enabled: Boolean(address) && Boolean(chainId),
+    refetchOnWindowFocus: false,
+    refetchIntervalInBackground: true,
+    refetchInterval: 2e4,
+    gcTime: 0
+  });
+};
+function invalidateEvmTokensBalances() {
+  const queryKey = ["evm-tokens-balances"];
+  const queryClient = reactjs_context_queryClient.getQueryClient();
+  queryClient.invalidateQueries({
+    queryKey
+  });
+}
+exports.invalidateEvmTokensBalances = invalidateEvmTokensBalances;
+exports.useGetEvmTokensBalancesQuery = useGetEvmTokensBalancesQuery;

package/reactjs/queries/useGetEvmTokensBalances.query.mjs

@@ -0,0 +1,77 @@
+import "../../index-DSnomXRI.mjs";
+import { u as useAppKitAccount } from "../../react-CSQpf1zk.mjs";
+import "viem";
+import "viem/chains";
+import { useMemo } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { getQueryClient } from "../context/queryClient.mjs";
+import { u as useBalances } from "../../useBalances-DA3zEruz.mjs";
+const useGetEvmTokensBalancesQuery = ({
+  tokens,
+  chainId
+}) => {
+  const { address } = useAppKitAccount();
+  const { fetchBalances } = useBalances();
+  const tokenIdentifiers = useMemo(() => {
+    return tokens.filter((token) => token.chainId.toString() === (chainId == null ? void 0 : chainId.toString())).map(({ address: tokenId }) => tokenId);
+  }, [tokens, chainId]);
+  const queryFn = async () => {
+    try {
+      if (!address) {
+        throw new Error("User address is required");
+      }
+      if (!chainId) {
+        throw new Error("Chain ID is required");
+      }
+      const assets = await fetchBalances({
+        address,
+        chainId: chainId.toString(),
+        tokenIdentifiers
+      });
+      return assets.map((asset) => {
+        const foundToken = tokens.find(
+          (token) => token.address === asset.tokenId
+        );
+        if (!foundToken) {
+          throw new Error("Token not found");
+        }
+        return {
+          ...foundToken,
+          balance: asset.balance.toString()
+        };
+      });
+    } catch (error) {
+      throw error;
+    }
+  };
+  const retry = (_failureCount, error) => {
+    var _a;
+    return ((_a = error.response) == null ? void 0 : _a.status) === 404;
+  };
+  return useQuery({
+    queryKey: [
+      "evm-tokens-balances",
+      address,
+      chainId,
+      tokenIdentifiers.sort()
+    ],
+    queryFn,
+    retry,
+    enabled: Boolean(address) && Boolean(chainId),
+    refetchOnWindowFocus: false,
+    refetchIntervalInBackground: true,
+    refetchInterval: 2e4,
+    gcTime: 0
+  });
+};
+function invalidateEvmTokensBalances() {
+  const queryKey = ["evm-tokens-balances"];
+  const queryClient = getQueryClient();
+  queryClient.invalidateQueries({
+    queryKey
+  });
+}
+export {
+  invalidateEvmTokensBalances,
+  useGetEvmTokensBalancesQuery
+};

package/reactjs/queries/useGetHistory.query.d.ts

@@ -0,0 +1,4 @@
+import { AxiosError } from 'axios';
+
+export declare const useGetHistoryQuery: () => import('@tanstack/react-query').UseQueryResult<import('../..').TransactionDTO[], AxiosError<unknown, any>>;
+export declare const invalidateHistoryQuery: () => void;

package/reactjs/queries/useGetHistory.query.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const reactQuery = require("@tanstack/react-query");
+const api_getTransactions = require("../../api/getTransactions.js");
+const helpers_getApiURL = require("../../helpers/getApiURL.js");
+const reactjs_context_queryClient = require("../context/queryClient.js");
+const reactjs_hooks_useAccount = require("../hooks/useAccount.js");
+const useGetHistoryQuery = () => {
+  const { address } = reactjs_hooks_useAccount.useAccount();
+  const queryFn = async () => {
+    if (!address) {
+      throw new Error("User is not connected");
+    }
+    try {
+      const { data } = await api_getTransactions.getTransactions({
+        url: helpers_getApiURL.getApiURL(),
+        userWalletAddress: address
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  };
+  const retry = (_failureCount, error) => {
+    var _a;
+    return ((_a = error.response) == null ? void 0 : _a.status) === 404;
+  };
+  return reactQuery.useQuery({
+    queryKey: ["user-history", address],
+    queryFn,
+    retry,
+    enabled: Boolean(address),
+    refetchOnWindowFocus: false,
+    refetchIntervalInBackground: true,
+    refetchInterval: 1e4,
+    gcTime: 0
+  });
+};
+const invalidateHistoryQuery = () => {
+  const queryClient = reactjs_context_queryClient.getQueryClient();
+  queryClient.invalidateQueries({
+    queryKey: ["user-history"]
+  });
+};
+exports.invalidateHistoryQuery = invalidateHistoryQuery;
+exports.useGetHistoryQuery = useGetHistoryQuery;

package/reactjs/queries/useGetHistory.query.mjs

@@ -0,0 +1,46 @@
+import { useQuery } from "@tanstack/react-query";
+import { getTransactions } from "../../api/getTransactions.mjs";
+import { getApiURL } from "../../helpers/getApiURL.mjs";
+import { getQueryClient } from "../context/queryClient.mjs";
+import { useAccount } from "../hooks/useAccount.mjs";
+const useGetHistoryQuery = () => {
+  const { address } = useAccount();
+  const queryFn = async () => {
+    if (!address) {
+      throw new Error("User is not connected");
+    }
+    try {
+      const { data } = await getTransactions({
+        url: getApiURL(),
+        userWalletAddress: address
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  };
+  const retry = (_failureCount, error) => {
+    var _a;
+    return ((_a = error.response) == null ? void 0 : _a.status) === 404;
+  };
+  return useQuery({
+    queryKey: ["user-history", address],
+    queryFn,
+    retry,
+    enabled: Boolean(address),
+    refetchOnWindowFocus: false,
+    refetchIntervalInBackground: true,
+    refetchInterval: 1e4,
+    gcTime: 0
+  });
+};
+const invalidateHistoryQuery = () => {
+  const queryClient = getQueryClient();
+  queryClient.invalidateQueries({
+    queryKey: ["user-history"]
+  });
+};
+export {
+  invalidateHistoryQuery,
+  useGetHistoryQuery
+};

package/reactjs/queries/useGetMvxTokensBalances.query.d.ts

@@ -0,0 +1,23 @@
+import { TokenType } from '../../types/token';
+import { AxiosError } from 'axios';
+
+export declare const useGetMvxTokensBalancesQuery: ({ tokens, mvxAddress, apiURL }: {
+    tokens: TokenType[];
+    mvxAddress?: string;
+    apiURL: string;
+}) => import('@tanstack/react-query').UseQueryResult<{
+    balance: string;
+    address: string;
+    symbol: string;
+    chainId: number;
+    name: string;
+    decimals: number;
+    crosschain: boolean;
+    pngUrl: string;
+    svgUrl: string;
+    metadata: {
+        minBridgeAmount: string;
+        maxBridgeAmount: string;
+    };
+}[], AxiosError<unknown, any>>;
+export declare function invalidateMvxTokensBalancesQuery(): void;

package/reactjs/queries/useGetMvxTokensBalances.query.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const reactQuery = require("@tanstack/react-query");
+const axios = require("axios");
+const require$$0 = require("react");
+const reactjs_context_queryClient = require("../context/queryClient.js");
+const useGetMvxTokensBalancesQuery = ({
+  tokens,
+  mvxAddress,
+  apiURL
+}) => {
+  const tokenIdentifiers = require$$0.useMemo(() => {
+    return tokens.map(({ address }) => address);
+  }, [tokens]);
+  const url = `${apiURL}/accounts/${mvxAddress}/tokens?identifiers=${tokenIdentifiers}`;
+  const queryFn = async () => {
+    const { data } = await axios.get(url, {
+      timeout: 3e3
+    });
+    return data.map((asset) => {
+      var _a;
+      const foundToken = tokens.find(
+        (token) => token.address === asset.identifier
+      );
+      if (!foundToken) {
+        throw new Error("Token not found");
+      }
+      return {
+        ...foundToken,
+        balance: ((_a = asset.balance) == null ? void 0 : _a.toString()) ?? "0",
+        address: asset.identifier,
+        symbol: asset.ticker ?? foundToken.symbol
+      };
+    });
+  };
+  const retry = (_failureCount, error) => {
+    var _a;
+    return ((_a = error.response) == null ? void 0 : _a.status) === 404;
+  };
+  return reactQuery.useQuery({
+    queryKey: ["mvx-tokens-balances", mvxAddress, tokenIdentifiers.sort()],
+    queryFn,
+    retry,
+    enabled: Boolean(mvxAddress) && tokenIdentifiers.length > 0,
+    refetchOnWindowFocus: false,
+    refetchIntervalInBackground: true,
+    refetchInterval: 2e4,
+    gcTime: 0
+  });
+};
+function invalidateMvxTokensBalancesQuery() {
+  const queryKey = ["mvx-tokens-balances"];
+  const queryClient = reactjs_context_queryClient.getQueryClient();
+  queryClient.invalidateQueries({
+    queryKey
+  });
+}
+exports.invalidateMvxTokensBalancesQuery = invalidateMvxTokensBalancesQuery;
+exports.useGetMvxTokensBalancesQuery = useGetMvxTokensBalancesQuery;

package/reactjs/queries/useGetMvxTokensBalances.query.mjs

@@ -0,0 +1,59 @@
+import { useQuery } from "@tanstack/react-query";
+import axios from "axios";
+import { useMemo } from "react";
+import { getQueryClient } from "../context/queryClient.mjs";
+const useGetMvxTokensBalancesQuery = ({
+  tokens,
+  mvxAddress,
+  apiURL
+}) => {
+  const tokenIdentifiers = useMemo(() => {
+    return tokens.map(({ address }) => address);
+  }, [tokens]);
+  const url = `${apiURL}/accounts/${mvxAddress}/tokens?identifiers=${tokenIdentifiers}`;
+  const queryFn = async () => {
+    const { data } = await axios.get(url, {
+      timeout: 3e3
+    });
+    return data.map((asset) => {
+      var _a;
+      const foundToken = tokens.find(
+        (token) => token.address === asset.identifier
+      );
+      if (!foundToken) {
+        throw new Error("Token not found");
+      }
+      return {
+        ...foundToken,
+        balance: ((_a = asset.balance) == null ? void 0 : _a.toString()) ?? "0",
+        address: asset.identifier,
+        symbol: asset.ticker ?? foundToken.symbol
+      };
+    });
+  };
+  const retry = (_failureCount, error) => {
+    var _a;
+    return ((_a = error.response) == null ? void 0 : _a.status) === 404;
+  };
+  return useQuery({
+    queryKey: ["mvx-tokens-balances", mvxAddress, tokenIdentifiers.sort()],
+    queryFn,
+    retry,
+    enabled: Boolean(mvxAddress) && tokenIdentifiers.length > 0,
+    refetchOnWindowFocus: false,
+    refetchIntervalInBackground: true,
+    refetchInterval: 2e4,
+    gcTime: 0
+  });
+};
+function invalidateMvxTokensBalancesQuery() {
+  const queryKey = ["mvx-tokens-balances"];
+  const queryClient = getQueryClient();
+  queryClient.invalidateQueries({
+    queryKey
+  });
+}
+export {
+  invalidateMvxTokensBalancesQuery,
+  useGetMvxTokensBalancesQuery
+};

package/reactjs/queries/useGetRate.mutation.d.ts

@@ -0,0 +1,6 @@
+import { RateRequestBody } from '../../types/rate';
+
+export declare const useGetRateMutation: () => import('@tanstack/react-query').UseMutationResult<import('../../types/rate').RateRequestResponse, Error, {
+    nativeAuthToken: string;
+    body: RateRequestBody;
+}, unknown>;

package/reactjs/queries/useGetRate.mutation.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const reactQuery = require("@tanstack/react-query");
+const api_getRate = require("../../api/getRate.js");
+const helpers_getApiURL = require("../../helpers/getApiURL.js");
+const useGetRateMutation = () => {
+  const mutationFn = async (params) => {
+    const { data } = await api_getRate.getRate({
+      url: helpers_getApiURL.getApiURL(),
+      ...params
+    });
+    return data;
+  };
+  return reactQuery.useMutation({
+    mutationFn
+  });
+};
+exports.useGetRateMutation = useGetRateMutation;

package/reactjs/queries/useGetRate.mutation.mjs

@@ -0,0 +1,18 @@
+import { useMutation } from "@tanstack/react-query";
+import { getRate } from "../../api/getRate.mjs";
+import { getApiURL } from "../../helpers/getApiURL.mjs";
+const useGetRateMutation = () => {
+  const mutationFn = async (params) => {
+    const { data } = await getRate({
+      url: getApiURL(),
+      ...params
+    });
+    return data;
+  };
+  return useMutation({
+    mutationFn
+  });
+};
+export {
+  useGetRateMutation
+};

package/reactjs/queries/useGetTokens.query.d.ts

@@ -0,0 +1,3 @@
+import { AxiosError } from 'axios';
+
+export declare const useGetTokensQuery: () => import('@tanstack/react-query').UseQueryResult<import('../..').TokenType[], AxiosError<unknown, any>>;

package/reactjs/queries/useGetTokens.query.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const reactQuery = require("@tanstack/react-query");
+const api_getTokens = require("../../api/getTokens.js");
+const helpers_getApiURL = require("../../helpers/getApiURL.js");
+const reactjs_hooks_useGetChainId = require("../hooks/useGetChainId.js");
+const useGetTokensQuery = () => {
+  const chainId = reactjs_hooks_useGetChainId.useGetChainId();
+  const queryFn = async () => {
+    try {
+      const { data } = await api_getTokens.getTokens({
+        url: helpers_getApiURL.getApiURL(),
+        chainId: Number(chainId)
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  };
+  const retry = (_failureCount, error) => {
+    var _a;
+    return ((_a = error.response) == null ? void 0 : _a.status) === 404;
+  };
+  return reactQuery.useQuery({
+    queryKey: ["tokens", chainId],
+    queryFn,
+    retry,
+    refetchOnWindowFocus: false,
+    gcTime: 5 * 60 * 1e3,
+    staleTime: 0
+  });
+};
+exports.useGetTokensQuery = useGetTokensQuery;

package/reactjs/queries/useGetTokens.query.mjs

@@ -0,0 +1,33 @@
+import { useQuery } from "@tanstack/react-query";
+import { getTokens } from "../../api/getTokens.mjs";
+import { getApiURL } from "../../helpers/getApiURL.mjs";
+import { useGetChainId } from "../hooks/useGetChainId.mjs";
+const useGetTokensQuery = () => {
+  const chainId = useGetChainId();
+  const queryFn = async () => {
+    try {
+      const { data } = await getTokens({
+        url: getApiURL(),
+        chainId: Number(chainId)
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  };
+  const retry = (_failureCount, error) => {
+    var _a;
+    return ((_a = error.response) == null ? void 0 : _a.status) === 404;
+  };
+  return useQuery({
+    queryKey: ["tokens", chainId],
+    queryFn,
+    retry,
+    refetchOnWindowFocus: false,
+    gcTime: 5 * 60 * 1e3,
+    staleTime: 0
+  });
+};
+export {
+  useGetTokensQuery
+};

package/reactjs/reexports.d.ts

@@ -0,0 +1,6 @@
+import { useWaitForTransactionReceipt } from 'wagmi';
+import { useAppKit, useAppKitAccount, useAppKitEvents, useAppKitNetwork, useAppKitState, useAppKitTheme, useDisconnect, useWalletInfo, useAppKitNetworkCore, useAppKitProvider } from '@reown/appkit/react';
+
+export type { Config, CreateConnectorFn } from 'wagmi';
+export type { AppKit } from '@reown/appkit';
+export { useAppKit, useAppKitAccount, useAppKitEvents, useAppKitNetwork, useAppKitState, useAppKitTheme, useDisconnect, useWalletInfo, useAppKitNetworkCore, useAppKitProvider, useWaitForTransactionReceipt };

package/reactjs/reexports.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react$1 = require("../react-BaXyw3AO.js");
+const wagmi = require("wagmi");
+const react = require("../react-CNXJSTCv.js");
+const index = require("../index-DZHiA1sX.js");
+exports.useAppKitNetwork = react$1.useAppKitNetwork;
+Object.defineProperty(exports, "useWaitForTransactionReceipt", {
+  enumerable: true,
+  get: () => wagmi.useWaitForTransactionReceipt
+});
+exports.useAppKitAccount = react.useAppKitAccount;
+exports.useAppKitNetworkCore = react.useAppKitNetworkCore;
+exports.useDisconnect = react.useDisconnect;
+exports.useAppKit = index.useAppKit;
+exports.useAppKitEvents = index.useAppKitEvents;
+exports.useAppKitProvider = index.useAppKitProvider;
+exports.useAppKitState = index.useAppKitState;
+exports.useAppKitTheme = index.useAppKitTheme;
+exports.useWalletInfo = index.useWalletInfo;

package/reactjs/reexports.mjs

@@ -0,0 +1,17 @@
+import { u } from "../react-B9sQBOh0.mjs";
+import { useWaitForTransactionReceipt } from "wagmi";
+import { u as u2, b, a } from "../react-CSQpf1zk.mjs";
+import { u as u3, a as a2, e, b as b2, c, d } from "../index-BXwpbIDQ.mjs";
+export {
+  u3 as useAppKit,
+  u2 as useAppKitAccount,
+  a2 as useAppKitEvents,
+  u as useAppKitNetwork,
+  b as useAppKitNetworkCore,
+  e as useAppKitProvider,
+  b2 as useAppKitState,
+  c as useAppKitTheme,
+  a as useDisconnect,
+  useWaitForTransactionReceipt,
+  d as useWalletInfo
+};

package/reactjs/utils/delay.d.ts

@@ -0,0 +1 @@
+export declare function delay(ms: number): Promise<unknown>;

package/reactjs/utils/delay.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+exports.delay = delay;

package/reactjs/utils/delay.mjs

@@ -0,0 +1,6 @@
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  delay
+};

package/reactjs/utils/formatAmount.d.ts

@@ -0,0 +1,7 @@
+export declare const formatAmount: ({ amount, decimals, addCommas, digits, showLastNonZeroDecimal }: {
+    digits?: number;
+    decimals?: number;
+    addCommas?: boolean;
+    amount?: string | null;
+    showLastNonZeroDecimal?: boolean;
+}) => string;

package/reactjs/utils/formatAmount.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const formatAmount$1 = require("@multiversx/sdk-dapp-utils/out/helpers/formatAmount");
+const stringIsInteger = require("@multiversx/sdk-dapp-utils/out/helpers/stringIsInteger");
+const reactjs_utils_roundAmount = require("./roundAmount.js");
+const formatAmount = ({
+  amount = "0",
+  decimals = 0,
+  addCommas = false,
+  digits = 4,
+  showLastNonZeroDecimal = true
+}) => {
+  if (amount == null || amount === "0" || !stringIsInteger.stringIsInteger(amount, false)) {
+    return "0";
+  }
+  const formattedAmount = formatAmount$1.formatAmount({
+    decimals,
+    input: amount,
+    showLastNonZeroDecimal
+  });
+  return reactjs_utils_roundAmount.roundAmount(formattedAmount, digits, addCommas);
+};
+exports.formatAmount = formatAmount;