@lightsparkdev/core 0.3.11 → 1.0.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @lightsparkdev/core
 
+## 1.0.1
+
+### Patch Changes
+
+- 808c77a: Consolidate some imports to lightspark-sdk and core
+
+## 1.0.0
+
+### Major Changes
+
+- 1f00a50: Change SigningKey hashing method depending on environment
+  BREAKING: NodeKeyCaches loadKey now requires signingKeyType as a parameter
+
 ## 0.3.11
 
 ### Patch Changes

package/dist/index.cjs

@@ -36,14 +36,25 @@ __export(src_exports, {
   LightsparkException: () => LightsparkException_default,
   LightsparkSigningException: () => LightsparkSigningException_default,
   NodeKeyCache: () => NodeKeyCache_default,
+  RSASigningKey: () => RSASigningKey,
   Requester: () => Requester_default,
+  Secp256k1SigningKey: () => Secp256k1SigningKey,
   ServerEnvironment: () => ServerEnvironment_default,
+  SigningKey: () => SigningKey,
+  SigningKeyType: () => SigningKeyType,
   StubAuthProvider: () => StubAuthProvider,
   apiDomainForEnvironment: () => apiDomainForEnvironment,
   b64decode: () => b64decode,
   b64encode: () => b64encode,
+  bytesToHex: () => bytesToHex,
   convertCurrencyAmount: () => convertCurrencyAmount,
+  createSha256Hash: () => createSha256Hash,
+  getErrorMsg: () => getErrorMsg,
+  hexToBytes: () => hexToBytes,
   isBrowser: () => isBrowser,
+  isError: () => isError,
+  isErrorMsg: () => isErrorMsg,
+  isErrorWithMessage: () => isErrorWithMessage,
   isNode: () => isNode,
   isType: () => isType,
   urlsafe_b64decode: () => urlsafe_b64decode
@@ -348,6 +359,50 @@ var KeyOrAlias = {
 
 // src/crypto/NodeKeyCache.ts
 var import_auto_bind = __toESM(require("auto-bind"), 1);
+
+// src/crypto/SigningKey.ts
+var import_secp256k1 = __toESM(require("secp256k1"), 1);
+function isAlias(key) {
+  return "alias" in key;
+}
+var SigningKey = class {
+  type;
+  constructor(type) {
+    this.type = type;
+  }
+};
+var RSASigningKey = class extends SigningKey {
+  constructor(privateKey, cryptoImpl) {
+    super("RSASigningKey" /* RSASigningKey */);
+    this.privateKey = privateKey;
+    this.cryptoImpl = cryptoImpl;
+  }
+  async sign(data) {
+    const key = isAlias(this.privateKey) ? this.privateKey.alias : this.privateKey;
+    return this.cryptoImpl.sign(key, data);
+  }
+};
+var Secp256k1SigningKey = class extends SigningKey {
+  constructor(privateKey) {
+    super("Secp256k1SigningKey" /* Secp256k1SigningKey */);
+    this.privateKey = privateKey;
+  }
+  async sign(data) {
+    const keyBytes = new Uint8Array(hexToBytes(this.privateKey));
+    const hash = await createSha256Hash(data);
+    const signResult = import_secp256k1.default.ecdsaSign(hash, keyBytes);
+    return signResult.signature;
+  }
+};
+
+// src/crypto/types.ts
+var SigningKeyType = /* @__PURE__ */ ((SigningKeyType2) => {
+  SigningKeyType2["RSASigningKey"] = "RSASigningKey";
+  SigningKeyType2["Secp256k1SigningKey"] = "Secp256k1SigningKey";
+  return SigningKeyType2;
+})(SigningKeyType || {});
+
+// src/crypto/NodeKeyCache.ts
 var NodeKeyCache = class {
   constructor(cryptoImpl = DefaultCrypto) {
     this.cryptoImpl = cryptoImpl;
@@ -355,16 +410,35 @@ var NodeKeyCache = class {
     (0, import_auto_bind.default)(this);
   }
   idToKey;
-  async loadKey(id, keyOrAlias) {
+  async loadKey(id, keyOrAlias, signingKeyType) {
+    let signingKey;
     if (keyOrAlias.alias !== void 0) {
-      this.idToKey.set(id, keyOrAlias.alias);
-      return keyOrAlias.alias;
+      switch (signingKeyType) {
+        case "RSASigningKey" /* RSASigningKey */:
+          signingKey = new RSASigningKey(
+            { alias: keyOrAlias.alias },
+            this.cryptoImpl
+          );
+          break;
+        default:
+          throw new LightsparkSigningException_default(
+            `Aliases are not supported for signing key type ${signingKeyType}`
+          );
+      }
+      this.idToKey.set(id, signingKey);
+      return signingKey;
     }
-    const decoded = b64decode(this.stripPemTags(keyOrAlias.key));
     try {
-      const key = await this.cryptoImpl.importPrivateSigningKey(decoded);
-      this.idToKey.set(id, key);
-      return key;
+      if (signingKeyType === "Secp256k1SigningKey" /* Secp256k1SigningKey */) {
+        signingKey = new Secp256k1SigningKey(keyOrAlias.key);
+      } else {
+        const decoded = b64decode(this.stripPemTags(keyOrAlias.key));
+        const cryptoKeyOrAlias = await this.cryptoImpl.importPrivateSigningKey(decoded);
+        const key = typeof cryptoKeyOrAlias === "string" ? { alias: cryptoKeyOrAlias } : cryptoKeyOrAlias;
+        signingKey = new RSASigningKey(key, this.cryptoImpl);
+      }
+      this.idToKey.set(id, signingKey);
+      return signingKey;
     } catch (e) {
       console.log("Error importing key: ", e);
     }
@@ -564,7 +638,7 @@ var Requester = class {
     const encodedPayload = new TextEncoderImpl().encode(
       JSON.stringify(payload)
     );
-    const signedPayload = await this.cryptoImpl.sign(key, encodedPayload);
+    const signedPayload = await key.sign(encodedPayload);
     const encodedSignedPayload = b64encode(signedPayload);
     headers["X-Lightspark-Signing"] = JSON.stringify({
       v: "1",
@@ -591,6 +665,16 @@ var apiDomainForEnvironment = (environment) => {
 };
 var ServerEnvironment_default = ServerEnvironment;
 
+// src/utils/createHash.ts
+var createSha256Hash = async (data) => {
+  if (isBrowser) {
+    return new Uint8Array(await window.crypto.subtle.digest("SHA-256", data));
+  } else {
+    const { createHash } = await import("crypto");
+    return createHash("sha256").update(data).digest();
+  }
+};
+
 // src/utils/currency.ts
 var CONVERSION_MAP = {
   ["BITCOIN" /* BITCOIN */]: {
@@ -661,6 +745,41 @@ var convertCurrencyAmount = (from, toUnit) => {
   };
 };
 
+// src/utils/errors.ts
+var isError = (e) => {
+  return Boolean(
+    typeof e === "object" && e !== null && "name" in e && typeof e.name === "string" && "message" in e && typeof e.message === "string" && "stack" in e && (!e.stack || typeof e.stack === "string")
+  );
+};
+var isErrorWithMessage = (e) => {
+  return Boolean(
+    typeof e === "object" && e !== null && "message" in e && typeof e.message === "string"
+  );
+};
+var getErrorMsg = (e) => {
+  return isErrorWithMessage(e) ? e.message : "Unknown error";
+};
+var isErrorMsg = (e, msg) => {
+  if (isError(e)) {
+    return e.message === msg;
+  }
+  return false;
+};
+
+// src/utils/hex.ts
+var bytesToHex = (bytes) => {
+  return bytes.reduce((acc, byte) => {
+    return acc += ("0" + byte.toString(16)).slice(-2);
+  }, "");
+};
+var hexToBytes = (hex) => {
+  const bytes = [];
+  for (let c = 0; c < hex.length; c += 2) {
+    bytes.push(parseInt(hex.substr(c, 2), 16));
+  }
+  return Uint8Array.from(bytes);
+};
+
 // src/utils/types.ts
 var isType = (typename) => (node) => {
   return node?.__typename === typename;
@@ -673,14 +792,25 @@ var isType = (typename) => (node) => {
   LightsparkException,
   LightsparkSigningException,
   NodeKeyCache,
+  RSASigningKey,
   Requester,
+  Secp256k1SigningKey,
   ServerEnvironment,
+  SigningKey,
+  SigningKeyType,
   StubAuthProvider,
   apiDomainForEnvironment,
   b64decode,
   b64encode,
+  bytesToHex,
   convertCurrencyAmount,
+  createSha256Hash,
+  getErrorMsg,
+  hexToBytes,
   isBrowser,
+  isError,
+  isErrorMsg,
+  isErrorWithMessage,
   isNode,
   isType,
   urlsafe_b64decode

package/dist/index.d.ts

@@ -66,12 +66,37 @@ declare const KeyOrAlias: {
     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): Promise<CryptoKey | string | null>;
-    getKey(id: string): CryptoKey | string | undefined;
+    loadKey(id: string, keyOrAlias: KeyOrAliasType, signingKeyType: SigningKeyType): Promise<SigningKey | null>;
+    getKey(id: string): SigningKey | undefined;
     hasKey(id: string): boolean;
     private stripPemTags;
 }
@@ -124,6 +149,8 @@ declare const b64decode: (encoded: string) => Uint8Array;
 declare const urlsafe_b64decode: (encoded: string) => Uint8Array;
 declare const b64encode: (data: ArrayBuffer) => string;
 
+declare const createSha256Hash: (data: Uint8Array) => Promise<Uint8Array>;
+
 /** Represents the value and unit for an amount of currency. **/
 type CurrencyAmount = {
     /** The original numeric value for this CurrencyAmount. **/
@@ -169,6 +196,17 @@ declare const convertCurrencyAmount: (from: CurrencyAmount, toUnit: CurrencyUnit
 declare const isBrowser: boolean;
 declare const isNode: 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;
+
 type Maybe<T> = T | null | undefined;
 type ExpandRecursively<T> = T extends object ? T extends infer O ? {
     [K in keyof O]: ExpandRecursively<O[K]>;
@@ -183,4 +221,4 @@ declare const isType: <T extends string>(typename: T) => <N extends {
     __typename: T;
 }>;
 
-export { AuthProvider, ById, CryptoInterface, DefaultCrypto, ExpandRecursively, GeneratedKeyPair, KeyOrAlias, KeyOrAliasType, LightsparkAuthException, LightsparkException, LightsparkSigningException, Maybe, NodeKeyCache, OmitTypename, Query, Requester, ServerEnvironment, StubAuthProvider, apiDomainForEnvironment, b64decode, b64encode, convertCurrencyAmount, isBrowser, isNode, isType, urlsafe_b64decode };
+export { AuthProvider, ById, CryptoInterface, DefaultCrypto, ExpandRecursively, GeneratedKeyPair, KeyOrAlias, KeyOrAliasType, LightsparkAuthException, LightsparkException, LightsparkSigningException, Maybe, NodeKeyCache, OmitTypename, Query, RSASigningKey, Requester, Secp256k1SigningKey, ServerEnvironment, SigningKey, SigningKeyType, StubAuthProvider, apiDomainForEnvironment, b64decode, b64encode, bytesToHex, convertCurrencyAmount, createSha256Hash, getErrorMsg, hexToBytes, isBrowser, isError, isErrorMsg, isErrorWithMessage, isNode, isType, urlsafe_b64decode };

package/dist/index.js

@@ -296,6 +296,50 @@ var KeyOrAlias = {
 
 // src/crypto/NodeKeyCache.ts
 import autoBind from "auto-bind";
+
+// src/crypto/SigningKey.ts
+import secp256k1 from "secp256k1";
+function isAlias(key) {
+  return "alias" in key;
+}
+var SigningKey = class {
+  type;
+  constructor(type) {
+    this.type = type;
+  }
+};
+var RSASigningKey = class extends SigningKey {
+  constructor(privateKey, cryptoImpl) {
+    super("RSASigningKey" /* RSASigningKey */);
+    this.privateKey = privateKey;
+    this.cryptoImpl = cryptoImpl;
+  }
+  async sign(data) {
+    const key = isAlias(this.privateKey) ? this.privateKey.alias : this.privateKey;
+    return this.cryptoImpl.sign(key, data);
+  }
+};
+var Secp256k1SigningKey = class extends SigningKey {
+  constructor(privateKey) {
+    super("Secp256k1SigningKey" /* Secp256k1SigningKey */);
+    this.privateKey = privateKey;
+  }
+  async sign(data) {
+    const keyBytes = new Uint8Array(hexToBytes(this.privateKey));
+    const hash = await createSha256Hash(data);
+    const signResult = secp256k1.ecdsaSign(hash, keyBytes);
+    return signResult.signature;
+  }
+};
+
+// src/crypto/types.ts
+var SigningKeyType = /* @__PURE__ */ ((SigningKeyType2) => {
+  SigningKeyType2["RSASigningKey"] = "RSASigningKey";
+  SigningKeyType2["Secp256k1SigningKey"] = "Secp256k1SigningKey";
+  return SigningKeyType2;
+})(SigningKeyType || {});
+
+// src/crypto/NodeKeyCache.ts
 var NodeKeyCache = class {
   constructor(cryptoImpl = DefaultCrypto) {
     this.cryptoImpl = cryptoImpl;
@@ -303,16 +347,35 @@ var NodeKeyCache = class {
     autoBind(this);
   }
   idToKey;
-  async loadKey(id, keyOrAlias) {
+  async loadKey(id, keyOrAlias, signingKeyType) {
+    let signingKey;
     if (keyOrAlias.alias !== void 0) {
-      this.idToKey.set(id, keyOrAlias.alias);
-      return keyOrAlias.alias;
+      switch (signingKeyType) {
+        case "RSASigningKey" /* RSASigningKey */:
+          signingKey = new RSASigningKey(
+            { alias: keyOrAlias.alias },
+            this.cryptoImpl
+          );
+          break;
+        default:
+          throw new LightsparkSigningException_default(
+            `Aliases are not supported for signing key type ${signingKeyType}`
+          );
+      }
+      this.idToKey.set(id, signingKey);
+      return signingKey;
     }
-    const decoded = b64decode(this.stripPemTags(keyOrAlias.key));
     try {
-      const key = await this.cryptoImpl.importPrivateSigningKey(decoded);
-      this.idToKey.set(id, key);
-      return key;
+      if (signingKeyType === "Secp256k1SigningKey" /* Secp256k1SigningKey */) {
+        signingKey = new Secp256k1SigningKey(keyOrAlias.key);
+      } else {
+        const decoded = b64decode(this.stripPemTags(keyOrAlias.key));
+        const cryptoKeyOrAlias = await this.cryptoImpl.importPrivateSigningKey(decoded);
+        const key = typeof cryptoKeyOrAlias === "string" ? { alias: cryptoKeyOrAlias } : cryptoKeyOrAlias;
+        signingKey = new RSASigningKey(key, this.cryptoImpl);
+      }
+      this.idToKey.set(id, signingKey);
+      return signingKey;
     } catch (e) {
       console.log("Error importing key: ", e);
     }
@@ -512,7 +575,7 @@ var Requester = class {
     const encodedPayload = new TextEncoderImpl().encode(
       JSON.stringify(payload)
     );
-    const signedPayload = await this.cryptoImpl.sign(key, encodedPayload);
+    const signedPayload = await key.sign(encodedPayload);
     const encodedSignedPayload = b64encode(signedPayload);
     headers["X-Lightspark-Signing"] = JSON.stringify({
       v: "1",
@@ -539,6 +602,16 @@ var apiDomainForEnvironment = (environment) => {
 };
 var ServerEnvironment_default = ServerEnvironment;
 
+// src/utils/createHash.ts
+var createSha256Hash = async (data) => {
+  if (isBrowser) {
+    return new Uint8Array(await window.crypto.subtle.digest("SHA-256", data));
+  } else {
+    const { createHash } = await import("crypto");
+    return createHash("sha256").update(data).digest();
+  }
+};
+
 // src/utils/currency.ts
 var CONVERSION_MAP = {
   ["BITCOIN" /* BITCOIN */]: {
@@ -609,6 +682,41 @@ var convertCurrencyAmount = (from, toUnit) => {
   };
 };
 
+// src/utils/errors.ts
+var isError = (e) => {
+  return Boolean(
+    typeof e === "object" && e !== null && "name" in e && typeof e.name === "string" && "message" in e && typeof e.message === "string" && "stack" in e && (!e.stack || typeof e.stack === "string")
+  );
+};
+var isErrorWithMessage = (e) => {
+  return Boolean(
+    typeof e === "object" && e !== null && "message" in e && typeof e.message === "string"
+  );
+};
+var getErrorMsg = (e) => {
+  return isErrorWithMessage(e) ? e.message : "Unknown error";
+};
+var isErrorMsg = (e, msg) => {
+  if (isError(e)) {
+    return e.message === msg;
+  }
+  return false;
+};
+
+// src/utils/hex.ts
+var bytesToHex = (bytes) => {
+  return bytes.reduce((acc, byte) => {
+    return acc += ("0" + byte.toString(16)).slice(-2);
+  }, "");
+};
+var hexToBytes = (hex) => {
+  const bytes = [];
+  for (let c = 0; c < hex.length; c += 2) {
+    bytes.push(parseInt(hex.substr(c, 2), 16));
+  }
+  return Uint8Array.from(bytes);
+};
+
 // src/utils/types.ts
 var isType = (typename) => (node) => {
   return node?.__typename === typename;
@@ -620,14 +728,25 @@ export {
   LightsparkException_default as LightsparkException,
   LightsparkSigningException_default as LightsparkSigningException,
   NodeKeyCache_default as NodeKeyCache,
+  RSASigningKey,
   Requester_default as Requester,
+  Secp256k1SigningKey,
   ServerEnvironment_default as ServerEnvironment,
+  SigningKey,
+  SigningKeyType,
   StubAuthProvider,
   apiDomainForEnvironment,
   b64decode,
   b64encode,
+  bytesToHex,
   convertCurrencyAmount,
+  createSha256Hash,
+  getErrorMsg,
+  hexToBytes,
   isBrowser,
+  isError,
+  isErrorMsg,
+  isErrorWithMessage,
   isNode,
   isType,
   urlsafe_b64decode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightsparkdev/core",
-  "version": "0.3.11",
+  "version": "1.0.1",
   "description": "Lightspark JS SDK",
   "author": "Lightspark Inc.",
   "keywords": [
@@ -36,7 +36,7 @@
     }
   },
   "engines": {
-    "node": ">=14.16"
+    "node": ">=18.17.0"
   },
   "browser": {
     "crypto": false
@@ -68,6 +68,7 @@
     "dayjs": "^1.11.7",
     "graphql": "^16.6.0",
     "graphql-ws": "^5.11.3",
+    "secp256k1": "^5.0.0",
     "text-encoding": "^0.7.0",
     "ws": "^8.12.1",
     "zen-observable-ts": "^1.1.0"
@@ -76,13 +77,14 @@
     "@lightsparkdev/eslint-config": "*",
     "@lightsparkdev/tsconfig": "0.0.0",
     "@types/crypto-js": "^4.1.1",
+    "@types/secp256k1": "^4.0.3",
     "@types/ws": "^8.5.4",
     "eslint": "^8.3.0",
     "eslint-watch": "^8.0.0",
-    "jest": "^29.4.1",
+    "jest": "^29.6.2",
     "prettier": "3.0.2",
     "prettier-plugin-organize-imports": "^3.2.2",
-    "ts-jest": "^29.0.5",
+    "ts-jest": "^29.1.1",
     "tsc-absolute": "^1.0.1",
     "tsup": "^6.7.0",
     "typescript": "^4.9.5"

package/src/crypto/NodeKeyCache.ts

@@ -4,11 +4,18 @@ import autoBind from "auto-bind";
 
 import { b64decode } from "../utils/base64.js";
 import type { CryptoInterface } from "./crypto.js";
-import { DefaultCrypto } from "./crypto.js";
+import { DefaultCrypto, LightsparkSigningException } from "./crypto.js";
 import type { KeyOrAliasType } from "./KeyOrAlias.js";
+import {
+  RSASigningKey,
+  Secp256k1SigningKey,
+  type SigningKey,
+} from "./SigningKey.js";
+import { SigningKeyType } from "./types.js";
 
 class NodeKeyCache {
-  private idToKey: Map<string, CryptoKey | string>;
+  private idToKey: Map<string, SigningKey>;
+
   constructor(private readonly cryptoImpl: CryptoInterface = DefaultCrypto) {
     this.idToKey = new Map();
     autoBind(this);
@@ -17,23 +24,51 @@ class NodeKeyCache {
   public async loadKey(
     id: string,
     keyOrAlias: KeyOrAliasType,
-  ): Promise<CryptoKey | string | null> {
+    signingKeyType: SigningKeyType,
+  ): Promise<SigningKey | null> {
+    let signingKey: SigningKey;
+
     if (keyOrAlias.alias !== undefined) {
-      this.idToKey.set(id, keyOrAlias.alias);
-      return keyOrAlias.alias;
+      switch (signingKeyType) {
+        case SigningKeyType.RSASigningKey:
+          signingKey = new RSASigningKey(
+            { alias: keyOrAlias.alias },
+            this.cryptoImpl,
+          );
+          break;
+        default:
+          throw new LightsparkSigningException(
+            `Aliases are not supported for signing key type ${signingKeyType}`,
+          );
+      }
+
+      this.idToKey.set(id, signingKey);
+      return signingKey;
     }
-    const decoded = b64decode(this.stripPemTags(keyOrAlias.key));
+
     try {
-      const key = await this.cryptoImpl.importPrivateSigningKey(decoded);
-      this.idToKey.set(id, key);
-      return key;
+      if (signingKeyType === SigningKeyType.Secp256k1SigningKey) {
+        signingKey = new Secp256k1SigningKey(keyOrAlias.key);
+      } else {
+        const decoded = b64decode(this.stripPemTags(keyOrAlias.key));
+        const cryptoKeyOrAlias =
+          await this.cryptoImpl.importPrivateSigningKey(decoded);
+        const key =
+          typeof cryptoKeyOrAlias === "string"
+            ? { alias: cryptoKeyOrAlias }
+            : cryptoKeyOrAlias;
+        signingKey = new RSASigningKey(key, this.cryptoImpl);
+      }
+
+      this.idToKey.set(id, signingKey);
+      return signingKey;
     } catch (e) {
       console.log("Error importing key: ", e);
     }
     return null;
   }
 
-  public getKey(id: string): CryptoKey | string | undefined {
+  public getKey(id: string): SigningKey | undefined {
     return this.idToKey.get(id);
   }
 

package/src/crypto/SigningKey.ts

@@ -0,0 +1,54 @@
+import secp256k1 from "secp256k1";
+import {
+  createSha256Hash,
+  hexToBytes,
+  SigningKeyType,
+  type CryptoInterface,
+} from "../index.js";
+
+interface Alias {
+  alias: string;
+}
+
+function isAlias(key: CryptoKey | Alias): key is Alias {
+  return "alias" in key;
+}
+
+export abstract class SigningKey {
+  readonly type: SigningKeyType;
+
+  constructor(type: SigningKeyType) {
+    this.type = type;
+  }
+
+  abstract sign(data: Uint8Array): Promise<ArrayBuffer>;
+}
+
+export class RSASigningKey extends SigningKey {
+  constructor(
+    private readonly privateKey: CryptoKey | Alias,
+    private readonly cryptoImpl: CryptoInterface,
+  ) {
+    super(SigningKeyType.RSASigningKey);
+  }
+
+  async sign(data: Uint8Array) {
+    const key = isAlias(this.privateKey)
+      ? this.privateKey.alias
+      : this.privateKey;
+    return this.cryptoImpl.sign(key, data);
+  }
+}
+
+export class Secp256k1SigningKey extends SigningKey {
+  constructor(private readonly privateKey: string) {
+    super(SigningKeyType.Secp256k1SigningKey);
+  }
+
+  async sign(data: Uint8Array) {
+    const keyBytes = new Uint8Array(hexToBytes(this.privateKey));
+    const hash = await createSha256Hash(data);
+    const signResult = secp256k1.ecdsaSign(hash, keyBytes);
+    return signResult.signature;
+  }
+}

package/src/crypto/index.ts

@@ -4,3 +4,5 @@ export * from "./crypto.js";
 export * from "./KeyOrAlias.js";
 export { default as LightsparkSigningException } from "./LightsparkSigningException.js";
 export { default as NodeKeyCache } from "./NodeKeyCache.js";
+export * from "./SigningKey.js";
+export * from "./types.js";

package/src/crypto/types.ts

@@ -0,0 +1,4 @@
+export enum SigningKeyType {
+  RSASigningKey = "RSASigningKey",
+  Secp256k1SigningKey = "Secp256k1SigningKey",
+}

package/src/requester/Requester.ts

@@ -228,9 +228,10 @@ class Requester {
     const encodedPayload = new TextEncoderImpl().encode(
       JSON.stringify(payload),
     );
-    const signedPayload = await this.cryptoImpl.sign(key, encodedPayload);
-    const encodedSignedPayload = b64encode(signedPayload);
 
+    const signedPayload = await key.sign(encodedPayload);
+
+    const encodedSignedPayload = b64encode(signedPayload);
     headers["X-Lightspark-Signing"] = JSON.stringify({
       v: "1",
       signature: encodedSignedPayload,

package/src/utils/createHash.ts

@@ -0,0 +1,12 @@
+import { isBrowser } from "./environment.js";
+
+export const createSha256Hash = async (
+  data: Uint8Array,
+): Promise<Uint8Array> => {
+  if (isBrowser) {
+    return new Uint8Array(await window.crypto.subtle.digest("SHA-256", data));
+  } else {
+    const { createHash } = await import("crypto");
+    return createHash("sha256").update(data).digest();
+  }
+};

package/src/utils/errors.ts

@@ -0,0 +1,36 @@
+export const isError = (e: unknown): e is Error => {
+  return Boolean(
+    typeof e === "object" &&
+      e !== null &&
+      "name" in e &&
+      typeof e.name === "string" &&
+      "message" in e &&
+      typeof e.message === "string" &&
+      "stack" in e &&
+      (!e.stack || typeof e.stack === "string"),
+  );
+};
+
+type ErrorWithMessage = {
+  message: string;
+};
+
+export const isErrorWithMessage = (e: unknown): e is ErrorWithMessage => {
+  return Boolean(
+    typeof e === "object" &&
+      e !== null &&
+      "message" in e &&
+      typeof e.message === "string",
+  );
+};
+
+export const getErrorMsg = (e: unknown): string => {
+  return isErrorWithMessage(e) ? e.message : "Unknown error";
+};
+
+export const isErrorMsg = (e: unknown, msg: string) => {
+  if (isError(e)) {
+    return e.message === msg;
+  }
+  return false;
+};

package/src/utils/hex.ts

@@ -0,0 +1,15 @@
+export const bytesToHex = (bytes: Uint8Array): string => {
+  return bytes.reduce((acc: string, byte: number) => {
+    return (acc += ("0" + byte.toString(16)).slice(-2));
+  }, "");
+};
+
+export const hexToBytes = (hex: string): Uint8Array => {
+  const bytes: number[] = [];
+
+  for (let c = 0; c < hex.length; c += 2) {
+    bytes.push(parseInt(hex.substr(c, 2), 16));
+  }
+
+  return Uint8Array.from(bytes);
+};

package/src/utils/index.ts

@@ -1,6 +1,9 @@
 // Copyright ©, 2023-present, Lightspark Group, Inc. - All Rights Reserved
 
 export * from "./base64.js";
+export * from "./createHash.js";
 export * from "./currency.js";
 export * from "./environment.js";
+export * from "./errors.js";
+export * from "./hex.js";
 export * from "./types.js";