@cofhe/sdk 0.2.1 → 0.3.0

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

@@ -1,4 +1,4 @@
-import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
+import { arbSepolia as cofheArbSepolia } from '@/chains';
 import { Encryptable } from '@/core';
 
 import { describe, it, expect, beforeAll } from 'vitest';
@@ -6,7 +6,7 @@ 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';
+import { createCofheClient, createCofheConfig, createCofheClientWithCustomWorker } from './index.js';
 
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 
@@ -30,26 +30,26 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
 
   describe('useWorkers config flag', () => {
     it('should use workers by default (useWorkers: true)', async () => {
-      const config = createCofhesdkConfig({
-        supportedChains: [cofhesdkArbSepolia],
+      const config = createCofheConfig({
+        supportedChains: [cofheArbSepolia],
         // useWorkers defaults to true
       });
 
       expect(config.useWorkers).toBe(true);
 
-      const client = createCofhesdkClient(config);
+      const client = createCofheClient(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) => {
+        .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
           }
         })
-        .encrypt();
+        .execute();
 
       expect(result).toBeDefined();
 
@@ -71,26 +71,26 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
     }, 60000);
 
     it('should disable workers when useWorkers: false', async () => {
-      const config = createCofhesdkConfig({
-        supportedChains: [cofhesdkArbSepolia],
+      const config = createCofheConfig({
+        supportedChains: [cofheArbSepolia],
         useWorkers: false,
       });
 
       expect(config.useWorkers).toBe(false);
 
-      const client = createCofhesdkClient(config);
+      const client = createCofheClient(config);
       await client.connect(publicClient, walletClient);
 
       // Track step callbacks
       let proveContext: any;
       const result = await client
         .encryptInputs([Encryptable.uint128(100n)])
-        .setStepCallback((step, context) => {
+        .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
           }
         })
-        .encrypt();
+        .execute();
 
       expect(result).toBeDefined();
 
@@ -103,12 +103,12 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
 
   describe('setUseWorker() method', () => {
     it('should override config with setUseWorker(false)', async () => {
-      const config = createCofhesdkConfig({
-        supportedChains: [cofhesdkArbSepolia],
+      const config = createCofheConfig({
+        supportedChains: [cofheArbSepolia],
         useWorkers: true, // Config says true
       });
 
-      const client = createCofhesdkClient(config);
+      const client = createCofheClient(config);
       await client.connect(publicClient, walletClient);
 
       // Track step callbacks
@@ -116,12 +116,12 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       const result = await client
         .encryptInputs([Encryptable.uint128(100n)])
         .setUseWorker(false) // Override to false
-        .setStepCallback((step, context) => {
+        .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
           }
         })
-        .encrypt();
+        .execute();
 
       expect(result).toBeDefined();
 
@@ -131,12 +131,12 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
     }, 60000);
 
     it('should override config with setUseWorker(true)', async () => {
-      const config = createCofhesdkConfig({
-        supportedChains: [cofhesdkArbSepolia],
+      const config = createCofheConfig({
+        supportedChains: [cofheArbSepolia],
         useWorkers: false, // Config says false
       });
 
-      const client = createCofhesdkClient(config);
+      const client = createCofheClient(config);
       await client.connect(publicClient, walletClient);
 
       // Track step callbacks
@@ -144,12 +144,12 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       const result = await client
         .encryptInputs([Encryptable.uint128(100n)])
         .setUseWorker(true) // Override to true
-        .setStepCallback((step, context) => {
+        .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
           }
         })
-        .encrypt();
+        .execute();
 
       expect(result).toBeDefined();
 
@@ -160,22 +160,22 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
 
   describe('Step callback worker context', () => {
     it('should include worker debug info in prove step', async () => {
-      const config = createCofhesdkConfig({
-        supportedChains: [cofhesdkArbSepolia],
+      const config = createCofheConfig({
+        supportedChains: [cofheArbSepolia],
       });
 
-      const client = createCofhesdkClient(config);
+      const client = createCofheClient(config);
       await client.connect(publicClient, walletClient);
 
       let proveContext: any;
       const result = await client
         .encryptInputs([Encryptable.uint128(100n)])
-        .setStepCallback((step, context) => {
+        .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
           }
         })
-        .encrypt();
+        .execute();
 
       expect(result).toBeDefined();
 
@@ -196,8 +196,8 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
 
   describe('Worker fallback behavior', () => {
     it('should fallback to main thread when worker fails', async () => {
-      const config = createCofhesdkConfig({
-        supportedChains: [cofhesdkArbSepolia],
+      const config = createCofheConfig({
+        supportedChains: [cofheArbSepolia],
         useWorkers: true,
       });
 
@@ -207,19 +207,19 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
       };
 
       // Inject the failing worker into the client
-      const client = createCofhesdkClientWithCustomWorker(config, failingWorkerFn);
+      const client = createCofheClientWithCustomWorker(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) => {
+        .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
           }
         })
-        .encrypt();
+        .execute();
 
       // Verify encryption succeeded via fallback to main thread
       expect(result).toBeDefined();
@@ -233,8 +233,8 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
     }, 60000);
 
     it('should fallback when encrypting multiple values', async () => {
-      const config = createCofhesdkConfig({
-        supportedChains: [cofhesdkArbSepolia],
+      const config = createCofheConfig({
+        supportedChains: [cofheArbSepolia],
         useWorkers: true,
       });
 
@@ -243,18 +243,18 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
         throw new Error('Worker unavailable');
       };
 
-      const client = createCofhesdkClientWithCustomWorker(config, failingWorkerFn);
+      const client = createCofheClientWithCustomWorker(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) => {
+        .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
           }
         })
-        .encrypt();
+        .execute();
 
       // All values should encrypt successfully via fallback
       expect(result).toBeDefined();
@@ -267,8 +267,8 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
     }, 60000);
 
     it('should handle async worker errors gracefully', async () => {
-      const config = createCofhesdkConfig({
-        supportedChains: [cofhesdkArbSepolia],
+      const config = createCofheConfig({
+        supportedChains: [cofheArbSepolia],
         useWorkers: true,
       });
 
@@ -278,18 +278,18 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
         throw new Error('Async worker failure');
       };
 
-      const client = createCofhesdkClientWithCustomWorker(config, asyncFailingWorkerFn);
+      const client = createCofheClientWithCustomWorker(config, asyncFailingWorkerFn);
       await client.connect(publicClient, walletClient);
 
       let proveContext: any;
       const result = await client
         .encryptInputs([Encryptable.uint8(42n)])
-        .setStepCallback((step, context) => {
+        .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
           }
         })
-        .encrypt();
+        .execute();
 
       expect(result).toBeDefined();
 
@@ -299,24 +299,24 @@ describe('@cofhe/sdk/web - Worker Configuration Tests', () => {
     }, 60000);
 
     it('should work without worker when explicitly disabled', async () => {
-      const config = createCofhesdkConfig({
-        supportedChains: [cofhesdkArbSepolia],
+      const config = createCofheConfig({
+        supportedChains: [cofheArbSepolia],
         useWorkers: true, // Config says use workers
       });
 
-      const client = createCofhesdkClient(config);
+      const client = createCofheClient(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) => {
+        .onStep((step, context) => {
           if (step === 'prove' && context?.isEnd) {
             proveContext = context;
           }
         })
-        .encrypt();
+        .execute();
 
       expect(result).toBeDefined();
 

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

@@ -1,4 +1,4 @@
-import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
+import { arbSepolia as cofheArbSepolia } from '@/chains';
 import { Encryptable } from '@/core';
 
 import { describe, it, expect, beforeAll } from 'vitest';
@@ -6,7 +6,7 @@ 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';
+import { createCofheClient, createCofheConfig } from './index.js';
 
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 
@@ -30,18 +30,18 @@ describe('@cofhe/sdk/web - Worker vs Main Thread Output Validation', () => {
 
   it('should produce consistent output format regardless of worker usage', async () => {
     // Create two clients - one with workers, one without
-    const configWithWorker = createCofhesdkConfig({
-      supportedChains: [cofhesdkArbSepolia],
+    const configWithWorker = createCofheConfig({
+      supportedChains: [cofheArbSepolia],
       useWorkers: true,
     });
 
-    const configWithoutWorker = createCofhesdkConfig({
-      supportedChains: [cofhesdkArbSepolia],
+    const configWithoutWorker = createCofheConfig({
+      supportedChains: [cofheArbSepolia],
       useWorkers: false,
     });
 
-    const clientWithWorker = createCofhesdkClient(configWithWorker);
-    const clientWithoutWorker = createCofhesdkClient(configWithoutWorker);
+    const clientWithWorker = createCofheClient(configWithWorker);
+    const clientWithoutWorker = createCofheClient(configWithoutWorker);
 
     await clientWithWorker.connect(publicClient, walletClient);
     await clientWithoutWorker.connect(publicClient, walletClient);
@@ -49,8 +49,8 @@ describe('@cofhe/sdk/web - Worker vs Main Thread Output Validation', () => {
     const value = Encryptable.uint128(12345n);
 
     const [resultWithWorker, resultWithoutWorker] = await Promise.all([
-      clientWithWorker.encryptInputs([value]).encrypt(),
-      clientWithoutWorker.encryptInputs([value]).encrypt(),
+      clientWithWorker.encryptInputs([value]).execute(),
+      clientWithoutWorker.encryptInputs([value]).execute(),
     ]);
 
     // Both should succeed