@cofhe/sdk 0.4.0 → 0.5.1

package/web/zkProve.worker.ts

@@ -6,6 +6,7 @@
 /// <reference lib="webworker" />
 /* eslint-disable no-undef */
 
+import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from '../core/consts';
 import type { ZkProveWorkerRequest, ZkProveWorkerResponse } from '../core/encrypt/zkPackProveVerify.js';
 
 // TFHE module (will be initialized on first use)
@@ -41,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.deserialize(fheKeyBytes);
-    const crs = tfheModule.CompactPkeCrs.deserialize(crsBytes);
-
-    // 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.serialize();
+      // 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);
+}

package/node/client.test.ts

@@ -1,147 +0,0 @@
-import { type CofheClient, CofheError, CofheErrorCode } from '@/core';
-import { arbSepolia as cofheArbSepolia } from '@/chains';
-
-import { describe, it, expect, beforeAll, beforeEach, vi } from 'vitest';
-import type { PublicClient, WalletClient } from 'viem';
-import { createPublicClient, createWalletClient, http } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-import { arbitrumSepolia as viemArbitrumSepolia } from 'viem/chains';
-import { createCofheClient, createCofheConfig } from './index.js';
-
-// Real test setup - no mocks
-const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
-const TEST_ACCOUNT = privateKeyToAccount(TEST_PRIVATE_KEY).address;
-
-describe('@cofhe/node - Client Integration Tests', () => {
-  let cofheClient: CofheClient;
-  let publicClient: PublicClient;
-  let walletClient: WalletClient;
-
-  beforeAll(() => {
-    // Create real viem clients
-    publicClient = createPublicClient({
-      chain: viemArbitrumSepolia,
-      transport: http(),
-    });
-
-    const account = privateKeyToAccount(TEST_PRIVATE_KEY);
-    walletClient = createWalletClient({
-      chain: viemArbitrumSepolia,
-      transport: http(),
-      account,
-    });
-  });
-
-  beforeEach(() => {
-    const config = createCofheConfig({
-      supportedChains: [cofheArbSepolia],
-    });
-    cofheClient = createCofheClient(config);
-  });
-
-  describe('Real Client Initialization', () => {
-    it('should create a client with real node-tfhe', () => {
-      expect(cofheClient).toBeDefined();
-      expect(cofheClient.config).toBeDefined();
-      expect(cofheClient.connected).toBe(false);
-    });
-
-    it('should automatically use filesystem storage as default', () => {
-      expect(cofheClient.config.fheKeyStorage).toBeDefined();
-      expect(cofheClient.config.fheKeyStorage).not.toBeNull();
-    });
-
-    it('should have all expected methods', () => {
-      expect(typeof cofheClient.connect).toBe('function');
-      expect(typeof cofheClient.encryptInputs).toBe('function');
-      expect(typeof cofheClient.decryptForView).toBe('function');
-      expect(typeof cofheClient.getSnapshot).toBe('function');
-      expect(typeof cofheClient.subscribe).toBe('function');
-    });
-  });
-
-  describe('Environment', () => {
-    it('should have the correct environment', () => {
-      expect(cofheClient.config.environment).toBe('node');
-    });
-  });
-
-  describe('Real Connection', () => {
-    it('should connect to real chain', async () => {
-      await cofheClient.connect(publicClient, walletClient);
-
-      expect(cofheClient.connected).toBe(true);
-
-      const snapshot = cofheClient.getSnapshot();
-      expect(snapshot.connected).toBe(true);
-      expect(snapshot.chainId).toBe(cofheArbSepolia.id);
-      expect(snapshot.account).toBe(TEST_ACCOUNT);
-    }, 30000);
-
-    it('should handle real network errors', async () => {
-      try {
-        await cofheClient.connect(
-          {
-            getChainId: vi.fn().mockRejectedValue(new Error('Network error')),
-          } as unknown as PublicClient,
-          walletClient
-        );
-      } catch (error) {
-        expect(error).toBeInstanceOf(CofheError);
-        expect((error as CofheError).code).toBe(CofheErrorCode.PublicWalletGetChainIdFailed);
-      }
-    }, 30000);
-  });
-
-  describe('State Management', () => {
-    it('should track connection state changes', async () => {
-      const states: any[] = [];
-      const unsubscribe = cofheClient.subscribe((snapshot) => {
-        states.push({ ...snapshot });
-      });
-
-      await cofheClient.connect(publicClient, walletClient);
-
-      unsubscribe();
-
-      expect(states.length).toBeGreaterThan(0);
-
-      // First state should be connecting
-      const firstState = states.find((s) => s.connecting);
-      expect(firstState).toBeDefined();
-      expect(firstState?.connecting).toBe(true);
-      expect(firstState?.connected).toBe(false);
-
-      // Last state should be connected
-      const lastState = states[states.length - 1];
-      expect(lastState.connected).toBe(true);
-      expect(lastState.connecting).toBe(false);
-      expect(lastState.chainId).toBe(cofheArbSepolia.id);
-    }, 30000);
-  });
-
-  describe('Builder Creation', () => {
-    it('should create encrypt builder after connection', async () => {
-      await cofheClient.connect(publicClient, walletClient);
-
-      const builder = cofheClient.encryptInputs([{ data: 100n, utype: 2, securityZone: 0 }]);
-
-      expect(builder).toBeDefined();
-      expect(typeof builder.setChainId).toBe('function');
-      expect(typeof builder.setAccount).toBe('function');
-      expect(typeof builder.setSecurityZone).toBe('function');
-      expect(typeof builder.execute).toBe('function');
-    }, 30000);
-
-    it('should create decrypt builder after connection', async () => {
-      await cofheClient.connect(publicClient, walletClient);
-
-      const builder = cofheClient.decryptForView('0x123', 2);
-
-      expect(builder).toBeDefined();
-      expect(typeof builder.setChainId).toBe('function');
-      expect(typeof builder.setAccount).toBe('function');
-      expect(typeof builder.execute).toBe('function');
-    }, 30000);
-  });
-});

package/node/config.test.ts

@@ -1,68 +0,0 @@
-import { arbSepolia } from '@/chains';
-
-import { describe, it, expect } from 'vitest';
-import { createCofheConfig, createCofheClient } from './index.js';
-
-describe('@cofhe/node - Config', () => {
-  describe('createCofheConfig', () => {
-    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]);
-    });
-
-    it('should allow overriding storage', async () => {
-      const customStorage = {
-        getItem: () => Promise.resolve(10),
-        setItem: () => Promise.resolve(),
-        removeItem: () => Promise.resolve(),
-      };
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-        fheKeyStorage: customStorage,
-      });
-
-      expect(await config.fheKeyStorage!.getItem('test')).toBe(10);
-    });
-
-    it('should allow null storage', () => {
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-        fheKeyStorage: null,
-      });
-
-      expect(config.fheKeyStorage).toBeNull();
-    });
-
-    it('should preserve all other config options', () => {
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-        mocks: {
-          decryptDelay: 0,
-        },
-      });
-
-      expect(config.supportedChains).toEqual([arbSepolia]);
-      expect(config.mocks.decryptDelay).toBe(0);
-      expect(config.fheKeyStorage).toBeDefined();
-    });
-  });
-
-  describe('createCofheClient with config', () => {
-    it('should create client with validated config', () => {
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-      });
-
-      const client = createCofheClient(config);
-
-      expect(client).toBeDefined();
-      expect(client.config).toBe(config);
-      expect(client.config.fheKeyStorage).toBeDefined();
-    });
-  });
-});

package/node/encryptInputs.test.ts

@@ -1,155 +0,0 @@
-import { Encryptable, FheTypes, type CofheClient, CofheErrorCode, CofheError } from '@/core';
-import { arbSepolia as cofheArbSepolia } from '@/chains';
-
-import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
-import type { PublicClient, WalletClient } from 'viem';
-import { createPublicClient, createWalletClient, http } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-import { arbitrumSepolia as viemArbitrumSepolia } from 'viem/chains';
-import { createCofheClient, createCofheConfig } from './index.js';
-
-// Real test setup - using actual node-tfhe
-const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
-
-describe('@cofhe/node - Encrypt Inputs', () => {
-  let cofheClient: CofheClient;
-  let publicClient: PublicClient;
-  let walletClient: WalletClient;
-
-  beforeAll(() => {
-    // Create real viem clients
-    publicClient = createPublicClient({
-      chain: viemArbitrumSepolia,
-      transport: http(),
-    });
-
-    const account = privateKeyToAccount(TEST_PRIVATE_KEY);
-    walletClient = createWalletClient({
-      chain: viemArbitrumSepolia,
-      transport: http(),
-      account,
-    });
-  });
-
-  beforeEach(() => {
-    const config = createCofheConfig({
-      supportedChains: [cofheArbSepolia],
-    });
-    cofheClient = createCofheClient(config);
-  });
-
-  describe('Real TFHE Initialization', () => {
-    it('should initialize node-tfhe on first encryption', async () => {
-      await cofheClient.connect(publicClient, walletClient);
-
-      // This will trigger real TFHE initialization
-      const encrypted = await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
-
-      // If we get here, TFHE was initialized successfully
-      expect(encrypted).toBeDefined();
-    }, 60000); // Longer timeout for real operations
-
-    it('should handle multiple encryptions without re-initializing', async () => {
-      await cofheClient.connect(publicClient, walletClient);
-
-      // First encryption
-      await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
-
-      // Second encryption should reuse initialization
-      await cofheClient.encryptInputs([Encryptable.uint64(50n)]).execute();
-    }, 120000);
-  });
-
-  describe('Real Encryption', () => {
-    it('should encrypt a bool with real TFHE', async () => {
-      await cofheClient.connect(publicClient, walletClient);
-
-      const encrypted = await cofheClient.encryptInputs([Encryptable.bool(true)]).execute();
-
-      expect(encrypted.length).toBe(1);
-      expect(encrypted[0].utype).toBe(FheTypes.Bool);
-      expect(encrypted[0].ctHash).toBeDefined();
-      expect(typeof encrypted[0].ctHash).toBe('bigint');
-      expect(encrypted[0].signature).toBeDefined();
-      expect(typeof encrypted[0].signature).toBe('string');
-      expect(encrypted[0].securityZone).toBe(0);
-    }, 60000);
-
-    it('should encrypt all supported types together', async () => {
-      await cofheClient.connect(publicClient, walletClient);
-
-      const inputs = [
-        Encryptable.bool(false),
-        Encryptable.uint8(1n),
-        Encryptable.uint16(2n),
-        Encryptable.uint32(3n),
-        Encryptable.uint64(4n),
-        Encryptable.uint128(5n),
-        Encryptable.address('0x742d35Cc6634C0532925a3b844D16faC4c175E99'),
-      ];
-
-      const encrypted = await cofheClient.encryptInputs(inputs).execute();
-
-      expect(encrypted.length).toBe(7);
-      // Verify each type
-      expect(encrypted[0].utype).toBe(FheTypes.Bool);
-      expect(encrypted[1].utype).toBe(FheTypes.Uint8);
-      expect(encrypted[2].utype).toBe(FheTypes.Uint16);
-      expect(encrypted[3].utype).toBe(FheTypes.Uint32);
-      expect(encrypted[4].utype).toBe(FheTypes.Uint64);
-      expect(encrypted[5].utype).toBe(FheTypes.Uint128);
-      expect(encrypted[6].utype).toBe(FheTypes.Uint160);
-    }, 90000); // Longer timeout for multiple encryptions
-  });
-
-  describe('Real Builder Pattern', () => {
-    it('should support chaining builder methods with real encryption', async () => {
-      await cofheClient.connect(publicClient, walletClient);
-
-      const snapshot = cofheClient.getSnapshot();
-      const encrypted = await cofheClient
-        .encryptInputs([Encryptable.uint128(100n)])
-        .setChainId(snapshot.chainId!)
-        .setAccount(snapshot.account!)
-        .setSecurityZone(0)
-        .execute();
-
-      expect(encrypted.length).toBe(1);
-      expect(encrypted[0].utype).toBe(FheTypes.Uint128);
-    }, 60000);
-  });
-
-  describe('Real Error Handling', () => {
-    it('should fail gracefully when not connected', async () => {
-      // Don't connect the client
-      try {
-        await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
-      } catch (error) {
-        expect(error).toBeInstanceOf(CofheError);
-        expect((error as CofheError).code).toBe(CofheErrorCode.NotConnected);
-      }
-    }, 30000);
-
-    it('should handle invalid CoFHE URL', async () => {
-      const badConfig = createCofheConfig({
-        supportedChains: [
-          {
-            ...cofheArbSepolia,
-            coFheUrl: 'http://invalid-cofhe-url.local',
-            verifierUrl: 'http://invalid-verifier-url.local',
-          },
-        ],
-      });
-
-      const badClient = createCofheClient(badConfig);
-      await badClient.connect(publicClient, walletClient);
-
-      try {
-        await badClient.encryptInputs([Encryptable.uint128(100n)]).execute();
-      } catch (error) {
-        expect(error).toBeInstanceOf(CofheError);
-        expect((error as CofheError).code).toBe(CofheErrorCode.ZkVerifyFailed);
-      }
-    }, 60000);
-  });
-});

package/web/config.web.test.ts

@@ -1,69 +0,0 @@
-import { arbSepolia } from '@/chains';
-
-import { describe, it, expect } from 'vitest';
-import { createCofheConfig, createCofheClient } from './index.js';
-
-describe('@cofhe/web - Config', () => {
-  describe('createCofheConfig', () => {
-    it('should automatically inject IndexedDB storage as default', () => {
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-      });
-
-      expect(config.fheKeyStorage).toBeDefined();
-      expect(config.fheKeyStorage).not.toBeNull();
-      expect(config.supportedChains).toEqual([arbSepolia]);
-    });
-
-    it('should allow overriding storage', async () => {
-      const customStorage = {
-        getItem: () => Promise.resolve(10),
-        setItem: () => Promise.resolve(),
-        removeItem: () => Promise.resolve(),
-      };
-
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-        fheKeyStorage: customStorage,
-      });
-
-      expect(await config.fheKeyStorage!.getItem('test')).toBe(10);
-    });
-
-    it('should allow null storage', () => {
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-        fheKeyStorage: null,
-      });
-
-      expect(config.fheKeyStorage).toBeNull();
-    });
-
-    it('should preserve all other config options', () => {
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-        mocks: {
-          decryptDelay: 500,
-        },
-      });
-
-      expect(config.supportedChains).toEqual([arbSepolia]);
-      expect(config.mocks.decryptDelay).toBe(500);
-      expect(config.fheKeyStorage).toBeDefined();
-    });
-  });
-
-  describe('createCofheClient with config', () => {
-    it('should create client with validated config', () => {
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-      });
-
-      const client = createCofheClient(config);
-
-      expect(client).toBeDefined();
-      expect(client.config).toBe(config);
-      expect(client.config.fheKeyStorage).toBeDefined();
-    });
-  });
-});