@cofhe/sdk 0.1.1 → 0.2.0

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);

package/core/result.test.ts

@@ -1,180 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ResultOk, ResultErr, ResultErrOrInternal, resultWrapper, resultWrapperSync, type Result } from './result.js';
-import { CofhesdkError, CofhesdkErrorCode } from './error.js';
-
-export const expectResultError = <T>(result: Result<T>, errorPartial: string) => {
-  expect(result.success).to.eq(false, 'Result should be an error');
-  expect(result.error!.message).to.include(errorPartial, `Error should contain error partial: ${errorPartial}`);
-};
-
-export const expectResultSuccess = <T>(result: Result<T>): T => {
-  expect(result.success).to.eq(true, 'Result should be a success');
-  return result.data!;
-};
-
-export const expectResultValue = <T>(result: Result<T>, value: T): T => {
-  expect(result.success).to.eq(true, 'Result should be a success');
-  expect(result.data).to.eq(value, `Result should have the expected value ${value}`);
-  return result.data!;
-};
-
-describe('Result Type', () => {
-  describe('ResultOk', () => {
-    it('should create a successful result', () => {
-      const result = ResultOk('test data');
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('test data');
-      expect(result.error).toBe(null);
-    });
-
-    it('should handle different data types', () => {
-      const stringResult = ResultOk('string');
-      const numberResult = ResultOk(42);
-      const objectResult = ResultOk({ key: 'value' });
-      const nullResult = ResultOk(null);
-
-      expect(stringResult.data).toBe('string');
-      expect(numberResult.data).toBe(42);
-      expect(objectResult.data).toEqual({ key: 'value' });
-      expect(nullResult.data).toBe(null);
-    });
-  });
-
-  describe('ResultErr', () => {
-    it('should create an error result', () => {
-      const error = new CofhesdkError({
-        code: CofhesdkErrorCode.InternalError,
-        message: 'Test error',
-      });
-      const result = ResultErr(error);
-
-      expect(result.success).toBe(false);
-      expect(result.data).toBe(null);
-      expect(result.error).toBe(error);
-    });
-  });
-});
-
-describe('Error Utilities', () => {
-  describe('ResultErrOrInternal', () => {
-    it('should wrap unknown errors as internal errors', () => {
-      const result = ResultErrOrInternal(new Error('string error'));
-      expect(result.success).toBe(false);
-      expect(result.error!).toBeInstanceOf(CofhesdkError);
-      expect(result.error!.code).toBe(CofhesdkErrorCode.InternalError);
-      expect(result.error!.message).toBe('An internal error occurred | Caused by: string error');
-    });
-
-    it('should preserve CofhesdkError instances', () => {
-      const originalError = new CofhesdkError({
-        code: CofhesdkErrorCode.MissingPublicClient,
-        message: 'Public client missing',
-      });
-      const result = ResultErrOrInternal(originalError);
-      expect(result.success).toBe(false);
-      expect(result.error!).toBe(originalError);
-    });
-
-    it('should handle Error instances', () => {
-      const error = new Error('Standard error');
-      const result = ResultErrOrInternal(error);
-      expect(result.success).toBe(false);
-      expect(result.error!).toBeInstanceOf(CofhesdkError);
-      expect(result.error!.cause).toBe(error);
-    });
-  });
-});
-
-describe('Result Wrappers', () => {
-  describe('resultWrapperSync', () => {
-    it('should wrap successful sync function', () => {
-      const result = resultWrapperSync(() => 'success');
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('success');
-    });
-
-    it('should wrap failing sync function', () => {
-      const result = resultWrapperSync(() => {
-        throw new Error('Sync error');
-      });
-      expect(result.success).toBe(false);
-      expect(result.error).toBeInstanceOf(CofhesdkError);
-    });
-  });
-
-  describe('resultWrapper', () => {
-    it('should wrap successful async function', async () => {
-      const result = await resultWrapper(async () => 'async success');
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('async success');
-    });
-
-    it('should wrap failing async function', async () => {
-      const result = await resultWrapper(async () => {
-        throw new Error('Async error');
-      });
-      expect(result.success).toBe(false);
-      expect(result.error).toBeInstanceOf(CofhesdkError);
-    });
-
-    it('should handle async operations', async () => {
-      const result = await resultWrapper(async () => {
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        return 'delayed result';
-      });
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('delayed result');
-    });
-
-    it('should handle Promise rejections', async () => {
-      const result = await resultWrapper(async () => {
-        return Promise.reject(new Error('Promise rejection'));
-      });
-      expect(result.success).toBe(false);
-      expect(result.error).toBeInstanceOf(CofhesdkError);
-    });
-  });
-});
-
-describe('Result Type Guards', () => {
-  it('should correctly identify success results', () => {
-    const successResult = ResultOk('data');
-    expect(successResult.success).toBe(true);
-    expect(successResult.data).toBe('data');
-    expect(successResult.error).toBe(null);
-  });
-
-  it('should correctly identify error results', () => {
-    const errorResult = ResultErr(
-      new CofhesdkError({
-        code: CofhesdkErrorCode.InternalError,
-        message: 'Test error',
-      })
-    );
-    expect(errorResult.success).toBe(false);
-    expect(errorResult.data).toBe(null);
-    expect(errorResult.error).toBeInstanceOf(CofhesdkError);
-  });
-});
-
-describe('Result Test Utilities', () => {
-  it('expectResultSuccess should return data for success', () => {
-    const result = ResultOk('data');
-    expect(expectResultSuccess(result)).toBe('data');
-  });
-
-  it('expectResultValue should validate and return matching data', () => {
-    const result = ResultOk('expected');
-    expect(expectResultValue(result, 'expected')).toBe('expected');
-  });
-
-  it('expectResultError should validate error messages', () => {
-    const result = ResultErr(
-      new CofhesdkError({
-        code: CofhesdkErrorCode.InternalError,
-        message: 'Test error message',
-      })
-    );
-    expectResultError(result, 'Test error');
-  });
-});

package/core/result.ts

@@ -1,67 +0,0 @@
-/* eslint-disable no-unused-vars */
-import { CofhesdkError, CofhesdkErrorCode } from './error.js';
-
-export type Result<T> = { success: true; data: T; error: null } | { success: false; data: null; error: CofhesdkError };
-
-export const ResultErr = <T>(error: CofhesdkError): Result<T> => ({
-  success: false,
-  data: null,
-  error,
-});
-
-export const ResultOk = <T>(data: T): Result<T> => ({
-  success: true,
-  data,
-  error: null,
-});
-
-export const ResultErrOrInternal = <T>(error: unknown): Result<T> => {
-  return ResultErr(CofhesdkError.fromError(error));
-};
-
-export const ResultHttpError = (error: unknown, url: string, status?: number): CofhesdkError => {
-  if (error instanceof CofhesdkError) return error;
-
-  const message = status ? `HTTP error ${status} from ${url}` : `HTTP request failed for ${url}`;
-
-  return new CofhesdkError({
-    code: CofhesdkErrorCode.InternalError,
-    message,
-    cause: error instanceof Error ? error : undefined,
-  });
-};
-
-export const ResultValidationError = (message: string): CofhesdkError => {
-  return new CofhesdkError({
-    code: CofhesdkErrorCode.InvalidPermitData,
-    message,
-  });
-};
-
-// Async resultWrapper
-export const resultWrapper = async <T>(
-  tryFn: () => Promise<T>,
-  catchFn?: (error: CofhesdkError) => void,
-  finallyFn?: () => void
-): Promise<Result<T>> => {
-  try {
-    const result = await tryFn();
-    return ResultOk(result);
-  } catch (error) {
-    const result = ResultErrOrInternal(error);
-    catchFn?.(result.error!);
-    return result as Result<T>;
-  } finally {
-    finallyFn?.();
-  }
-};
-
-// Sync resultWrapper
-export const resultWrapperSync = <T>(fn: () => T): Result<T> => {
-  try {
-    const result = fn();
-    return ResultOk(result);
-  } catch (error) {
-    return ResultErrOrInternal(error);
-  }
-};

package/core/test-utils.ts

@@ -1,45 +0,0 @@
-import { expect } from 'vitest';
-import { type Result } from './result.js';
-import { CofhesdkError, CofhesdkErrorCode } from './error.js';
-
-/**
- * Assert that a Result is successful and return its data
- * Useful for type narrowing in tests
- */
-export const expectResultSuccess = <T>(result: Result<T>): NonNullable<T> => {
-  expect(result.error, `Result error: ${result.error?.toString()}`).toBe(null);
-  expect(result.success, `Result: ${bigintSafeJsonStringify(result)}`).toBe(true);
-  expect(result.data, `Result: ${bigintSafeJsonStringify(result)}`).not.toBe(null);
-  return result.data!;
-};
-
-/**
- * Assert that a Result is an error and optionally verify the error details
- */
-export const expectResultError = <T>(
-  result: Result<T>,
-  errorCode?: CofhesdkErrorCode,
-  errorMessage?: string
-): CofhesdkError => {
-  expect(result.success, `Result: ${bigintSafeJsonStringify(result)}`).toBe(false);
-  expect(result.data, `Result: ${bigintSafeJsonStringify(result)}`).toBe(null);
-  expect(result.error, `Result: ${bigintSafeJsonStringify(result)}`).not.toBe(null);
-  const error = result.error as CofhesdkError;
-  expect(error, `Result error: ${result.error?.toString()}`).toBeInstanceOf(CofhesdkError);
-  if (errorCode) {
-    expect(error.code, `Result error: ${result.error?.toString()}`).toBe(errorCode);
-  }
-  if (errorMessage) {
-    expect(error.message, `Result error: ${result.error?.toString()}`).toBe(errorMessage);
-  }
-  return error;
-};
-
-const bigintSafeJsonStringify = (value: unknown): string => {
-  return JSON.stringify(value, (key, value) => {
-    if (typeof value === 'bigint') {
-      return `${value}n`;
-    }
-    return value;
-  });
-};