@lightsparkdev/core 1.0.8 → 1.0.10

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @lightsparkdev/core
 
+## 1.0.10
+
+### Patch Changes
+
+- aefe52c: Update tsup to latest
+- 09dfcee: Prevent ts compile of test files for builds and update lint configuration
+
+## 1.0.9
+
+### Patch Changes
+
+- 0d43a39: Add common config enum for app reference
+
 ## 1.0.8
 
 ### Patch Changes

package/dist/{chunk-UU6SHVGX.js → chunk-MAZP7ETK.js}

@@ -816,39 +816,38 @@ function sleep(ms) {
 function getDefaultMaxPollsError() {
   return new Error("pollUntil: Max polls reached");
 }
-function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
-  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, {
-            stopPolling: false,
-            value: null
-          });
-          if (result.stopPolling) {
-            stopPolling = true;
-            resolve(result.value);
-          }
-        } catch (e) {
-          if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
-            stopPolling = true;
-            reject(e);
-          }
-        }
-        await sleep(pollIntervalMs);
+async function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
+  let polls = 0;
+  let stopPolling = false;
+  let result = {
+    stopPolling: false,
+    value: null
+  };
+  while (!stopPolling) {
+    polls += 1;
+    if (polls > maxPolls) {
+      stopPolling = true;
+      const maxPollsError = getMaxPollsError(maxPolls);
+      throw maxPollsError;
+    }
+    try {
+      const asyncResult = await asyncFn();
+      result = getValue(asyncResult, {
+        stopPolling: false,
+        value: null
+      });
+      if (result.stopPolling) {
+        stopPolling = true;
       }
-    })();
-  });
+    } catch (e) {
+      if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
+        stopPolling = true;
+        throw e;
+      }
+    }
+    await sleep(pollIntervalMs);
+  }
+  return result.value;
 }
 
 // src/utils/types.ts

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, {
+  ConfigKeys: () => ConfigKeys,
   CurrencyUnit: () => CurrencyUnit,
   DefaultCrypto: () => DefaultCrypto,
   KeyOrAlias: () => KeyOrAlias,
@@ -59,6 +60,7 @@ __export(src_exports, {
   formatCurrencyStr: () => formatCurrencyStr,
   getCurrentLocale: () => getCurrentLocale,
   getErrorMsg: () => getErrorMsg,
+  getLocalStorageConfigItem: () => getLocalStorageConfigItem,
   hexToBytes: () => hexToBytes,
   isBrowser: () => isBrowser,
   isCurrencyAmount: () => isCurrencyAmount,
@@ -107,14 +109,27 @@ var LightsparkAuthException_default = LightsparkAuthException;
 
 // src/auth/StubAuthProvider.ts
 var StubAuthProvider = class {
-  async addAuthHeaders(headers) {
-    return headers;
+  addAuthHeaders(headers) {
+    return Promise.resolve(headers);
   }
-  async isAuthorized() {
-    return false;
+  isAuthorized() {
+    return Promise.resolve(false);
+  }
+  addWsConnectionParams(params) {
+    return Promise.resolve(params);
   }
-  async addWsConnectionParams(params) {
-    return params;
+};
+
+// src/constants/localStorage.ts
+var ConfigKeys = {
+  LoggingEnabled: "lightspark-logging-enabled",
+  ConsoleToolsEnabled: "lightspark-console-tools-enabled"
+};
+var getLocalStorageConfigItem = (key) => {
+  try {
+    return localStorage.getItem(key) === "1";
+  } catch (e) {
+    return false;
   }
 };
 
@@ -252,7 +267,7 @@ var decrypt = async (header_json, ciphertext, password) => {
   if (header.v < 0 || header.v > 4) {
     throw new LightsparkException_default(
       "DecryptionError",
-      "Unknown version ".concat(header.v)
+      `Unknown version ${header.v}`
     );
   }
   const cryptoImpl = await getCrypto();
@@ -1146,39 +1161,38 @@ function sleep(ms) {
 function getDefaultMaxPollsError() {
   return new Error("pollUntil: Max polls reached");
 }
-function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
-  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, {
-            stopPolling: false,
-            value: null
-          });
-          if (result.stopPolling) {
-            stopPolling = true;
-            resolve(result.value);
-          }
-        } catch (e) {
-          if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
-            stopPolling = true;
-            reject(e);
-          }
-        }
-        await sleep(pollIntervalMs);
+async function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
+  let polls = 0;
+  let stopPolling = false;
+  let result = {
+    stopPolling: false,
+    value: null
+  };
+  while (!stopPolling) {
+    polls += 1;
+    if (polls > maxPolls) {
+      stopPolling = true;
+      const maxPollsError = getMaxPollsError(maxPolls);
+      throw maxPollsError;
+    }
+    try {
+      const asyncResult = await asyncFn();
+      result = getValue(asyncResult, {
+        stopPolling: false,
+        value: null
+      });
+      if (result.stopPolling) {
+        stopPolling = true;
       }
-    })();
-  });
+    } catch (e) {
+      if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
+        stopPolling = true;
+        throw e;
+      }
+    }
+    await sleep(pollIntervalMs);
+  }
+  return result.value;
 }
 
 // src/utils/types.ts
@@ -1287,7 +1301,7 @@ var Logger = class {
   loggingEnabled = false;
   constructor(loggerContext, getLoggingEnabled) {
     this.context = loggerContext;
-    this.updateLoggingEnabled(getLoggingEnabled);
+    void this.updateLoggingEnabled(getLoggingEnabled);
   }
   async updateLoggingEnabled(getLoggingEnabled) {
     if (getLoggingEnabled) {
@@ -1296,7 +1310,9 @@ var Logger = class {
       this.loggingEnabled = true;
     } else if (isBrowser) {
       try {
-        this.loggingEnabled = localStorage.getItem("lightspark-logging-enabled") === "1";
+        this.loggingEnabled = getLocalStorageConfigItem(
+          ConfigKeys.LoggingEnabled
+        );
       } catch (e) {
       }
     }
@@ -1483,7 +1499,7 @@ var Requester = class {
       nonce,
       expires_at: expiration
     };
-    const key = await this.nodeKeyCache.getKey(signingNodeId);
+    const key = this.nodeKeyCache.getKey(signingNodeId);
     if (!key) {
       throw new LightsparkSigningException_default(
         "Missing node of encrypted_signing_private_key"
@@ -1524,6 +1540,7 @@ var apiDomainForEnvironment = (environment) => {
 var ServerEnvironment_default = ServerEnvironment;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ConfigKeys,
   CurrencyUnit,
   DefaultCrypto,
   KeyOrAlias,
@@ -1553,6 +1570,7 @@ var ServerEnvironment_default = ServerEnvironment;
   formatCurrencyStr,
   getCurrentLocale,
   getErrorMsg,
+  getLocalStorageConfigItem,
   hexToBytes,
   isBrowser,
   isCurrencyAmount,

package/dist/index.d.cts

@@ -0,0 +1,165 @@
+import { Observable } from 'zen-observable-ts';
+export { ById, CurrencyAmountArg, CurrencyAmountObj, CurrencyAmountType, CurrencyCodes, CurrencyLocales, CurrencyMap, CurrencyUnit, DeepPartial, ExpandRecursively, Maybe, OmitTypename, abbrCurrencyUnit, 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, separateCurrencyStrParts, sleep, urlsafe_b64decode } from './utils/index.cjs';
+
+type Headers = Record<string, string>;
+type WsConnectionParams = Record<string, unknown>;
+interface AuthProvider {
+    addAuthHeaders(headers: Headers): Promise<Headers>;
+    isAuthorized(): Promise<boolean>;
+    addWsConnectionParams(params: WsConnectionParams): Promise<WsConnectionParams>;
+}
+
+declare class LightsparkException extends Error {
+    code: string;
+    message: string;
+    extraInfo: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, extraInfo?: Record<string, unknown>);
+}
+
+declare class LightsparkAuthException extends LightsparkException {
+    constructor(message: string, extraInfo?: Record<string, unknown>);
+}
+
+declare class StubAuthProvider implements AuthProvider {
+    addAuthHeaders(headers: Headers): Promise<Headers>;
+    isAuthorized(): Promise<boolean>;
+    addWsConnectionParams(params: WsConnectionParams): Promise<WsConnectionParams>;
+}
+
+declare const ConfigKeys: {
+    readonly LoggingEnabled: "lightspark-logging-enabled";
+    readonly ConsoleToolsEnabled: "lightspark-console-tools-enabled";
+};
+type ConfigKeys = (typeof ConfigKeys)[keyof typeof ConfigKeys];
+declare const getLocalStorageConfigItem: (key: ConfigKeys) => boolean;
+
+declare class LightsparkSigningException extends LightsparkException {
+    constructor(message: string, extraInfo?: Record<string, unknown>);
+}
+
+type GeneratedKeyPair = {
+    publicKey: CryptoKey | string;
+    privateKey: CryptoKey | string;
+    keyAlias?: string;
+};
+type CryptoInterface = {
+    decryptSecretWithNodePassword: (cipher: string, encryptedSecret: string, nodePassword: string) => Promise<ArrayBuffer | null>;
+    generateSigningKeyPair: () => Promise<GeneratedKeyPair>;
+    serializeSigningKey: (key: CryptoKey | string, format: "pkcs8" | "spki") => Promise<ArrayBuffer>;
+    getNonce: () => Promise<number>;
+    sign: (keyOrAlias: CryptoKey | string, data: Uint8Array) => Promise<ArrayBuffer>;
+    importPrivateSigningKey: (keyData: Uint8Array) => Promise<CryptoKey | string>;
+};
+declare function decryptSecretWithNodePassword(cipher: string, encryptedSecret: string, nodePassword: string): Promise<ArrayBuffer | null>;
+declare const DefaultCrypto: {
+    decryptSecretWithNodePassword: typeof decryptSecretWithNodePassword;
+    generateSigningKeyPair: () => Promise<GeneratedKeyPair>;
+    serializeSigningKey: (key: CryptoKey | string, format: "pkcs8" | "spki") => Promise<ArrayBuffer>;
+    getNonce: () => Promise<number>;
+    sign: (keyOrAlias: CryptoKey | string, data: Uint8Array) => Promise<ArrayBuffer>;
+    importPrivateSigningKey: (keyData: Uint8Array) => Promise<CryptoKey | string>;
+};
+
+type OnlyKey = {
+    key: string;
+    alias?: never;
+};
+type OnlyAlias = {
+    key?: never;
+    alias: string;
+};
+type KeyOrAliasType = OnlyKey | OnlyAlias;
+declare const KeyOrAlias: {
+    key: (key: string) => OnlyKey;
+    alias: (alias: string) => OnlyAlias;
+};
+
+interface Alias {
+    alias: string;
+}
+declare abstract class SigningKey {
+    readonly type: SigningKeyType;
+    constructor(type: SigningKeyType);
+    abstract sign(data: Uint8Array): Promise<ArrayBuffer>;
+}
+declare class RSASigningKey extends SigningKey {
+    private readonly privateKey;
+    private readonly cryptoImpl;
+    constructor(privateKey: CryptoKey | Alias, cryptoImpl: CryptoInterface);
+    sign(data: Uint8Array): Promise<ArrayBuffer>;
+}
+declare class Secp256k1SigningKey extends SigningKey {
+    private readonly privateKey;
+    constructor(privateKey: string);
+    sign(data: Uint8Array): Promise<Uint8Array>;
+}
+
+declare enum SigningKeyType {
+    RSASigningKey = "RSASigningKey",
+    Secp256k1SigningKey = "Secp256k1SigningKey"
+}
+
+declare class NodeKeyCache {
+    private readonly cryptoImpl;
+    private idToKey;
+    constructor(cryptoImpl?: CryptoInterface);
+    loadKey(id: string, keyOrAlias: KeyOrAliasType, signingKeyType: SigningKeyType): Promise<SigningKey | null>;
+    getKey(id: string): SigningKey | undefined;
+    hasKey(id: string): boolean;
+    private stripPemTags;
+}
+
+type GetLoggingEnabled = (() => Promise<boolean> | boolean) | undefined;
+declare class Logger {
+    context: string;
+    loggingEnabled: boolean;
+    constructor(loggerContext: string, getLoggingEnabled?: GetLoggingEnabled);
+    updateLoggingEnabled(getLoggingEnabled: GetLoggingEnabled): Promise<void>;
+    info(message: string, ...rest: unknown[]): void;
+}
+
+type Query<T> = {
+    /** The string representation of the query payload for graphQL. **/
+    queryPayload: string;
+    /** The variables that will be passed to the query. **/
+    variables?: {
+        [key: string]: unknown;
+    };
+    /** The function that will be called to construct the object from the response. **/
+    constructObject: (rawData: any) => T;
+    /** The id of the node that will be used to sign the query. **/
+    signingNodeId?: string;
+    /** True if auth headers should be omitted for this query. **/
+    skipAuth?: boolean;
+};
+
+declare class Requester {
+    private readonly nodeKeyCache;
+    private readonly schemaEndpoint;
+    private readonly sdkUserAgent;
+    private readonly authProvider;
+    private readonly baseUrl;
+    private readonly cryptoImpl;
+    private readonly wsClient;
+    constructor(nodeKeyCache: NodeKeyCache, schemaEndpoint: string, sdkUserAgent: string, authProvider?: AuthProvider, baseUrl?: string, cryptoImpl?: CryptoInterface);
+    executeQuery<T>(query: Query<T>): Promise<T | null>;
+    subscribe<T>(queryPayload: string, variables?: {
+        [key: string]: unknown;
+    }): Observable<{
+        data: T;
+    }>;
+    makeRawRequest(queryPayload: string, variables?: {
+        [key: string]: unknown;
+    }, signingNodeId?: string | undefined, skipAuth?: boolean): Promise<any>;
+    private getSdkUserAgent;
+    private stripProtocol;
+    private addSigningDataIfNeeded;
+}
+
+declare enum ServerEnvironment {
+    PRODUCTION = "production",
+    DEV = "dev"
+}
+declare const apiDomainForEnvironment: (environment: ServerEnvironment) => string;
+
+export { AuthProvider, ConfigKeys, CryptoInterface, DefaultCrypto, GeneratedKeyPair, KeyOrAlias, KeyOrAliasType, LightsparkAuthException, LightsparkException, LightsparkSigningException, Logger, NodeKeyCache, Query, RSASigningKey, Requester, Secp256k1SigningKey, ServerEnvironment, SigningKey, SigningKeyType, StubAuthProvider, apiDomainForEnvironment, getLocalStorageConfigItem };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from 'zen-observable-ts';
-export { ById, CurrencyAmountArg, CurrencyAmountObj, CurrencyAmountType, CurrencyCodes, CurrencyLocales, CurrencyMap, CurrencyUnit, ExpandRecursively, Maybe, OmitTypename, abbrCurrencyUnit, 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, separateCurrencyStrParts, sleep, urlsafe_b64decode } from './utils/index.js';
+export { ById, CurrencyAmountArg, CurrencyAmountObj, CurrencyAmountType, CurrencyCodes, CurrencyLocales, CurrencyMap, CurrencyUnit, DeepPartial, ExpandRecursively, Maybe, OmitTypename, abbrCurrencyUnit, 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, separateCurrencyStrParts, sleep, urlsafe_b64decode } from './utils/index.js';
 
 type Headers = Record<string, string>;
 type WsConnectionParams = Record<string, unknown>;
@@ -26,6 +26,13 @@ declare class StubAuthProvider implements AuthProvider {
     addWsConnectionParams(params: WsConnectionParams): Promise<WsConnectionParams>;
 }
 
+declare const ConfigKeys: {
+    readonly LoggingEnabled: "lightspark-logging-enabled";
+    readonly ConsoleToolsEnabled: "lightspark-console-tools-enabled";
+};
+type ConfigKeys = (typeof ConfigKeys)[keyof typeof ConfigKeys];
+declare const getLocalStorageConfigItem: (key: ConfigKeys) => boolean;
+
 declare class LightsparkSigningException extends LightsparkException {
     constructor(message: string, extraInfo?: Record<string, unknown>);
 }
@@ -143,7 +150,7 @@ declare class Requester {
     }>;
     makeRawRequest(queryPayload: string, variables?: {
         [key: string]: unknown;
-    }, signingNodeId?: string | undefined, skipAuth?: boolean): Promise<any | null>;
+    }, signingNodeId?: string | undefined, skipAuth?: boolean): Promise<any>;
     private getSdkUserAgent;
     private stripProtocol;
     private addSigningDataIfNeeded;
@@ -155,4 +162,4 @@ declare enum ServerEnvironment {
 }
 declare const apiDomainForEnvironment: (environment: ServerEnvironment) => string;
 
-export { AuthProvider, CryptoInterface, DefaultCrypto, GeneratedKeyPair, KeyOrAlias, KeyOrAliasType, LightsparkAuthException, LightsparkException, LightsparkSigningException, Logger, NodeKeyCache, Query, RSASigningKey, Requester, Secp256k1SigningKey, ServerEnvironment, SigningKey, SigningKeyType, StubAuthProvider, apiDomainForEnvironment };
+export { AuthProvider, ConfigKeys, CryptoInterface, DefaultCrypto, GeneratedKeyPair, KeyOrAlias, KeyOrAliasType, LightsparkAuthException, LightsparkException, LightsparkSigningException, Logger, NodeKeyCache, Query, RSASigningKey, Requester, Secp256k1SigningKey, ServerEnvironment, SigningKey, SigningKeyType, StubAuthProvider, apiDomainForEnvironment, getLocalStorageConfigItem };

package/dist/index.js

@@ -35,7 +35,7 @@ import {
   separateCurrencyStrParts,
   sleep,
   urlsafe_b64decode
-} from "./chunk-UU6SHVGX.js";
+} from "./chunk-MAZP7ETK.js";
 
 // src/auth/LightsparkAuthException.ts
 var LightsparkAuthException = class extends LightsparkException_default {
@@ -47,14 +47,27 @@ var LightsparkAuthException_default = LightsparkAuthException;
 
 // src/auth/StubAuthProvider.ts
 var StubAuthProvider = class {
-  async addAuthHeaders(headers) {
-    return headers;
+  addAuthHeaders(headers) {
+    return Promise.resolve(headers);
   }
-  async isAuthorized() {
-    return false;
+  isAuthorized() {
+    return Promise.resolve(false);
+  }
+  addWsConnectionParams(params) {
+    return Promise.resolve(params);
   }
-  async addWsConnectionParams(params) {
-    return params;
+};
+
+// src/constants/localStorage.ts
+var ConfigKeys = {
+  LoggingEnabled: "lightspark-logging-enabled",
+  ConsoleToolsEnabled: "lightspark-console-tools-enabled"
+};
+var getLocalStorageConfigItem = (key) => {
+  try {
+    return localStorage.getItem(key) === "1";
+  } catch (e) {
+    return false;
   }
 };
 
@@ -149,7 +162,7 @@ var decrypt = async (header_json, ciphertext, password) => {
   if (header.v < 0 || header.v > 4) {
     throw new LightsparkException_default(
       "DecryptionError",
-      "Unknown version ".concat(header.v)
+      `Unknown version ${header.v}`
     );
   }
   const cryptoImpl = await getCrypto();
@@ -381,7 +394,7 @@ var Logger = class {
   loggingEnabled = false;
   constructor(loggerContext, getLoggingEnabled) {
     this.context = loggerContext;
-    this.updateLoggingEnabled(getLoggingEnabled);
+    void this.updateLoggingEnabled(getLoggingEnabled);
   }
   async updateLoggingEnabled(getLoggingEnabled) {
     if (getLoggingEnabled) {
@@ -390,7 +403,9 @@ var Logger = class {
       this.loggingEnabled = true;
     } else if (isBrowser) {
       try {
-        this.loggingEnabled = localStorage.getItem("lightspark-logging-enabled") === "1";
+        this.loggingEnabled = getLocalStorageConfigItem(
+          ConfigKeys.LoggingEnabled
+        );
       } catch (e) {
       }
     }
@@ -577,7 +592,7 @@ var Requester = class {
       nonce,
       expires_at: expiration
     };
-    const key = await this.nodeKeyCache.getKey(signingNodeId);
+    const key = this.nodeKeyCache.getKey(signingNodeId);
     if (!key) {
       throw new LightsparkSigningException_default(
         "Missing node of encrypted_signing_private_key"
@@ -617,6 +632,7 @@ var apiDomainForEnvironment = (environment) => {
 };
 var ServerEnvironment_default = ServerEnvironment;
 export {
+  ConfigKeys,
   CurrencyUnit,
   DefaultCrypto,
   KeyOrAlias,
@@ -646,6 +662,7 @@ export {
   formatCurrencyStr,
   getCurrentLocale,
   getErrorMsg,
+  getLocalStorageConfigItem,
   hexToBytes,
   isBrowser,
   isCurrencyAmount,

package/dist/utils/index.cjs

@@ -886,39 +886,38 @@ function sleep(ms) {
 function getDefaultMaxPollsError() {
   return new Error("pollUntil: Max polls reached");
 }
-function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
-  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, {
-            stopPolling: false,
-            value: null
-          });
-          if (result.stopPolling) {
-            stopPolling = true;
-            resolve(result.value);
-          }
-        } catch (e) {
-          if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
-            stopPolling = true;
-            reject(e);
-          }
-        }
-        await sleep(pollIntervalMs);
+async function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
+  let polls = 0;
+  let stopPolling = false;
+  let result = {
+    stopPolling: false,
+    value: null
+  };
+  while (!stopPolling) {
+    polls += 1;
+    if (polls > maxPolls) {
+      stopPolling = true;
+      const maxPollsError = getMaxPollsError(maxPolls);
+      throw maxPollsError;
+    }
+    try {
+      const asyncResult = await asyncFn();
+      result = getValue(asyncResult, {
+        stopPolling: false,
+        value: null
+      });
+      if (result.stopPolling) {
+        stopPolling = true;
       }
-    })();
-  });
+    } catch (e) {
+      if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
+        stopPolling = true;
+        throw e;
+      }
+    }
+    await sleep(pollIntervalMs);
+  }
+  return result.value;
 }
 
 // src/utils/types.ts

package/dist/utils/index.d.cts

@@ -0,0 +1,223 @@
+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>;
+
+declare const defaultCurrencyCode = "USD";
+/** This enum identifies the unit of currency associated with a CurrencyAmount. **/
+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"
+}
+/** This object represents the value and unit for an amount of currency. **/
+type CurrencyAmountType = {
+    /** 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 function convertCurrencyAmountValue(fromUnit: CurrencyUnit, toUnit: CurrencyUnit, amount: number, centsPerBtc?: number): number;
+declare const convertCurrencyAmount: (from: CurrencyAmountType, toUnit: CurrencyUnit) => CurrencyAmountType;
+type CurrencyMap = {
+    sats: number;
+    msats: number;
+    btc: number;
+    [CurrencyUnit.BITCOIN]: number;
+    [CurrencyUnit.SATOSHI]: number;
+    [CurrencyUnit.MILLISATOSHI]: number;
+    [CurrencyUnit.MICROBITCOIN]: number;
+    [CurrencyUnit.MILLIBITCOIN]: number;
+    [CurrencyUnit.NANOBITCOIN]: number;
+    [CurrencyUnit.USD]: number;
+    [CurrencyUnit.FUTURE_VALUE]: number;
+    formatted: {
+        sats: string;
+        msats: string;
+        btc: string;
+        [CurrencyUnit.BITCOIN]: string;
+        [CurrencyUnit.SATOSHI]: string;
+        [CurrencyUnit.MILLISATOSHI]: string;
+        [CurrencyUnit.MILLIBITCOIN]: string;
+        [CurrencyUnit.MICROBITCOIN]: string;
+        [CurrencyUnit.NANOBITCOIN]: string;
+        [CurrencyUnit.USD]: string;
+        [CurrencyUnit.FUTURE_VALUE]: string;
+    };
+    isZero: boolean;
+    isLessThan: (other: CurrencyMap | CurrencyAmountObj | number) => boolean;
+    isGreaterThan: (other: CurrencyMap | CurrencyAmountObj | number) => boolean;
+    isEqualTo: (other: CurrencyMap | CurrencyAmountObj | number) => boolean;
+    type: "CurrencyMap";
+};
+type CurrencyAmountObj = {
+    value?: number | string | null;
+    unit?: CurrencyUnit;
+    __typename?: "CurrencyAmount";
+};
+type CurrencyAmountArg = CurrencyAmountObj | CurrencyAmountType | undefined | null;
+declare function isCurrencyAmountObj(arg: unknown): arg is CurrencyAmountObj;
+declare function isCurrencyAmount(arg: unknown): arg is CurrencyAmountType;
+declare function mapCurrencyAmount(currencyAmountArg: CurrencyAmountArg, centsPerBtc?: number): CurrencyMap;
+declare const isCurrencyMap: (currencyMap: unknown) => currencyMap is CurrencyMap;
+declare const abbrCurrencyUnit: (unit: CurrencyUnit) => "USD" | "BTC" | "SAT" | "MSAT" | "Unsupported CurrencyUnit";
+declare function formatCurrencyStr(amount: CurrencyAmountArg, maxFractionDigits?: number, compact?: boolean, showBtcSymbol?: boolean, options?: Intl.NumberFormatOptions): string;
+declare function separateCurrencyStrParts(currencyStr: string): {
+    symbol: string;
+    amount: string;
+};
+declare function localeToCurrencySymbol(locale: string): string;
+
+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 getCurrentLocale(): string;
+
+declare const countryCodesToCurrencyCodes: {
+    readonly AD: "EUR";
+    readonly AR: "ARS";
+    readonly AS: "USD";
+    readonly AT: "EUR";
+    readonly AU: "AUD";
+    readonly AX: "EUR";
+    readonly BE: "EUR";
+    readonly BL: "EUR";
+    readonly BQ: "USD";
+    readonly BR: "BRL";
+    readonly CA: "CAD";
+    readonly CO: "COP";
+    readonly CY: "EUR";
+    readonly DE: "EUR";
+    readonly EC: "USD";
+    readonly EE: "EUR";
+    readonly ES: "EUR";
+    readonly FI: "EUR";
+    readonly FM: "USD";
+    readonly FR: "EUR";
+    readonly GB: "GBP";
+    readonly GF: "EUR";
+    readonly GG: "GBP";
+    readonly GP: "EUR";
+    readonly GR: "EUR";
+    readonly GS: "GBP";
+    readonly GU: "USD";
+    readonly IE: "EUR";
+    readonly IM: "GBP";
+    readonly IN: "INR";
+    readonly IO: "USD";
+    readonly IT: "EUR";
+    readonly JE: "GBP";
+    readonly LT: "EUR";
+    readonly LU: "EUR";
+    readonly LV: "EUR";
+    readonly MC: "EUR";
+    readonly ME: "EUR";
+    readonly MF: "EUR";
+    readonly MH: "USD";
+    readonly MP: "USD";
+    readonly MQ: "EUR";
+    readonly MT: "EUR";
+    readonly MX: "MXN";
+    readonly NF: "AUD";
+    readonly NL: "EUR";
+    readonly NR: "AUD";
+    readonly PM: "EUR";
+    readonly PR: "USD";
+    readonly PT: "EUR";
+    readonly PW: "USD";
+    readonly RE: "EUR";
+    readonly SI: "EUR";
+    readonly SK: "EUR";
+    readonly SM: "EUR";
+    readonly TC: "USD";
+    readonly TF: "EUR";
+    readonly TL: "USD";
+    readonly TV: "AUD";
+    readonly UM: "USD";
+    readonly US: "USD";
+    readonly VA: "EUR";
+    readonly VG: "USD";
+    readonly VI: "USD";
+    readonly YT: "EUR";
+};
+type CurrencyLocales = keyof typeof countryCodesToCurrencyCodes;
+type CurrencyCodes = (typeof countryCodesToCurrencyCodes)[CurrencyLocales];
+declare function localeToCurrencyCode(locale: string): CurrencyCodes;
+
+declare function clamp(val: number, min: number, max: number): number;
+declare function linearInterpolate(value: number, fromRangeStart: number, fromRangeEnd: number, toRangeStart: number, toRangeEnd: number): number;
+declare function round(num: number, decimalPlaces?: number): number;
+declare function isNumber(value: unknown): value is number;
+
+type GetValueResult<T> = {
+    stopPolling: boolean;
+    value: null | T;
+};
+declare function pollUntil<D extends () => Promise<unknown>, T>(asyncFn: D, getValue: (data: Awaited<ReturnType<D>>, response: {
+    stopPolling: boolean;
+    value: null | T;
+}) => GetValueResult<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;
+}>;
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+
+export { ById, CurrencyAmountArg, CurrencyAmountObj, CurrencyAmountType, CurrencyCodes, CurrencyLocales, CurrencyMap, CurrencyUnit, DeepPartial, ExpandRecursively, Maybe, OmitTypename, abbrCurrencyUnit, 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, separateCurrencyStrParts, sleep, urlsafe_b64decode };

package/dist/utils/index.d.ts

@@ -192,13 +192,14 @@ declare function linearInterpolate(value: number, fromRangeStart: number, fromRa
 declare function round(num: number, decimalPlaces?: number): number;
 declare function isNumber(value: unknown): value is number;
 
-declare function pollUntil<D extends () => Promise<unknown>, T>(asyncFn: D, getValue: (data: Awaited<ReturnType<D>>, response: {
+type GetValueResult<T> = {
     stopPolling: boolean;
     value: null | T;
-}) => {
+};
+declare function pollUntil<D extends () => Promise<unknown>, T>(asyncFn: D, getValue: (data: Awaited<ReturnType<D>>, response: {
     stopPolling: boolean;
     value: null | T;
-}, maxPolls?: number, pollIntervalMs?: number, ignoreErrors?: boolean | ((e: unknown) => boolean), getMaxPollsError?: (maxPolls: number) => Error): Promise<T>;
+}) => GetValueResult<T>, maxPolls?: number, pollIntervalMs?: number, ignoreErrors?: boolean | ((e: unknown) => boolean), getMaxPollsError?: (maxPolls: number) => Error): Promise<T>;
 
 declare function sleep(ms: number): Promise<unknown>;
 
@@ -215,5 +216,8 @@ declare const isType: <T extends string>(typename: T) => <N extends {
 }>(node: N | null | undefined) => node is Extract<N, {
     __typename: T;
 }>;
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
 
-export { ById, CurrencyAmountArg, CurrencyAmountObj, CurrencyAmountType, CurrencyCodes, CurrencyLocales, CurrencyMap, CurrencyUnit, ExpandRecursively, Maybe, OmitTypename, abbrCurrencyUnit, 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, separateCurrencyStrParts, sleep, urlsafe_b64decode };
+export { ById, CurrencyAmountArg, CurrencyAmountObj, CurrencyAmountType, CurrencyCodes, CurrencyLocales, CurrencyMap, CurrencyUnit, DeepPartial, ExpandRecursively, Maybe, OmitTypename, abbrCurrencyUnit, 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, separateCurrencyStrParts, sleep, urlsafe_b64decode };

package/dist/utils/index.js

@@ -34,7 +34,7 @@ import {
   separateCurrencyStrParts,
   sleep,
   urlsafe_b64decode
-} from "../chunk-UU6SHVGX.js";
+} from "../chunk-MAZP7ETK.js";
 export {
   CurrencyUnit,
   abbrCurrencyUnit,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightsparkdev/core",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Lightspark JS SDK",
   "author": "Lightspark Inc.",
   "keywords": [
@@ -96,11 +96,11 @@
     "eslint": "^8.3.0",
     "eslint-watch": "^8.0.0",
     "jest": "^29.6.2",
-    "prettier": "3.0.2",
-    "prettier-plugin-organize-imports": "^3.2.2",
+    "prettier": "3.0.3",
+    "prettier-plugin-organize-imports": "^3.2.4",
     "ts-jest": "^29.1.1",
     "tsc-absolute": "^1.0.1",
-    "tsup": "^6.7.0",
+    "tsup": "^7.2.0",
     "typescript": "^4.9.5"
   }
 }

package/src/Logger.ts

@@ -1,3 +1,4 @@
+import { ConfigKeys, getLocalStorageConfigItem } from "./index.js";
 import { isBrowser, isTest } from "./utils/environment.js";
 
 type GetLoggingEnabled = (() => Promise<boolean> | boolean) | undefined;
@@ -8,7 +9,7 @@ export class Logger {
 
   constructor(loggerContext: string, getLoggingEnabled?: GetLoggingEnabled) {
     this.context = loggerContext;
-    this.updateLoggingEnabled(getLoggingEnabled);
+    void this.updateLoggingEnabled(getLoggingEnabled);
   }
 
   async updateLoggingEnabled(getLoggingEnabled: GetLoggingEnabled) {
@@ -18,8 +19,9 @@ export class Logger {
       this.loggingEnabled = true;
     } else if (isBrowser) {
       try {
-        this.loggingEnabled =
-          localStorage.getItem("lightspark-logging-enabled") === "1";
+        this.loggingEnabled = getLocalStorageConfigItem(
+          ConfigKeys.LoggingEnabled,
+        );
       } catch (e) {
         /* ignore */
       }

package/src/auth/StubAuthProvider.ts

@@ -4,14 +4,13 @@ import type AuthProvider from "./AuthProvider.js";
 import { type Headers, type WsConnectionParams } from "./AuthProvider.js";
 
 export default class StubAuthProvider implements AuthProvider {
-  async addAuthHeaders(headers: Headers) {
-    return headers;
+  addAuthHeaders(headers: Headers) {
+    return Promise.resolve(headers);
   }
-  async isAuthorized(): Promise<boolean> {
-    return false;
+  isAuthorized(): Promise<boolean> {
+    return Promise.resolve(false);
   }
-
-  async addWsConnectionParams(params: WsConnectionParams) {
-    return params;
+  addWsConnectionParams(params: WsConnectionParams) {
+    return Promise.resolve(params);
   }
 }

package/src/constants/index.ts

@@ -0,0 +1 @@
+export * from "./localStorage.js";

package/src/constants/localStorage.ts

@@ -0,0 +1,13 @@
+export const ConfigKeys = {
+  LoggingEnabled: "lightspark-logging-enabled",
+  ConsoleToolsEnabled: "lightspark-console-tools-enabled",
+} as const;
+export type ConfigKeys = (typeof ConfigKeys)[keyof typeof ConfigKeys];
+
+export const getLocalStorageConfigItem = (key: ConfigKeys) => {
+  try {
+    return localStorage.getItem(key) === "1";
+  } catch (e) {
+    return false;
+  }
+};

package/src/crypto/crypto.ts

@@ -117,6 +117,8 @@ const deriveKey = async (
   return [key, iv];
 };
 
+type Header = { v: number; i: number; lsv?: number };
+
 const decrypt = async (
   header_json: string,
   ciphertext: string,
@@ -124,7 +126,7 @@ const decrypt = async (
 ): Promise<ArrayBuffer> => {
   let decoded = b64decode(ciphertext);
 
-  let header;
+  let header: Header;
   if (header_json === "AES_256_CBC_PBKDF2_5000_SHA256") {
     header = {
       v: 0,
@@ -133,13 +135,13 @@ const decrypt = async (
     // Strip "Salted__" prefix
     decoded = decoded.slice(8);
   } else {
-    header = JSON.parse(header_json);
+    header = JSON.parse(header_json) as Header;
   }
 
   if (header.v < 0 || header.v > 4) {
     throw new LightsparkException(
       "DecryptionError",
-      "Unknown version ".concat(header.v),
+      `Unknown version ${header.v}`,
     );
   }
 
@@ -244,7 +246,7 @@ const sign = async (
       name: "RSA-PSS",
       saltLength: 32,
     },
-    keyOrAlias as CryptoKey,
+    keyOrAlias,
     data,
   );
 };

package/src/crypto/tests/crypto.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from "@jest/globals";
+import { b64encode, DefaultCrypto } from "../../index.js";
+
+describe("Crypto tests", () => {
+  test("should generate a key", async () => {
+    const { privateKey, publicKey } =
+      await DefaultCrypto.generateSigningKeyPair();
+
+    const serializedKeypair = {
+      privateKey: b64encode(
+        await DefaultCrypto.serializeSigningKey(privateKey, "pkcs8"),
+      ),
+      publicKey: b64encode(
+        await DefaultCrypto.serializeSigningKey(publicKey, "spki"),
+      ),
+    };
+
+    expect(serializedKeypair.privateKey).not.toBeNull();
+    expect(serializedKeypair.publicKey).not.toBeNull();
+  }, 60_000);
+});

package/src/index.ts

@@ -1,6 +1,7 @@
 // Copyright ©, 2023-present, Lightspark Group, Inc. - All Rights Reserved
 
 export * from "./auth/index.js";
+export * from "./constants/index.js";
 export * from "./crypto/index.js";
 export { default as LightsparkException } from "./LightsparkException.js";
 export { Logger } from "./Logger.js";

package/src/requester/Requester.ts

@@ -26,6 +26,14 @@ export const LIGHTSPARK_BETA_HEADER_VALUE =
   "z2h0BBYxTA83cjW7fi8QwWtBPCzkQKiemcuhKY08LOo";
 dayjs.extend(utc);
 
+type BodyData = {
+  query: string;
+  variables: { [key: string]: unknown };
+  operationName: string;
+  nonce?: number;
+  expires_at?: string;
+};
+
 class Requester {
   private readonly wsClient: WsClient;
   constructor(
@@ -55,6 +63,7 @@ class Requester {
   }
 
   public async executeQuery<T>(query: Query<T>): Promise<T | null> {
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- LIG-3400 */
     const data = await this.makeRawRequest(
       query.queryPayload,
       query.variables || {},
@@ -89,7 +98,7 @@ class Requester {
       }
     }
     const operation = operationMatch[2];
-    const bodyData = {
+    const bodyData: BodyData = {
       query: queryPayload,
       variables,
       operationName: operation,
@@ -111,7 +120,7 @@ class Requester {
     signingNodeId: string | undefined = undefined,
     skipAuth: boolean = false,
     /* eslint-disable-next-line @typescript-eslint/no-explicit-any -- LIG-3400 */
-  ): Promise<any | null> {
+  ): Promise<any> {
     const operationNameRegex = /^\s*(query|mutation|subscription)\s+(\w+)/i;
     const operationMatch = queryPayload.match(operationNameRegex);
     if (!operationMatch || operationMatch.length < 3) {
@@ -131,7 +140,7 @@ class Requester {
       }
     }
     const operation = operationMatch[2];
-    let bodyData = {
+    let bodyData: BodyData = {
       query: queryPayload,
       variables,
       operationName: operation,
@@ -179,7 +188,10 @@ class Requester {
         `Request ${operation} failed. ${response.statusText}`,
       );
     }
-    const responseJson = await response.json();
+    const responseJson = (await response.json()) as {
+      data: unknown;
+      errors: unknown;
+    };
     const data = responseJson.data;
     if (!data) {
       throw new LightsparkException(
@@ -201,11 +213,11 @@ class Requester {
   }
 
   private async addSigningDataIfNeeded(
-    queryPayload: { query: string; variables: unknown; operationName: string },
+    queryPayload: BodyData,
     headers: { [key: string]: string },
     signingNodeId: string | undefined,
     /* eslint-disable-next-line @typescript-eslint/no-explicit-any -- LIG-3400 */
-  ): Promise<any> {
+  ): Promise<BodyData> {
     if (!signingNodeId) {
       return queryPayload;
     }
@@ -225,7 +237,7 @@ class Requester {
       expires_at: expiration,
     };
 
-    const key = await this.nodeKeyCache.getKey(signingNodeId);
+    const key = this.nodeKeyCache.getKey(signingNodeId);
     if (!key) {
       throw new LightsparkSigningException(
         "Missing node of encrypted_signing_private_key",

package/src/utils/pollUntil.ts

@@ -5,50 +5,51 @@ function getDefaultMaxPollsError() {
   return new Error("pollUntil: Max polls reached");
 }
 
-export function pollUntil<D extends () => Promise<unknown>, T>(
+type GetValueResult<T> = {
+  stopPolling: boolean;
+  value: null | T;
+};
+
+export async 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;
-  },
+  ) => GetValueResult<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);
+  let polls = 0;
+  let stopPolling = false;
+  let result: GetValueResult<T> = {
+    stopPolling: false,
+    value: null,
+  };
+  while (!stopPolling) {
+    polls += 1;
+    if (polls > maxPolls) {
+      stopPolling = true;
+      const maxPollsError = getMaxPollsError(maxPolls);
+      throw maxPollsError;
+    }
+    try {
+      const asyncResult = await asyncFn();
+      result = getValue(asyncResult as Awaited<ReturnType<D>>, {
+        stopPolling: false,
+        value: null,
+      });
+      if (result.stopPolling) {
+        stopPolling = true;
+      }
+    } catch (e) {
+      if (!ignoreErrors || (isFunction(ignoreErrors) && !ignoreErrors(e))) {
+        stopPolling = true;
+        throw e;
       }
-    })();
-  });
+    }
+    await sleep(pollIntervalMs);
+  }
+  return result.value as T;
 }

package/src/utils/types.ts

@@ -21,3 +21,9 @@ export const isType =
   ): node is Extract<N, { __typename: T }> => {
     return node?.__typename === typename;
   };
+
+export type DeepPartial<T> = T extends object
+  ? {
+      [P in keyof T]?: DeepPartial<T[P]>;
+    }
+  : T;