@cofhe/sdk 0.4.0 → 0.5.1

package/dist/web.d.cts

@@ -1,10 +1,12 @@
-import { C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-ACVWbrXL.cjs';
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-BSbwairE.cjs';
 import 'viem';
-import './types-YiAC4gig.cjs';
+import './types-C07FK-cL.cjs';
 import 'zod';
-import './permit-MZ502UBl.cjs';
+import './permit-DnVMDT5h.cjs';
 import 'zustand/vanilla';
 
+declare function createSsrStorage(): IStorage;
+
 /**
  * Terminate the worker
  */
@@ -14,6 +16,8 @@ declare function terminateWorker(): void;
  */
 declare function areWorkersAvailable(): boolean;
 
+declare const hasDOM: boolean;
+
 /**
  * Creates a CoFHE configuration for web with IndexedDB storage as default
  * @param config - The CoFHE input configuration (fheKeyStorage will default to IndexedDB if not provided)
@@ -35,4 +39,4 @@ declare function createCofheClient<TConfig extends CofheConfig>(config: TConfig)
  */
 declare function createCofheClientWithCustomWorker(config: CofheConfig, customZkProveWorkerFn: (fheKeyHex: string, crsHex: string, items: EncryptableItem[], metadata: Uint8Array) => Promise<Uint8Array>): CofheClient;
 
-export { areWorkersAvailable, createCofheClient, createCofheClientWithCustomWorker, createCofheConfig, terminateWorker };
+export { areWorkersAvailable, createCofheClient, createCofheClientWithCustomWorker, createCofheConfig, createSsrStorage, hasDOM, terminateWorker };

package/dist/web.d.ts

@@ -1,10 +1,12 @@
-import { C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-kkrRdawm.js';
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-DDmcgZ0a.js';
 import 'viem';
-import './types-YiAC4gig.js';
+import './types-C07FK-cL.js';
 import 'zod';
-import './permit-MZ502UBl.js';
+import './permit-DnVMDT5h.js';
 import 'zustand/vanilla';
 
+declare function createSsrStorage(): IStorage;
+
 /**
  * Terminate the worker
  */
@@ -14,6 +16,8 @@ declare function terminateWorker(): void;
  */
 declare function areWorkersAvailable(): boolean;
 
+declare const hasDOM: boolean;
+
 /**
  * Creates a CoFHE configuration for web with IndexedDB storage as default
  * @param config - The CoFHE input configuration (fheKeyStorage will default to IndexedDB if not provided)
@@ -35,4 +39,4 @@ declare function createCofheClient<TConfig extends CofheConfig>(config: TConfig)
  */
 declare function createCofheClientWithCustomWorker(config: CofheConfig, customZkProveWorkerFn: (fheKeyHex: string, crsHex: string, items: EncryptableItem[], metadata: Uint8Array) => Promise<Uint8Array>): CofheClient;
 
-export { areWorkersAvailable, createCofheClient, createCofheClientWithCustomWorker, createCofheConfig, terminateWorker };
+export { areWorkersAvailable, createCofheClient, createCofheClientWithCustomWorker, createCofheConfig, createSsrStorage, hasDOM, terminateWorker };

package/dist/web.js

@@ -1,15 +1,21 @@
-import { createCofheConfigBase, createCofheClientBase, fheTypeToString } from './chunk-MXND5SVN.js';
+import { createCofheConfigBase, createCofheClientBase, fheTypeToString } from './chunk-S7OKGLFD.js';
 import './chunk-TBLR7NNE.js';
-import './chunk-NWDKXBIP.js';
+import './chunk-MRCKUMOS.js';
+import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-4FP4V35O.js';
 import { constructClient } from 'iframe-shared-storage';
-import init, { init_panic_hook, TfheCompactPublicKey, CompactPkeCrs, ProvenCompactCiphertextList } from 'tfhe';
 
-var createWebStorage = () => {
+// web/const.ts
+var hasDOM = typeof globalThis?.document !== "undefined" && typeof globalThis?.window !== "undefined";
+
+// web/storage.ts
+var createWebStorage = (opts = { enableLog: false }) => {
+  if (!hasDOM)
+    throw new Error("createWebStorage can only be used in a browser environment");
   const client = constructClient({
     iframe: {
       src: "https://iframe-shared-storage.vercel.app/hub.html",
       messagingOptions: {
-        enableLog: "both"
+        enableLog: opts.enableLog ? "both" : void 0
       },
       iframeReadyTimeoutMs: 3e4,
       // if the iframe is not initied during this interval AND a reuqest is made, such request will throw an error
@@ -32,6 +38,16 @@ var createWebStorage = () => {
     }
   };
 };
+function createSsrStorage() {
+  console.warn("using no-op server-side SSR storage");
+  return {
+    getItem: async () => null,
+    setItem: async () => {
+    },
+    removeItem: async () => {
+    }
+  };
+}
 
 // web/workerManager.ts
 var ZkProveWorkerManager = class {
@@ -171,15 +187,25 @@ function terminateWorker() {
 function areWorkersAvailable() {
   return typeof Worker !== "undefined";
 }
+
+// web/index.ts
+var tfheModule = null;
 var tfheInitialized = false;
 async function initTfhe() {
   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() {
+  if (!tfheModule) {
+    throw new Error("TFHE not initialized \u2014 call initTfhe() (or any client method that triggers it) first");
+  }
+  return tfheModule;
+}
 var fromHexString = (hexString) => {
   const cleanString = hexString.length % 2 === 1 ? `0${hexString}` : hexString;
   const arr = cleanString.replace(/^0x/, "").match(/.{1,2}/g);
@@ -187,16 +213,25 @@ var fromHexString = (hexString) => {
     return new Uint8Array();
   return new Uint8Array(arr.map((byte) => parseInt(byte, 16)));
 };
+var _deserializeTfhePublicKey = (buff) => {
+  return requireTfhe().TfheCompactPublicKey.safe_deserialize(
+    fromHexString(buff),
+    TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT
+  );
+};
+var _deserializeCompactPkeCrs = (buff) => {
+  return requireTfhe().CompactPkeCrs.safe_deserialize(fromHexString(buff), TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
+};
 var tfhePublicKeyDeserializer = (buff) => {
-  TfheCompactPublicKey.deserialize(fromHexString(buff));
+  _deserializeTfhePublicKey(buff);
 };
 var compactPkeCrsDeserializer = (buff) => {
-  CompactPkeCrs.deserialize(fromHexString(buff));
+  _deserializeCompactPkeCrs(buff);
 };
 var zkBuilderAndCrsGenerator = (fhe, crs) => {
-  const fhePublicKey = TfheCompactPublicKey.deserialize(fromHexString(fhe));
-  const zkBuilder = ProvenCompactCiphertextList.builder(fhePublicKey);
-  const zkCrs = CompactPkeCrs.deserialize(fromHexString(crs));
+  const fhePublicKey = _deserializeTfhePublicKey(fhe);
+  const zkBuilder = requireTfhe().ProvenCompactCiphertextList.builder(fhePublicKey);
+  const zkCrs = _deserializeCompactPkeCrs(crs);
   return { zkBuilder, zkCrs };
 };
 async function zkProveWithWorker(fheKeyHex, crsHex, items, metadata) {
@@ -211,7 +246,7 @@ function createCofheConfig(config) {
   return createCofheConfigBase({
     environment: "web",
     ...config,
-    fheKeyStorage: config.fheKeyStorage === null ? null : config.fheKeyStorage ?? createWebStorage()
+    fheKeyStorage: config.fheKeyStorage === null ? null : config.fheKeyStorage ?? (hasDOM ? createWebStorage() : createSsrStorage())
   });
 }
 function createCofheClient(config) {
@@ -237,4 +272,4 @@ function createCofheClientWithCustomWorker(config, customZkProveWorkerFn) {
   });
 }
 
-export { areWorkersAvailable, createCofheClient, createCofheClientWithCustomWorker, createCofheConfig, terminateWorker };
+export { areWorkersAvailable, createCofheClient, createCofheClientWithCustomWorker, createCofheConfig, createSsrStorage, hasDOM, terminateWorker };

package/dist/zkProve.worker.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+// core/consts.ts
+var TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT = BigInt(1 << 30);
+
 // web/zkProve.worker.ts
 var tfheModule = null;
 var initialized = false;
@@ -24,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.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}`);
+    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.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"
-});
+  };
+  self.postMessage({
+    id: "init",
+    type: "ready"
+  });
+}

package/dist/zkProve.worker.js

@@ -1,3 +1,5 @@
+import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-4FP4V35O.js';
+
 // web/zkProve.worker.ts
 var tfheModule = null;
 var initialized = false;
@@ -22,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.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}`);
+    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.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"
-});
+  };
+  self.postMessage({
+    id: "init",
+    type: "ready"
+  });
+}

package/node/index.ts

@@ -8,6 +8,7 @@ import {
   type CofheInputConfig,
   type ZkBuilderAndCrsGenerator,
   type FheKeyDeserializer,
+  TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT,
 } from '@/core';
 
 // Import node-specific storage (internal use only)
@@ -39,12 +40,20 @@ const fromHexString = (hexString: string): Uint8Array => {
   return new Uint8Array(arr.map((byte) => parseInt(byte, 16)));
 };
 
+const _deserializeTfhePublicKey = (buff: string): TfheCompactPublicKey => {
+  return 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);
+};
+
 /**
  * Serializer for TFHE public keys
  * Validates that the buffer can be deserialized into a TfheCompactPublicKey
  */
 const tfhePublicKeyDeserializer: FheKeyDeserializer = (buff: string): void => {
-  TfheCompactPublicKey.deserialize(fromHexString(buff));
+  _deserializeTfhePublicKey(buff);
 };
 
 /**
@@ -52,7 +61,7 @@ const tfhePublicKeyDeserializer: FheKeyDeserializer = (buff: string): void => {
  * Validates that the buffer can be deserialized into ZkCompactPkePublicParams
  */
 const compactPkeCrsDeserializer: FheKeyDeserializer = (buff: string): void => {
-  CompactPkeCrs.deserialize(fromHexString(buff));
+  _deserializeCompactPkeCrs(buff);
 };
 
 /**
@@ -60,9 +69,9 @@ const compactPkeCrsDeserializer: FheKeyDeserializer = (buff: string): void => {
  * This is used internally by the SDK to create encrypted inputs
  */
 const zkBuilderAndCrsGenerator: ZkBuilderAndCrsGenerator = (fhe: string, crs: string) => {
-  const fhePublicKey = TfheCompactPublicKey.deserialize(fromHexString(fhe));
+  const fhePublicKey = _deserializeTfhePublicKey(fhe);
   const zkBuilder = ProvenCompactCiphertextList.builder(fhePublicKey);
-  const zkCrs = CompactPkeCrs.deserialize(fromHexString(crs));
+  const zkCrs = _deserializeCompactPkeCrs(crs);
 
   return { zkBuilder, zkCrs };
 };

package/node/test/client.test.ts

@@ -0,0 +1,25 @@
+import { type CofheClient } from '@/core';
+import { arbSepolia as cofheArbSepolia } from '@/chains';
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createCofheClient, createCofheConfig } from '../index.js';
+
+describe('@cofhe/node - Client', () => {
+  let cofheClient: CofheClient;
+
+  beforeEach(() => {
+    const config = createCofheConfig({
+      supportedChains: [cofheArbSepolia],
+    });
+    cofheClient = createCofheClient(config);
+  });
+
+  it('should automatically use filesystem storage as default', () => {
+    expect(cofheClient.config.fheKeyStorage).toBeDefined();
+    expect(cofheClient.config.fheKeyStorage).not.toBeNull();
+  });
+
+  it('should have the correct environment', () => {
+    expect(cofheClient.config.environment).toBe('node');
+  });
+});

package/node/test/config.test.ts

@@ -0,0 +1,16 @@
+import { arbSepolia } from '@/chains';
+
+import { describe, it, expect } from 'vitest';
+import { createCofheConfig } from '../index.js';
+
+describe('@cofhe/node - Config', () => {
+  it('should automatically inject filesystem storage as default', () => {
+    const config = createCofheConfig({
+      supportedChains: [arbSepolia],
+    });
+
+    expect(config.fheKeyStorage).toBeDefined();
+    expect(config.fheKeyStorage).not.toBeNull();
+    expect(config.supportedChains).toEqual([arbSepolia]);
+  });
+});