@lightsparkdev/core 1.0.5 → 1.0.6

package/dist/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  CurrencyUnit: () => CurrencyUnit,
   DefaultCrypto: () => DefaultCrypto,
   KeyOrAlias: () => KeyOrAlias,
   LightsparkAuthException: () => LightsparkAuthException_default,
@@ -44,22 +45,38 @@ __export(src_exports, {
   SigningKey: () => SigningKey,
   SigningKeyType: () => SigningKeyType,
   StubAuthProvider: () => StubAuthProvider,
+  abbrCurrencyUnit: () => abbrCurrencyUnit,
   apiDomainForEnvironment: () => apiDomainForEnvironment,
   b64decode: () => b64decode,
   b64encode: () => b64encode,
   bytesToHex: () => bytesToHex,
+  clamp: () => clamp,
   convertCurrencyAmount: () => convertCurrencyAmount,
+  convertCurrencyAmountValue: () => convertCurrencyAmountValue,
+  countryCodesToCurrencyCodes: () => countryCodesToCurrencyCodes,
   createSha256Hash: () => createSha256Hash,
+  defaultCurrencyCode: () => defaultCurrencyCode,
+  formatCurrencyStr: () => formatCurrencyStr,
+  getCurrentLocale: () => getCurrentLocale,
   getErrorMsg: () => getErrorMsg,
   hexToBytes: () => hexToBytes,
   isBrowser: () => isBrowser,
+  isCurrencyAmount: () => isCurrencyAmount,
+  isCurrencyAmountObj: () => isCurrencyAmountObj,
+  isCurrencyMap: () => isCurrencyMap,
   isError: () => isError,
   isErrorMsg: () => isErrorMsg,
   isErrorWithMessage: () => isErrorWithMessage,
   isNode: () => isNode,
+  isNumber: () => isNumber,
   isTest: () => isTest,
   isType: () => isType,
+  linearInterpolate: () => linearInterpolate,
+  localeToCurrencyCode: () => localeToCurrencyCode,
+  localeToCurrencySymbol: () => localeToCurrencySymbol,
+  mapCurrencyAmount: () => mapCurrencyAmount,
   pollUntil: () => pollUntil,
+  round: () => round,
   sleep: () => sleep,
   urlsafe_b64decode: () => urlsafe_b64decode
 });
@@ -407,7 +424,314 @@ async function createSha256Hash(data, asHex) {
   }
 }
 
+// src/utils/locale.ts
+function getCurrentLocale() {
+  return Intl.NumberFormat().resolvedOptions().locale;
+}
+
+// src/utils/localeToCurrencyCodes.ts
+var countryCodesToCurrencyCodes = {
+  AD: "EUR",
+  // AE: "AED",
+  // AF: "AFN",
+  // AG: "XCD",
+  // AI: "XCD",
+  // AL: "ALL",
+  // AM: "AMD",
+  // AO: "AOA",
+  AR: "ARS",
+  AS: "USD",
+  AT: "EUR",
+  AU: "AUD",
+  // AW: "AWG",
+  AX: "EUR",
+  // AZ: "AZN",
+  // BA: "BAM",
+  // BB: "BBD",
+  // BD: "BDT",
+  BE: "EUR",
+  // BF: "XOF",
+  // BG: "BGN",
+  // BH: "BHD",
+  // BI: "BIF",
+  // BJ: "XOF",
+  BL: "EUR",
+  // BM: "BMD",
+  // BN: "BND",
+  // BO: "BOB",
+  BQ: "USD",
+  BR: "BRL",
+  // BS: "BSD",
+  // BT: "BTN",
+  // BV: "NOK",
+  // BW: "BWP",
+  // BY: "BYN",
+  // BZ: "BZD",
+  CA: "CAD",
+  // CC: "AUD",
+  // CD: "CDF",
+  // CF: "XAF",
+  // CG: "XAF",
+  // CH: "CHF",
+  // CI: "XOF",
+  // CK: "NZD",
+  // CL: "CLP",
+  // CM: "XAF",
+  // CN: "CNY",
+  CO: "COP",
+  // CR: "CRC",
+  // CU: "CUP",
+  // CV: "CVE",
+  // CW: "ANG",
+  // CX: "AUD",
+  CY: "EUR",
+  // CZ: "CZK",
+  DE: "EUR",
+  // DJ: "DJF",
+  // DK: "DKK",
+  // DM: "XCD",
+  // DO: "DOP",
+  // DZ: "DZD",
+  EC: "USD",
+  EE: "EUR",
+  // EG: "EGP",
+  // EH: "MAD",
+  // ER: "ERN",
+  ES: "EUR",
+  // ET: "ETB",
+  FI: "EUR",
+  // FJ: "FJD",
+  // FK: "FKP",
+  FM: "USD",
+  // FO: "DKK",
+  FR: "EUR",
+  // GA: "XAF",
+  GB: "GBP",
+  // GD: "XCD",
+  // GE: "GEL",
+  GF: "EUR",
+  GG: "GBP",
+  // GH: "GHS",
+  // GI: "GIP",
+  // GL: "DKK",
+  // GM: "GMD",
+  // GN: "GNF",
+  GP: "EUR",
+  // GQ: "XAF",
+  GR: "EUR",
+  GS: "GBP",
+  // GT: "GTQ",
+  GU: "USD",
+  // GW: "XOF",
+  // GY: "GYD",
+  // HK: "HKD",
+  // HM: "AUD",
+  // HN: "HNL",
+  // HR: "HRK",
+  // HT: "HTG",
+  // HU: "HUF",
+  // ID: "IDR",
+  IE: "EUR",
+  // IL: "ILS",
+  IM: "GBP",
+  IN: "INR",
+  IO: "USD",
+  // IQ: "IQD",
+  // IR: "IRR",
+  // IS: "ISK",
+  IT: "EUR",
+  JE: "GBP",
+  // JM: "JMD",
+  // JO: "JOD",
+  // JP: "JPY",
+  // KE: "KES",
+  // KG: "KGS",
+  // KH: "KHR",
+  // KI: "AUD",
+  // KM: "KMF",
+  // KN: "XCD",
+  // KP: "KPW",
+  // KR: "KRW",
+  // KW: "KWD",
+  // KY: "KYD",
+  // KZ: "KZT",
+  // LA: "LAK",
+  // LB: "LBP",
+  // LC: "XCD",
+  // LI: "CHF",
+  // LK: "LKR",
+  // LR: "LRD",
+  // LS: "LSL",
+  LT: "EUR",
+  LU: "EUR",
+  LV: "EUR",
+  // LY: "LYD",
+  // MA: "MAD",
+  MC: "EUR",
+  // MD: "MDL",
+  ME: "EUR",
+  MF: "EUR",
+  // MG: "MGA",
+  MH: "USD",
+  // MK: "MKD",
+  // ML: "XOF",
+  // MM: "MMK",
+  // MN: "MNT",
+  // MO: "MOP",
+  MP: "USD",
+  MQ: "EUR",
+  // MR: "MRO",
+  // MS: "XCD",
+  MT: "EUR",
+  // MU: "MUR",
+  // MV: "MVR",
+  // MW: "MWK",
+  MX: "MXN",
+  // MY: "MYR",
+  // MZ: "MZN",
+  // NA: "NAD",
+  // NC: "XPF",
+  // NE: "XOF",
+  NF: "AUD",
+  // NG: "NGN",
+  // NI: "NIO",
+  NL: "EUR",
+  // NO: "NOK",
+  // NP: "NPR",
+  NR: "AUD",
+  // NU: "NZD",
+  // NZ: "NZD",
+  // OM: "OMR",
+  // PA: "PAB",
+  // PE: "PEN",
+  // PF: "XPF",
+  // PG: "PGK",
+  // PH: "PHP",
+  // PK: "PKR",
+  // PL: "PLN",
+  PM: "EUR",
+  // PN: "NZD",
+  PR: "USD",
+  // PS: "ILS",
+  PT: "EUR",
+  PW: "USD",
+  // PY: "PYG",
+  // QA: "QAR",
+  RE: "EUR",
+  // RO: "RON",
+  // RS: "RSD",
+  // RU: "RUB",
+  // RW: "RWF",
+  // SA: "SAR",
+  // SB: "SBD",
+  // SC: "SCR",
+  // SD: "SDG",
+  // SE: "SEK",
+  // SG: "SGD",
+  // SH: "SHP",
+  SI: "EUR",
+  // SJ: "NOK",
+  SK: "EUR",
+  // SL: "SLL",
+  SM: "EUR",
+  // SN: "XOF",
+  // SO: "SOS",
+  // SR: "SRD",
+  // ST: "STD",
+  // SV: "SVC",
+  // SX: "ANG",
+  // SY: "SYP",
+  // SZ: "SZL",
+  TC: "USD",
+  // TD: "XAF",
+  TF: "EUR",
+  // TG: "XOF",
+  // TH: "THB",
+  // TJ: "TJS",
+  // TK: "NZD",
+  TL: "USD",
+  // TM: "TMT",
+  // TN: "TND",
+  // TO: "TOP",
+  // TR: "TRY",
+  // TT: "TTD",
+  TV: "AUD",
+  // TW: "TWD",
+  // TZ: "TZS",
+  // UA: "UAH",
+  // UG: "UGX",
+  UM: "USD",
+  US: "USD",
+  // UY: "UYU",
+  // UZ: "UZS",
+  VA: "EUR",
+  // VC: "XCD",
+  // VE: "VEF",
+  VG: "USD",
+  VI: "USD",
+  // VN: "VND",
+  // VU: "VUV",
+  // WF: "XPF",
+  // WS: "WST",
+  // YE: "YER",
+  YT: "EUR"
+  // ZA: "ZAR",
+  // ZM: "ZMW",
+  // ZW: "ZWL",
+};
+function getCountryCode(localeString) {
+  let components = localeString.split("_");
+  if (components.length === 2) {
+    return components.pop();
+  }
+  components = localeString.split("-");
+  if (components.length === 2) {
+    return components.pop();
+  }
+  return localeString;
+}
+function localeToCurrencyCode(locale) {
+  const countryCode = getCountryCode(locale);
+  return countryCodesToCurrencyCodes[countryCode];
+}
+
+// src/utils/numbers.ts
+function clamp(val, min, max) {
+  return val > max ? max : val < min ? min : val;
+}
+function linearInterpolate(value, fromRangeStart, fromRangeEnd, toRangeStart, toRangeEnd) {
+  const fromRangeMax = fromRangeEnd - fromRangeStart;
+  const fromRangeVal = value - fromRangeStart;
+  const toRangeMax = toRangeEnd - toRangeStart;
+  const val = fromRangeVal / fromRangeMax * toRangeMax + toRangeStart;
+  return clamp(
+    val,
+    Math.min(toRangeStart, toRangeEnd),
+    Math.max(toRangeStart, toRangeEnd)
+  );
+}
+function round(num, decimalPlaces = 0) {
+  const p = Math.pow(10, decimalPlaces);
+  const n = num * p * (1 + Number.EPSILON);
+  return Math.round(n) / p;
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+
 // src/utils/currency.ts
+var defaultCurrencyCode = "USD";
+var CurrencyUnit = /* @__PURE__ */ ((CurrencyUnit2) => {
+  CurrencyUnit2["FUTURE_VALUE"] = "FUTURE_VALUE";
+  CurrencyUnit2["BITCOIN"] = "BITCOIN";
+  CurrencyUnit2["SATOSHI"] = "SATOSHI";
+  CurrencyUnit2["MILLISATOSHI"] = "MILLISATOSHI";
+  CurrencyUnit2["USD"] = "USD";
+  CurrencyUnit2["NANOBITCOIN"] = "NANOBITCOIN";
+  CurrencyUnit2["MICROBITCOIN"] = "MICROBITCOIN";
+  CurrencyUnit2["MILLIBITCOIN"] = "MILLIBITCOIN";
+  return CurrencyUnit2;
+})(CurrencyUnit || {});
 var CONVERSION_MAP = {
   ["BITCOIN" /* BITCOIN */]: {
     ["BITCOIN" /* BITCOIN */]: (v) => v,
@@ -415,67 +739,298 @@ var CONVERSION_MAP = {
     ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => v * 1e3,
     ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 1e11,
     ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v * 1e9,
-    ["SATOSHI" /* SATOSHI */]: (v) => v * 1e8
+    ["SATOSHI" /* SATOSHI */]: (v) => v * 1e8,
+    ["USD" /* USD */]: (v, centsPerBtc = 1) => (
+      /* Round without decimals since we're returning cents: */
+      round(v * centsPerBtc, 2)
+    )
   },
   ["MICROBITCOIN" /* MICROBITCOIN */]: {
-    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e6),
+    ["BITCOIN" /* BITCOIN */]: (v) => v / 1e6,
     ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => v,
-    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => Math.round(v / 1e3),
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => v / 1e3,
     ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 1e5,
     ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v * 1e3,
-    ["SATOSHI" /* SATOSHI */]: (v) => v * 100
+    ["SATOSHI" /* SATOSHI */]: (v) => v * 100,
+    ["USD" /* USD */]: (v, centsPerBtc = 1) => (
+      /* Round without decimals since we're returning cents: */
+      round(v / 1e6 * centsPerBtc)
+    )
   },
   ["MILLIBITCOIN" /* MILLIBITCOIN */]: {
-    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e3),
+    ["BITCOIN" /* BITCOIN */]: (v) => v / 1e3,
     ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => v * 1e3,
     ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => v,
     ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 1e8,
     ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v * 1e6,
-    ["SATOSHI" /* SATOSHI */]: (v) => v * 1e5
+    ["SATOSHI" /* SATOSHI */]: (v) => v * 1e5,
+    ["USD" /* USD */]: (v, centsPerBtc = 1) => (
+      /* Round without decimals since we're returning cents: */
+      round(v / 1e3 * centsPerBtc)
+    )
   },
   ["MILLISATOSHI" /* MILLISATOSHI */]: {
-    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e11),
-    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => Math.round(v / 1e5),
-    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => Math.round(v / 1e8),
+    ["BITCOIN" /* BITCOIN */]: (v) => v / 1e11,
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => v / 1e5,
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => v / 1e8,
     ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v,
-    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => Math.round(v / 100),
-    ["SATOSHI" /* SATOSHI */]: (v) => Math.round(v / 1e3)
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v / 100,
+    ["SATOSHI" /* SATOSHI */]: (v) => v / 1e3,
+    ["USD" /* USD */]: (v, centsPerBtc = 1) => (
+      /* Round without decimals since we're returning cents: */
+      round(v / 1e11 * centsPerBtc)
+    )
   },
   ["NANOBITCOIN" /* NANOBITCOIN */]: {
-    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e9),
-    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => Math.round(v / 1e3),
-    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => Math.round(v / 1e6),
+    ["BITCOIN" /* BITCOIN */]: (v) => v / 1e9,
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => v / 1e3,
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => v / 1e6,
     ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 100,
     ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v,
-    ["SATOSHI" /* SATOSHI */]: (v) => Math.round(v / 10)
+    ["SATOSHI" /* SATOSHI */]: (v) => v / 10,
+    ["USD" /* USD */]: (v, centsPerBtc = 1) => (
+      /* Round without decimals since we're returning cents: */
+      round(v / 1e9 * centsPerBtc)
+    )
   },
   ["SATOSHI" /* SATOSHI */]: {
-    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e8),
-    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => Math.round(v / 100),
-    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => Math.round(v / 1e5),
+    ["BITCOIN" /* BITCOIN */]: (v) => v / 1e8,
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => v / 100,
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => v / 1e5,
     ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 1e3,
     ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v * 10,
-    ["SATOSHI" /* SATOSHI */]: (v) => v
+    ["SATOSHI" /* SATOSHI */]: (v) => v,
+    ["USD" /* USD */]: (v, centsPerBtc = 1) => (
+      /* Round without decimals since we're returning cents: */
+      round(v / 1e8 * centsPerBtc)
+    )
+  },
+  ["USD" /* USD */]: {
+    ["BITCOIN" /* BITCOIN */]: (v, centsPerBtc = 1) => v / centsPerBtc,
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v, centsPerBtc = 1) => v / centsPerBtc * 1e6,
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v, centsPerBtc = 1) => v / centsPerBtc * 1e3,
+    ["MILLISATOSHI" /* MILLISATOSHI */]: (v, centsPerBtc = 1) => v / centsPerBtc * 1e11,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v, centsPerBtc = 1) => v / centsPerBtc * 1e9,
+    ["SATOSHI" /* SATOSHI */]: (v, centsPerBtc = 1) => v / centsPerBtc * 1e8,
+    ["USD" /* USD */]: (v) => v
   }
 };
-var convertCurrencyAmount = (from, toUnit) => {
-  if (from.originalUnit === "FUTURE_VALUE" /* FUTURE_VALUE */ || from.originalUnit === "USD" /* USD */ || toUnit === "FUTURE_VALUE" /* FUTURE_VALUE */ || toUnit === "USD" /* USD */) {
+function convertCurrencyAmountValue(fromUnit, toUnit, amount, centsPerBtc = 1) {
+  if (fromUnit === "FUTURE_VALUE" /* FUTURE_VALUE */ || toUnit === "FUTURE_VALUE" /* FUTURE_VALUE */) {
     throw new LightsparkException_default("CurrencyError", `Unsupported CurrencyUnit.`);
   }
-  const conversionFn = CONVERSION_MAP[from.originalUnit][toUnit];
+  if (fromUnit === toUnit) {
+    return amount;
+  }
+  const conversionFn = CONVERSION_MAP[fromUnit][toUnit];
   if (!conversionFn) {
     throw new LightsparkException_default(
       "CurrencyError",
-      `Cannot convert from ${from.originalUnit} to ${toUnit}`
+      `Cannot convert from ${fromUnit} to ${toUnit}`
     );
   }
+  return conversionFn(amount, centsPerBtc);
+}
+var convertCurrencyAmount = (from, toUnit) => {
+  const value = convertCurrencyAmountValue(
+    from.originalUnit,
+    toUnit,
+    from.originalValue
+  );
   return {
     ...from,
     preferredCurrencyUnit: toUnit,
-    preferredCurrencyValueApprox: conversionFn(from.originalValue),
-    preferredCurrencyValueRounded: conversionFn(from.originalValue)
+    preferredCurrencyValueApprox: value,
+    preferredCurrencyValueRounded: value
   };
 };
+function isCurrencyAmountObj(arg) {
+  return typeof arg === "object" && arg !== null && "value" in arg && "unit" in arg;
+}
+function isCurrencyAmount(arg) {
+  return typeof arg === "object" && arg !== null && "originalValue" in arg && "originalUnit" in arg && "preferredCurrencyUnit" in arg && "preferredCurrencyValueRounded" in arg && "preferredCurrencyValueApprox" in arg;
+}
+function asNumber(value) {
+  if (typeof value === "string") {
+    return Number(value);
+  }
+  return value || 0;
+}
+function getCurrencyAmount(currencyAmountArg) {
+  let value = 0;
+  let unit = void 0;
+  if (isCurrencyAmountObj(currencyAmountArg)) {
+    value = asNumber(currencyAmountArg.value);
+    unit = currencyAmountArg.unit;
+  } else if (isCurrencyAmount(currencyAmountArg)) {
+    value = currencyAmountArg.originalValue;
+    unit = currencyAmountArg.originalUnit;
+  }
+  return {
+    value: asNumber(value),
+    unit: unit || "SATOSHI" /* SATOSHI */
+  };
+}
+function mapCurrencyAmount(currencyAmountArg, centsPerBtc = 1) {
+  const { value, unit } = getCurrencyAmount(currencyAmountArg);
+  const convert = convertCurrencyAmountValue;
+  const sats = convert(unit, "SATOSHI" /* SATOSHI */, value, centsPerBtc);
+  const btc = convert(unit, "BITCOIN" /* BITCOIN */, value, centsPerBtc);
+  const msats = convert(unit, "MILLISATOSHI" /* MILLISATOSHI */, value, centsPerBtc);
+  const usd = convert(unit, "USD" /* USD */, value, centsPerBtc);
+  const mibtc = convert(unit, "MICROBITCOIN" /* MICROBITCOIN */, value, centsPerBtc);
+  const mlbtc = convert(unit, "MILLIBITCOIN" /* MILLIBITCOIN */, value, centsPerBtc);
+  const nbtc = convert(unit, "NANOBITCOIN" /* NANOBITCOIN */, value, centsPerBtc);
+  const mapWithCurrencyUnits = {
+    ["BITCOIN" /* BITCOIN */]: btc,
+    ["SATOSHI" /* SATOSHI */]: sats,
+    ["MILLISATOSHI" /* MILLISATOSHI */]: msats,
+    ["USD" /* USD */]: usd,
+    ["MICROBITCOIN" /* MICROBITCOIN */]: mibtc,
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: mlbtc,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: nbtc,
+    ["FUTURE_VALUE" /* FUTURE_VALUE */]: NaN,
+    formatted: {
+      ["BITCOIN" /* BITCOIN */]: formatCurrencyStr({
+        value: btc,
+        unit: "BITCOIN" /* BITCOIN */
+      }),
+      ["SATOSHI" /* SATOSHI */]: formatCurrencyStr({
+        value: sats,
+        unit: "SATOSHI" /* SATOSHI */
+      }),
+      ["MILLISATOSHI" /* MILLISATOSHI */]: formatCurrencyStr({
+        value: msats,
+        unit: "MILLISATOSHI" /* MILLISATOSHI */
+      }),
+      ["MICROBITCOIN" /* MICROBITCOIN */]: formatCurrencyStr({
+        value: mibtc,
+        unit: "MICROBITCOIN" /* MICROBITCOIN */
+      }),
+      ["MILLIBITCOIN" /* MILLIBITCOIN */]: formatCurrencyStr({
+        value: mlbtc,
+        unit: "MILLIBITCOIN" /* MILLIBITCOIN */
+      }),
+      ["NANOBITCOIN" /* NANOBITCOIN */]: formatCurrencyStr({
+        value: nbtc,
+        unit: "NANOBITCOIN" /* NANOBITCOIN */
+      }),
+      ["USD" /* USD */]: formatCurrencyStr({
+        value: usd,
+        unit: "USD" /* USD */
+      }),
+      ["FUTURE_VALUE" /* FUTURE_VALUE */]: "-"
+    }
+  };
+  return {
+    ...mapWithCurrencyUnits,
+    btc,
+    sats,
+    msats,
+    isZero: msats === 0,
+    isLessThan: (other) => {
+      if (isNumber(other)) {
+        return msats < other;
+      }
+      if (isCurrencyAmountObj(other)) {
+        other = mapCurrencyAmount(other);
+      }
+      return msats < other.msats;
+    },
+    isGreaterThan: (other) => {
+      if (isNumber(other)) {
+        return msats > other;
+      }
+      if (isCurrencyAmountObj(other)) {
+        other = mapCurrencyAmount(other);
+      }
+      return msats > other.msats;
+    },
+    isEqualTo: (other) => {
+      if (isNumber(other)) {
+        return msats === other;
+      }
+      if (isCurrencyAmountObj(other)) {
+        other = mapCurrencyAmount(other);
+      }
+      return msats === other.msats;
+    },
+    formatted: {
+      ...mapWithCurrencyUnits.formatted,
+      btc: mapWithCurrencyUnits.formatted["BITCOIN" /* BITCOIN */],
+      sats: mapWithCurrencyUnits.formatted["SATOSHI" /* SATOSHI */],
+      msats: mapWithCurrencyUnits.formatted["MILLISATOSHI" /* MILLISATOSHI */]
+    },
+    type: "CurrencyMap"
+  };
+}
+var isCurrencyMap = (currencyMap) => typeof currencyMap === "object" && currencyMap !== null && "type" in currencyMap && typeof currencyMap.type === "string" && currencyMap.type === "CurrencyMap";
+var abbrCurrencyUnit = (unit) => {
+  switch (unit) {
+    case "BITCOIN" /* BITCOIN */:
+      return "BTC";
+    case "SATOSHI" /* SATOSHI */:
+      return "SAT";
+    case "MILLISATOSHI" /* MILLISATOSHI */:
+      return "MSAT";
+    case "USD" /* USD */:
+      return "USD";
+  }
+  return "Unsupported CurrencyUnit";
+};
+function formatCurrencyStr(amount, maxFractionDigits, compact, showBtcSymbol = false, options = {}) {
+  const currencyAmount = getCurrencyAmount(amount);
+  let { value: num } = currencyAmount;
+  const { unit } = currencyAmount;
+  if (unit === "USD" /* USD */) {
+    num = num / 100;
+  }
+  function getDefaultMaxFractionDigits(defaultDigits) {
+    return typeof maxFractionDigits === "undefined" ? compact ? 1 : defaultDigits : maxFractionDigits;
+  }
+  const symbol = !showBtcSymbol ? "" : unit === "BITCOIN" /* BITCOIN */ ? "\uE903" : unit === "SATOSHI" /* SATOSHI */ ? "\uE902" : "";
+  const currentLocale = getCurrentLocale();
+  switch (unit) {
+    case "BITCOIN" /* BITCOIN */:
+      return `${symbol}${num.toLocaleString(currentLocale, {
+        notation: compact ? "compact" : void 0,
+        maximumFractionDigits: getDefaultMaxFractionDigits(4),
+        ...options
+      })}`;
+    case "MILLISATOSHI" /* MILLISATOSHI */:
+    case "SATOSHI" /* SATOSHI */:
+    case "MICROBITCOIN" /* MICROBITCOIN */:
+    case "MILLIBITCOIN" /* MILLIBITCOIN */:
+    case "NANOBITCOIN" /* NANOBITCOIN */:
+    default:
+      return `${symbol}${num.toLocaleString(currentLocale, {
+        notation: compact ? "compact" : void 0,
+        maximumFractionDigits: getDefaultMaxFractionDigits(0),
+        ...options
+      })}`;
+    case "USD" /* USD */:
+      return num.toLocaleString(currentLocale, {
+        style: "currency",
+        currency: defaultCurrencyCode,
+        notation: compact ? "compact" : void 0,
+        maximumFractionDigits: getDefaultMaxFractionDigits(2),
+        ...options
+      });
+  }
+}
+function localeToCurrencySymbol(locale) {
+  const currencyCode = localeToCurrencyCode(locale);
+  const formatted = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: currencyCode,
+    useGrouping: false,
+    // to avoid thousands separators
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0
+  }).format(0);
+  const symbol = formatted.replace(/[0-9\s\u00a0]/g, "");
+  return symbol;
+}
 
 // src/utils/errors.ts
 var isError = (e) => {
@@ -958,6 +1513,7 @@ var apiDomainForEnvironment = (environment) => {
 var ServerEnvironment_default = ServerEnvironment;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CurrencyUnit,
   DefaultCrypto,
   KeyOrAlias,
   LightsparkAuthException,
@@ -972,22 +1528,38 @@ var ServerEnvironment_default = ServerEnvironment;
   SigningKey,
   SigningKeyType,
   StubAuthProvider,
+  abbrCurrencyUnit,
   apiDomainForEnvironment,
   b64decode,
   b64encode,
   bytesToHex,
+  clamp,
   convertCurrencyAmount,
+  convertCurrencyAmountValue,
+  countryCodesToCurrencyCodes,
   createSha256Hash,
+  defaultCurrencyCode,
+  formatCurrencyStr,
+  getCurrentLocale,
   getErrorMsg,
   hexToBytes,
   isBrowser,
+  isCurrencyAmount,
+  isCurrencyAmountObj,
+  isCurrencyMap,
   isError,
   isErrorMsg,
   isErrorWithMessage,
   isNode,
+  isNumber,
   isTest,
   isType,
+  linearInterpolate,
+  localeToCurrencyCode,
+  localeToCurrencySymbol,
+  mapCurrencyAmount,
   pollUntil,
+  round,
   sleep,
   urlsafe_b64decode
 });