@wishknish/knishio-client-js 0.9.0 → 0.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wishknish/knishio-client-js",
-  "version": "0.9.0",
+  "version": "0.9.3",
   "type": "module",
   "productName": "Knish.IO Javascript SDK Client",
   "description": "JavaScript implementation of the Knish.IO SDK to consume Knish.IO GraphQL APIs.",
@@ -65,22 +65,18 @@
     "wonka": "^6.3.5"
   },
   "devDependencies": {
-    "@jest/globals": "^29.7.0",
+    "@jest/globals": "^30.4.1",
     "@rollup/plugin-babel": "^6.1.0",
     "@rollup/plugin-commonjs": "^28.0.9",
     "@rollup/plugin-node-resolve": "^16.0.3",
+    "@swc/core": "^1.15.43",
+    "@swc/jest": "^0.2.39",
     "buffer": "^6.0.3",
-    "esbuild-jest": "^0.5.0",
-    "eslint": "^8.57.1",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-n": "^16.6.2",
-    "eslint-plugin-promise": "^6.6.0",
-    "eslint-plugin-vue": "^9.33.0",
-    "esmock": "^2.7.3",
-    "jest": "^29.7.0",
+    "eslint": "^9.39.0",
+    "jest": "^30.4.2",
+    "neostandard": "^0.13.0",
     "rollup": "^4.57.1",
-    "vite": "^6.4.1"
+    "vite": "^7.3.5"
   },
   "browserslist": [
     "> 1%",
@@ -89,7 +85,7 @@
   ],
   "scripts": {
     "build": "vite build --config build/vite.config.mjs",
-    "lint": "eslint --ext .js src",
+    "lint": "eslint src",
     "test": "jest",
     "test:coverage": "jest --coverage",
     "selftest": "npm run build && node tests/scripts/self-test.js",

package/src/Wallet.js

@@ -300,10 +300,23 @@ export default class Wallet {
   }
 
   serializeKey (key) {
-    return btoa(String.fromCharCode.apply(null, key))
+    if (typeof Buffer !== 'undefined') {
+      return Buffer.from(key).toString('base64')
+    }
+    // String.fromCharCode.apply(null, key) overflows the call stack once the
+    // payload exceeds the engine's argument limit (~64K), so convert in chunks.
+    let binary = ''
+    const CHUNK_SIZE = 0x8000
+    for (let i = 0; i < key.length; i += CHUNK_SIZE) {
+      binary += String.fromCharCode(...key.subarray(i, i + CHUNK_SIZE))
+    }
+    return btoa(binary)
   }
 
   deserializeKey (serializedKey) {
+    if (typeof Buffer !== 'undefined') {
+      return new Uint8Array(Buffer.from(serializedKey, 'base64'))
+    }
     const binaryString = atob(serializedKey)
     return new Uint8Array(binaryString.length).map((_, i) => binaryString.charCodeAt(i))
   }
@@ -486,6 +499,18 @@ export default class Wallet {
     const messageString = JSON.stringify(message)
     const messageUint8 = new TextEncoder().encode(messageString)
     const deserializedPubkey = this.deserializeKey(recipientPubkey)
+    // ML-KEM-768 public keys are exactly 1184 bytes. A wrong-length key here almost always means the
+    // node did not advertise an ML-KEM public key in its auth `key` field (e.g. a validator predating
+    // the PQ-transport build). Fail with an actionable message rather than the crypto lib's cryptic
+    // `"publicKey" expected Uint8Array of length 1184, got length=N` assertion.
+    const ML_KEM_768_PUBLIC_KEY_BYTES = 1184
+    if (deserializedPubkey.length !== ML_KEM_768_PUBLIC_KEY_BYTES) {
+      throw new Error(
+        `KnishIO: cannot ML-KEM-encrypt — recipient public key is ${deserializedPubkey.length} bytes, ` +
+        `expected ${ML_KEM_768_PUBLIC_KEY_BYTES} (ML-KEM-768). The node likely did not advertise an ML-KEM ` +
+        'public key (upgrade the validator to a PQ-transport build), or authenticate with { encrypt: false }.'
+      )
+    }
     const { cipherText, sharedSecret } = MlKEM768.encapsulate(deserializedPubkey)
     const encryptedMessage = await this.encryptWithSharedSecret(messageUint8, sharedSecret)
     return {

package/src/libraries/array.js

@@ -6,11 +6,13 @@
  * @return {array}
  */
 export function chunkArray (arr, size) {
-  if (!arr.length) {
-    return []
+  // Iterative: the previous recursive form (`concat` + `slice(size)` per level) blew
+  // the call stack and allocated O(n^2) once arr grew past a few thousand elements.
+  const chunks = []
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size))
   }
-
-  return [arr.slice(0, size)].concat(chunkArray(arr.slice(size), size))
+  return chunks
 }
 
 export function deepCloning (

package/src/libraries/strings.js

@@ -45,13 +45,18 @@ export function chunkSubstr (str, size) {
  * @return {string}
  */
 export function randomString (length = 256, alphabet = 'abcdef0123456789') {
-  let array = new Uint8Array(length)
+  const array = new Uint8Array(length)
 
-  array = crypto.getRandomValues(array)
+  crypto.getRandomValues(array)
 
-  array = array.map(x => alphabet.charCodeAt(x % alphabet.length))
-
-  return String.fromCharCode.apply(null, array)
+  // Build in a loop: String.fromCharCode.apply(null, array) spread every byte as a
+  // function argument and overflowed the call stack for a large caller-supplied length.
+  // `alphabet.charAt(x % len)` is the same mapping as the old fromCharCode(charCodeAt).
+  let result = ''
+  for (let i = 0; i < length; i++) {
+    result += alphabet.charAt(array[i] % alphabet.length)
+  }
+  return result
 }
 
 /**
@@ -120,7 +125,19 @@ export function hexStringToBuffer (hexString) {
  */
 export function hexToBase64 (string) {
   const bytes = hexStringToBuffer(string)
-  return btoa(String.fromCharCode.apply(null, bytes))
+  // Buffer fast path (Node). Byte-identical to the btoa encoding below.
+  if (typeof Buffer !== 'undefined') {
+    return Buffer.from(bytes).toString('base64')
+  }
+  // Browser fallback: String.fromCharCode.apply(null, bytes) spreads every byte as a
+  // function argument and overflows the call stack past the engine's argument limit
+  // (~64K), so convert in chunks.
+  let binary = ''
+  const CHUNK_SIZE = 0x8000
+  for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK_SIZE))
+  }
+  return btoa(binary)
 }
 
 /**
@@ -130,7 +147,16 @@ export function hexToBase64 (string) {
  * @return {string}
  */
 export function base64ToHex (string) {
-  const bytes = new Uint8Array(atob(string).split('').map(char => char.charCodeAt(0)))
+  // Buffer fast path (Node); index loop otherwise. The old `atob(string).split('')`
+  // allocated one single-char string per byte — prohibitive for multi-MB payloads.
+  if (typeof Buffer !== 'undefined') {
+    return bufferToHexString(new Uint8Array(Buffer.from(string, 'base64')))
+  }
+  const binary = atob(string)
+  const bytes = new Uint8Array(binary.length)
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i)
+  }
   return bufferToHexString(bytes)
 }
 

package/src/types/index.js

@@ -1,2 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })