@lightsparkdev/core 1.0.3 → 1.0.5

package/dist/utils/index.d.ts

@@ -0,0 +1,90 @@
+declare const b64decode: (encoded: string) => Uint8Array;
+declare const urlsafe_b64decode: (encoded: string) => Uint8Array;
+declare const b64encode: (data: ArrayBuffer) => string;
+
+type SourceData = Uint8Array | string;
+declare function createSha256Hash(data: SourceData): Promise<Uint8Array>;
+declare function createSha256Hash(data: SourceData, asHex: true): Promise<string>;
+
+/** Represents the value and unit for an amount of currency. **/
+type CurrencyAmount = {
+    /** The original numeric value for this CurrencyAmount. **/
+    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.
+     **/
+    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;
+};
+declare 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"
+}
+declare const convertCurrencyAmount: (from: CurrencyAmount, toUnit: CurrencyUnit) => CurrencyAmount;
+
+declare const isBrowser: boolean;
+declare const isNode: boolean;
+declare const isTest: boolean;
+
+declare const isError: (e: unknown) => e is Error;
+type ErrorWithMessage = {
+    message: string;
+};
+declare const isErrorWithMessage: (e: unknown) => e is ErrorWithMessage;
+declare const getErrorMsg: (e: unknown) => string;
+declare const isErrorMsg: (e: unknown, msg: string) => boolean;
+
+declare const bytesToHex: (bytes: Uint8Array) => string;
+declare const hexToBytes: (hex: string) => Uint8Array;
+
+declare function pollUntil<D extends () => Promise<unknown>, T>(asyncFn: D, getValue: (data: Awaited<ReturnType<D>>, response: {
+    stopPolling: boolean;
+    value: null | T;
+}) => {
+    stopPolling: boolean;
+    value: null | T;
+}, maxPolls?: number, pollIntervalMs?: number, ignoreErrors?: boolean | ((e: unknown) => boolean), getMaxPollsError?: (maxPolls: number) => Error): Promise<T>;
+
+declare function sleep(ms: number): Promise<unknown>;
+
+type Maybe<T> = T | null | undefined;
+type ExpandRecursively<T> = T extends object ? T extends infer O ? {
+    [K in keyof O]: ExpandRecursively<O[K]>;
+} : never : T;
+type ById<T> = {
+    [id: string]: T;
+};
+type OmitTypename<T> = Omit<T, "__typename">;
+declare const isType: <T extends string>(typename: T) => <N extends {
+    __typename: string;
+}>(node: N | null | undefined) => node is Extract<N, {
+    __typename: T;
+}>;
+
+export { ById, ExpandRecursively, Maybe, OmitTypename, b64decode, b64encode, bytesToHex, convertCurrencyAmount, createSha256Hash, getErrorMsg, hexToBytes, isBrowser, isError, isErrorMsg, isErrorWithMessage, isNode, isTest, isType, pollUntil, sleep, urlsafe_b64decode };

package/dist/utils/index.js

@@ -0,0 +1,38 @@
+import {
+  b64decode,
+  b64encode,
+  bytesToHex,
+  convertCurrencyAmount,
+  createSha256Hash,
+  getErrorMsg,
+  hexToBytes,
+  isBrowser,
+  isError,
+  isErrorMsg,
+  isErrorWithMessage,
+  isNode,
+  isTest,
+  isType,
+  pollUntil,
+  sleep,
+  urlsafe_b64decode
+} from "../chunk-5P2KZ44N.js";
+export {
+  b64decode,
+  b64encode,
+  bytesToHex,
+  convertCurrencyAmount,
+  createSha256Hash,
+  getErrorMsg,
+  hexToBytes,
+  isBrowser,
+  isError,
+  isErrorMsg,
+  isErrorWithMessage,
+  isNode,
+  isTest,
+  isType,
+  pollUntil,
+  sleep,
+  urlsafe_b64decode
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightsparkdev/core",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Lightspark JS SDK",
   "author": "Lightspark Inc.",
   "keywords": [
@@ -33,6 +33,19 @@
         "types": "./dist/index.d.ts",
         "default": "./dist/index.cjs"
       }
+    },
+    "./utils": {
+      "types": "./dist/utils/index.d.ts",
+      "import": {
+        "types": "./dist/utils/index.d.ts",
+        "default": "./dist/utils/index.js"
+      },
+      "module": "./dist/utils/index.js",
+      "require": {
+        "types": "./dist/utils/index.d.ts",
+        "default": "./dist/utils/index.cjs"
+      },
+      "default": "./dist/utils/index.cjs"
     }
   },
   "engines": {
@@ -47,7 +60,8 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "yarn tsc && tsup src/index.ts --format cjs,esm --dts",
+    "build": "yarn tsc && tsup",
+    "build:watch": "yarn build --watch",
     "clean": "rm -rf .turbo && rm -rf dist",
     "dev": "yarn build -- --watch",
     "format:fix": "prettier src --write",

package/src/Logger.ts

@@ -1,4 +1,4 @@
-import { isBrowser } from "./index.js";
+import { isBrowser, isTest } from "./utils/environment.js";
 
 type GetLoggingEnabled = (() => Promise<boolean> | boolean) | undefined;
 
@@ -14,6 +14,8 @@ export class Logger {
   async updateLoggingEnabled(getLoggingEnabled: GetLoggingEnabled) {
     if (getLoggingEnabled) {
       this.loggingEnabled = await getLoggingEnabled();
+    } else if (isTest) {
+      this.loggingEnabled = true;
     } else if (isBrowser) {
       try {
         this.loggingEnabled =

package/src/crypto/SigningKey.ts

@@ -1,10 +1,6 @@
 import secp256k1 from "secp256k1";
-import {
-  createSha256Hash,
-  hexToBytes,
-  SigningKeyType,
-  type CryptoInterface,
-} from "../index.js";
+import { SigningKeyType, type CryptoInterface } from "../index.js";
+import { createSha256Hash, hexToBytes } from "../utils/index.js";
 
 interface Alias {
   alias: string;

package/src/requester/Requester.ts

@@ -68,13 +68,14 @@ class Requester {
     queryPayload: string,
     variables: { [key: string]: unknown } = {},
   ) {
-    logger.info(`Requester.subscribe params`, queryPayload, variables);
+    logger.info(`Requester.subscribe variables`, variables);
     const operationNameRegex = /^\s*(query|mutation|subscription)\s+(\w+)/i;
     const operationMatch = queryPayload.match(operationNameRegex);
     if (!operationMatch || operationMatch.length < 3) {
       throw new LightsparkException("InvalidQuery", "Invalid query payload");
     }
     const operationType = operationMatch[1];
+    logger.info(`Requester.subscribe operationType`, operationType);
     if (operationType == "mutation") {
       throw new LightsparkException(
         "InvalidQuery",
@@ -94,7 +95,6 @@ class Requester {
       operationName: operation,
     };
 
-    logger.info(`Requester.subscribe bodyData`, bodyData);
     return new Observable<{ data: T }>((observer) => {
       logger.info(`Requester.subscribe observer`, observer);
       return this.wsClient.subscribe(bodyData, {

package/src/utils/createHash.ts

@@ -1,13 +1,34 @@
 import { isBrowser } from "./environment.js";
+import { bytesToHex } from "./hex.js";
 
-export const createSha256Hash = async (
-  data: Uint8Array,
-): Promise<Uint8Array> => {
+type SourceData = Uint8Array | string;
+
+export async function createSha256Hash(data: SourceData): Promise<Uint8Array>;
+export async function createSha256Hash(
+  data: SourceData,
+  asHex: true,
+): Promise<string>;
+
+export async function createSha256Hash(
+  data: SourceData,
+  asHex?: boolean,
+): Promise<Uint8Array | string> {
   if (isBrowser) {
-    return new Uint8Array(await window.crypto.subtle.digest("SHA-256", data));
+    const source =
+      typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const buffer = await window.crypto.subtle.digest("SHA-256", source);
+    const arr = new Uint8Array(buffer);
+    if (asHex) {
+      return bytesToHex(arr);
+    }
+    return arr;
   } else {
     const { createHash } = await import("crypto");
+    if (asHex) {
+      const hexStr = createHash("sha256").update(data).digest("hex");
+      return hexStr;
+    }
     const buffer = createHash("sha256").update(data).digest();
     return new Uint8Array(buffer);
   }
-};
+}

package/src/utils/environment.ts

@@ -5,3 +5,5 @@ export const isNode =
   typeof process !== "undefined" &&
   process.versions != null &&
   process.versions.node != null;
+
+export const isTest = isNode && process.env.NODE_ENV === "test";

package/src/utils/index.ts

@@ -6,4 +6,6 @@ export * from "./currency.js";
 export * from "./environment.js";
 export * from "./errors.js";
 export * from "./hex.js";
+export * from "./pollUntil.js";
+export * from "./sleep.js";
 export * from "./types.js";

package/src/utils/pollUntil.ts

@@ -0,0 +1,54 @@
+import { isFunction } from "lodash-es";
+import { sleep } from "./sleep.js";
+
+function getDefaultMaxPollsError() {
+  return new Error("pollUntil: Max polls reached");
+}
+
+export function pollUntil<D extends () => Promise<unknown>, T>(
+  asyncFn: D,
+  getValue: (
+    data: Awaited<ReturnType<D>>,
+    response: { stopPolling: boolean; value: null | T },
+  ) => {
+    stopPolling: boolean;
+    value: null | T;
+  },
+  maxPolls = 60,
+  pollIntervalMs = 500,
+  ignoreErrors: boolean | ((e: unknown) => boolean) = false,
+  getMaxPollsError: (maxPolls: number) => Error = getDefaultMaxPollsError,
+): Promise<T> {
+  return new Promise((resolve, reject) => {
+    let polls = 0;
+    let stopPolling = false;
+    (async function () {
+      while (!stopPolling) {
+        polls += 1;
+        if (polls > maxPolls) {
+          stopPolling = true;
+          const maxPollsError = getMaxPollsError(maxPolls);
+          reject(maxPollsError);
+          break;
+        }
+        try {
+          const asyncResult = await asyncFn();
+          const result = getValue(asyncResult as Awaited<ReturnType<D>>, {
+            stopPolling: false,
+            value: null,
+          });
+          if (result.stopPolling) {
+            stopPolling = true;
+            resolve(result.value as T);
+          }
+        } catch (e) {
+          if (!ignoreErrors || (isFunction(ignoreErrors) && !ignoreErrors(e))) {
+            stopPolling = true;
+            reject(e);
+          }
+        }
+        await sleep(pollIntervalMs);
+      }
+    })();
+  });
+}

package/src/utils/sleep.ts

@@ -0,0 +1,3 @@
+export function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}