@wishknish/knishio-client-ts 0.9.2 → 0.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wishknish/knishio-client-ts",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "productName": "Knish.IO TypeScript SDK Client",
   "description": "TypeScript implementation of the Knish.IO SDK to consume Knish.IO GraphQL APIs with enhanced type safety.",
   "license": "GPL-3.0-or-later",

package/src/core/Wallet.ts

@@ -608,11 +608,30 @@ export default class Wallet {
   }
 
   serializeKey(key: Uint8Array): string {
-    return btoa(String.fromCharCode(...key))
+    if (typeof Buffer !== 'undefined') {
+      return Buffer.from(key).toString('base64')
+    }
+    // A single String.fromCharCode(...key) spread 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: string): Uint8Array {
+    if (typeof Buffer !== 'undefined') {
+      return new Uint8Array(Buffer.from(serializedKey, 'base64'))
+    }
+    // Spreading the binary string ([...str]) allocates one single-char string per
+    // byte — prohibitive for multi-MB payloads. Index directly instead.
     const binaryString = atob(serializedKey)
-    return new Uint8Array([...binaryString].map(char => char.charCodeAt(0)))
+    const bytes = new Uint8Array(binaryString.length)
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i)
+    }
+    return bytes
   }
 }

package/src/libraries/array.ts

@@ -57,11 +57,13 @@ export function deepCloning<T>(
  * Used for batch processing operations
  */
 export function chunkArray<T>(arr: T[], size: number): T[][] {
-  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: T[][] = []
+  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
 }
 
 /**

package/src/libraries/strings.ts

@@ -220,15 +220,20 @@ export function hexToBase64(hexString: string): string {
     
     // Convert hex to bytes
     const bytes = hexStringToBuffer(cleanHex)
-    
-    // Convert to base64
-    if (typeof btoa !== 'undefined') {
-      // Browser environment
-      return btoa(String.fromCharCode(...bytes))
-    } else {
-      // Node.js environment or manual conversion
+
+    // Buffer fast path (Node). Byte-identical to the btoa encoding below.
+    if (typeof Buffer !== 'undefined') {
       return Buffer.from(bytes).toString('base64')
     }
+    // Browser fallback: a single String.fromCharCode(...bytes) spread 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 < bytes.length; i += CHUNK_SIZE) {
+      binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK_SIZE))
+    }
+    return btoa(binary)
   } catch (error) {
     throw new Error(`Failed to convert hex to base64: ${error instanceof Error ? error.message : String(error)}`)
   }