@cofhe/sdk 0.1.1 → 0.2.0

package/web/worker.config.web.test.ts

@@ -0,0 +1,329 @@
+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, createCofhesdkClientWithCustomWorker } from './index.js';
+
+const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+
+describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
+  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,
+    });
+  });
+
+  describe('useWorkers config flag', () => {
+    it('should use workers by default (useWorkers: true)', async () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [cofhesdkArbSepolia],
+        // useWorkers defaults to true
+      });
+
+      expect(config.useWorkers).toBe(true);
+
+      const client = createCofhesdkClient(config);
+      await client.connect(publicClient, walletClient);
+
+      // Track step callbacks to see worker usage
+      let proveContext: any;
+      const result = await client
+        .encryptInputs([Encryptable.uint128(100n)])
+        .setStepCallback((step, context) => {
+          if (step === 'prove' && context?.isEnd) {
+            proveContext = context;
+          }
+        })
+        .encrypt();
+
+      expect(result).toBeDefined();
+
+      // Check that worker was attempted
+      expect(proveContext).toBeDefined();
+      expect(proveContext.useWorker).toBe(true);
+      // Note: Workers may fail to initialize in Playwright test environment
+      // due to WASM module loading issues. Verify fallback works correctly.
+      expect(proveContext.usedWorker).toBeDefined();
+      // The test cannot load tfhe module, so the worker fallback occurs.
+      // The real test is to check that usedWorker is true
+      // TBD: Find a way to test this in the test environment.
+
+      // Log if fallback occurred for debugging
+      if (!proveContext.usedWorker) {
+        console.log('Worker fallback occurred (expected in test env):', proveContext.workerFailedError);
+        expect(proveContext.workerFailedError).toBeDefined();
+      }
+    }, 60000);
+
+    it('should disable workers when useWorkers: false', async () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [cofhesdkArbSepolia],
+        useWorkers: false,
+      });
+
+      expect(config.useWorkers).toBe(false);
+
+      const client = createCofhesdkClient(config);
+      await client.connect(publicClient, walletClient);
+
+      // Track step callbacks
+      let proveContext: any;
+      const result = await client
+        .encryptInputs([Encryptable.uint128(100n)])
+        .setStepCallback((step, context) => {
+          if (step === 'prove' && context?.isEnd) {
+            proveContext = context;
+          }
+        })
+        .encrypt();
+
+      expect(result).toBeDefined();
+
+      // Should explicitly NOT use workers
+      expect(proveContext).toBeDefined();
+      expect(proveContext.useWorker).toBe(false);
+      expect(proveContext.usedWorker).toBe(false);
+    }, 60000);
+  });
+
+  describe('setUseWorker() method', () => {
+    it('should override config with setUseWorker(false)', async () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [cofhesdkArbSepolia],
+        useWorkers: true, // Config says true
+      });
+
+      const client = createCofhesdkClient(config);
+      await client.connect(publicClient, walletClient);
+
+      // Track step callbacks
+      let proveContext: any;
+      const result = await client
+        .encryptInputs([Encryptable.uint128(100n)])
+        .setUseWorker(false) // Override to false
+        .setStepCallback((step, context) => {
+          if (step === 'prove' && context?.isEnd) {
+            proveContext = context;
+          }
+        })
+        .encrypt();
+
+      expect(result).toBeDefined();
+
+      // Should respect the override
+      expect(proveContext.useWorker).toBe(false);
+      expect(proveContext.usedWorker).toBe(false);
+    }, 60000);
+
+    it('should override config with setUseWorker(true)', async () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [cofhesdkArbSepolia],
+        useWorkers: false, // Config says false
+      });
+
+      const client = createCofhesdkClient(config);
+      await client.connect(publicClient, walletClient);
+
+      // Track step callbacks
+      let proveContext: any;
+      const result = await client
+        .encryptInputs([Encryptable.uint128(100n)])
+        .setUseWorker(true) // Override to true
+        .setStepCallback((step, context) => {
+          if (step === 'prove' && context?.isEnd) {
+            proveContext = context;
+          }
+        })
+        .encrypt();
+
+      expect(result).toBeDefined();
+
+      // Should use worker since we overrode to true
+      expect(proveContext.useWorker).toBe(true);
+    }, 60000);
+  });
+
+  describe('Step callback worker context', () => {
+    it('should include worker debug info in prove step', async () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [cofhesdkArbSepolia],
+      });
+
+      const client = createCofhesdkClient(config);
+      await client.connect(publicClient, walletClient);
+
+      let proveContext: any;
+      const result = await client
+        .encryptInputs([Encryptable.uint128(100n)])
+        .setStepCallback((step, context) => {
+          if (step === 'prove' && context?.isEnd) {
+            proveContext = context;
+          }
+        })
+        .encrypt();
+
+      expect(result).toBeDefined();
+
+      // Verify all worker-related fields are present
+      expect(proveContext).toBeDefined();
+      expect(proveContext).toHaveProperty('useWorker');
+      expect(proveContext).toHaveProperty('usedWorker');
+      expect(proveContext).toHaveProperty('isEnd');
+      expect(proveContext).toHaveProperty('duration');
+
+      // If worker failed, should have error message
+      if (proveContext.useWorker && !proveContext.usedWorker) {
+        expect(proveContext).toHaveProperty('workerFailedError');
+        expect(typeof proveContext.workerFailedError).toBe('string');
+      }
+    }, 60000);
+  });
+
+  describe('Worker fallback behavior', () => {
+    it('should fallback to main thread when worker fails', async () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [cofhesdkArbSepolia],
+        useWorkers: true,
+      });
+
+      // Create a worker function that ALWAYS fails
+      const failingWorkerFn = async () => {
+        throw new Error('Worker failed intentionally');
+      };
+
+      // Inject the failing worker into the client
+      const client = createCofhesdkClientWithCustomWorker(config, failingWorkerFn);
+      await client.connect(publicClient, walletClient);
+
+      // Track step callbacks to verify fallback
+      let proveContext: any;
+      const result = await client
+        .encryptInputs([Encryptable.uint128(100n)])
+        .setStepCallback((step, context) => {
+          if (step === 'prove' && context?.isEnd) {
+            proveContext = context;
+          }
+        })
+        .encrypt();
+
+      // Verify encryption succeeded via fallback to main thread
+      expect(result).toBeDefined();
+      expect(result.length).toBe(1);
+
+      // Verify worker was attempted but failed, triggering fallback
+      expect(proveContext).toBeDefined();
+      expect(proveContext.useWorker).toBe(true); // Worker was requested
+      expect(proveContext.usedWorker).toBe(false); // But it failed
+      expect(proveContext.workerFailedError).toBe('Worker failed intentionally');
+    }, 60000);
+
+    it('should fallback when encrypting multiple values', async () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [cofhesdkArbSepolia],
+        useWorkers: true,
+      });
+
+      // Failing worker with different error message
+      const failingWorkerFn = async () => {
+        throw new Error('Worker unavailable');
+      };
+
+      const client = createCofhesdkClientWithCustomWorker(config, failingWorkerFn);
+      await client.connect(publicClient, walletClient);
+
+      let proveContext: any;
+      const result = await client
+        .encryptInputs([Encryptable.uint128(100n), Encryptable.uint64(50n), Encryptable.bool(true)])
+        .setStepCallback((step, context) => {
+          if (step === 'prove' && context?.isEnd) {
+            proveContext = context;
+          }
+        })
+        .encrypt();
+
+      // All values should encrypt successfully via fallback
+      expect(result).toBeDefined();
+      expect(result.length).toBe(3);
+
+      // Verify fallback occurred
+      expect(proveContext.useWorker).toBe(true);
+      expect(proveContext.usedWorker).toBe(false);
+      expect(proveContext.workerFailedError).toBe('Worker unavailable');
+    }, 60000);
+
+    it('should handle async worker errors gracefully', async () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [cofhesdkArbSepolia],
+        useWorkers: true,
+      });
+
+      // Worker that fails after a delay
+      const asyncFailingWorkerFn = async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        throw new Error('Async worker failure');
+      };
+
+      const client = createCofhesdkClientWithCustomWorker(config, asyncFailingWorkerFn);
+      await client.connect(publicClient, walletClient);
+
+      let proveContext: any;
+      const result = await client
+        .encryptInputs([Encryptable.uint8(42n)])
+        .setStepCallback((step, context) => {
+          if (step === 'prove' && context?.isEnd) {
+            proveContext = context;
+          }
+        })
+        .encrypt();
+
+      expect(result).toBeDefined();
+
+      expect(proveContext.useWorker).toBe(true);
+      expect(proveContext.usedWorker).toBe(false);
+      expect(proveContext.workerFailedError).toBe('Async worker failure');
+    }, 60000);
+
+    it('should work without worker when explicitly disabled', async () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [cofhesdkArbSepolia],
+        useWorkers: true, // Config says use workers
+      });
+
+      const client = createCofhesdkClient(config);
+      await client.connect(publicClient, walletClient);
+
+      let proveContext: any;
+      const result = await client
+        .encryptInputs([Encryptable.uint8(42n)])
+        .setUseWorker(false) // But override to disable worker
+        .setStepCallback((step, context) => {
+          if (step === 'prove' && context?.isEnd) {
+            proveContext = context;
+          }
+        })
+        .encrypt();
+
+      expect(result).toBeDefined();
+
+      // Should NOT attempt worker at all
+      expect(proveContext.useWorker).toBe(false);
+      expect(proveContext.usedWorker).toBe(false);
+      expect(proveContext.workerFailedError).toBeUndefined();
+    }, 60000);
+  });
+});

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';
+}