@cofhe/sdk 0.2.0 → 0.3.0

package/dist/web.d.cts

@@ -1,8 +1,8 @@
-import { C as CofhesdkInputConfig, a as CofhesdkConfig, b as CofhesdkClient, E as EncryptableItem } from './clientTypes-5_1nwtUe.cjs';
+import { C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-Bhq7pCSA.cjs';
 import 'viem';
-import './types-KImPrEIe.cjs';
+import './types-YiAC4gig.cjs';
 import 'zod';
-import './permit-fUSe6KKq.cjs';
+import './permit-MZ502UBl.cjs';
 import 'zustand/vanilla';
 
 /**
@@ -15,24 +15,24 @@ declare function terminateWorker(): void;
 declare function areWorkersAvailable(): boolean;
 
 /**
- * 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)
- * @returns The CoFHE SDK configuration with web defaults applied
+ * Creates a CoFHE configuration for web with IndexedDB storage as default
+ * @param config - The CoFHE input configuration (fheKeyStorage will default to IndexedDB if not provided)
+ * @returns The CoFHE configuration with web defaults applied
  */
-declare function createCofhesdkConfig(config: CofhesdkInputConfig): CofhesdkConfig;
+declare function createCofheConfig(config: CofheInputConfig): CofheConfig;
 /**
- * Creates a CoFHE SDK client instance for web with TFHE automatically configured
+ * Creates a CoFHE 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
+ * @param config - The CoFHE configuration (use createCofheConfig to create with web defaults)
+ * @returns The CoFHE client instance
  */
-declare function createCofhesdkClient<TConfig extends CofhesdkConfig>(config: TConfig): CofhesdkClient<TConfig>;
+declare function createCofheClient<TConfig extends CofheConfig>(config: TConfig): CofheClient<TConfig>;
 
 /**
  * Test helper: Create a client with custom worker function (for testing fallback behavior)
  * @internal - Only for testing purposes
  */
-declare function createCofhesdkClientWithCustomWorker(config: CofhesdkConfig, customZkProveWorkerFn: (fheKeyHex: string, crsHex: string, items: EncryptableItem[], metadata: Uint8Array) => Promise<Uint8Array>): CofhesdkClient;
+declare function createCofheClientWithCustomWorker(config: CofheConfig, customZkProveWorkerFn: (fheKeyHex: string, crsHex: string, items: EncryptableItem[], metadata: Uint8Array) => Promise<Uint8Array>): CofheClient;
 
-export { areWorkersAvailable, createCofhesdkClient, createCofhesdkClientWithCustomWorker, createCofhesdkConfig, terminateWorker };
+export { areWorkersAvailable, createCofheClient, createCofheClientWithCustomWorker, createCofheConfig, terminateWorker };

package/dist/web.d.ts

@@ -1,8 +1,8 @@
-import { C as CofhesdkInputConfig, a as CofhesdkConfig, b as CofhesdkClient, E as EncryptableItem } from './clientTypes-Es7fyi65.js';
+import { C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-6aTZPQ_4.js';
 import 'viem';
-import './types-KImPrEIe.js';
+import './types-YiAC4gig.js';
 import 'zod';
-import './permit-fUSe6KKq.js';
+import './permit-MZ502UBl.js';
 import 'zustand/vanilla';
 
 /**
@@ -15,24 +15,24 @@ declare function terminateWorker(): void;
 declare function areWorkersAvailable(): boolean;
 
 /**
- * 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)
- * @returns The CoFHE SDK configuration with web defaults applied
+ * Creates a CoFHE configuration for web with IndexedDB storage as default
+ * @param config - The CoFHE input configuration (fheKeyStorage will default to IndexedDB if not provided)
+ * @returns The CoFHE configuration with web defaults applied
  */
-declare function createCofhesdkConfig(config: CofhesdkInputConfig): CofhesdkConfig;
+declare function createCofheConfig(config: CofheInputConfig): CofheConfig;
 /**
- * Creates a CoFHE SDK client instance for web with TFHE automatically configured
+ * Creates a CoFHE 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
+ * @param config - The CoFHE configuration (use createCofheConfig to create with web defaults)
+ * @returns The CoFHE client instance
  */
-declare function createCofhesdkClient<TConfig extends CofhesdkConfig>(config: TConfig): CofhesdkClient<TConfig>;
+declare function createCofheClient<TConfig extends CofheConfig>(config: TConfig): CofheClient<TConfig>;
 
 /**
  * Test helper: Create a client with custom worker function (for testing fallback behavior)
  * @internal - Only for testing purposes
  */
-declare function createCofhesdkClientWithCustomWorker(config: CofhesdkConfig, customZkProveWorkerFn: (fheKeyHex: string, crsHex: string, items: EncryptableItem[], metadata: Uint8Array) => Promise<Uint8Array>): CofhesdkClient;
+declare function createCofheClientWithCustomWorker(config: CofheConfig, customZkProveWorkerFn: (fheKeyHex: string, crsHex: string, items: EncryptableItem[], metadata: Uint8Array) => Promise<Uint8Array>): CofheClient;
 
-export { areWorkersAvailable, createCofhesdkClient, createCofhesdkClientWithCustomWorker, createCofhesdkConfig, terminateWorker };
+export { areWorkersAvailable, createCofheClient, createCofheClientWithCustomWorker, createCofheConfig, terminateWorker };

package/dist/web.js

@@ -1,6 +1,6 @@
-import { createCofhesdkConfigBase, createCofhesdkClientBase, fheTypeToString } from './chunk-WGCRJCBR.js';
-import './chunk-WEAZ25JO.js';
-import './chunk-UGBVZNRT.js';
+import { createCofheConfigBase, createCofheClientBase, fheTypeToString } from './chunk-2TPSCOW3.js';
+import './chunk-TBLR7NNE.js';
+import './chunk-NWDKXBIP.js';
 import { constructClient } from 'iframe-shared-storage';
 import init, { init_panic_hook, TfheCompactPublicKey, CompactPkeCrs, ProvenCompactCiphertextList } from 'tfhe';
 
@@ -207,15 +207,15 @@ async function zkProveWithWorker(fheKeyHex, crsHex, items, metadata) {
   const workerManager2 = getWorkerManager();
   return await workerManager2.submitProof(fheKeyHex, crsHex, serializedItems, metadata);
 }
-function createCofhesdkConfig(config) {
-  return createCofhesdkConfigBase({
+function createCofheConfig(config) {
+  return createCofheConfigBase({
     environment: "web",
     ...config,
     fheKeyStorage: config.fheKeyStorage === null ? null : config.fheKeyStorage ?? createWebStorage()
   });
 }
-function createCofhesdkClient(config) {
-  return createCofhesdkClientBase({
+function createCofheClient(config) {
+  return createCofheClientBase({
     config,
     zkBuilderAndCrsGenerator,
     tfhePublicKeyDeserializer,
@@ -226,8 +226,8 @@ function createCofhesdkClient(config) {
     zkProveWorkerFn: areWorkersAvailable() ? zkProveWithWorker : void 0
   });
 }
-function createCofhesdkClientWithCustomWorker(config, customZkProveWorkerFn) {
-  return createCofhesdkClientBase({
+function createCofheClientWithCustomWorker(config, customZkProveWorkerFn) {
+  return createCofheClientBase({
     config,
     zkBuilderAndCrsGenerator,
     tfhePublicKeyDeserializer,
@@ -237,4 +237,4 @@ function createCofhesdkClientWithCustomWorker(config, customZkProveWorkerFn) {
   });
 }
 
-export { areWorkersAvailable, createCofhesdkClient, createCofhesdkClientWithCustomWorker, createCofhesdkConfig, terminateWorker };
+export { areWorkersAvailable, createCofheClient, createCofheClientWithCustomWorker, createCofheConfig, terminateWorker };

package/node/client.test.ts

@@ -1,19 +1,19 @@
-import { type CofhesdkClient, CofhesdkError, CofhesdkErrorCode } from '@/core';
-import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
+import { type CofheClient, CofheError, CofheErrorCode } from '@/core';
+import { arbSepolia as cofheArbSepolia } from '@/chains';
 
 import { describe, it, expect, beforeAll, beforeEach, vi } 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';
+import { createCofheClient, createCofheConfig } from './index.js';
 
 // Real test setup - no mocks
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 const TEST_ACCOUNT = privateKeyToAccount(TEST_PRIVATE_KEY).address;
 
 describe('@cofhe/node - Client Integration Tests', () => {
-  let cofhesdkClient: CofhesdkClient;
+  let cofheClient: CofheClient;
   let publicClient: PublicClient;
   let walletClient: WalletClient;
 
@@ -33,62 +33,62 @@ describe('@cofhe/node - Client Integration Tests', () => {
   });
 
   beforeEach(() => {
-    const config = createCofhesdkConfig({
-      supportedChains: [cofhesdkArbSepolia],
+    const config = createCofheConfig({
+      supportedChains: [cofheArbSepolia],
     });
-    cofhesdkClient = createCofhesdkClient(config);
+    cofheClient = createCofheClient(config);
   });
 
   describe('Real Client Initialization', () => {
     it('should create a client with real node-tfhe', () => {
-      expect(cofhesdkClient).toBeDefined();
-      expect(cofhesdkClient.config).toBeDefined();
-      expect(cofhesdkClient.connected).toBe(false);
+      expect(cofheClient).toBeDefined();
+      expect(cofheClient.config).toBeDefined();
+      expect(cofheClient.connected).toBe(false);
     });
 
     it('should automatically use filesystem storage as default', () => {
-      expect(cofhesdkClient.config.fheKeyStorage).toBeDefined();
-      expect(cofhesdkClient.config.fheKeyStorage).not.toBeNull();
+      expect(cofheClient.config.fheKeyStorage).toBeDefined();
+      expect(cofheClient.config.fheKeyStorage).not.toBeNull();
     });
 
     it('should have all expected methods', () => {
-      expect(typeof cofhesdkClient.connect).toBe('function');
-      expect(typeof cofhesdkClient.encryptInputs).toBe('function');
-      expect(typeof cofhesdkClient.decryptHandle).toBe('function');
-      expect(typeof cofhesdkClient.getSnapshot).toBe('function');
-      expect(typeof cofhesdkClient.subscribe).toBe('function');
+      expect(typeof cofheClient.connect).toBe('function');
+      expect(typeof cofheClient.encryptInputs).toBe('function');
+      expect(typeof cofheClient.decryptForView).toBe('function');
+      expect(typeof cofheClient.getSnapshot).toBe('function');
+      expect(typeof cofheClient.subscribe).toBe('function');
     });
   });
 
   describe('Environment', () => {
     it('should have the correct environment', () => {
-      expect(cofhesdkClient.config.environment).toBe('node');
+      expect(cofheClient.config.environment).toBe('node');
     });
   });
 
   describe('Real Connection', () => {
     it('should connect to real chain', async () => {
-      await cofhesdkClient.connect(publicClient, walletClient);
+      await cofheClient.connect(publicClient, walletClient);
 
-      expect(cofhesdkClient.connected).toBe(true);
+      expect(cofheClient.connected).toBe(true);
 
-      const snapshot = cofhesdkClient.getSnapshot();
+      const snapshot = cofheClient.getSnapshot();
       expect(snapshot.connected).toBe(true);
-      expect(snapshot.chainId).toBe(cofhesdkArbSepolia.id);
+      expect(snapshot.chainId).toBe(cofheArbSepolia.id);
       expect(snapshot.account).toBe(TEST_ACCOUNT);
     }, 30000);
 
     it('should handle real network errors', async () => {
       try {
-        await cofhesdkClient.connect(
+        await cofheClient.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);
+        expect(error).toBeInstanceOf(CofheError);
+        expect((error as CofheError).code).toBe(CofheErrorCode.PublicWalletGetChainIdFailed);
       }
     }, 30000);
   });
@@ -96,11 +96,11 @@ describe('@cofhe/node - Client Integration Tests', () => {
   describe('State Management', () => {
     it('should track connection state changes', async () => {
       const states: any[] = [];
-      const unsubscribe = cofhesdkClient.subscribe((snapshot) => {
+      const unsubscribe = cofheClient.subscribe((snapshot) => {
         states.push({ ...snapshot });
       });
 
-      await cofhesdkClient.connect(publicClient, walletClient);
+      await cofheClient.connect(publicClient, walletClient);
 
       unsubscribe();
 
@@ -116,32 +116,32 @@ describe('@cofhe/node - Client Integration Tests', () => {
       const lastState = states[states.length - 1];
       expect(lastState.connected).toBe(true);
       expect(lastState.connecting).toBe(false);
-      expect(lastState.chainId).toBe(cofhesdkArbSepolia.id);
+      expect(lastState.chainId).toBe(cofheArbSepolia.id);
     }, 30000);
   });
 
   describe('Builder Creation', () => {
     it('should create encrypt builder after connection', async () => {
-      await cofhesdkClient.connect(publicClient, walletClient);
+      await cofheClient.connect(publicClient, walletClient);
 
-      const builder = cofhesdkClient.encryptInputs([{ data: 100n, utype: 2, securityZone: 0 }]);
+      const builder = cofheClient.encryptInputs([{ data: 100n, utype: 2, securityZone: 0 }]);
 
       expect(builder).toBeDefined();
       expect(typeof builder.setChainId).toBe('function');
       expect(typeof builder.setAccount).toBe('function');
       expect(typeof builder.setSecurityZone).toBe('function');
-      expect(typeof builder.encrypt).toBe('function');
+      expect(typeof builder.execute).toBe('function');
     }, 30000);
 
     it('should create decrypt builder after connection', async () => {
-      await cofhesdkClient.connect(publicClient, walletClient);
+      await cofheClient.connect(publicClient, walletClient);
 
-      const builder = cofhesdkClient.decryptHandle(123n, 2);
+      const builder = cofheClient.decryptForView(123n, 2);
 
       expect(builder).toBeDefined();
       expect(typeof builder.setChainId).toBe('function');
       expect(typeof builder.setAccount).toBe('function');
-      expect(typeof builder.decrypt).toBe('function');
+      expect(typeof builder.execute).toBe('function');
     }, 30000);
   });
 });

package/node/config.test.ts

@@ -1,12 +1,12 @@
 import { arbSepolia } from '@/chains';
 
 import { describe, it, expect } from 'vitest';
-import { createCofhesdkConfig, createCofhesdkClient } from './index.js';
+import { createCofheConfig, createCofheClient } from './index.js';
 
 describe('@cofhe/node - Config', () => {
-  describe('createCofhesdkConfig', () => {
+  describe('createCofheConfig', () => {
     it('should automatically inject filesystem storage as default', () => {
-      const config = createCofhesdkConfig({
+      const config = createCofheConfig({
         supportedChains: [arbSepolia],
       });
 
@@ -21,7 +21,7 @@ describe('@cofhe/node - Config', () => {
         setItem: () => Promise.resolve(),
         removeItem: () => Promise.resolve(),
       };
-      const config = createCofhesdkConfig({
+      const config = createCofheConfig({
         supportedChains: [arbSepolia],
         fheKeyStorage: customStorage,
       });
@@ -30,7 +30,7 @@ describe('@cofhe/node - Config', () => {
     });
 
     it('should allow null storage', () => {
-      const config = createCofhesdkConfig({
+      const config = createCofheConfig({
         supportedChains: [arbSepolia],
         fheKeyStorage: null,
       });
@@ -39,26 +39,26 @@ describe('@cofhe/node - Config', () => {
     });
 
     it('should preserve all other config options', () => {
-      const config = createCofhesdkConfig({
+      const config = createCofheConfig({
         supportedChains: [arbSepolia],
         mocks: {
-          sealOutputDelay: 0,
+          decryptDelay: 0,
         },
       });
 
       expect(config.supportedChains).toEqual([arbSepolia]);
-      expect(config.mocks.sealOutputDelay).toBe(0);
+      expect(config.mocks.decryptDelay).toBe(0);
       expect(config.fheKeyStorage).toBeDefined();
     });
   });
 
-  describe('createCofhesdkClient with config', () => {
+  describe('createCofheClient with config', () => {
     it('should create client with validated config', () => {
-      const config = createCofhesdkConfig({
+      const config = createCofheConfig({
         supportedChains: [arbSepolia],
       });
 
-      const client = createCofhesdkClient(config);
+      const client = createCofheClient(config);
 
       expect(client).toBeDefined();
       expect(client.config).toBe(config);

package/node/encryptInputs.test.ts

@@ -1,18 +1,18 @@
-import { Encryptable, FheTypes, type CofhesdkClient, CofhesdkErrorCode, CofhesdkError } from '@/core';
-import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
+import { Encryptable, FheTypes, type CofheClient, CofheErrorCode, CofheError } from '@/core';
+import { arbSepolia as cofheArbSepolia } from '@/chains';
 
 import { describe, it, expect, beforeAll, beforeEach } 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';
+import { createCofheClient, createCofheConfig } from './index.js';
 
 // Real test setup - using actual node-tfhe
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 
 describe('@cofhe/node - Encrypt Inputs', () => {
-  let cofhesdkClient: CofhesdkClient;
+  let cofheClient: CofheClient;
   let publicClient: PublicClient;
   let walletClient: WalletClient;
 
@@ -32,39 +32,39 @@ describe('@cofhe/node - Encrypt Inputs', () => {
   });
 
   beforeEach(() => {
-    const config = createCofhesdkConfig({
-      supportedChains: [cofhesdkArbSepolia],
+    const config = createCofheConfig({
+      supportedChains: [cofheArbSepolia],
     });
-    cofhesdkClient = createCofhesdkClient(config);
+    cofheClient = createCofheClient(config);
   });
 
   describe('Real TFHE Initialization', () => {
     it('should initialize node-tfhe on first encryption', async () => {
-      await cofhesdkClient.connect(publicClient, walletClient);
+      await cofheClient.connect(publicClient, walletClient);
 
       // This will trigger real TFHE initialization
-      const encrypted = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+      const encrypted = await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
 
       // If we get here, TFHE was initialized successfully
       expect(encrypted).toBeDefined();
     }, 60000); // Longer timeout for real operations
 
     it('should handle multiple encryptions without re-initializing', async () => {
-      await cofhesdkClient.connect(publicClient, walletClient);
+      await cofheClient.connect(publicClient, walletClient);
 
       // First encryption
-      await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+      await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
 
       // Second encryption should reuse initialization
-      await cofhesdkClient.encryptInputs([Encryptable.uint64(50n)]).encrypt();
+      await cofheClient.encryptInputs([Encryptable.uint64(50n)]).execute();
     }, 120000);
   });
 
   describe('Real Encryption', () => {
     it('should encrypt a bool with real TFHE', async () => {
-      await cofhesdkClient.connect(publicClient, walletClient);
+      await cofheClient.connect(publicClient, walletClient);
 
-      const encrypted = await cofhesdkClient.encryptInputs([Encryptable.bool(true)]).encrypt();
+      const encrypted = await cofheClient.encryptInputs([Encryptable.bool(true)]).execute();
 
       expect(encrypted.length).toBe(1);
       expect(encrypted[0].utype).toBe(FheTypes.Bool);
@@ -76,7 +76,7 @@ describe('@cofhe/node - Encrypt Inputs', () => {
     }, 60000);
 
     it('should encrypt all supported types together', async () => {
-      await cofhesdkClient.connect(publicClient, walletClient);
+      await cofheClient.connect(publicClient, walletClient);
 
       const inputs = [
         Encryptable.bool(false),
@@ -88,7 +88,7 @@ describe('@cofhe/node - Encrypt Inputs', () => {
         Encryptable.address('0x742d35Cc6634C0532925a3b844D16faC4c175E99'),
       ];
 
-      const encrypted = await cofhesdkClient.encryptInputs(inputs).encrypt();
+      const encrypted = await cofheClient.encryptInputs(inputs).execute();
 
       expect(encrypted.length).toBe(7);
       // Verify each type
@@ -104,15 +104,15 @@ describe('@cofhe/node - Encrypt Inputs', () => {
 
   describe('Real Builder Pattern', () => {
     it('should support chaining builder methods with real encryption', async () => {
-      await cofhesdkClient.connect(publicClient, walletClient);
+      await cofheClient.connect(publicClient, walletClient);
 
-      const snapshot = cofhesdkClient.getSnapshot();
-      const encrypted = await cofhesdkClient
+      const snapshot = cofheClient.getSnapshot();
+      const encrypted = await cofheClient
         .encryptInputs([Encryptable.uint128(100n)])
         .setChainId(snapshot.chainId!)
         .setAccount(snapshot.account!)
         .setSecurityZone(0)
-        .encrypt();
+        .execute();
 
       expect(encrypted.length).toBe(1);
       expect(encrypted[0].utype).toBe(FheTypes.Uint128);
@@ -123,32 +123,32 @@ describe('@cofhe/node - Encrypt Inputs', () => {
     it('should fail gracefully when not connected', async () => {
       // Don't connect the client
       try {
-        await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+        await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
       } catch (error) {
-        expect(error).toBeInstanceOf(CofhesdkError);
-        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.NotConnected);
+        expect(error).toBeInstanceOf(CofheError);
+        expect((error as CofheError).code).toBe(CofheErrorCode.NotConnected);
       }
     }, 30000);
 
     it('should handle invalid CoFHE URL', async () => {
-      const badConfig = createCofhesdkConfig({
+      const badConfig = createCofheConfig({
         supportedChains: [
           {
-            ...cofhesdkArbSepolia,
+            ...cofheArbSepolia,
             coFheUrl: 'http://invalid-cofhe-url.local',
             verifierUrl: 'http://invalid-verifier-url.local',
           },
         ],
       });
 
-      const badClient = createCofhesdkClient(badConfig);
+      const badClient = createCofheClient(badConfig);
       await badClient.connect(publicClient, walletClient);
 
       try {
-        await badClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+        await badClient.encryptInputs([Encryptable.uint128(100n)]).execute();
       } catch (error) {
-        expect(error).toBeInstanceOf(CofhesdkError);
-        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.ZkVerifyFailed);
+        expect(error).toBeInstanceOf(CofheError);
+        expect((error as CofheError).code).toBe(CofheErrorCode.ZkVerifyFailed);
       }
     }, 60000);
   });

package/node/index.ts

@@ -1,11 +1,11 @@
 // Node.js specific functionality only
 
 import {
-  createCofhesdkClientBase,
-  createCofhesdkConfigBase,
-  type CofhesdkClient,
-  type CofhesdkConfig,
-  type CofhesdkInputConfig,
+  createCofheClientBase,
+  createCofheConfigBase,
+  type CofheClient,
+  type CofheConfig,
+  type CofheInputConfig,
   type ZkBuilderAndCrsGenerator,
   type FheKeyDeserializer,
 } from '@/core';
@@ -68,12 +68,12 @@ const zkBuilderAndCrsGenerator: ZkBuilderAndCrsGenerator = (fhe: string, crs: st
 };
 
 /**
- * Creates a CoFHE SDK configuration for Node.js with filesystem storage as default
- * @param config - The CoFHE SDK input configuration (fheKeyStorage will default to filesystem if not provided)
- * @returns The CoFHE SDK configuration with Node.js defaults applied
+ * Creates a CoFHE configuration for Node.js with filesystem storage as default
+ * @param config - The CoFHE input configuration (fheKeyStorage will default to filesystem if not provided)
+ * @returns The CoFHE configuration with Node.js defaults applied
  */
-export function createCofhesdkConfig(config: CofhesdkInputConfig): CofhesdkConfig {
-  return createCofhesdkConfigBase({
+export function createCofheConfig(config: CofheInputConfig): CofheConfig {
+  return createCofheConfigBase({
     environment: 'node',
     ...config,
     fheKeyStorage: config.fheKeyStorage === null ? null : config.fheKeyStorage ?? createNodeStorage(),
@@ -81,13 +81,13 @@ export function createCofhesdkConfig(config: CofhesdkInputConfig): CofhesdkConfi
 }
 
 /**
- * Creates a CoFHE SDK client instance for Node.js with node-tfhe automatically configured
+ * Creates a CoFHE client instance for Node.js with node-tfhe automatically configured
  * TFHE will be initialized automatically on first encryption - no manual setup required
- * @param config - The CoFHE SDK configuration (use createCofhesdkConfig to create with Node.js defaults)
- * @returns The CoFHE SDK client instance
+ * @param config - The CoFHE configuration (use createCofheConfig to create with Node.js defaults)
+ * @returns The CoFHE client instance
  */
-export function createCofhesdkClient(config: CofhesdkConfig): CofhesdkClient {
-  return createCofhesdkClientBase({
+export function createCofheClient(config: CofheConfig): CofheClient {
+  return createCofheClientBase({
     config,
     zkBuilderAndCrsGenerator,
     tfhePublicKeyDeserializer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cofhe/sdk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "SDK for Fhenix COFHE coprocessor interaction",
   "main": "./dist/core.cjs",
@@ -63,7 +63,7 @@
     "tfhe": "0.11.1",
     "tweetnacl": "^1.0.3",
     "viem": "^2.38.6",
-    "zod": "^3.22.0",
+    "zod": "^4.0.0",
     "zustand": "^5.0.1"
   },
   "peerDependencies": {
@@ -111,7 +111,7 @@
     "build": "tsup",
     "dev": "tsup --watch",
     "lint": "eslint \"**/*.ts*\"",
-    "type-check": "tsc --noEmit",
+    "check:types": "tsc --noEmit",
     "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
     "test": "vitest run",
     "test:watch": "vitest",