@cofhe/sdk 0.1.1 → 0.2.0

package/dist/web.d.cts

@@ -1,10 +1,19 @@
-import { d as CofhesdkInputConfig, b as CofhesdkConfig, a as CofhesdkClient } from './types-bB7wLj0q.cjs';
-import './permit-S9CnI6MF.cjs';
-import 'zod';
+import { C as CofhesdkInputConfig, a as CofhesdkConfig, b as CofhesdkClient, E as EncryptableItem } from './clientTypes-5_1nwtUe.cjs';
 import 'viem';
 import './types-KImPrEIe.cjs';
+import 'zod';
+import './permit-fUSe6KKq.cjs';
 import 'zustand/vanilla';
 
+/**
+ * Terminate the worker
+ */
+declare function terminateWorker(): void;
+/**
+ * Check if workers are available
+ */
+declare function areWorkersAvailable(): boolean;
+
 /**
  * Creates a CoFHE SDK configuration for web with IndexedDB storage as default
  * @param config - The CoFHE SDK input configuration (fheKeyStorage will default to IndexedDB if not provided)
@@ -14,9 +23,16 @@ declare function createCofhesdkConfig(config: CofhesdkInputConfig): CofhesdkConf
 /**
  * Creates a CoFHE SDK client instance for web with TFHE automatically configured
  * TFHE will be initialized automatically on first encryption - no manual setup required
+ * Workers are automatically enabled if available (can be disabled via config.useWorkers)
  * @param config - The CoFHE SDK configuration (use createCofhesdkConfig to create with web defaults)
  * @returns The CoFHE SDK client instance
  */
-declare function createCofhesdkClient(config: CofhesdkConfig): CofhesdkClient;
+declare function createCofhesdkClient<TConfig extends CofhesdkConfig>(config: TConfig): CofhesdkClient<TConfig>;
+
+/**
+ * Test helper: Create a client with custom worker function (for testing fallback behavior)
+ * @internal - Only for testing purposes
+ */
+declare function createCofhesdkClientWithCustomWorker(config: CofhesdkConfig, customZkProveWorkerFn: (fheKeyHex: string, crsHex: string, items: EncryptableItem[], metadata: Uint8Array) => Promise<Uint8Array>): CofhesdkClient;
 
-export { createCofhesdkClient, createCofhesdkConfig };
+export { areWorkersAvailable, createCofhesdkClient, createCofhesdkClientWithCustomWorker, createCofhesdkConfig, terminateWorker };

package/dist/web.d.ts

@@ -1,10 +1,19 @@
-import { d as CofhesdkInputConfig, b as CofhesdkConfig, a as CofhesdkClient } from './types-PhwGgQvs.js';
-import './permit-S9CnI6MF.js';
-import 'zod';
+import { C as CofhesdkInputConfig, a as CofhesdkConfig, b as CofhesdkClient, E as EncryptableItem } from './clientTypes-Es7fyi65.js';
 import 'viem';
 import './types-KImPrEIe.js';
+import 'zod';
+import './permit-fUSe6KKq.js';
 import 'zustand/vanilla';
 
+/**
+ * Terminate the worker
+ */
+declare function terminateWorker(): void;
+/**
+ * Check if workers are available
+ */
+declare function areWorkersAvailable(): boolean;
+
 /**
  * Creates a CoFHE SDK configuration for web with IndexedDB storage as default
  * @param config - The CoFHE SDK input configuration (fheKeyStorage will default to IndexedDB if not provided)
@@ -14,9 +23,16 @@ declare function createCofhesdkConfig(config: CofhesdkInputConfig): CofhesdkConf
 /**
  * Creates a CoFHE SDK client instance for web with TFHE automatically configured
  * TFHE will be initialized automatically on first encryption - no manual setup required
+ * Workers are automatically enabled if available (can be disabled via config.useWorkers)
  * @param config - The CoFHE SDK configuration (use createCofhesdkConfig to create with web defaults)
  * @returns The CoFHE SDK client instance
  */
-declare function createCofhesdkClient(config: CofhesdkConfig): CofhesdkClient;
+declare function createCofhesdkClient<TConfig extends CofhesdkConfig>(config: TConfig): CofhesdkClient<TConfig>;
+
+/**
+ * Test helper: Create a client with custom worker function (for testing fallback behavior)
+ * @internal - Only for testing purposes
+ */
+declare function createCofhesdkClientWithCustomWorker(config: CofhesdkConfig, customZkProveWorkerFn: (fheKeyHex: string, crsHex: string, items: EncryptableItem[], metadata: Uint8Array) => Promise<Uint8Array>): CofhesdkClient;
 
-export { createCofhesdkClient, createCofhesdkConfig };
+export { areWorkersAvailable, createCofhesdkClient, createCofhesdkClientWithCustomWorker, createCofhesdkConfig, terminateWorker };

package/dist/web.js

@@ -1,22 +1,176 @@
-import { createCofhesdkConfigBase, createCofhesdkClientBase } from './chunk-KFGPTJ6X.js';
-import './chunk-GZCQQYVI.js';
-import './chunk-LU7BMUUT.js';
-import { get, set, del } from 'idb-keyval';
+import { createCofhesdkConfigBase, createCofhesdkClientBase, fheTypeToString } from './chunk-WGCRJCBR.js';
+import './chunk-WEAZ25JO.js';
+import './chunk-UGBVZNRT.js';
+import { constructClient } from 'iframe-shared-storage';
 import init, { init_panic_hook, TfheCompactPublicKey, CompactPkeCrs, ProvenCompactCiphertextList } from 'tfhe';
 
 var createWebStorage = () => {
+  const client = constructClient({
+    iframe: {
+      src: "https://iframe-shared-storage.vercel.app/hub.html",
+      messagingOptions: {
+        enableLog: "both"
+      },
+      iframeReadyTimeoutMs: 3e4,
+      // if the iframe is not initied during this interval AND a reuqest is made, such request will throw an error
+      methodCallTimeoutMs: 1e4,
+      // if a method call is not answered during this interval, the call will throw an error
+      methodCallRetries: 3
+      // number of retries for a method call if it times out
+    }
+  });
+  const indexedDBKeyval = client.indexedDBKeyval;
   return {
     getItem: async (name) => {
-      return await get(name) || null;
+      return await indexedDBKeyval.get(name) ?? null;
     },
     setItem: async (name, value) => {
-      await set(name, value);
+      await indexedDBKeyval.set(name, value);
     },
     removeItem: async (name) => {
-      await del(name);
+      await indexedDBKeyval.del(name);
     }
   };
 };
+
+// web/workerManager.ts
+var ZkProveWorkerManager = class {
+  worker = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  requestCounter = 0;
+  workerReady = false;
+  initializationPromise = null;
+  /**
+   * Initialize the worker
+   */
+  async initializeWorker() {
+    if (this.worker && this.workerReady) {
+      return;
+    }
+    if (this.initializationPromise) {
+      return this.initializationPromise;
+    }
+    this.initializationPromise = new Promise((resolve, reject) => {
+      try {
+        if (typeof Worker === "undefined") {
+          reject(new Error("Web Workers not supported"));
+          return;
+        }
+        try {
+          this.worker = new Worker(new URL("./zkProve.worker.js", import.meta.url), { type: "module" });
+        } catch (error) {
+          reject(new Error(`Failed to create worker: ${error}`));
+          return;
+        }
+        this.worker.onmessage = (event) => {
+          const { id, type, result, error } = event.data;
+          if (type === "ready") {
+            this.workerReady = true;
+            resolve();
+            return;
+          }
+          const pending = this.pendingRequests.get(id);
+          if (!pending) {
+            console.warn("[Worker Manager] Received response for unknown request:", id);
+            return;
+          }
+          clearTimeout(pending.timeoutId);
+          this.pendingRequests.delete(id);
+          if (type === "success" && result) {
+            pending.resolve(new Uint8Array(result));
+          } else if (type === "error") {
+            pending.reject(new Error(error || "Worker error"));
+          } else {
+            pending.reject(new Error("Invalid response from worker"));
+          }
+        };
+        this.worker.onerror = (error) => {
+          console.error("[Worker Manager] Worker error event:", error);
+          console.error("[Worker Manager] Error message:", error.message);
+          console.error("[Worker Manager] Error filename:", error.filename);
+          console.error("[Worker Manager] Error lineno:", error.lineno);
+          if (!this.workerReady) {
+            reject(new Error(`Worker failed to initialize: ${error.message || "Unknown error"}`));
+          }
+          this.pendingRequests.forEach(({ reject: reject2, timeoutId }) => {
+            clearTimeout(timeoutId);
+            reject2(new Error("Worker encountered an error"));
+          });
+          this.pendingRequests.clear();
+        };
+        setTimeout(() => {
+          if (!this.workerReady) {
+            reject(new Error("Worker initialization timeout"));
+          }
+        }, 5e3);
+      } catch (error) {
+        reject(error);
+      }
+    });
+    return this.initializationPromise;
+  }
+  /**
+   * Submit a proof generation request to the worker
+   */
+  async submitProof(fheKeyHex, crsHex, items, metadata) {
+    await this.initializeWorker();
+    const id = `zkprove-${Date.now()}-${this.requestCounter++}`;
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error("Worker request timeout (30s)"));
+      }, 3e4);
+      this.pendingRequests.set(id, { resolve, reject, timeoutId });
+      const message = {
+        id,
+        type: "zkProve",
+        fheKeyHex,
+        crsHex,
+        items,
+        metadata: Array.from(metadata)
+      };
+      this.worker.postMessage(message);
+    });
+  }
+  /**
+   * Terminate the worker and clean up
+   */
+  terminate() {
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+      this.workerReady = false;
+      this.initializationPromise = null;
+    }
+    this.pendingRequests.forEach(({ reject, timeoutId }) => {
+      clearTimeout(timeoutId);
+      reject(new Error("Worker terminated"));
+    });
+    this.pendingRequests.clear();
+  }
+  /**
+   * Check if worker is available
+   */
+  isAvailable() {
+    return typeof Worker !== "undefined";
+  }
+};
+var workerManager = null;
+function getWorkerManager() {
+  if (!workerManager) {
+    workerManager = new ZkProveWorkerManager();
+  }
+  return workerManager;
+}
+function terminateWorker() {
+  if (workerManager) {
+    workerManager.terminate();
+    workerManager = null;
+  }
+}
+function areWorkersAvailable() {
+  return typeof Worker !== "undefined";
+}
 var tfheInitialized = false;
 async function initTfhe() {
   if (tfheInitialized)
@@ -45,8 +199,17 @@ var zkBuilderAndCrsGenerator = (fhe, crs) => {
   const zkCrs = CompactPkeCrs.deserialize(fromHexString(crs));
   return { zkBuilder, zkCrs };
 };
+async function zkProveWithWorker(fheKeyHex, crsHex, items, metadata) {
+  const serializedItems = items.map((item) => ({
+    utype: fheTypeToString(item.utype),
+    data: typeof item.data === "bigint" ? item.data.toString() : item.data
+  }));
+  const workerManager2 = getWorkerManager();
+  return await workerManager2.submitProof(fheKeyHex, crsHex, serializedItems, metadata);
+}
 function createCofhesdkConfig(config) {
   return createCofhesdkConfigBase({
+    environment: "web",
     ...config,
     fheKeyStorage: config.fheKeyStorage === null ? null : config.fheKeyStorage ?? createWebStorage()
   });
@@ -57,8 +220,21 @@ function createCofhesdkClient(config) {
     zkBuilderAndCrsGenerator,
     tfhePublicKeyDeserializer,
     compactPkeCrsDeserializer,
-    initTfhe
+    initTfhe,
+    // Always provide the worker function if available - config.useWorkers controls usage
+    // areWorkersAvailable will return true if the Worker API is available and false in Node.js
+    zkProveWorkerFn: areWorkersAvailable() ? zkProveWithWorker : void 0
+  });
+}
+function createCofhesdkClientWithCustomWorker(config, customZkProveWorkerFn) {
+  return createCofhesdkClientBase({
+    config,
+    zkBuilderAndCrsGenerator,
+    tfhePublicKeyDeserializer,
+    compactPkeCrsDeserializer,
+    initTfhe,
+    zkProveWorkerFn: customZkProveWorkerFn
   });
 }
 
-export { createCofhesdkClient, createCofhesdkConfig };
+export { areWorkersAvailable, createCofhesdkClient, createCofhesdkClientWithCustomWorker, createCofhesdkConfig, terminateWorker };

package/dist/zkProve.worker.cjs

@@ -0,0 +1,93 @@
+'use strict';
+
+// web/zkProve.worker.ts
+var tfheModule = null;
+var initialized = false;
+async function initTfhe() {
+  if (initialized)
+    return;
+  try {
+    tfheModule = await import('tfhe');
+    await tfheModule.default();
+    await tfheModule.init_panic_hook();
+    initialized = true;
+    console.log("[Worker] TFHE initialized");
+  } catch (error) {
+    console.error("[Worker] Failed to initialize TFHE:", error);
+    throw error;
+  }
+}
+function fromHexString(hexString) {
+  const cleanString = hexString.length % 2 === 1 ? `0${hexString}` : hexString;
+  const arr = cleanString.replace(/^0x/, "").match(/.{1,2}/g);
+  if (!arr)
+    return new Uint8Array();
+  return new Uint8Array(arr.map((byte) => parseInt(byte, 16)));
+}
+self.onmessage = async (event) => {
+  const { id, type, fheKeyHex, crsHex, items, metadata } = event.data;
+  if (type !== "zkProve") {
+    self.postMessage({
+      id,
+      type: "error",
+      error: "Invalid message type"
+    });
+    return;
+  }
+  try {
+    await initTfhe();
+    if (!tfheModule) {
+      throw new Error("TFHE module not initialized");
+    }
+    const fheKeyBytes = fromHexString(fheKeyHex);
+    const crsBytes = fromHexString(crsHex);
+    const fheKey = tfheModule.TfheCompactPublicKey.deserialize(fheKeyBytes);
+    const crs = tfheModule.CompactPkeCrs.deserialize(crsBytes);
+    const builder = tfheModule.ProvenCompactCiphertextList.builder(fheKey);
+    for (const item of items) {
+      switch (item.utype) {
+        case "bool":
+          builder.push_boolean(Boolean(item.data));
+          break;
+        case "uint8":
+          builder.push_u8(Number(item.data));
+          break;
+        case "uint16":
+          builder.push_u16(Number(item.data));
+          break;
+        case "uint32":
+          builder.push_u32(Number(item.data));
+          break;
+        case "uint64":
+          builder.push_u64(BigInt(item.data));
+          break;
+        case "uint128":
+          builder.push_u128(BigInt(item.data));
+          break;
+        case "uint160":
+          builder.push_u160(BigInt(item.data));
+          break;
+        default:
+          throw new Error(`Unsupported type: ${item.utype}`);
+      }
+    }
+    const metadataBytes = new Uint8Array(metadata);
+    const compactList = builder.build_with_proof_packed(crs, metadataBytes, 1);
+    const result = compactList.serialize();
+    self.postMessage({
+      id,
+      type: "success",
+      result: Array.from(result)
+    });
+  } catch (error) {
+    self.postMessage({
+      id,
+      type: "error",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+};
+self.postMessage({
+  id: "init",
+  type: "ready"
+});

package/dist/zkProve.worker.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/zkProve.worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/zkProve.worker.js

@@ -0,0 +1,91 @@
+// web/zkProve.worker.ts
+var tfheModule = null;
+var initialized = false;
+async function initTfhe() {
+  if (initialized)
+    return;
+  try {
+    tfheModule = await import('tfhe');
+    await tfheModule.default();
+    await tfheModule.init_panic_hook();
+    initialized = true;
+    console.log("[Worker] TFHE initialized");
+  } catch (error) {
+    console.error("[Worker] Failed to initialize TFHE:", error);
+    throw error;
+  }
+}
+function fromHexString(hexString) {
+  const cleanString = hexString.length % 2 === 1 ? `0${hexString}` : hexString;
+  const arr = cleanString.replace(/^0x/, "").match(/.{1,2}/g);
+  if (!arr)
+    return new Uint8Array();
+  return new Uint8Array(arr.map((byte) => parseInt(byte, 16)));
+}
+self.onmessage = async (event) => {
+  const { id, type, fheKeyHex, crsHex, items, metadata } = event.data;
+  if (type !== "zkProve") {
+    self.postMessage({
+      id,
+      type: "error",
+      error: "Invalid message type"
+    });
+    return;
+  }
+  try {
+    await initTfhe();
+    if (!tfheModule) {
+      throw new Error("TFHE module not initialized");
+    }
+    const fheKeyBytes = fromHexString(fheKeyHex);
+    const crsBytes = fromHexString(crsHex);
+    const fheKey = tfheModule.TfheCompactPublicKey.deserialize(fheKeyBytes);
+    const crs = tfheModule.CompactPkeCrs.deserialize(crsBytes);
+    const builder = tfheModule.ProvenCompactCiphertextList.builder(fheKey);
+    for (const item of items) {
+      switch (item.utype) {
+        case "bool":
+          builder.push_boolean(Boolean(item.data));
+          break;
+        case "uint8":
+          builder.push_u8(Number(item.data));
+          break;
+        case "uint16":
+          builder.push_u16(Number(item.data));
+          break;
+        case "uint32":
+          builder.push_u32(Number(item.data));
+          break;
+        case "uint64":
+          builder.push_u64(BigInt(item.data));
+          break;
+        case "uint128":
+          builder.push_u128(BigInt(item.data));
+          break;
+        case "uint160":
+          builder.push_u160(BigInt(item.data));
+          break;
+        default:
+          throw new Error(`Unsupported type: ${item.utype}`);
+      }
+    }
+    const metadataBytes = new Uint8Array(metadata);
+    const compactList = builder.build_with_proof_packed(crs, metadataBytes, 1);
+    const result = compactList.serialize();
+    self.postMessage({
+      id,
+      type: "success",
+      result: Array.from(result)
+    });
+  } catch (error) {
+    self.postMessage({
+      id,
+      type: "error",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+};
+self.postMessage({
+  id: "init",
+  type: "ready"
+});

package/node/client.test.ts

@@ -1,4 +1,4 @@
-import { type CofhesdkClient } from '@/core';
+import { type CofhesdkClient, CofhesdkError, CofhesdkErrorCode } from '@/core';
 import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
 
 import { describe, it, expect, beforeAll, beforeEach, vi } from 'vitest';
@@ -60,11 +60,16 @@ describe('@cofhe/node - Client Integration Tests', () => {
     });
   });
 
+  describe('Environment', () => {
+    it('should have the correct environment', () => {
+      expect(cofhesdkClient.config.environment).toBe('node');
+    });
+  });
+
   describe('Real Connection', () => {
     it('should connect to real chain', async () => {
-      const result = await cofhesdkClient.connect(publicClient, walletClient);
+      await cofhesdkClient.connect(publicClient, walletClient);
 
-      expect(result.success).toBe(true);
       expect(cofhesdkClient.connected).toBe(true);
 
       const snapshot = cofhesdkClient.getSnapshot();
@@ -74,15 +79,17 @@ describe('@cofhe/node - Client Integration Tests', () => {
     }, 30000);
 
     it('should handle real network errors', async () => {
-      const result = await cofhesdkClient.connect(
-        {
-          getChainId: vi.fn().mockRejectedValue(new Error('Network error')),
-        } as unknown as PublicClient,
-        walletClient
-      );
-
-      expect(result.success).toBe(false);
-      expect(cofhesdkClient.connected).toBe(false);
+      try {
+        await cofhesdkClient.connect(
+          {
+            getChainId: vi.fn().mockRejectedValue(new Error('Network error')),
+          } as unknown as PublicClient,
+          walletClient
+        );
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.PublicWalletGetChainIdFailed);
+      }
     }, 30000);
   });
 
@@ -113,23 +120,11 @@ describe('@cofhe/node - Client Integration Tests', () => {
     }, 30000);
   });
 
-  describe('Initialization Results', () => {
-    it('should have keyFetchResult promise', () => {
-      expect(cofhesdkClient.initializationResults).toBeDefined();
-      expect(cofhesdkClient.initializationResults.keyFetchResult).toBeInstanceOf(Promise);
-    });
-
-    it('should resolve keyFetchResult', async () => {
-      const result = await cofhesdkClient.initializationResults.keyFetchResult;
-      expect(result.success).toBe(true);
-    });
-  });
-
   describe('Builder Creation', () => {
     it('should create encrypt builder after connection', async () => {
       await cofhesdkClient.connect(publicClient, walletClient);
 
-      const builder = cofhesdkClient.encryptInputs([{ data: 100n, utype: 2 }]);
+      const builder = cofhesdkClient.encryptInputs([{ data: 100n, utype: 2, securityZone: 0 }]);
 
       expect(builder).toBeDefined();
       expect(typeof builder.setChainId).toBe('function');