@cofhe/sdk 0.6.0 → 0.7.0

package/web/test/inherited.web.test.ts

@@ -1,9 +1,11 @@
+import { STAGING_TESTS, stagingViemChain } from '../../core/test/stagingRedirect';
 import { Encryptable, FheTypes, type CofheClient } from '@/core';
-import { arbSepolia as cofheArbSepolia, getChainById } from '@/chains';
+import { arbSepolia as cofheArbSepolia, getChainById, stagingCofhe } from '@/chains';
 import {
   TEST_PRIVATE_KEY,
   PRIMARY_TEST_CHAIN,
   primaryTestChainRegistry,
+  stagingTestChainRegistry,
   isPrimaryTestChainReady,
 } from '@cofhe/test-setup';
 
@@ -28,6 +30,9 @@ const VIEM_CHAINS: Record<number, Chain> = {
   11155111: sepolia,
 };
 
+const testViemChain = STAGING_TESTS ? stagingViemChain : arbitrumSepolia;
+const testCofheChain = STAGING_TESTS ? stagingCofhe : cofheArbSepolia;
+
 describe('@cofhe/web - Inherited Client Tests', () => {
   let cofheClient: CofheClient;
   let publicClient: PublicClient;
@@ -36,18 +41,18 @@ describe('@cofhe/web - Inherited Client Tests', () => {
 
   beforeAll(() => {
     publicClient = createPublicClient({
-      chain: arbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
     });
 
     bobWalletClient = createWalletClient({
-      chain: arbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
       account: bobAccount,
     });
 
     aliceWalletClient = createWalletClient({
-      chain: arbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
       account: aliceAccount,
     });
@@ -55,7 +60,7 @@ describe('@cofhe/web - Inherited Client Tests', () => {
 
   beforeEach(() => {
     const config = createCofheConfig({
-      supportedChains: [cofheArbSepolia],
+      supportedChains: [testCofheChain],
     });
     cofheClient = createCofheClient(config);
   });
@@ -72,7 +77,7 @@ describe('@cofhe/web - Inherited Client Tests', () => {
       expect(typeof cofheClient.decryptForTx).toBe('function');
       expect(typeof cofheClient.getSnapshot).toBe('function');
       expect(typeof cofheClient.subscribe).toBe('function');
-      expect(cofheClient.permits).toBeDefined();
+      expect(cofheClient.acp).toBeDefined();
     });
   });
 
@@ -84,7 +89,7 @@ describe('@cofhe/web - Inherited Client Tests', () => {
 
       const snapshot = cofheClient.getSnapshot();
       expect(snapshot.connected).toBe(true);
-      expect(snapshot.chainId).toBe(cofheArbSepolia.id);
+      expect(snapshot.chainId).toBe(testCofheChain.id);
       expect(snapshot.account).toBe(bobAccount.address);
     }, 30000);
   });
@@ -93,81 +98,85 @@ describe('@cofhe/web - Inherited Client Tests', () => {
     it('should encrypt a uint128 value', async () => {
       await cofheClient.connect(publicClient, bobWalletClient);
 
-      const encrypted = await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
+      const encrypted = await cofheClient
+        .encryptInputs([Encryptable.uint128(100n)])
+        .setConsumingContract(bobAccount.address)
+        .execute();
 
+      // [hash, signature] - one hash per input, followed by the shared batch signature.
       expect(encrypted).toBeDefined();
-      expect(encrypted.length).toBe(1);
-      expect(encrypted[0].utype).toBe(FheTypes.Uint128);
-      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);
+      expect(encrypted.length).toBe(2);
+
+      const [hash, signature] = encrypted;
+      expect(typeof hash).toBe('string');
+      expect(hash).toMatch(/^0x[0-9a-fA-F]+$/);
+      expect(typeof signature).toBe('string');
+      expect(signature).toMatch(/^0x[0-9a-fA-F]+$/);
+    }, 120000);
   });
 
-  describe('Self Permit', () => {
-    it('should create a self permit', async () => {
+  describe('Self ACP', () => {
+    it('should create a self acp', async () => {
       await cofheClient.connect(publicClient, bobWalletClient);
 
-      const permit = await cofheClient.permits.createSelf({
+      const acp = await cofheClient.acp.createSelf({
         issuer: bobAccount.address,
-        name: 'Test Self Permit',
+        name: 'Test Self ACP',
       });
 
-      expect(permit).toBeDefined();
-      expect(permit.type).toBe('self');
-      expect(permit.name).toBe('Test Self Permit');
-      expect(permit.issuer).toBe(bobAccount.address);
-      expect(permit.issuerSignature).not.toBe('0x');
-      expect(permit.sealingPair).toBeDefined();
-      expect(permit.sealingPair.publicKey).toBeDefined();
-
-      const activePermit = cofheClient.permits.getActivePermit();
-      expect(activePermit).toBeDefined();
-      expect(activePermit!.hash).toBe(permit.hash);
+      expect(acp).toBeDefined();
+      expect(acp.type).toBe('self');
+      expect(acp.name).toBe('Test Self ACP');
+      expect(acp.issuer).toBe(bobAccount.address);
+      expect(acp.issuerSignature).not.toBe('0x');
+      expect(acp.sealingPrivateKey).toBeDefined();
+      expect(acp.sealingKey).toBeDefined();
+
+      const activeACP = cofheClient.acp.getActiveACP();
+      expect(activeACP).toBeDefined();
+      expect(activeACP!.hash).toBe(acp.hash);
     }, 30000);
   });
 
-  describe('Sharing Permit', () => {
-    it('should create a sharing permit, export it, and import it as another user', async () => {
+  describe('Sharing ACP', () => {
+    it('should create a sharing acp, export it, and import it as another user', async () => {
       await cofheClient.connect(publicClient, bobWalletClient);
 
-      const sharingPermit = await cofheClient.permits.createSharing({
+      const sharingACP = await cofheClient.acp.createSharing({
         issuer: bobAccount.address,
         recipient: aliceAccount.address,
-        name: 'Test Sharing Permit',
+        name: 'Test Sharing ACP',
       });
 
-      expect(sharingPermit).toBeDefined();
-      expect(sharingPermit.type).toBe('sharing');
-      expect(sharingPermit.issuer).toBe(bobAccount.address);
-      expect(sharingPermit.recipient).toBe(aliceAccount.address);
-      expect(sharingPermit.issuerSignature).not.toBe('0x');
+      expect(sharingACP).toBeDefined();
+      expect(sharingACP.type).toBe('sharing');
+      expect(sharingACP.issuer).toBe(bobAccount.address);
+      expect(sharingACP.recipient).toBe(aliceAccount.address);
+      expect(sharingACP.issuerSignature).not.toBe('0x');
 
-      const exported = cofheClient.permits.export(sharingPermit);
+      const exported = cofheClient.acp.export(sharingACP);
       expect(exported).toBeDefined();
       const parsed = JSON.parse(exported);
       expect(parsed.type).toBe('sharing');
       expect(parsed.issuer).toBe(bobAccount.address);
       expect(parsed.recipient).toBe(aliceAccount.address);
       expect(parsed.issuerSignature).toBeDefined();
-      expect(parsed).not.toHaveProperty('sealingPair');
+      expect(parsed).not.toHaveProperty('sealingPrivateKey');
 
       const aliceConfig = createCofheConfig({
-        supportedChains: [cofheArbSepolia],
+        supportedChains: [testCofheChain],
       });
       const aliceClient = createCofheClient(aliceConfig);
       await aliceClient.connect(publicClient, aliceWalletClient);
 
-      const importedPermit = await aliceClient.permits.importShared(exported);
+      const importedACP = await aliceClient.acp.importShared(exported);
 
-      expect(importedPermit).toBeDefined();
-      expect(importedPermit.type).toBe('recipient');
-      expect(importedPermit.issuer).toBe(bobAccount.address);
-      expect(importedPermit.recipient).toBe(aliceAccount.address);
-      expect(importedPermit.recipientSignature).not.toBe('0x');
-      expect(importedPermit.sealingPair).toBeDefined();
+      expect(importedACP).toBeDefined();
+      expect(importedACP.type).toBe('recipient');
+      expect(importedACP.issuer).toBe(bobAccount.address);
+      expect(importedACP.recipient).toBe(aliceAccount.address);
+      expect(importedACP.recipientSignature).not.toBe('0x');
+      expect(importedACP.sealingPrivateKey).toBeDefined();
     }, 30000);
   });
 
@@ -182,15 +191,16 @@ describe('@cofhe/web - Inherited Client Tests', () => {
     let publicValue: bigint;
 
     beforeAll(() => {
-      if (!isPrimaryTestChainReady(primaryTestChainRegistry)) {
-        throw new Error('Primary test chain registry not initialized. Run `pnpm test:setup` first.');
+      const reg = STAGING_TESTS
+        ? (stagingTestChainRegistry as typeof primaryTestChainRegistry)
+        : primaryTestChainRegistry;
+      if (!isPrimaryTestChainReady(reg)) {
+        throw new Error('Test chain registry not initialized. Run `pnpm test:setup` first.');
       }
-
-      const reg = primaryTestChainRegistry;
-      const viemChain = VIEM_CHAINS[reg.chainId];
+      const viemChain = STAGING_TESTS ? stagingViemChain : VIEM_CHAINS[reg.chainId];
       if (!viemChain) throw new Error(`No viem chain mapping for chain ${reg.chainId}`);
 
-      const cofheChain = getChainById(reg.chainId);
+      const cofheChain = STAGING_TESTS ? stagingCofhe : getChainById(reg.chainId);
       if (!cofheChain) throw new Error(`No cofhe chain config for chain ${reg.chainId}`);
 
       privateCtHash = reg.privateValue.ctHash as `0x${string}`;
@@ -205,37 +215,37 @@ describe('@cofhe/web - Inherited Client Tests', () => {
       decryptClient = createCofheClient(config);
     });
 
-    it('decryptForView — private value with permit', async () => {
+    it('decryptForView — private value with acp', async () => {
       await decryptClient.connect(decryptPublicClient, decryptWalletClient);
 
-      await decryptClient.permits.createSelf({
+      await decryptClient.acp.createSelf({
         issuer: bobAccount.address,
-        name: 'Decrypt View Permit',
+        name: 'Decrypt View ACP',
       });
 
       const result = await decryptClient.decryptForView(privateCtHash, FheTypes.Uint32).execute();
       expect(result).toBe(privateValue);
     }, 180000);
 
-    it('decryptForTx — public value without permit', async () => {
+    it('decryptForTx — public value without acp', async () => {
       await decryptClient.connect(decryptPublicClient, decryptWalletClient);
 
-      const result = await decryptClient.decryptForTx(publicCtHash).withoutPermit().execute();
+      const result = await decryptClient.decryptForTx(publicCtHash).withoutACP().execute();
 
       expect(BigInt(result.ctHash)).toBe(BigInt(publicCtHash));
       expect(result.decryptedValue).toBe(publicValue);
       expect(result.signature).toMatch(/^0x[0-9a-fA-F]+$/);
     }, 180000);
 
-    it('decryptForTx — private value with permit', async () => {
+    it('decryptForTx — private value with acp', async () => {
       await decryptClient.connect(decryptPublicClient, decryptWalletClient);
 
-      const permit = await decryptClient.permits.createSelf({
+      const acp = await decryptClient.acp.createSelf({
         issuer: bobAccount.address,
-        name: 'Decrypt Tx Permit',
+        name: 'Decrypt Tx ACP',
       });
 
-      const result = await decryptClient.decryptForTx(privateCtHash).withPermit(permit).execute();
+      const result = await decryptClient.decryptForTx(privateCtHash).withACP(acp).execute();
 
       expect(BigInt(result.ctHash)).toBe(BigInt(privateCtHash));
       expect(result.decryptedValue).toBe(privateValue);

package/web/test/tfheinit.web.test.ts

@@ -1,4 +1,5 @@
-import { arbSepolia as cofheArbSepolia } from '@/chains';
+import { STAGING_TESTS, stagingViemChain } from '../../core/test/stagingRedirect';
+import { arbSepolia as cofheArbSepolia, stagingCofhe } from '@/chains';
 import { Encryptable, type CofheClient } from '@/core';
 
 import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
@@ -11,6 +12,9 @@ import { createCofheClient, createCofheConfig } from '../index.js';
 // Real test setup - runs in browser with real tfhe
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 
+const testViemChain = STAGING_TESTS ? stagingViemChain : viemArbitrumSepolia;
+const testCofheChain = STAGING_TESTS ? stagingCofhe : cofheArbSepolia;
+
 // Logs per-step durations using the built-in `context.duration` provided by the SDK.
 // Each encryption run is a separate entry so multi-encrypt tests show per-run breakdowns.
 function makeStepLogger(testName: string) {
@@ -48,25 +52,27 @@ describe('@cofhe/web - TFHE Initialization Browser Tests', () => {
   let cofheClient: CofheClient;
   let publicClient: PublicClient;
   let walletClient: WalletClient;
+  let consumingContract: `0x${string}`;
 
   beforeAll(() => {
     // Create real viem clients
     publicClient = createPublicClient({
-      chain: viemArbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
     });
 
     const account = privateKeyToAccount(TEST_PRIVATE_KEY);
     walletClient = createWalletClient({
-      chain: viemArbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
       account,
     });
+    consumingContract = account.address;
   });
 
   beforeEach(() => {
     const config = createCofheConfig({
-      supportedChains: [cofheArbSepolia],
+      supportedChains: [testCofheChain],
     });
     cofheClient = createCofheClient(config);
   });
@@ -81,6 +87,7 @@ describe('@cofhe/web - TFHE Initialization Browser Tests', () => {
       // This will trigger real TFHE initialization in browser
       const result = await cofheClient
         .encryptInputs([Encryptable.uint128(100n)])
+        .setConsumingContract(consumingContract)
         .onStep((step, context) => {
           logger.onStep(step, context);
           if (step === 'initTfhe' && context?.isEnd) {
@@ -95,7 +102,7 @@ describe('@cofhe/web - TFHE Initialization Browser Tests', () => {
       expect(result).toBeDefined();
       expect(initTfheContext).toBeDefined();
       expect(initTfheContext?.tfheInitializationExecuted).toBe(true);
-    }, 60000); // Longer timeout for real operations
+    }, 120000); // Longer timeout for real operations
 
     it('should handle multiple encryptions without re-initializing', async () => {
       await cofheClient.connect(publicClient, walletClient);
@@ -106,6 +113,7 @@ describe('@cofhe/web - TFHE Initialization Browser Tests', () => {
       // First encryption
       const firstResult = await cofheClient
         .encryptInputs([Encryptable.uint128(100n)])
+        .setConsumingContract(consumingContract)
         .onStep((step, context) => {
           logger.onStep(step, context);
           if (step === 'initTfhe' && context?.isEnd) {
@@ -119,6 +127,7 @@ describe('@cofhe/web - TFHE Initialization Browser Tests', () => {
       // Second encryption should reuse initialization
       const secondResult = await cofheClient
         .encryptInputs([Encryptable.uint64(50n)])
+        .setConsumingContract(consumingContract)
         .onStep((step, context) => {
           logger.onStep(step, context);
           if (step === 'initTfhe' && context?.isEnd) {

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

@@ -1,4 +1,5 @@
-import { arbSepolia as cofheArbSepolia } from '@/chains';
+import { STAGING_TESTS, stagingViemChain } from '../../core/test/stagingRedirect';
+import { arbSepolia as cofheArbSepolia, stagingCofhe } from '@/chains';
 import { Encryptable } from '@/core';
 
 import { describe, it, expect, beforeAll } from 'vitest';
@@ -10,28 +11,33 @@ import { createCofheClient, createCofheConfig, createCofheClientWithCustomWorker
 
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 
+const testViemChain = STAGING_TESTS ? stagingViemChain : viemArbitrumSepolia;
+const testCofheChain = STAGING_TESTS ? stagingCofhe : cofheArbSepolia;
+
 describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
   let publicClient: PublicClient;
   let walletClient: WalletClient;
+  let consumingContract: `0x${string}`;
 
   beforeAll(() => {
     publicClient = createPublicClient({
-      chain: viemArbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
     });
 
     const account = privateKeyToAccount(TEST_PRIVATE_KEY);
     walletClient = createWalletClient({
-      chain: viemArbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
       account,
     });
+    consumingContract = account.address;
   });
 
   describe('useWorkers config flag', () => {
     it('should use workers by default (useWorkers: true)', async () => {
       const config = createCofheConfig({
-        supportedChains: [cofheArbSepolia],
+        supportedChains: [testCofheChain],
         // useWorkers defaults to true
       });
 
@@ -44,6 +50,7 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       let proveContext: any;
       const result = await client
         .encryptInputs([Encryptable.uint128(100n)])
+        .setConsumingContract(consumingContract)
         .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
@@ -68,11 +75,11 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
         console.log('Worker fallback occurred (expected in test env):', proveContext.workerFailedError);
         expect(proveContext.workerFailedError).toBeDefined();
       }
-    }, 60000);
+    }, 120000);
 
     it('should disable workers when useWorkers: false', async () => {
       const config = createCofheConfig({
-        supportedChains: [cofheArbSepolia],
+        supportedChains: [testCofheChain],
         useWorkers: false,
       });
 
@@ -85,6 +92,7 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       let proveContext: any;
       const result = await client
         .encryptInputs([Encryptable.uint128(100n)])
+        .setConsumingContract(consumingContract)
         .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
@@ -98,13 +106,13 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       expect(proveContext).toBeDefined();
       expect(proveContext.useWorker).toBe(false);
       expect(proveContext.usedWorker).toBe(false);
-    }, 60000);
+    }, 120000);
   });
 
   describe('setUseWorker() method', () => {
     it('should override config with setUseWorker(false)', async () => {
       const config = createCofheConfig({
-        supportedChains: [cofheArbSepolia],
+        supportedChains: [testCofheChain],
         useWorkers: true, // Config says true
       });
 
@@ -115,6 +123,7 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       let proveContext: any;
       const result = await client
         .encryptInputs([Encryptable.uint128(100n)])
+        .setConsumingContract(consumingContract)
         .setUseWorker(false) // Override to false
         .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
@@ -128,11 +137,11 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       // Should respect the override
       expect(proveContext.useWorker).toBe(false);
       expect(proveContext.usedWorker).toBe(false);
-    }, 60000);
+    }, 120000);
 
     it('should override config with setUseWorker(true)', async () => {
       const config = createCofheConfig({
-        supportedChains: [cofheArbSepolia],
+        supportedChains: [testCofheChain],
         useWorkers: false, // Config says false
       });
 
@@ -143,6 +152,7 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       let proveContext: any;
       const result = await client
         .encryptInputs([Encryptable.uint128(100n)])
+        .setConsumingContract(consumingContract)
         .setUseWorker(true) // Override to true
         .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
@@ -155,13 +165,13 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
 
       // Should use worker since we overrode to true
       expect(proveContext.useWorker).toBe(true);
-    }, 60000);
+    }, 120000);
   });
 
   describe('Step callback worker context', () => {
     it('should include worker debug info in prove step', async () => {
       const config = createCofheConfig({
-        supportedChains: [cofheArbSepolia],
+        supportedChains: [testCofheChain],
       });
 
       const client = createCofheClient(config);
@@ -170,6 +180,7 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       let proveContext: any;
       const result = await client
         .encryptInputs([Encryptable.uint128(100n)])
+        .setConsumingContract(consumingContract)
         .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
@@ -191,13 +202,13 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
         expect(proveContext).toHaveProperty('workerFailedError');
         expect(typeof proveContext.workerFailedError).toBe('string');
       }
-    }, 60000);
+    }, 120000);
   });
 
   describe('Worker fallback behavior', () => {
     it('should fallback to main thread when worker fails', async () => {
       const config = createCofheConfig({
-        supportedChains: [cofheArbSepolia],
+        supportedChains: [testCofheChain],
         useWorkers: true,
       });
 
@@ -214,6 +225,7 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       let proveContext: any;
       const result = await client
         .encryptInputs([Encryptable.uint128(100n)])
+        .setConsumingContract(consumingContract)
         .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
@@ -223,18 +235,18 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
 
       // Verify encryption succeeded via fallback to main thread
       expect(result).toBeDefined();
-      expect(result.length).toBe(1);
+      expect(result.length).toBe(2); // 1 ctHash + shared signature
 
       // 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);
+    }, 120000);
 
     it('should fallback when encrypting multiple values', async () => {
       const config = createCofheConfig({
-        supportedChains: [cofheArbSepolia],
+        supportedChains: [testCofheChain],
         useWorkers: true,
       });
 
@@ -249,6 +261,7 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       let proveContext: any;
       const result = await client
         .encryptInputs([Encryptable.uint128(100n), Encryptable.uint64(50n), Encryptable.bool(true)])
+        .setConsumingContract(consumingContract)
         .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
@@ -258,17 +271,17 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
 
       // All values should encrypt successfully via fallback
       expect(result).toBeDefined();
-      expect(result.length).toBe(3);
+      expect(result.length).toBe(4); // 3 ctHashes + shared signature
 
       // Verify fallback occurred
       expect(proveContext.useWorker).toBe(true);
       expect(proveContext.usedWorker).toBe(false);
       expect(proveContext.workerFailedError).toBe('Worker unavailable');
-    }, 60000);
+    }, 120000);
 
     it('should handle async worker errors gracefully', async () => {
       const config = createCofheConfig({
-        supportedChains: [cofheArbSepolia],
+        supportedChains: [testCofheChain],
         useWorkers: true,
       });
 
@@ -284,6 +297,7 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       let proveContext: any;
       const result = await client
         .encryptInputs([Encryptable.uint8(42n)])
+        .setConsumingContract(consumingContract)
         .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
@@ -296,11 +310,11 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       expect(proveContext.useWorker).toBe(true);
       expect(proveContext.usedWorker).toBe(false);
       expect(proveContext.workerFailedError).toBe('Async worker failure');
-    }, 60000);
+    }, 120000);
 
     it('should work without worker when explicitly disabled', async () => {
       const config = createCofheConfig({
-        supportedChains: [cofheArbSepolia],
+        supportedChains: [testCofheChain],
         useWorkers: true, // Config says use workers
       });
 
@@ -310,6 +324,7 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       let proveContext: any;
       const result = await client
         .encryptInputs([Encryptable.uint8(42n)])
+        .setConsumingContract(consumingContract)
         .setUseWorker(false) // But override to disable worker
         .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
@@ -324,6 +339,6 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       expect(proveContext.useWorker).toBe(false);
       expect(proveContext.usedWorker).toBe(false);
       expect(proveContext.workerFailedError).toBeUndefined();
-    }, 60000);
+    }, 120000);
   });
 });