@lightsparkdev/core 1.0.21 → 1.1.0

package/src/requester/Requester.ts

@@ -137,7 +137,7 @@ class Requester {
       }
     }
     const operation = operationMatch[2];
-    let bodyData: BodyData = {
+    const payload: BodyData = {
       query: queryPayload,
       variables,
       operationName: operation,
@@ -149,16 +149,22 @@ class Requester {
       "Content-Type": "application/json",
       "X-Lightspark-SDK": sdkUserAgent,
       "User-Agent": browserUserAgent || sdkUserAgent,
+      "X-GraphQL-Operation": operation,
     };
-    const headers = skipAuth
+    const headers: { [key: string]: string } = skipAuth
       ? baseHeaders
       : await this.authProvider.addAuthHeaders(baseHeaders);
-    bodyData = await this.addSigningDataIfNeeded(
-      bodyData,
+    let bodyData = await this.addSigningDataIfNeeded(
+      payload,
       headers,
       signingNodeId,
     );
 
+    if (bodyData.length > 1024 && typeof CompressionStream != "undefined") {
+      bodyData = await compress(bodyData);
+      headers["Content-Encoding"] = "deflate";
+    }
+
     let urlWithProtocol = this.baseUrl;
     if (
       !urlWithProtocol.startsWith("https://") &&
@@ -177,7 +183,7 @@ class Requester {
     const response = await fetch(url, {
       method: "POST",
       headers: headers,
-      body: JSON.stringify(bodyData),
+      body: bodyData,
     });
     if (!response.ok) {
       throw new LightsparkException(
@@ -214,9 +220,16 @@ class Requester {
     headers: { [key: string]: string },
     signingNodeId: string | undefined,
     /* eslint-disable-next-line @typescript-eslint/no-explicit-any -- LIG-3400 */
-  ): Promise<BodyData> {
+  ): Promise<Uint8Array> {
+    let TextEncoderImpl;
+    if (typeof TextEncoder === "undefined") {
+      TextEncoderImpl = (await import("text-encoding")).TextEncoder;
+    } else {
+      TextEncoderImpl = TextEncoder;
+    }
+
     if (!signingNodeId) {
-      return queryPayload;
+      return new TextEncoderImpl().encode(JSON.stringify(queryPayload));
     }
 
     const query = queryPayload.query;
@@ -241,12 +254,6 @@ class Requester {
       );
     }
 
-    let TextEncoderImpl;
-    if (typeof TextEncoder === "undefined") {
-      TextEncoderImpl = (await import("text-encoding")).TextEncoder;
-    } else {
-      TextEncoderImpl = TextEncoder;
-    }
     const encodedPayload = new TextEncoderImpl().encode(
       JSON.stringify(payload),
     );
@@ -258,8 +265,22 @@ class Requester {
       v: "1",
       signature: encodedSignedPayload,
     });
-    return payload;
+    return encodedPayload;
+  }
+}
+
+async function compress(data: Uint8Array): Promise<Uint8Array> {
+  const stream = new Blob([data]).stream();
+  const compressedStream = stream.pipeThrough(new CompressionStream("deflate"));
+  const reader = compressedStream.getReader();
+  const chunks = [];
+  let done, value;
+  while (!done) {
+    ({ done, value } = await reader.read()); // eslint-disable-line @typescript-eslint/no-unsafe-assignment
+    chunks.push(value);
   }
+  const blob = new Blob(chunks);
+  return new Uint8Array(await blob.arrayBuffer());
 }
 
 export default Requester;

package/src/utils/currency.ts

@@ -7,75 +7,35 @@ import { isNumber, round } from "./numbers.js";
 
 export const defaultCurrencyCode = "USD";
 
-/**
- * This enum identifies the unit of currency associated with a CurrencyAmount.
- * *
- */
-export enum CurrencyUnit {
-  /**
-   * This is an enum value that represents values that could be added in the
-   * future. Clients should support unknown values as more of them could be
-   * added without notice.
-   */
-  FUTURE_VALUE = "FUTURE_VALUE",
-  /**
-   * Bitcoin is the cryptocurrency native to the Bitcoin network.
-   * It is used as the native medium for value transfer for the Lightning
-   * Network. *
-   */
-  BITCOIN = "BITCOIN",
-  /**
-   * 0.00000001 (10e-8) Bitcoin or one hundred millionth of a Bitcoin.
-   * This is the unit most commonly used in Lightning transactions.
-   * *
-   */
-  SATOSHI = "SATOSHI",
-  /**
-   * 0.001 Satoshi, or 10e-11 Bitcoin. We recommend using the Satoshi unit
-   * instead when possible. *
-   */
-  MILLISATOSHI = "MILLISATOSHI",
-  /** United States Dollar. **/
-  USD = "USD",
-  /**
-   * 0.000000001 (10e-9) Bitcoin or a billionth of a Bitcoin.
-   * We recommend using the Satoshi unit instead when possible.
-   * *
-   */
-  NANOBITCOIN = "NANOBITCOIN",
-  /**
-   * 0.000001 (10e-6) Bitcoin or a millionth of a Bitcoin.
-   * We recommend using the Satoshi unit instead when possible.
-   * *
-   */
-  MICROBITCOIN = "MICROBITCOIN",
-  /**
-   * 0.001 (10e-3) Bitcoin or a thousandth of a Bitcoin.
-   * We recommend using the Satoshi unit instead when possible.
-   * *
-   */
-  MILLIBITCOIN = "MILLIBITCOIN",
-}
-
-/** This object represents the value and unit for an amount of currency. **/
-export type CurrencyAmountType = {
-  /** The original numeric value for this CurrencyAmount. **/
+/* This const identifies the unit of currency associated with a CurrencyAmount as created by the SDK
+ * writer and used in JS SDKs. The schema version uses camel case for the keys so we convert
+ * arguments of that type to this format for use in the functions below. */
+export const CurrencyUnit = {
+  FUTURE_VALUE: "FUTURE_VALUE",
+  BITCOIN: "BITCOIN",
+  SATOSHI: "SATOSHI",
+  MILLISATOSHI: "MILLISATOSHI",
+  USD: "USD",
+  NANOBITCOIN: "NANOBITCOIN",
+  MICROBITCOIN: "MICROBITCOIN",
+  MILLIBITCOIN: "MILLIBITCOIN",
+
+  Bitcoin: "BITCOIN",
+  Microbitcoin: "MICROBITCOIN",
+  Millibitcoin: "MILLIBITCOIN",
+  Millisatoshi: "MILLISATOSHI",
+  Nanobitcoin: "NANOBITCOIN",
+  Satoshi: "SATOSHI",
+  Usd: "USD",
+} as const;
+
+export type CurrencyUnitType = (typeof CurrencyUnit)[keyof typeof CurrencyUnit];
+
+export type SDKCurrencyAmountType = {
   originalValue: number;
-  /** The original unit of currency for this CurrencyAmount. **/
-  originalUnit: CurrencyUnit;
-  /** The unit of user's preferred currency. **/
-  preferredCurrencyUnit: CurrencyUnit;
-  /**
-   * The rounded numeric value for this CurrencyAmount in the very base level
-   * of user's preferred currency. For example, for USD, the value will be in
-   * cents.
-   **/
+  originalUnit: CurrencyUnitType;
+  preferredCurrencyUnit: CurrencyUnitType;
   preferredCurrencyValueRounded: number;
-  /**
-   * The approximate float value for this CurrencyAmount in the very base level
-   * of user's preferred currency. For example, for USD, the value will be in
-   * cents.
-   **/
   preferredCurrencyValueApprox: number;
 };
 
@@ -163,8 +123,8 @@ const CONVERSION_MAP = {
 };
 
 export function convertCurrencyAmountValue(
-  fromUnit: CurrencyUnit,
-  toUnit: CurrencyUnit,
+  fromUnit: CurrencyUnitType,
+  toUnit: CurrencyUnitType,
   amount: number,
   centsPerBtc = 1,
 ): number {
@@ -191,9 +151,9 @@ export function convertCurrencyAmountValue(
 }
 
 export const convertCurrencyAmount = (
-  from: CurrencyAmountType,
-  toUnit: CurrencyUnit,
-): CurrencyAmountType => {
+  from: SDKCurrencyAmountType,
+  toUnit: CurrencyUnitType,
+): SDKCurrencyAmountType => {
   const value = convertCurrencyAmountValue(
     from.originalUnit,
     toUnit,
@@ -240,21 +200,17 @@ export type CurrencyMap = {
 };
 
 export type CurrencyAmountObj = {
-  /*
-   * Technically the generated graphql schema has value as `any` but it's
-   * always a number.
-   * We are intentionally widening the type here to allow for more forgiving
-   * input:
-   */
+  /* Technically the generated graphql schema has value as `any` but it's always a number.
+   * We are intentionally widening the type here to allow for more forgiving input: */
   value?: number | string | null;
   /* assume satoshi if not provided */
-  unit?: CurrencyUnit;
-  __typename?: "CurrencyAmount";
+  unit?: CurrencyUnitType;
+  __typename?: "CurrencyAmount" | undefined;
 };
 
 export type CurrencyAmountArg =
   | CurrencyAmountObj
-  | CurrencyAmountType
+  | SDKCurrencyAmountType
   | undefined
   | null;
 
@@ -264,10 +220,13 @@ export function isCurrencyAmountObj(arg: unknown): arg is CurrencyAmountObj {
   );
 }
 
-export function isCurrencyAmount(arg: unknown): arg is CurrencyAmountType {
+export function isSDKCurrencyAmount(
+  arg: unknown,
+): arg is SDKCurrencyAmountType {
   return (
     typeof arg === "object" &&
     arg !== null &&
+    /* We can expect all SDK CurrencyAmount types to always have these exact properties: */
     "originalValue" in arg &&
     "originalUnit" in arg &&
     "preferredCurrencyUnit" in arg &&
@@ -275,7 +234,6 @@ export function isCurrencyAmount(arg: unknown): arg is CurrencyAmountType {
     "preferredCurrencyValueApprox" in arg
   );
 }
-
 function asNumber(value: string | number | null | undefined) {
   if (typeof value === "string") {
     return Number(value);
@@ -287,12 +245,12 @@ function getCurrencyAmount(currencyAmountArg: CurrencyAmountArg) {
   let value = 0;
   let unit = undefined;
 
-  if (isCurrencyAmountObj(currencyAmountArg)) {
-    value = asNumber(currencyAmountArg.value);
-    unit = currencyAmountArg.unit;
-  } else if (isCurrencyAmount(currencyAmountArg)) {
+  if (isSDKCurrencyAmount(currencyAmountArg)) {
     value = currencyAmountArg.originalValue;
     unit = currencyAmountArg.originalUnit;
+  } else if (isCurrencyAmountObj(currencyAmountArg)) {
+    value = asNumber(currencyAmountArg.value);
+    unit = currencyAmountArg.unit;
   }
 
   return {
@@ -410,7 +368,7 @@ export const isCurrencyMap = (
   typeof currencyMap.type === "string" &&
   currencyMap.type === "CurrencyMap";
 
-export const abbrCurrencyUnit = (unit: CurrencyUnit) => {
+export const abbrCurrencyUnit = (unit: CurrencyUnitType) => {
   switch (unit) {
     case CurrencyUnit.BITCOIN:
       return "BTC";
@@ -424,35 +382,54 @@ export const abbrCurrencyUnit = (unit: CurrencyUnit) => {
   return "Unsupported CurrencyUnit";
 };
 
+const defaultOptions = {
+  /* undefined indicates to use default precision for unit defined below */
+  precision: undefined,
+  compact: false,
+  showBtcSymbol: false,
+};
+
+type FormatCurrencyStrOptions = {
+  /* undefined indicates to use default precision for unit defined below */
+  precision?: number | "full" | undefined;
+  compact?: boolean | undefined;
+  showBtcSymbol?: boolean | undefined;
+};
+
 export function formatCurrencyStr(
   amount: CurrencyAmountArg,
-  maxFractionDigits?: number,
-  compact?: boolean,
-  showBtcSymbol = false,
-  options: Intl.NumberFormatOptions = {},
+  options?: FormatCurrencyStrOptions,
 ) {
+  const { precision, compact, showBtcSymbol } = {
+    ...defaultOptions,
+    ...options,
+  };
+
   const currencyAmount = getCurrencyAmount(amount);
   let { value: num } = currencyAmount;
   const { unit } = currencyAmount;
 
-  /**
-   * Currencies should always be represented in the smallest unit, e.g.
-   * cents for USD:
-   */
+  /* Currencies should always be represented in the smallest unit, e.g. cents for USD: */
   if (unit === CurrencyUnit.USD) {
     num = num / 100;
   }
 
-  function getDefaultMaxFractionDigits(defaultDigits: number) {
-    return typeof maxFractionDigits === "undefined"
-      ? compact
-        ? 1
-        : defaultDigits
-      : maxFractionDigits;
+  function getDefaultMaxFractionDigits(
+    defaultDigits: number,
+    fullPrecisionDigits: number,
+  ) {
+    let digits = defaultDigits;
+    if (precision === "full") {
+      digits = fullPrecisionDigits;
+    } else if (typeof precision === "number") {
+      digits = precision;
+    } else if (compact) {
+      digits = 1;
+    }
+    return digits;
   }
 
-  // Symbol handled by toLocaleString for USD.
-  // These rely on the LightsparkIcons font
+  /* Symbol handled by toLocaleString for USD. These rely on the LightsparkIcons font: */
   const symbol = !showBtcSymbol
     ? ""
     : unit === CurrencyUnit.BITCOIN
@@ -465,35 +442,41 @@ export function formatCurrencyStr(
 
   switch (unit) {
     case CurrencyUnit.BITCOIN:
+      /* In most cases product prefers 4 precision digtis for BTC. In a few places
+         full precision (8 digits) are preferred, e.g. for a transaction details page: */
       return `${symbol}${num.toLocaleString(currentLocale, {
         notation: compact ? ("compact" as const) : undefined,
-        maximumFractionDigits: getDefaultMaxFractionDigits(4),
-        ...options,
+        maximumFractionDigits: getDefaultMaxFractionDigits(4, 8),
       })}`;
-    case CurrencyUnit.MILLISATOSHI:
     case CurrencyUnit.SATOSHI:
+      /* In most cases product prefers hiding sub sat precision (msats). In a few
+         places full precision (3 digits) are preferred, e.g. for Lightning fees
+         paid on a transaction details page: */
+      return `${symbol}${num.toLocaleString(currentLocale, {
+        notation: compact ? ("compact" as const) : undefined,
+        maximumFractionDigits: getDefaultMaxFractionDigits(0, 3),
+      })}`;
+    case CurrencyUnit.MILLISATOSHI:
     case CurrencyUnit.MICROBITCOIN:
     case CurrencyUnit.MILLIBITCOIN:
     case CurrencyUnit.NANOBITCOIN:
     default:
       return `${symbol}${num.toLocaleString(currentLocale, {
         notation: compact ? ("compact" as const) : undefined,
-        maximumFractionDigits: getDefaultMaxFractionDigits(0),
-        ...options,
+        maximumFractionDigits: getDefaultMaxFractionDigits(0, 0),
       })}`;
     case CurrencyUnit.USD:
       return num.toLocaleString(currentLocale, {
         style: "currency",
         currency: defaultCurrencyCode,
         notation: compact ? ("compact" as const) : undefined,
-        maximumFractionDigits: getDefaultMaxFractionDigits(2),
-        ...options,
+        maximumFractionDigits: getDefaultMaxFractionDigits(2, 2),
       });
   }
 }
 
 export function separateCurrencyStrParts(currencyStr: string) {
-  // split the currency string into the symbol and the amount
+  /* split the currency string into the symbol and the amount */
   const symbol = currencyStr.replace(/[0-9\s\u00a0.,]/g, "");
   const amount = currencyStr.replace(/[^\d.,-]/g, "");
   return { symbol, amount };
@@ -509,8 +492,7 @@ export function localeToCurrencySymbol(locale: string) {
     maximumFractionDigits: 0,
   }).format(0);
 
-  // Remove numeric and non-breaking space characters to extract the currency
-  // symbol
+  /* Remove numeric and non-breaking space characters to extract the currency symbol */
   const { symbol } = separateCurrencyStrParts(formatted);
   return symbol;
 }

package/src/utils/types.ts

@@ -39,3 +39,9 @@ export function notNullUndefined<TValue>(
 ): value is TValue {
   return value !== null && value !== undefined;
 }
+
+/* Make specific properties on object optional: */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+/* Opposite of Partial - make all keys required with NonNullable values */
+export type Complete<T> = { [P in keyof T]-?: NonNullable<T[P]> };