@cofhe/sdk 0.5.0 → 0.5.2

package/dist/zkProve.worker.cjs

@@ -27,70 +27,75 @@ function fromHexString(hexString) {
     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");
+if (typeof self !== "undefined") {
+  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;
     }
-    const fheKeyBytes = fromHexString(fheKeyHex);
-    const crsBytes = fromHexString(crsHex);
-    const fheKey = tfheModule.TfheCompactPublicKey.safe_deserialize(fheKeyBytes, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
-    const crs = tfheModule.CompactPkeCrs.safe_deserialize(crsBytes, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
-    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}`);
+    try {
+      await initTfhe();
+      if (!tfheModule) {
+        throw new Error("TFHE module not initialized");
+      }
+      const fheKeyBytes = fromHexString(fheKeyHex);
+      const crsBytes = fromHexString(crsHex);
+      const fheKey = tfheModule.TfheCompactPublicKey.safe_deserialize(
+        fheKeyBytes,
+        TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT
+      );
+      const crs = tfheModule.CompactPkeCrs.safe_deserialize(crsBytes, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
+      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.safe_serialize(TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
+      self.postMessage({
+        id,
+        type: "success",
+        result: Array.from(result)
+      });
+    } catch (error) {
+      self.postMessage({
+        id,
+        type: "error",
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
-    const metadataBytes = new Uint8Array(metadata);
-    const compactList = builder.build_with_proof_packed(crs, metadataBytes, 1);
-    const result = compactList.safe_serialize(TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
-    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"
-});
+  };
+  self.postMessage({
+    id: "init",
+    type: "ready"
+  });
+}

package/dist/zkProve.worker.js

@@ -24,70 +24,75 @@ function fromHexString(hexString) {
     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");
+if (typeof self !== "undefined") {
+  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;
     }
-    const fheKeyBytes = fromHexString(fheKeyHex);
-    const crsBytes = fromHexString(crsHex);
-    const fheKey = tfheModule.TfheCompactPublicKey.safe_deserialize(fheKeyBytes, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
-    const crs = tfheModule.CompactPkeCrs.safe_deserialize(crsBytes, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
-    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}`);
+    try {
+      await initTfhe();
+      if (!tfheModule) {
+        throw new Error("TFHE module not initialized");
+      }
+      const fheKeyBytes = fromHexString(fheKeyHex);
+      const crsBytes = fromHexString(crsHex);
+      const fheKey = tfheModule.TfheCompactPublicKey.safe_deserialize(
+        fheKeyBytes,
+        TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT
+      );
+      const crs = tfheModule.CompactPkeCrs.safe_deserialize(crsBytes, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
+      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.safe_serialize(TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
+      self.postMessage({
+        id,
+        type: "success",
+        result: Array.from(result)
+      });
+    } catch (error) {
+      self.postMessage({
+        id,
+        type: "error",
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
-    const metadataBytes = new Uint8Array(metadata);
-    const compactList = builder.build_with_proof_packed(crs, metadataBytes, 1);
-    const result = compactList.safe_serialize(TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
-    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"
-});
+  };
+  self.postMessage({
+    id: "init",
+    type: "ready"
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cofhe/sdk",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "type": "module",
   "description": "SDK for Fhenix COFHE coprocessor interaction",
   "main": "./dist/core.cjs",
@@ -101,8 +101,8 @@
     "tsup": "8.0.2",
     "typescript": "5.5.4",
     "vitest": "3.2.4",
-    "@cofhe/test-setup": "0.0.0",
     "@cofhe/eslint-config": "0.2.1",
+    "@cofhe/test-setup": "0.0.0",
     "@cofhe/tsconfig": "0.1.2"
   },
   "publishConfig": {

package/web/index.ts

@@ -19,8 +19,11 @@ import { createSsrStorage, createWebStorage } from './storage.js';
 // Import worker manager
 import { getWorkerManager, terminateWorker, areWorkersAvailable } from './workerManager.js';
 
-// Import tfhe for web
-import init, { init_panic_hook, TfheCompactPublicKey, ProvenCompactCiphertextList, CompactPkeCrs } from 'tfhe';
+// Type-only import for tfhe — the runtime is loaded lazily via `await import('tfhe')`
+// inside `initTfhe()` so that simply importing `@cofhe/sdk/web` (e.g. transitively
+// through `@cofhe/react`) does not pull tfhe — and its worker helpers that
+// reference `self` at module top — into the import graph during Next.js SSR.
+import type { TfheCompactPublicKey, ProvenCompactCiphertextList, CompactPkeCrs } from 'tfhe';
 import { hasDOM } from './const';
 
 /**
@@ -28,15 +31,24 @@ import { hasDOM } from './const';
  * Called automatically on first encryption - users don't need to call this manually
  * @returns true if TFHE was initialized, false if already initialized
  */
+let tfheModule: typeof import('tfhe') | null = null;
 let tfheInitialized = false;
 async function initTfhe(): Promise<boolean> {
   if (tfheInitialized) return false;
-  await init();
-  await init_panic_hook();
+  tfheModule = await import('tfhe');
+  await tfheModule.default();
+  await tfheModule.init_panic_hook();
   tfheInitialized = true;
   return true;
 }
 
+function requireTfhe(): typeof import('tfhe') {
+  if (!tfheModule) {
+    throw new Error('TFHE not initialized — call initTfhe() (or any client method that triggers it) first');
+  }
+  return tfheModule;
+}
+
 /**
  * Utility to convert the hex string key to a Uint8Array for use with tfhe
  */
@@ -48,11 +60,14 @@ const fromHexString = (hexString: string): Uint8Array => {
 };
 
 const _deserializeTfhePublicKey = (buff: string): TfheCompactPublicKey => {
-  return TfheCompactPublicKey.safe_deserialize(fromHexString(buff), TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
+  return requireTfhe().TfheCompactPublicKey.safe_deserialize(
+    fromHexString(buff),
+    TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT
+  );
 };
 
 const _deserializeCompactPkeCrs = (buff: string): CompactPkeCrs => {
-  return CompactPkeCrs.safe_deserialize(fromHexString(buff), TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
+  return requireTfhe().CompactPkeCrs.safe_deserialize(fromHexString(buff), TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
 };
 
 /**
@@ -77,7 +92,7 @@ const compactPkeCrsDeserializer: FheKeyDeserializer = (buff: string): void => {
  */
 const zkBuilderAndCrsGenerator: ZkBuilderAndCrsGenerator = (fhe: string, crs: string) => {
   const fhePublicKey = _deserializeTfhePublicKey(fhe);
-  const zkBuilder = ProvenCompactCiphertextList.builder(fhePublicKey);
+  const zkBuilder = requireTfhe().ProvenCompactCiphertextList.builder(fhePublicKey);
   const zkCrs = _deserializeCompactPkeCrs(crs);
 
   return { zkBuilder, zkCrs };

package/web/test/tfheinit.web.test.ts

@@ -53,10 +53,10 @@ describe('@cofhe/web - TFHE Initialization Browser Tests', () => {
       await cofheClient.connect(publicClient, walletClient);
 
       // First encryption
-      expect(cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute()).resolves.not.toThrow();
+      await expect(cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute()).resolves.not.toThrow();
 
       // Second encryption should reuse initialization
-      expect(cofheClient.encryptInputs([Encryptable.uint64(50n)]).execute()).resolves.not.toThrow();
-    }, 60000);
+      await expect(cofheClient.encryptInputs([Encryptable.uint64(50n)]).execute()).resolves.not.toThrow();
+    }, 120000);
   });
 });

package/web/zkProve.worker.ts

@@ -42,93 +42,102 @@ function fromHexString(hexString: string): Uint8Array {
   return new Uint8Array(arr.map((byte) => parseInt(byte, 16)));
 }
 
-/**
- * Main message handler
- */
-self.onmessage = async (event: MessageEvent) => {
-  const { id, type, fheKeyHex, crsHex, items, metadata } = event.data as ZkProveWorkerRequest;
-
-  if (type !== 'zkProve') {
-    self.postMessage({
-      id,
-      type: 'error',
-      error: 'Invalid message type',
-    } as ZkProveWorkerResponse);
-    return;
-  }
-
-  try {
-    // Initialize TFHE if needed
-    await initTfhe();
-
-    if (!tfheModule) {
-      throw new Error('TFHE module not initialized');
+// Guard the top-level `self` references so this file is safe to evaluate in
+// non-worker contexts (e.g. when bundlers like webpack pull the worker chunk
+// into the server bundle for SSR). The body is dead code anywhere `self` is
+// undefined, so skipping it is harmless.
+if (typeof self !== 'undefined') {
+  /**
+   * Main message handler
+   */
+  self.onmessage = async (event: MessageEvent) => {
+    const { id, type, fheKeyHex, crsHex, items, metadata } = event.data as ZkProveWorkerRequest;
+
+    if (type !== 'zkProve') {
+      self.postMessage({
+        id,
+        type: 'error',
+        error: 'Invalid message type',
+      } as ZkProveWorkerResponse);
+      return;
     }
 
-    // Deserialize FHE public key and CRS from hex strings
-    const fheKeyBytes = fromHexString(fheKeyHex);
-    const crsBytes = fromHexString(crsHex);
-
-    const fheKey = tfheModule.TfheCompactPublicKey.safe_deserialize(fheKeyBytes, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
-    const crs = tfheModule.CompactPkeCrs.safe_deserialize(crsBytes, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
-
-    // Create builder
-    const builder = tfheModule.ProvenCompactCiphertextList.builder(fheKey);
-
-    // Pack all items (duplicate of zkPack logic)
-    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}`);
-      }
-    }
+    try {
+      // Initialize TFHE if needed
+      await initTfhe();
 
-    // THE HEAVY OPERATION - but in worker thread!
-    const metadataBytes = new Uint8Array(metadata);
-    const compactList = builder.build_with_proof_packed(crs, metadataBytes, 1);
+      if (!tfheModule) {
+        throw new Error('TFHE module not initialized');
+      }
 
-    // Serialize result
-    const result = compactList.safe_serialize(TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
+      // Deserialize FHE public key and CRS from hex strings
+      const fheKeyBytes = fromHexString(fheKeyHex);
+      const crsBytes = fromHexString(crsHex);
+
+      const fheKey = tfheModule.TfheCompactPublicKey.safe_deserialize(
+        fheKeyBytes,
+        TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT
+      );
+      const crs = tfheModule.CompactPkeCrs.safe_deserialize(crsBytes, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
+
+      // Create builder
+      const builder = tfheModule.ProvenCompactCiphertextList.builder(fheKey);
+
+      // Pack all items (duplicate of zkPack logic)
+      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}`);
+        }
+      }
 
-    // Send success response
-    self.postMessage({
-      id,
-      type: 'success',
-      result: Array.from(result),
-    } as ZkProveWorkerResponse);
-  } catch (error) {
-    // Send error response
-    self.postMessage({
-      id,
-      type: 'error',
-      error: error instanceof Error ? error.message : String(error),
-    } as ZkProveWorkerResponse);
-  }
-};
+      // THE HEAVY OPERATION - but in worker thread!
+      const metadataBytes = new Uint8Array(metadata);
+      const compactList = builder.build_with_proof_packed(crs, metadataBytes, 1);
+
+      // Serialize result
+      const result = compactList.safe_serialize(TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
+
+      // Send success response
+      self.postMessage({
+        id,
+        type: 'success',
+        result: Array.from(result),
+      } as ZkProveWorkerResponse);
+    } catch (error) {
+      // Send error response
+      self.postMessage({
+        id,
+        type: 'error',
+        error: error instanceof Error ? error.message : String(error),
+      } as ZkProveWorkerResponse);
+    }
+  };
 
-// Signal ready - send proper message format
-self.postMessage({
-  id: 'init',
-  type: 'ready',
-} as ZkProveWorkerResponse);
+  // Signal ready - send proper message format
+  self.postMessage({
+    id: 'init',
+    type: 'ready',
+  } as ZkProveWorkerResponse);
+}