@cofhe/sdk 0.1.1 → 0.2.1

package/web/worker.output.web.test.ts

@@ -0,0 +1,84 @@
+import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
+import { Encryptable } from '@/core';
+
+import { describe, it, expect, beforeAll } 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 { createCofhesdkClient, createCofhesdkConfig } from './index.js';
+
+const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+
+describe('@cofhe/sdk/web - Worker vs Main Thread Output Validation', () => {
+  let publicClient: PublicClient;
+  let walletClient: WalletClient;
+
+  beforeAll(() => {
+    publicClient = createPublicClient({
+      chain: viemArbitrumSepolia,
+      transport: http(),
+    });
+
+    const account = privateKeyToAccount(TEST_PRIVATE_KEY);
+    walletClient = createWalletClient({
+      chain: viemArbitrumSepolia,
+      transport: http(),
+      account,
+    });
+  });
+
+  it('should produce consistent output format regardless of worker usage', async () => {
+    // Create two clients - one with workers, one without
+    const configWithWorker = createCofhesdkConfig({
+      supportedChains: [cofhesdkArbSepolia],
+      useWorkers: true,
+    });
+
+    const configWithoutWorker = createCofhesdkConfig({
+      supportedChains: [cofhesdkArbSepolia],
+      useWorkers: false,
+    });
+
+    const clientWithWorker = createCofhesdkClient(configWithWorker);
+    const clientWithoutWorker = createCofhesdkClient(configWithoutWorker);
+
+    await clientWithWorker.connect(publicClient, walletClient);
+    await clientWithoutWorker.connect(publicClient, walletClient);
+
+    const value = Encryptable.uint128(12345n);
+
+    const [resultWithWorker, resultWithoutWorker] = await Promise.all([
+      clientWithWorker.encryptInputs([value]).encrypt(),
+      clientWithoutWorker.encryptInputs([value]).encrypt(),
+    ]);
+
+    // Both should succeed
+    expect(resultWithWorker).toBeDefined();
+    expect(resultWithoutWorker).toBeDefined();
+
+    // Both should have same structure (but different encrypted values)
+    const withWorker = resultWithWorker[0];
+    const withoutWorker = resultWithoutWorker[0];
+
+    expect(withWorker).toHaveProperty('ctHash');
+    expect(withWorker).toHaveProperty('signature');
+    expect(withWorker).toHaveProperty('utype');
+    expect(withWorker).toHaveProperty('securityZone');
+    expect(withoutWorker).toHaveProperty('ctHash');
+    expect(withoutWorker).toHaveProperty('signature');
+    expect(withoutWorker).toHaveProperty('utype');
+    expect(withoutWorker).toHaveProperty('securityZone');
+
+    // Format should be identical
+    expect(typeof withWorker.ctHash).toBe('bigint');
+    expect(typeof withoutWorker.ctHash).toBe('bigint');
+    expect(withWorker.signature.startsWith('0x')).toBe(true);
+    expect(withoutWorker.signature.startsWith('0x')).toBe(true);
+    expect(typeof withWorker.utype).toBe('number');
+    expect(typeof withoutWorker.utype).toBe('number');
+
+    // Note: The actual encrypted values will differ because of randomness
+    // in the encryption process, so we don't check equality
+  }, 90000);
+});

package/web/workerManager.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { getWorkerManager, terminateWorker, areWorkersAvailable } from './workerManager.js';
+
+describe('WorkerManager', () => {
+  afterEach(() => {
+    // Clean up worker after each test
+    terminateWorker();
+  });
+
+  describe('areWorkersAvailable', () => {
+    it('should return false in Node.js environment', () => {
+      // In Node.js/Vitest, workers aren't available
+      expect(areWorkersAvailable()).toBe(false);
+    });
+  });
+
+  describe('getWorkerManager', () => {
+    it('should return a singleton instance', () => {
+      const manager1 = getWorkerManager();
+      const manager2 = getWorkerManager();
+      expect(manager1).toBe(manager2);
+    });
+
+    it('should create new instance after termination', () => {
+      const manager1 = getWorkerManager();
+      terminateWorker();
+      const manager2 = getWorkerManager();
+
+      // After termination, a new instance should be created
+      expect(manager1).toBeDefined();
+      expect(manager2).toBeDefined();
+      // They should NOT be the same instance anymore
+      expect(manager1).not.toBe(manager2);
+    });
+  });
+
+  describe('submitProof', () => {
+    it('should throw immediately when workers not available', async () => {
+      if (!areWorkersAvailable()) {
+        const manager = getWorkerManager();
+
+        await expect(manager.submitProof('invalid', 'invalid', [], new Uint8Array())).rejects.toThrow(
+          'Web Workers not supported'
+        );
+      }
+    });
+  });
+
+  describe('terminateWorker', () => {
+    it('should clean up worker instance and allow getting a new one', () => {
+      const manager1 = getWorkerManager();
+      expect(manager1).toBeDefined();
+
+      // Terminate the worker
+      terminateWorker();
+
+      // After termination, should be able to get a new instance
+      const manager2 = getWorkerManager();
+      expect(manager2).toBeDefined();
+
+      // The new instance should be different from the terminated one
+      expect(manager2).not.toBe(manager1);
+    });
+
+    it('should reject pending requests when terminated', async () => {
+      if (!areWorkersAvailable()) {
+        const manager = getWorkerManager();
+
+        // Start a request that will fail
+        const requestPromise = manager.submitProof('test', 'test', [], new Uint8Array());
+
+        // Terminate while request is pending
+        terminateWorker();
+
+        // The pending request should be rejected
+        await expect(requestPromise).rejects.toThrow();
+      }
+    });
+  });
+});

package/web/workerManager.ts

@@ -0,0 +1,214 @@
+/**
+ * Worker Manager for ZK Proof Generation
+ * Manages worker lifecycle and request/response handling
+ */
+
+import type { ZkProveWorkerRequest, ZkProveWorkerResponse } from '@/core';
+
+// Declare Worker type for environments where it's not available
+declare const Worker: any;
+
+interface PendingRequest {
+  resolve: (value: Uint8Array) => void;
+  reject: (error: Error) => void;
+  timeoutId: ReturnType<typeof setTimeout>;
+}
+
+class ZkProveWorkerManager {
+  private worker: (typeof Worker extends new (...args: any[]) => infer W ? W : any) | null = null;
+  private pendingRequests = new Map<string, PendingRequest>();
+  private requestCounter = 0;
+  private workerReady = false;
+  private initializationPromise: Promise<void> | null = null;
+
+  /**
+   * Initialize the worker
+   */
+  private async initializeWorker(): Promise<void> {
+    if (this.worker && this.workerReady) {
+      return;
+    }
+
+    if (this.initializationPromise) {
+      return this.initializationPromise;
+    }
+
+    this.initializationPromise = new Promise((resolve, reject) => {
+      try {
+        // Check if Worker is supported
+        if (typeof Worker === 'undefined') {
+          reject(new Error('Web Workers not supported'));
+          return;
+        }
+
+        // Create worker
+        // Note: In production, this will try to load the worker from the same directory
+        // The bundler should handle this Worker instantiation
+        try {
+          this.worker = new Worker(new URL('./zkProve.worker.js', import.meta.url), { type: 'module' }) as any;
+        } catch (error) {
+          // If Worker creation fails, reject immediately
+          reject(new Error(`Failed to create worker: ${error}`));
+          return;
+        }
+
+        // Set up message handler
+        (this.worker as any).onmessage = (event: any) => {
+          const { id, type, result, error } = event.data as ZkProveWorkerResponse;
+
+          // Handle ready signal
+          if (type === 'ready') {
+            this.workerReady = true;
+            resolve();
+            return;
+          }
+
+          // Handle proof responses
+          const pending = this.pendingRequests.get(id);
+          if (!pending) {
+            console.warn('[Worker Manager] Received response for unknown request:', id);
+            return;
+          }
+
+          // Clear timeout
+          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'));
+          }
+        };
+
+        // Set up error handler
+        (this.worker as any).onerror = (error: any) => {
+          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);
+
+          // Reject initialization if not ready yet
+          if (!this.workerReady) {
+            reject(new Error(`Worker failed to initialize: ${error.message || 'Unknown error'}`));
+          }
+
+          // Reject all pending requests
+          this.pendingRequests.forEach(({ reject, timeoutId }) => {
+            clearTimeout(timeoutId);
+            reject(new Error('Worker encountered an error'));
+          });
+          this.pendingRequests.clear();
+        };
+
+        // Timeout if worker doesn't signal ready within 5 seconds
+        setTimeout(() => {
+          if (!this.workerReady) {
+            reject(new Error('Worker initialization timeout'));
+          }
+        }, 5000);
+      } catch (error) {
+        reject(error);
+      }
+    });
+
+    return this.initializationPromise;
+  }
+
+  /**
+   * Submit a proof generation request to the worker
+   */
+  async submitProof(
+    fheKeyHex: string,
+    crsHex: string,
+    items: Array<{ utype: string; data: any }>,
+    metadata: Uint8Array
+  ): Promise<Uint8Array> {
+    // Initialize worker if needed
+    await this.initializeWorker();
+
+    // Generate unique request ID
+    const id = `zkprove-${Date.now()}-${this.requestCounter++}`;
+
+    return new Promise((resolve, reject) => {
+      // Set up timeout (30 seconds)
+      const timeoutId = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error('Worker request timeout (30s)'));
+      }, 30000);
+
+      // Store pending request
+      this.pendingRequests.set(id, { resolve, reject, timeoutId });
+
+      // Send message to worker
+      const message: ZkProveWorkerRequest = {
+        id,
+        type: 'zkProve',
+        fheKeyHex,
+        crsHex,
+        items,
+        metadata: Array.from(metadata),
+      };
+
+      (this.worker as any).postMessage(message);
+    });
+  }
+
+  /**
+   * Terminate the worker and clean up
+   */
+  terminate(): void {
+    if (this.worker) {
+      (this.worker as any).terminate();
+      this.worker = null;
+      this.workerReady = false;
+      this.initializationPromise = null;
+    }
+
+    // Reject all pending requests
+    this.pendingRequests.forEach(({ reject, timeoutId }) => {
+      clearTimeout(timeoutId);
+      reject(new Error('Worker terminated'));
+    });
+    this.pendingRequests.clear();
+  }
+
+  /**
+   * Check if worker is available
+   */
+  isAvailable(): boolean {
+    return typeof Worker !== 'undefined';
+  }
+}
+
+// Singleton instance
+let workerManager: ZkProveWorkerManager | null = null;
+
+/**
+ * Get the worker manager instance
+ */
+export function getWorkerManager(): ZkProveWorkerManager {
+  if (!workerManager) {
+    workerManager = new ZkProveWorkerManager();
+  }
+  return workerManager;
+}
+
+/**
+ * Terminate the worker
+ */
+export function terminateWorker(): void {
+  if (workerManager) {
+    workerManager.terminate();
+    workerManager = null;
+  }
+}
+
+/**
+ * Check if workers are available
+ */
+export function areWorkersAvailable(): boolean {
+  return typeof Worker !== 'undefined';
+}

package/web/workerManager.web.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { getWorkerManager, terminateWorker, areWorkersAvailable } from './workerManager.js';
+
+describe('WorkerManager (Browser)', () => {
+  afterEach(() => {
+    // Clean up worker after each test
+    terminateWorker();
+  });
+
+  describe('areWorkersAvailable', () => {
+    it('should return true in browser environment', () => {
+      // In real browser with Playwright, workers should be available
+      expect(areWorkersAvailable()).toBe(true);
+    });
+  });
+
+  describe('Worker lifecycle', () => {
+    it('should initialize worker successfully', async () => {
+      const manager = getWorkerManager();
+      expect(manager).toBeDefined();
+
+      // Worker should be available
+      expect(areWorkersAvailable()).toBe(true);
+    });
+
+    it('should handle worker termination', () => {
+      const manager = getWorkerManager();
+      expect(manager).toBeDefined();
+
+      terminateWorker();
+
+      // Should be able to get a new instance
+      const newManager = getWorkerManager();
+      expect(newManager).toBeDefined();
+    });
+  });
+
+  describe('submitProof', () => {
+    it('should reject invalid data with error message', async () => {
+      const manager = getWorkerManager();
+
+      // Submit with invalid data - should fail quickly
+      await expect(manager.submitProof('invalid', 'invalid', [], new Uint8Array())).rejects.toThrow();
+    }, 35000);
+
+    it('should reject invalid message type', async () => {
+      const manager = getWorkerManager();
+
+      // Submit with invalid data that will cause worker error
+      await expect(
+        manager.submitProof(
+          '', // empty key
+          '', // empty crs
+          [{ utype: 'invalid', data: 'test' }],
+          new Uint8Array([1, 2, 3])
+        )
+      ).rejects.toThrow();
+    }, 35000);
+  });
+
+  describe('Concurrent requests', () => {
+    it('should handle multiple concurrent proof requests', async () => {
+      const manager = getWorkerManager();
+
+      // Submit multiple requests concurrently
+      const requests = [
+        manager.submitProof('key1', 'crs1', [], new Uint8Array([1])),
+        manager.submitProof('key2', 'crs2', [], new Uint8Array([2])),
+        manager.submitProof('key3', 'crs3', [], new Uint8Array([3])),
+      ];
+
+      // All should reject (invalid data), but shouldn't crash
+      const results = await Promise.allSettled(requests);
+
+      expect(results).toHaveLength(3);
+      results.forEach((result) => {
+        expect(result.status).toBe('rejected');
+      });
+    }, 35000);
+  });
+
+  describe('Worker error handling', () => {
+    it('should handle worker errors gracefully', async () => {
+      const manager = getWorkerManager();
+
+      // This should cause an error in the worker
+      await expect(
+        manager.submitProof(
+          'malformed-hex',
+          'malformed-crs',
+          [{ utype: 'uint128', data: 'not-a-number' }],
+          new Uint8Array([])
+        )
+      ).rejects.toThrow();
+    }, 35000);
+  });
+
+  describe('Termination during processing', () => {
+    it('should reject pending requests on termination', async () => {
+      const manager = getWorkerManager();
+
+      // Start a request (will timeout)
+      const proofPromise = manager.submitProof('test', 'test', [], new Uint8Array());
+
+      // Terminate immediately
+      setTimeout(() => {
+        terminateWorker();
+      }, 100);
+
+      // Request should be rejected
+      await expect(proofPromise).rejects.toThrow();
+    }, 5000);
+  });
+});

package/web/zkProve.worker.ts

@@ -0,0 +1,133 @@
+/**
+ * Web Worker for ZK Proof Generation
+ * Performs heavy WASM computation off the main thread
+ */
+
+/// <reference lib="webworker" />
+/* eslint-disable no-undef */
+
+import type { ZkProveWorkerRequest, ZkProveWorkerResponse } from '../core/encrypt/zkPackProveVerify.js';
+
+// TFHE module (will be initialized on first use)
+let tfheModule: any = null;
+let initialized = false;
+
+/**
+ * Initialize TFHE in worker context
+ */
+async function initTfhe() {
+  if (initialized) return;
+
+  try {
+    // Dynamic import of tfhe module
+    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;
+  }
+}
+
+/**
+ * Convert hex string to Uint8Array
+ */
+function fromHexString(hexString: string): Uint8Array {
+  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)));
+}
+
+/**
+ * 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');
+    }
+
+    // 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}`);
+      }
+    }
+
+    // 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.serialize();
+
+    // 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);