@cofhe/sdk 0.1.1 → 0.2.0

package/permits/validation.ts

@@ -8,6 +8,8 @@ const SerializedSealingPair = z.object({
   publicKey: z.string(),
 });
 
+const DEFAULT_EXPIRATION_FN = () => Math.round(Date.now() / 1000) + 7 * 24 * 60 * 60; // 7 days from now
+
 const zPermitWithDefaults = z.object({
   name: z.string().optional().default('Unnamed Permit'),
   type: z.enum(['self', 'sharing', 'recipient']),
@@ -19,7 +21,7 @@ const zPermitWithDefaults = z.object({
     .refine((val) => val !== zeroAddress, {
       message: 'Permit issuer :: must not be zeroAddress',
     }),
-  expiration: z.number().optional().default(1000000000000),
+  expiration: z.number().optional().default(DEFAULT_EXPIRATION_FN),
   recipient: z
     .string()
     .optional()
@@ -75,11 +77,14 @@ export const SelfPermitOptionsValidator = z
       .refine((val) => isAddress(val), {
         message: 'Self permit issuer :: invalid address',
       })
+      .refine((val) => is0xPrefixed(val), {
+        message: 'Self permit issuer :: must be 0x prefixed',
+      })
       .refine((val) => val !== zeroAddress, {
         message: 'Self permit issuer :: must not be zeroAddress',
       }),
     name: z.string().optional().default('Unnamed Permit'),
-    expiration: z.number().optional().default(1000000000000),
+    expiration: z.number().optional().default(DEFAULT_EXPIRATION_FN),
     recipient: z
       .string()
       .optional()
@@ -87,6 +92,9 @@ export const SelfPermitOptionsValidator = z
       .refine((val) => isAddress(val), {
         message: 'Self permit recipient :: invalid address',
       })
+      .refine((val) => is0xPrefixed(val), {
+        message: 'Self permit recipient :: must be 0x prefixed',
+      })
       .refine((val) => val === zeroAddress, {
         message: 'Self permit recipient :: must be zeroAddress',
       }),
@@ -148,6 +156,9 @@ export const SharingPermitOptionsValidator = z
       .refine((val) => isAddress(val), {
         message: 'Sharing permit issuer :: invalid address',
       })
+      .refine((val) => is0xPrefixed(val), {
+        message: 'Sharing permit issuer :: must be 0x prefixed',
+      })
       .refine((val) => val !== zeroAddress, {
         message: 'Sharing permit issuer :: must not be zeroAddress',
       }),
@@ -156,11 +167,14 @@ export const SharingPermitOptionsValidator = z
       .refine((val) => isAddress(val), {
         message: 'Sharing permit recipient :: invalid address',
       })
+      .refine((val) => is0xPrefixed(val), {
+        message: 'Sharing permit recipient :: must be 0x prefixed',
+      })
       .refine((val) => val !== zeroAddress, {
         message: 'Sharing permit recipient :: must not be zeroAddress',
       }),
     name: z.string().optional().default('Unnamed Permit'),
-    expiration: z.number().optional().default(1000000000000),
+    expiration: z.number().optional().default(DEFAULT_EXPIRATION_FN),
     validatorId: z.number().optional().default(0),
     validatorContract: z
       .string()
@@ -219,6 +233,9 @@ export const ImportPermitOptionsValidator = z
       .refine((val) => isAddress(val), {
         message: 'Import permit issuer :: invalid address',
       })
+      .refine((val) => is0xPrefixed(val), {
+        message: 'Import permit issuer :: must be 0x prefixed',
+      })
       .refine((val) => val !== zeroAddress, {
         message: 'Import permit issuer :: must not be zeroAddress',
       }),
@@ -227,6 +244,9 @@ export const ImportPermitOptionsValidator = z
       .refine((val) => isAddress(val), {
         message: 'Import permit recipient :: invalid address',
       })
+      .refine((val) => is0xPrefixed(val), {
+        message: 'Import permit recipient :: must be 0x prefixed',
+      })
       .refine((val) => val !== zeroAddress, {
         message: 'Import permit recipient :: must not be zeroAddress',
       }),
@@ -239,7 +259,7 @@ export const ImportPermitOptionsValidator = z
         message: 'Import permit :: issuerSignature must be provided',
       }),
     name: z.string().optional().default('Unnamed Permit'),
-    expiration: z.number().optional().default(1000000000000),
+    expiration: z.number().optional().default(DEFAULT_EXPIRATION_FN),
     validatorId: z.number().optional().default(0),
     validatorContract: z
       .string()

package/web/client.web.test.ts

@@ -1,4 +1,4 @@
-import { type CofhesdkClient } from '@/core';
+import { CofhesdkErrorCode, CofhesdkError, type CofhesdkClient } from '@/core';
 import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
 
 import { describe, it, expect, beforeAll, beforeEach, vi } from 'vitest';
@@ -60,11 +60,16 @@ describe('@cofhe/web - Client', () => {
     });
   });
 
+  describe('Environment', () => {
+    it('should have the correct environment', () => {
+      expect(cofhesdkClient.config.environment).toBe('web');
+    });
+  });
+
   describe('Connection', () => {
     it('should connect to real chain', async () => {
-      const result = await cofhesdkClient.connect(publicClient, walletClient);
+      await cofhesdkClient.connect(publicClient, walletClient);
 
-      expect(result.success).toBe(true);
       expect(cofhesdkClient.connected).toBe(true);
 
       const snapshot = cofhesdkClient.getSnapshot();
@@ -74,15 +79,17 @@ describe('@cofhe/web - Client', () => {
     }, 30000);
 
     it('should handle network errors', async () => {
-      const result = await cofhesdkClient.connect(
-        {
-          getChainId: vi.fn().mockRejectedValue(new Error('Network error')),
-        } as unknown as PublicClient,
-        walletClient
-      );
-
-      expect(result.success).toBe(false);
-      expect(cofhesdkClient.connected).toBe(false);
+      try {
+        await cofhesdkClient.connect(
+          {
+            getChainId: vi.fn().mockRejectedValue(new Error('Network error')),
+          } as unknown as PublicClient,
+          walletClient
+        );
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.PublicWalletGetChainIdFailed);
+      }
     }, 30000);
   });
 
@@ -113,23 +120,11 @@ describe('@cofhe/web - Client', () => {
     }, 30000);
   });
 
-  describe('Initialization Results', () => {
-    it('should have keyFetchResult promise', () => {
-      expect(cofhesdkClient.initializationResults).toBeDefined();
-      expect(cofhesdkClient.initializationResults.keyFetchResult).toBeInstanceOf(Promise);
-    });
-
-    it('should resolve keyFetchResult', async () => {
-      const result = await cofhesdkClient.initializationResults.keyFetchResult;
-      expect(result.success).toBe(true);
-    });
-  });
-
   describe('Builder Creation', () => {
     it('should create encrypt builder after connection', async () => {
       await cofhesdkClient.connect(publicClient, walletClient);
 
-      const builder = cofhesdkClient.encryptInputs([{ data: 100n, utype: 2 }]);
+      const builder = cofhesdkClient.encryptInputs([{ data: 100n, utype: 2, securityZone: 0 }]);
 
       expect(builder).toBeDefined();
       expect(typeof builder.setChainId).toBe('function');

package/web/config.web.test.ts

@@ -42,14 +42,12 @@ describe('@cofhe/web - Config', () => {
     it('should preserve all other config options', () => {
       const config = createCofhesdkConfig({
         supportedChains: [arbSepolia],
-        fheKeysPrefetching: 'OFF',
         mocks: {
           sealOutputDelay: 500,
         },
       });
 
       expect(config.supportedChains).toEqual([arbSepolia]);
-      expect(config.fheKeysPrefetching).toBe('OFF');
       expect(config.mocks.sealOutputDelay).toBe(500);
       expect(config.fheKeyStorage).toBeDefined();
     });

package/web/encryptInputs.web.test.ts

@@ -1,5 +1,5 @@
 import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
-import { Encryptable, FheTypes, type CofhesdkClient, type Result, CofhesdkErrorCode, CofhesdkError } from '@/core';
+import { Encryptable, FheTypes, type CofhesdkClient, CofhesdkErrorCode, CofhesdkError } from '@/core';
 
 import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
 import type { PublicClient, WalletClient } from 'viem';
@@ -11,22 +11,6 @@ import { createCofhesdkClient, createCofhesdkConfig } from './index.js';
 // Real test setup - runs in browser with real tfhe
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 
-const expectResultSuccess = <T>(result: Result<T>): T => {
-  expect(result.success, `Result error: ${result.error?.toString()}`).toBe(true);
-  return result.data!;
-};
-
-const expectResultError = <T>(result: Result<T>, errorCode?: CofhesdkErrorCode): void => {
-  expect(result.success).toBe(false);
-  expect(result.data).toBe(null);
-  expect(result.error).not.toBe(null);
-  const error = result.error as CofhesdkError;
-  expect(error).toBeInstanceOf(CofhesdkError);
-  if (errorCode) {
-    expect(error.code, `Result error: ${result.error?.toString()}`).toBe(errorCode);
-  }
-};
-
 describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
   let cofhesdkClient: CofhesdkClient;
   let publicClient: PublicClient;
@@ -60,22 +44,19 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
 
       // This will trigger real TFHE initialization in browser
       const result = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
-      const encrypted = expectResultSuccess(result);
 
       // If we get here, TFHE was initialized successfully
-      expect(encrypted).toBeDefined();
+      expect(result).toBeDefined();
     }, 60000); // Longer timeout for real operations
 
     it('should handle multiple encryptions without re-initializing', async () => {
       await cofhesdkClient.connect(publicClient, walletClient);
 
       // First encryption
-      const result1 = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
-      expectResultSuccess(result1);
+      expect(cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt()).resolves.not.toThrow();
 
       // Second encryption should reuse initialization
-      const result2 = await cofhesdkClient.encryptInputs([Encryptable.uint64(50n)]).encrypt();
-      expectResultSuccess(result2);
+      expect(cofhesdkClient.encryptInputs([Encryptable.uint64(50n)]).encrypt()).resolves.not.toThrow();
     }, 60000);
   });
 
@@ -84,15 +65,15 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
       await cofhesdkClient.connect(publicClient, walletClient);
 
       const result = await cofhesdkClient.encryptInputs([Encryptable.bool(true)]).encrypt();
-      const encrypted = expectResultSuccess(result);
 
-      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);
+      expect(result).toBeDefined();
+      expect(result.length).toBe(1);
+      expect(result[0].utype).toBe(FheTypes.Bool);
+      expect(result[0].ctHash).toBeDefined();
+      expect(typeof result[0].ctHash).toBe('bigint');
+      expect(result[0].signature).toBeDefined();
+      expect(typeof result[0].signature).toBe('string');
+      expect(result[0].securityZone).toBe(0);
     }, 60000);
 
     it('should encrypt all supported types together', async () => {
@@ -109,17 +90,17 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
       ];
 
       const result = await cofhesdkClient.encryptInputs(inputs).encrypt();
-      const encrypted = expectResultSuccess(result);
+      expect(result).toBeDefined();
 
-      expect(encrypted.length).toBe(7);
+      expect(result.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);
+      expect(result[0].utype).toBe(FheTypes.Bool);
+      expect(result[1].utype).toBe(FheTypes.Uint8);
+      expect(result[2].utype).toBe(FheTypes.Uint16);
+      expect(result[3].utype).toBe(FheTypes.Uint32);
+      expect(result[4].utype).toBe(FheTypes.Uint64);
+      expect(result[5].utype).toBe(FheTypes.Uint128);
+      expect(result[6].utype).toBe(FheTypes.Uint160);
     }, 90000); // Longer timeout for multiple encryptions
   });
 
@@ -128,14 +109,13 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
       await cofhesdkClient.connect(publicClient, walletClient);
 
       const snapshot = cofhesdkClient.getSnapshot();
-      const result = await cofhesdkClient
+      const encrypted = await cofhesdkClient
         .encryptInputs([Encryptable.uint128(100n)])
         .setChainId(snapshot.chainId!)
         .setAccount(snapshot.account!)
         .setSecurityZone(0)
         .encrypt();
 
-      const encrypted = expectResultSuccess(result);
       expect(encrypted.length).toBe(1);
       expect(encrypted[0].utype).toBe(FheTypes.Uint128);
     }, 60000);
@@ -144,9 +124,12 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
   describe('Browser Error Handling', () => {
     it('should fail gracefully when not connected', async () => {
       // Don't connect the client
-      const result = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
-
-      expectResultError(result, CofhesdkErrorCode.NotConnected);
+      try {
+        const promise = cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.NotConnected);
+      }
     }, 30000);
 
     it('should handle invalid CoFHE URL', async () => {
@@ -158,18 +141,13 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
             verifierUrl: 'http://invalid-verifier-url.local',
           },
         ],
-        fheKeysPrefetching: 'OFF',
       });
 
       const badClient = createCofhesdkClient(badConfig);
       await badClient.connect(publicClient, walletClient);
 
-      const result = await badClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
-
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error).toBeDefined();
-      }
+      const promise = badClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+      expect(promise).rejects.toThrow();
     }, 60000);
   });
 
@@ -181,8 +159,7 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
 
       // Perform 5 encryptions
       for (let i = 0; i < 5; i++) {
-        const result = await cofhesdkClient.encryptInputs([Encryptable.uint128(BigInt(i))]).encrypt();
-        expectResultSuccess(result);
+        await cofhesdkClient.encryptInputs([Encryptable.uint128(BigInt(i))]).encrypt();
       }
 
       const duration = Date.now() - start;

package/web/index.ts

@@ -8,11 +8,16 @@ import {
   type CofhesdkInputConfig,
   type ZkBuilderAndCrsGenerator,
   type FheKeyDeserializer,
+  type EncryptableItem,
+  fheTypeToString,
 } from '@/core';
 
 // Import web-specific storage (internal use only)
 import { createWebStorage } from './storage.js';
 
+// Import worker manager
+import { getWorkerManager, terminateWorker, areWorkersAvailable } from './workerManager.js';
+
 // Import tfhe for web
 import init, { init_panic_hook, TfheCompactPublicKey, ProvenCompactCiphertextList, CompactPkeCrs } from 'tfhe';
 
@@ -68,6 +73,27 @@ const zkBuilderAndCrsGenerator: ZkBuilderAndCrsGenerator = (fhe: string, crs: st
   return { zkBuilder, zkCrs };
 };
 
+/**
+ * Worker-enabled zkProve function
+ * This submits proof generation to a Web Worker
+ */
+async function zkProveWithWorker(
+  fheKeyHex: string,
+  crsHex: string,
+  items: EncryptableItem[],
+  metadata: Uint8Array
+): Promise<Uint8Array> {
+  // Serialize items for worker (convert enum to string name)
+  const serializedItems = items.map((item) => ({
+    utype: fheTypeToString(item.utype),
+    data: typeof item.data === 'bigint' ? item.data.toString() : item.data,
+  }));
+
+  // Submit to worker
+  const workerManager = getWorkerManager();
+  return await workerManager.submitProof(fheKeyHex, crsHex, serializedItems, metadata);
+}
+
 /**
  * Creates a CoFHE SDK configuration for web with IndexedDB storage as default
  * @param config - The CoFHE SDK input configuration (fheKeyStorage will default to IndexedDB if not provided)
@@ -75,6 +101,7 @@ const zkBuilderAndCrsGenerator: ZkBuilderAndCrsGenerator = (fhe: string, crs: st
  */
 export function createCofhesdkConfig(config: CofhesdkInputConfig): CofhesdkConfig {
   return createCofhesdkConfigBase({
+    environment: 'web',
     ...config,
     fheKeyStorage: config.fheKeyStorage === null ? null : config.fheKeyStorage ?? createWebStorage(),
   });
@@ -83,15 +110,52 @@ export function createCofhesdkConfig(config: CofhesdkInputConfig): CofhesdkConfi
 /**
  * Creates a CoFHE SDK client instance for web with TFHE automatically configured
  * TFHE will be initialized automatically on first encryption - no manual setup required
+ * Workers are automatically enabled if available (can be disabled via config.useWorkers)
  * @param config - The CoFHE SDK configuration (use createCofhesdkConfig to create with web defaults)
  * @returns The CoFHE SDK client instance
  */
-export function createCofhesdkClient(config: CofhesdkConfig): CofhesdkClient {
+export function createCofhesdkClient<TConfig extends CofhesdkConfig>(config: TConfig): CofhesdkClient<TConfig> {
+  return createCofhesdkClientBase({
+    config,
+    zkBuilderAndCrsGenerator,
+    tfhePublicKeyDeserializer,
+    compactPkeCrsDeserializer,
+    initTfhe,
+    // Always provide the worker function if available - config.useWorkers controls usage
+    // areWorkersAvailable will return true if the Worker API is available and false in Node.js
+    zkProveWorkerFn: areWorkersAvailable() ? zkProveWithWorker : undefined,
+  });
+}
+
+/**
+ * Terminate the worker (call on app cleanup)
+ */
+export { terminateWorker };
+
+/**
+ * Check if workers are available
+ */
+export { areWorkersAvailable };
+
+/**
+ * Test helper: Create a client with custom worker function (for testing fallback behavior)
+ * @internal - Only for testing purposes
+ */
+export function createCofhesdkClientWithCustomWorker(
+  config: CofhesdkConfig,
+  customZkProveWorkerFn: (
+    fheKeyHex: string,
+    crsHex: string,
+    items: EncryptableItem[],
+    metadata: Uint8Array
+  ) => Promise<Uint8Array>
+): CofhesdkClient {
   return createCofhesdkClientBase({
     config,
     zkBuilderAndCrsGenerator,
     tfhePublicKeyDeserializer,
     compactPkeCrsDeserializer,
     initTfhe,
+    zkProveWorkerFn: customZkProveWorkerFn,
   });
 }

package/web/storage.ts

@@ -1,20 +1,34 @@
 import type { IStorage } from '@/core';
-import { get, set, del } from 'idb-keyval';
-
+import { constructClient } from 'iframe-shared-storage';
 /**
  * Creates a web storage implementation using IndexedDB
  * @returns IStorage implementation for browser environments
  */
 export const createWebStorage = (): IStorage => {
+  const client = constructClient({
+    iframe: {
+      src: 'https://iframe-shared-storage.vercel.app/hub.html',
+      messagingOptions: {
+        enableLog: 'both',
+      },
+
+      iframeReadyTimeoutMs: 30_000, // if the iframe is not initied during this interval AND a reuqest is made, such request will throw an error
+      methodCallTimeoutMs: 10_000, // if a method call is not answered during this interval, the call will throw an error
+      methodCallRetries: 3, // number of retries for a method call if it times out
+    },
+  });
+
+  const indexedDBKeyval = client.indexedDBKeyval;
   return {
     getItem: async (name: string) => {
-      return (await get(name)) || null;
+      // IndexedDBKeyval returns undefined if not found, but we want null (a json-deserialized value is expected)
+      return (await indexedDBKeyval.get(name)) ?? null;
     },
     setItem: async (name: string, value: any) => {
-      await set(name, value);
+      await indexedDBKeyval.set(name, value);
     },
     removeItem: async (name: string) => {
-      await del(name);
+      await indexedDBKeyval.del(name);
     },
   };
 };

package/web/worker.builder.web.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import { createCofhesdkClient, createCofhesdkConfig } from './index.js';
+import { Encryptable, type CofhesdkClient } from '@/core';
+import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
+import { arbitrumSepolia as viemArbitrumSepolia } from 'viem/chains';
+import { createPublicClient, createWalletClient, http, type PublicClient, type WalletClient } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+
+const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+
+describe('@cofhe/sdk/web - EncryptInputsBuilder Worker Methods', () => {
+  let cofhesdkClient: CofhesdkClient;
+  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,
+    });
+  });
+
+  beforeEach(async () => {
+    const config = createCofhesdkConfig({
+      supportedChains: [cofhesdkArbSepolia],
+    });
+    cofhesdkClient = createCofhesdkClient(config);
+    await cofhesdkClient.connect(publicClient, walletClient);
+  });
+
+  describe('setUseWorker method', () => {
+    it('should have setUseWorker method on EncryptInputsBuilder', () => {
+      const builder = cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]);
+
+      expect(builder).toHaveProperty('setUseWorker');
+      expect(typeof builder.setUseWorker).toBe('function');
+    });
+
+    it('should return builder for method chaining', () => {
+      const builder = cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]);
+      const returnedBuilder = builder.setUseWorker(false);
+
+      // Should return the same builder instance (or at least same type)
+      expect(returnedBuilder).toBe(builder);
+    });
+
+    it('should allow chaining with other builder methods', () => {
+      // Should be able to chain setUseWorker with setStepCallback
+      const builder = cofhesdkClient
+        .encryptInputs([Encryptable.uint128(100n)])
+        .setUseWorker(false)
+        .setStepCallback(() => {});
+
+      expect(builder).toBeDefined();
+      expect(builder).toHaveProperty('encrypt');
+    });
+
+    it('should accept true parameter', () => {
+      expect(() => {
+        cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).setUseWorker(true);
+      }).not.toThrow();
+    });
+
+    it('should accept false parameter', () => {
+      expect(() => {
+        cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).setUseWorker(false);
+      }).not.toThrow();
+    });
+
+    it('should have getUseWorker method', () => {
+      const builder = cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]);
+
+      expect(builder).toHaveProperty('getUseWorker');
+      expect(typeof builder.getUseWorker).toBe('function');
+    });
+
+    it('should return current useWorker value', () => {
+      const builderWithWorkers = cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).setUseWorker(true);
+      const builderWithoutWorkers = cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).setUseWorker(false);
+
+      // Should reflect config values
+      expect(builderWithWorkers.getUseWorker()).toBe(true);
+      expect(builderWithoutWorkers.getUseWorker()).toBe(false);
+    });
+
+    it('should reflect changes from setUseWorker', () => {
+      const builder = cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).setUseWorker(true);
+      expect(builder.getUseWorker()).toBe(true);
+
+      builder.setUseWorker(false);
+      expect(builder.getUseWorker()).toBe(false);
+
+      builder.setUseWorker(true);
+      expect(builder.getUseWorker()).toBe(true);
+    });
+  });
+
+  describe('Worker function availability', () => {
+    it('should initialize client without errors', () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [cofhesdkArbSepolia],
+        useWorkers: true,
+      });
+
+      expect(() => {
+        createCofhesdkClient(config);
+      }).not.toThrow();
+    });
+
+    it('should handle worker function when workers enabled', async () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [cofhesdkArbSepolia],
+        useWorkers: true,
+      });
+
+      const client = createCofhesdkClient(config);
+      await client.connect(publicClient, walletClient);
+      const builder = client.encryptInputs([Encryptable.uint128(100n)]);
+
+      // Should not throw even though workers aren't available in Node
+      expect(() => {
+        builder.setUseWorker(true);
+      }).not.toThrow();
+    });
+
+    it('should handle when workers disabled', async () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [cofhesdkArbSepolia],
+        useWorkers: false,
+      });
+
+      const client = createCofhesdkClient(config);
+      await client.connect(publicClient, walletClient);
+      const builder = client.encryptInputs([Encryptable.uint128(100n)]);
+
+      expect(() => {
+        builder.setUseWorker(false);
+      }).not.toThrow();
+    });
+  });
+});