@blocklet/payment-react 1.24.4 → 1.25.1

package/es/libs/util.js

@@ -1,4 +1,4 @@
-import { BN, fromUnitToToken } from "@ocap/util";
+import { BN, fromUnitToToken, fromTokenToUnit } from "@ocap/util";
 import omit from "lodash/omit";
 import trimEnd from "lodash/trimEnd";
 import numbro from "numbro";
@@ -167,6 +167,87 @@ export function formatNumber(n, precision = 6, trim = true, thousandSeparated =
   const [left, right] = result.split(".");
   return right ? [left, trimEnd(right, "0")].filter(Boolean).join(".") : left;
 }
+export function formatDynamicPrice(n, isDynamic, precision = 6, trim = true, thousandSeparated = true) {
+  if (!isDynamic) {
+    return formatNumber(n, precision, trim, thousandSeparated);
+  }
+  const num = Number(n);
+  if (!Number.isFinite(num)) {
+    return formatNumber(n, precision, trim, thousandSeparated);
+  }
+  const abs = Math.abs(num);
+  const targetPrecision = abs > 0 && abs < 0.01 ? precision : 2;
+  return formatNumber(n, targetPrecision, trim, thousandSeparated);
+}
+const USD_DECIMALS = 8;
+export function getUsdAmountFromBaseAmount(amount, quantity, scale = BASE_AMOUNT_SCALE) {
+  if (amount === void 0 || amount === null || !quantity || quantity <= 0) {
+    return null;
+  }
+  const scaled = toScaledBaseAmount(amount, quantity, scale);
+  return formatScaledAmount(scaled, scale);
+}
+export function getUsdAmountFromTokenUnits(tokenAmount, tokenDecimals, exchangeRate) {
+  if (!exchangeRate && exchangeRate !== "0") {
+    return null;
+  }
+  if (tokenDecimals === void 0 || tokenDecimals === null) {
+    return null;
+  }
+  try {
+    const amountBN = tokenAmount instanceof BN ? tokenAmount : new BN(tokenAmount || "0");
+    const tokenScale = new BN(10).pow(new BN(tokenDecimals));
+    if (tokenScale.isZero()) {
+      return null;
+    }
+    const rateBN = new BN(exchangeRate.replace(".", ""));
+    const rateDecimalPlaces = exchangeRate.includes(".") ? exchangeRate.split(".")[1]?.length || 0 : 0;
+    const rateScale = new BN(10).pow(new BN(rateDecimalPlaces));
+    const usdPrecisionScale = new BN(10).pow(new BN(USD_DECIMALS));
+    const usdUnit = amountBN.mul(rateBN).mul(usdPrecisionScale).div(tokenScale.mul(rateScale));
+    return fromUnitToToken(usdUnit.toString(), USD_DECIMALS);
+  } catch {
+    return null;
+  }
+}
+export function formatUsdAmount(amount, locale = "en") {
+  if (!amount && amount !== "0") {
+    return null;
+  }
+  const num = Number(amount);
+  if (!Number.isFinite(num)) {
+    return null;
+  }
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  }).format(num);
+}
+export function formatExchangeRate(amount) {
+  if (!amount && amount !== "0") {
+    return null;
+  }
+  const value = String(amount);
+  const num = Number(value);
+  if (!Number.isFinite(num)) {
+    return null;
+  }
+  return value;
+}
+export function formatExchangeRateDisplay(rate, currency = "USD", decimals = 2) {
+  if (rate === null || rate === void 0) {
+    return null;
+  }
+  const num = Number(rate);
+  if (!Number.isFinite(num)) {
+    return null;
+  }
+  const formattedValue = num.toFixed(decimals);
+  if (currency === "USD") {
+    return `$${formattedValue}`;
+  }
+  return `${formattedValue} ${currency}`;
+}
 export const formatPrice = (price, currency, unit_label, quantity = 1, bn = true, locale = "en") => {
   if (!currency) {
     return "";
@@ -174,6 +255,22 @@ export const formatPrice = (price, currency, unit_label, quantity = 1, bn = true
   if (price.custom_unit_amount) {
     return `Custom (${currency.symbol})`;
   }
+  if (price.pricing_type === "dynamic" && price.base_amount && price.base_currency === "USD") {
+    const baseAmount = price.base_amount;
+    const usdAmount = Number(baseAmount) * quantity;
+    const formattedUsd = formatUsdAmount(usdAmount.toString(), locale);
+    if (price?.type === "recurring" && price.recurring) {
+      const recurring = formatRecurring(price.recurring, false, "slash", locale);
+      if (unit_label) {
+        return `$${formattedUsd} / ${unit_label} ${recurring}`;
+      }
+      if (price.recurring.usage_type === "metered") {
+        return `$${formattedUsd} / unit ${recurring}`;
+      }
+      return `$${formattedUsd} ${recurring}`;
+    }
+    return `$${formattedUsd}`;
+  }
   const unit = getPriceUintAmountByCurrency(price, currency);
   const amount = bn ? fromUnitToToken(new BN(unit).mul(new BN(quantity)), currency.decimal).toString() : +unit * quantity;
   if (price?.type === "recurring" && price.recurring) {
@@ -188,10 +285,25 @@ export const formatPrice = (price, currency, unit_label, quantity = 1, bn = true
   }
   return `${amount} ${currency.symbol}`;
 };
-export const formatPriceAmount = (price, currency, unit_label, quantity = 1, bn = true) => {
+export const formatPriceAmount = (price, currency, unit_label, quantity = 1, bn = true, locale = "en") => {
   if (!currency) {
     return "";
   }
+  if (price.pricing_type === "dynamic" && price.base_amount && price.base_currency === "USD") {
+    const baseAmount = price.base_amount;
+    const usdAmount = Number(baseAmount) * quantity;
+    const formattedUsd = formatUsdAmount(usdAmount.toString(), locale);
+    if (price?.type === "recurring" && price.recurring) {
+      if (unit_label) {
+        return `$${formattedUsd} / ${unit_label}`;
+      }
+      if (price.recurring.usage_type === "metered") {
+        return `$${formattedUsd} / unit`;
+      }
+      return `$${formattedUsd}`;
+    }
+    return `$${formattedUsd}`;
+  }
   const unit = getPriceUintAmountByCurrency(price, currency);
   const amount = bn ? fromUnitToToken(new BN(unit).mul(new BN(quantity)), currency.decimal).toString() : +unit * quantity;
   if (price?.type === "recurring" && price.recurring) {
@@ -272,18 +384,122 @@ export function getPriceCurrencyOptions(price) {
     }
   ];
 }
-export function formatLineItemPricing(item, currency, { trialEnd, trialInDays }, locale = "en") {
+const BASE_AMOUNT_SCALE = 8;
+function formatScaledAmount(value, scale = BASE_AMOUNT_SCALE) {
+  const isNegative = value.isNeg();
+  const absValue = value.abs();
+  const str = absValue.toString().padStart(scale + 1, "0");
+  const integerPart = str.slice(0, str.length - scale) || "0";
+  const fraction = str.slice(-scale).replace(/0+$/, "");
+  const formatted = fraction ? `${integerPart}.${fraction}` : integerPart;
+  return isNegative ? `-${formatted}` : formatted;
+}
+function toScaledBaseAmount(amount, quantity, scale = BASE_AMOUNT_SCALE) {
+  if (!amount || !quantity) {
+    return new BN(0);
+  }
+  const normalized = String(amount);
+  const [integer = "0", fraction = ""] = normalized.split(".");
+  const frac = `${fraction}`.padEnd(scale, "0").slice(0, scale);
+  const digits = `${integer.replace("-", "")}${frac}` || "0";
+  const scaled = new BN(digits).mul(new BN(quantity));
+  return normalized.startsWith("-") ? scaled.neg() : scaled;
+}
+export function getLineItemAmounts(item, currency, { useUpsell = true, exchangeRate = null } = {}) {
+  if (!currency) {
+    return { unitAmount: new BN(0), totalAmount: new BN(0), isDynamicQuote: false };
+  }
+  const price = useUpsell ? item.upsell_price || item.price : item.price;
+  const quantity = new BN(item.quantity || 0);
+  const quoteAmount = item?.quoted_amount;
+  const quoteCurrencyId = item?.quote_currency_id;
+  const isDynamicPrice = price?.pricing_type === "dynamic";
+  const isQuoteValidForCurrency = isDynamicPrice && quoteAmount && quoteCurrencyId === currency.id;
+  if (isQuoteValidForCurrency) {
+    const totalAmount = new BN(quoteAmount || "0");
+    const unitAmount2 = quantity.gt(new BN(0)) ? totalAmount.add(quantity).sub(new BN(1)).div(quantity) : new BN(0);
+    return { unitAmount: unitAmount2, totalAmount, isDynamicQuote: true };
+  }
+  if (isDynamicPrice && exchangeRate && price?.base_amount) {
+    const rate = Number(exchangeRate);
+    if (rate > 0 && Number.isFinite(rate)) {
+      const baseAmountUsd = Number(price.base_amount);
+      if (baseAmountUsd > 0 && Number.isFinite(baseAmountUsd)) {
+        const tokenAmount = baseAmountUsd / rate;
+        const unitAmount2 = fromTokenToUnit(tokenAmount.toFixed(currency.decimal || 8), currency.decimal || 8);
+        return {
+          unitAmount: unitAmount2,
+          totalAmount: unitAmount2.mul(quantity),
+          isDynamicQuote: false
+        };
+      }
+    }
+  }
+  const unitAmount = new BN(getPriceUintAmountByCurrency(price, currency));
+  return {
+    unitAmount,
+    totalAmount: unitAmount.mul(quantity),
+    isDynamicQuote: false
+  };
+}
+export function getQuoteLockInfo(items, currency) {
+  if (!items?.length || !currency) {
+    return null;
+  }
+  const dynamicItems = items.filter((item) => {
+    const price = item.upsell_price || item.price;
+    return price?.pricing_type === "dynamic" && item?.quoted_amount;
+  });
+  if (!dynamicItems.length) {
+    return null;
+  }
+  let totalBaseAmount = new BN(0);
+  let totalTokenAmount = new BN(0);
+  let expiresAt = null;
+  dynamicItems.forEach((item) => {
+    const price = item.upsell_price || item.price;
+    const quoteAmount = new BN(item?.quoted_amount || "0");
+    totalTokenAmount = totalTokenAmount.add(quoteAmount);
+    const baseAmount = price?.base_amount;
+    if (baseAmount) {
+      totalBaseAmount = totalBaseAmount.add(toScaledBaseAmount(baseAmount, item.quantity));
+    }
+    if (item?.expires_at) {
+      expiresAt = expiresAt === null ? item?.expires_at : Math.min(expiresAt, item?.expires_at);
+    }
+  });
+  return {
+    baseAmount: formatScaledAmount(totalBaseAmount, BASE_AMOUNT_SCALE),
+    baseCurrency: (dynamicItems[0]?.upsell_price || dynamicItems[0]?.price)?.base_currency || "USD",
+    tokenAmount: fromUnitToToken(totalTokenAmount, currency.decimal).toString(),
+    tokenSymbol: currency.symbol,
+    expiresAt
+  };
+}
+export function formatLineItemPricing(item, currency, {
+  trialEnd,
+  trialInDays,
+  exchangeRate = null
+}, locale = "en") {
   if (!currency) {
     return { primary: "", secondary: "", quantity: "" };
   }
   const price = item.upsell_price || item.price;
+  if (!price) {
+    return { primary: "", secondary: "", quantity: "" };
+  }
   let quantity = t("common.qty", locale, { count: item.quantity });
   if (price.recurring?.usage_type === "metered" || +item.quantity === 1) {
     quantity = "";
   }
-  const unitValue = new BN(getPriceUintAmountByCurrency(price, currency));
-  const total = `${fromUnitToToken(unitValue.mul(new BN(item.quantity)), currency.decimal)} ${currency.symbol}`;
-  const unit = `${fromUnitToToken(unitValue, currency.decimal)} ${currency.symbol}`;
+  const { unitAmount, totalAmount } = getLineItemAmounts(item, currency, { exchangeRate });
+  const isDynamic = price?.pricing_type === "dynamic";
+  const formatLineItemAmount = (bn) => {
+    const value = fromUnitToToken(bn, currency.decimal);
+    return formatDynamicPrice(value, isDynamic, 6);
+  };
+  const total = `${formatLineItemAmount(totalAmount)} ${currency.symbol}`;
+  const unit = `${formatLineItemAmount(unitAmount)} ${currency.symbol}`;
   const trialResult = getFreeTrialTime({ trialInDays, trialEnd }, locale);
   const appendUnit = (v, alt) => {
     if (price.product.unit_label) {
@@ -397,8 +613,11 @@ export function getWebhookStatusColor(status) {
       return "default";
   }
 }
-export function getCheckoutAmount(items, currency, trialing = false, upsell = true) {
-  if (items.find((x) => (x.upsell_price || x.price).custom_unit_amount) && items.length > 1) {
+export function getCheckoutAmount(items, currency, trialing = false, upsell = true, { exchangeRate = null } = {}) {
+  if (items.find((x) => {
+    const price = upsell ? x.upsell_price || x.price : x.price;
+    return price?.custom_unit_amount;
+  }) && items.length > 1) {
     throw new Error("Multiple items with custom unit amount are not supported");
   }
   let renew = new BN(0);
@@ -406,18 +625,15 @@ export function getCheckoutAmount(items, currency, trialing = false, upsell = tr
     const price = upsell ? x.upsell_price || x.price : x.price;
     return price != null;
   }).reduce((acc, x) => {
-    if (x.custom_amount) {
+    const quoteCurrencyId = x?.quote_currency_id;
+    const isQuoteForDifferentCurrency = quoteCurrencyId && quoteCurrencyId !== currency.id;
+    if (x.custom_amount && !isQuoteForDifferentCurrency) {
       return acc.add(new BN(x.custom_amount));
     }
     const price = upsell ? x.upsell_price || x.price : x.price;
-    const unitPrice = getPriceUintAmountByCurrency(price, currency);
-    if (price.custom_unit_amount) {
-      if (unitPrice) {
-        return acc.add(new BN(unitPrice).mul(new BN(x.quantity)));
-      }
-    }
+    const { totalAmount } = getLineItemAmounts(x, currency, { useUpsell: upsell, exchangeRate });
     if (price?.type === "recurring") {
-      renew = renew.add(new BN(unitPrice).mul(new BN(x.quantity)));
+      renew = renew.add(totalAmount);
       if (trialing) {
         return acc;
       }
@@ -425,9 +641,16 @@ export function getCheckoutAmount(items, currency, trialing = false, upsell = tr
         return acc;
       }
     }
-    return acc.add(new BN(unitPrice).mul(new BN(x.quantity)));
+    return acc.add(totalAmount);
   }, new BN(0)).toString();
-  return { subtotal: total, total, renew: renew.toString(), discount: "0", shipping: "0", tax: "0" };
+  return {
+    subtotal: total,
+    total,
+    renew: formatDynamicPrice(renew.toString(), !!exchangeRate),
+    discount: "0",
+    shipping: "0",
+    tax: "0"
+  };
 }
 export function getRecurringPeriod(recurring) {
   const { interval } = recurring;
@@ -452,7 +675,7 @@ export function formatUpsellSaving(items, currency) {
   if (items[0]?.upsell_price_id) {
     return "0";
   }
-  if (!items[0]?.price.upsell?.upsells_to) {
+  if (!items[0]?.price?.upsell?.upsells_to) {
     return "0";
   }
   const from = getCheckoutAmount(items, currency, false, false);
@@ -482,6 +705,12 @@ export function formatMeteredThen(subscription, recurring, hasMetered, locale =
   }
   return t("payment.checkout.then", locale, { subscription, recurring });
 }
+export function formatThenValue(subscription, recurring, hasMetered, locale = "en") {
+  if (hasMetered) {
+    return t("payment.checkout.metered", locale, { recurring });
+  }
+  return [subscription, recurring].filter(Boolean).join(" ");
+}
 export function formatPriceDisplay({ amount, then, actualAmount, showThen }, recurring, hasMetered, locale = "en") {
   if (Number(actualAmount) === 0 && hasMetered) {
     return t("payment.checkout.metered", locale, { recurring });
@@ -534,9 +763,9 @@ export function getFreeTrialTime({ trialInDays, trialEnd }, locale = "en") {
     interval: t("common.day", locale)
   };
 }
-export function formatCheckoutHeadlines(items, currency, { trialInDays, trialEnd }, locale = "en") {
+export function formatCheckoutHeadlines(items, currency, { trialInDays, trialEnd }, locale = "en", { exchangeRate = null } = {}) {
   const brand = getStatementDescriptor(items);
-  const { total } = getCheckoutAmount(items, currency, trialInDays > 0);
+  const { total } = getCheckoutAmount(items, currency, trialInDays > 0, true, { exchangeRate });
   const actualAmount = fromUnitToToken(total, currency.decimal);
   const amount = `${fromUnitToToken(total, currency.decimal)} ${currency.symbol}`;
   const trialResult = getFreeTrialTime({ trialInDays, trialEnd }, locale);
@@ -549,118 +778,177 @@ export function formatCheckoutHeadlines(items, currency, { trialInDays, trialEnd
       priceDisplay: "0"
     };
   }
-  const { name } = items[0]?.price.product || { name: "" };
-  if (items.every((x) => x.price.type === "one_time")) {
+  const { name } = items[0]?.price?.product || { name: "" };
+  if (items.every((x) => x.price?.type === "one_time")) {
     const action = t("payment.checkout.pay", locale, { payee: brand });
     if (items.length > 1) {
       return { action, amount, actualAmount, priceDisplay: amount };
     }
     return { action, amount, then: "", actualAmount, priceDisplay: amount };
   }
-  const item = items.find((x) => x.price.type === "recurring");
+  const item = items.find((x) => x.price?.type === "recurring");
   const recurring = formatRecurring(
     (item?.upsell_price || item?.price)?.recurring,
     false,
     "per",
     locale
   );
-  const hasMetered = items.some((x) => x.price.type === "recurring" && x.price.recurring?.usage_type === "metered");
+  const hasMetered = items.some((x) => x.price?.type === "recurring" && x.price?.recurring?.usage_type === "metered");
   const differentRecurring = hasMultipleRecurringIntervals(items);
-  if (items.every((x) => x.price.type === "recurring")) {
+  if (items.every((x) => x.price?.type === "recurring")) {
     const subscription2 = [
       hasMetered ? t("payment.checkout.least", locale) : "",
-      fromUnitToToken(
-        items.reduce((acc, x) => {
-          if (x.price.recurring?.usage_type === "metered") {
-            return acc;
-          }
-          return acc.add(
-            new BN(getPriceUintAmountByCurrency(x.upsell_price || x.price, currency)).mul(new BN(x.quantity))
-          );
-        }, new BN(0)),
-        currency.decimal
+      formatDynamicPrice(
+        fromUnitToToken(
+          items.reduce((acc, x) => {
+            const price = x.upsell_price || x.price;
+            if (price?.recurring?.usage_type === "metered") {
+              return acc;
+            }
+            return acc.add(getLineItemAmounts(x, currency, { exchangeRate }).totalAmount);
+          }, new BN(0)),
+          currency.decimal
+        ),
+        !!exchangeRate
       ),
       currency.symbol
     ].filter(Boolean).join(" ");
     if (items.length > 1) {
       if (trialResult.count > 0) {
+        const thenDisplay4 = formatMeteredThen(
+          subscription2,
+          recurring,
+          hasMetered && Number(subscription2) === 0,
+          locale
+        );
+        const thenValue4 = formatThenValue(subscription2, recurring, hasMetered && Number(subscription2) === 0, locale);
         const result4 = {
           action: t("payment.checkout.try2", locale, { name, count: items.length - 1 }),
           amount: t("payment.checkout.free", locale, { count: trialResult.count, interval: trialResult.interval }),
-          then: formatMeteredThen(subscription2, recurring, hasMetered && Number(subscription2) === 0, locale),
+          then: thenDisplay4,
+          thenValue: thenValue4,
           showThen: true,
           actualAmount: "0"
         };
         return {
           ...result4,
-          priceDisplay: formatPriceDisplay(result4, recurring, hasMetered, locale)
+          priceDisplay: formatPriceDisplay(
+            { amount: result4.amount, then: thenDisplay4, actualAmount: result4.actualAmount, showThen: result4.showThen },
+            recurring,
+            hasMetered,
+            locale
+          )
         };
       }
+      const thenDisplay3 = hasMetered ? t("payment.checkout.meteredThen", locale, { recurring }) : recurring;
+      const thenValue3 = hasMetered ? t("payment.checkout.metered", locale, { recurring }) : recurring;
       const result3 = {
         action: t("payment.checkout.sub2", locale, { name, count: items.length - 1 }),
         amount,
-        then: hasMetered ? t("payment.checkout.meteredThen", locale, { recurring }) : recurring,
+        then: thenDisplay3,
+        thenValue: thenValue3,
         showThen: hasMetered,
         actualAmount
       };
       return {
         ...result3,
-        priceDisplay: formatPriceDisplay(result3, recurring, hasMetered, locale)
+        priceDisplay: formatPriceDisplay(
+          { amount: result3.amount, then: thenDisplay3, actualAmount: result3.actualAmount, showThen: result3.showThen },
+          recurring,
+          hasMetered,
+          locale
+        )
       };
     }
     if (trialResult.count > 0) {
+      const thenDisplay3 = formatMeteredThen(subscription2, recurring, hasMetered && Number(subscription2) === 0, locale);
+      const thenValue3 = formatThenValue(subscription2, recurring, hasMetered && Number(subscription2) === 0, locale);
       const result3 = {
         action: t("payment.checkout.try1", locale, { name }),
         amount: t("payment.checkout.free", locale, { count: trialResult.count, interval: trialResult.interval }),
-        then: formatMeteredThen(subscription2, recurring, hasMetered && Number(subscription2) === 0, locale),
+        then: thenDisplay3,
+        thenValue: thenValue3,
         showThen: true,
         actualAmount: "0"
       };
       return {
         ...result3,
-        priceDisplay: formatPriceDisplay(result3, recurring, hasMetered, locale)
+        priceDisplay: formatPriceDisplay(
+          { amount: result3.amount, then: thenDisplay3, actualAmount: result3.actualAmount, showThen: result3.showThen },
+          recurring,
+          hasMetered,
+          locale
+        )
       };
     }
+    const thenDisplay2 = hasMetered ? t("payment.checkout.meteredThen", locale, { recurring }) : recurring;
+    const thenValue2 = hasMetered ? t("payment.checkout.metered", locale, { recurring }) : recurring;
     const result2 = {
       action: t("payment.checkout.sub1", locale, { name }),
       amount,
-      then: hasMetered ? t("payment.checkout.meteredThen", locale, { recurring }) : recurring,
+      then: thenDisplay2,
+      thenValue: thenValue2,
       showThen: hasMetered && !differentRecurring,
       actualAmount
     };
     return {
       ...result2,
-      priceDisplay: formatPriceDisplay(result2, recurring, hasMetered, locale)
+      priceDisplay: formatPriceDisplay(
+        { amount: result2.amount, then: thenDisplay2, actualAmount: result2.actualAmount, showThen: result2.showThen },
+        recurring,
+        hasMetered,
+        locale
+      )
     };
   }
   const subscription = fromUnitToToken(
-    items.filter((x) => x.price.type === "recurring").reduce((acc, x) => {
-      if (x.price.recurring?.usage_type === "metered") {
+    items.filter((x) => x.price?.type === "recurring").reduce((acc, x) => {
+      if (x.price?.recurring?.usage_type === "metered") {
         return acc;
       }
-      return acc.add(new BN(getPriceUintAmountByCurrency(x.price, currency)).mul(new BN(x.quantity)));
+      return acc.add(getLineItemAmounts(x, currency, { useUpsell: false, exchangeRate }).totalAmount);
     }, new BN(0)),
     currency.decimal
   );
+  const thenDisplay = formatMeteredThen(
+    `${subscription} ${currency.symbol}`,
+    recurring,
+    hasMetered && Number(subscription) === 0,
+    locale
+  );
+  const thenValue = formatThenValue(
+    `${subscription} ${currency.symbol}`,
+    recurring,
+    hasMetered && Number(subscription) === 0,
+    locale
+  );
   const result = {
     action: t("payment.checkout.pay", locale, { payee: brand }),
     amount,
-    then: formatMeteredThen(
-      `${subscription} ${currency.symbol}`,
-      recurring,
-      hasMetered && Number(subscription) === 0,
-      locale
-    ),
+    then: thenDisplay,
+    thenValue,
     showThen: !differentRecurring,
     actualAmount
   };
   return {
     ...result,
-    priceDisplay: formatPriceDisplay(result, recurring, hasMetered, locale)
+    priceDisplay: formatPriceDisplay(
+      { amount: result.amount, then: thenDisplay, actualAmount: result.actualAmount, showThen: result.showThen },
+      recurring,
+      hasMetered,
+      locale
+    )
   };
 }
-export function formatAmount(amount, decimals) {
-  return fromUnitToToken(amount, decimals);
+export function formatAmount(amount, decimals, precision = 2) {
+  const tokenAmount = fromUnitToToken(amount, decimals);
+  const numericValue = Number(tokenAmount);
+  if (!Number.isFinite(numericValue)) {
+    return formatBNStr(amount, decimals, precision, true, false);
+  }
+  const abs = Math.abs(numericValue);
+  const targetPrecision = abs > 0 && abs < 0.01 ? decimals : 2;
+  return formatNumber(tokenAmount, targetPrecision, true, false);
 }
 export function findCurrency(methods, currencyId) {
   for (const method of methods) {
@@ -1063,7 +1351,7 @@ export function showStaking(method, currency, noStake) {
   if (noStake) {
     return false;
   }
-  if (method.type === "arcblock") {
+  if (method && method.type === "arcblock") {
     return currency.type !== "credit";
   }
   return false;