@cofhe/sdk 0.4.0 → 0.5.1

package/core/{encrypt → test}/encryptInputsBuilder.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { EncryptInputsBuilder } from './encryptInputsBuilder.js';
+import { EncryptInputsBuilder } from '../encrypt/encryptInputsBuilder.js';
 import {
   type EncryptableItem,
   FheTypes,
@@ -12,9 +12,9 @@ import { CofheError, CofheErrorCode } from '../error.js';
 import { fromHexString, toHexString } from '../utils.js';
 import { type PublicClient, createPublicClient, http, type WalletClient, createWalletClient } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
-import { arbitrumSepolia, hardhat } from 'viem/chains';
+import { arbitrumSepolia } from 'viem/chains';
 import { type CofheConfig, createCofheConfigBase } from '../config.js';
-import { type ZkBuilderAndCrsGenerator } from './zkPackProveVerify.js';
+import { type ZkBuilderAndCrsGenerator } from '../encrypt/zkPackProveVerify.js';
 import { type KeysStorage, createKeysStore } from '../keyStore.js';
 import { type FheKeyDeserializer } from '../fetchKeys.js';
 
@@ -122,8 +122,7 @@ class MockZkListBuilder {
 
 const MockCrs = {
   free: () => {},
-  serialize: () => new Uint8Array(),
-  safe_serialize: () => new Uint8Array(),
+  safe_serialize: (_serializedSizeLimit: bigint) => new Uint8Array(),
 };
 
 // Setup fetch mock for http://localhost:3001/verify
@@ -223,7 +222,7 @@ class MockZkProvenList {
     this.metadata = metadata;
   }
 
-  serialize(): Uint8Array {
+  safe_serialize(_serializedSizeLimit: bigint): Uint8Array {
     // Serialize this.items into JSON, then encode as Uint8Array (utf-8)
     const json = stringifyWithBigInt({ items: this.items, metadata: this.metadata });
     return new TextEncoder().encode(json);
@@ -744,4 +743,60 @@ describe('EncryptInputsBuilder', () => {
       expect(encryptedMetadata2.chainId).toBe(defaultChainId);
     });
   });
+
+  describe('setUseWorker and getUseWorker', () => {
+    it('should have setUseWorker method', () => {
+      expect(builder).toHaveProperty('setUseWorker');
+      expect(typeof builder.setUseWorker).toBe('function');
+    });
+
+    it('should have getUseWorker method', () => {
+      expect(builder).toHaveProperty('getUseWorker');
+      expect(typeof builder.getUseWorker).toBe('function');
+    });
+
+    it('should return builder for method chaining', () => {
+      const returnedBuilder = builder.setUseWorker(false);
+      expect(returnedBuilder).toBe(builder);
+    });
+
+    it('should allow chaining with other builder methods', () => {
+      const chainedBuilder = builder.setUseWorker(false).onStep(() => {});
+      expect(chainedBuilder).toBeDefined();
+      expect(chainedBuilder).toHaveProperty('execute');
+    });
+
+    it('should accept true and false parameters without throwing', () => {
+      expect(() => builder.setUseWorker(true)).not.toThrow();
+      expect(() => builder.setUseWorker(false)).not.toThrow();
+    });
+
+    it('should return current useWorker value via getUseWorker', () => {
+      builder.setUseWorker(true);
+      expect(builder.getUseWorker()).toBe(true);
+
+      builder.setUseWorker(false);
+      expect(builder.getUseWorker()).toBe(false);
+    });
+
+    it('should reflect changes across multiple setUseWorker calls', () => {
+      builder.setUseWorker(true);
+      expect(builder.getUseWorker()).toBe(true);
+
+      builder.setUseWorker(false);
+      expect(builder.getUseWorker()).toBe(false);
+
+      builder.setUseWorker(true);
+      expect(builder.getUseWorker()).toBe(true);
+    });
+
+    it('should default useWorker based on config.useWorkers', () => {
+      const configWithWorkers = createMockCofheConfig(defaultChainId, MockZkVerifierUrl);
+      const builderWithWorkers = new EncryptInputsBuilder({
+        ...createDefaultParams(),
+        config: configWithWorkers,
+      });
+      expect(builderWithWorkers.getUseWorker()).toBe(configWithWorkers.useWorkers);
+    });
+  });
 });

package/core/{fetchKeys.test.ts → test/fetchKeys.test.ts}

@@ -4,9 +4,9 @@
 import { sepolia, arbSepolia } from '@/chains';
 
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { fetchKeys } from './fetchKeys.js';
-import { type CofheConfig, createCofheConfigBase } from './config.js';
-import { createKeysStore, type KeysStorage } from './keyStore.js';
+import { fetchKeys } from '../fetchKeys.js';
+import { type CofheConfig, createCofheConfigBase } from '../config.js';
+import { createKeysStore, type KeysStorage } from '../keyStore.js';
 
 describe('fetchKeys', () => {
   let config: CofheConfig;

package/core/{keyStore.test.ts → test/keyStore.test.ts}

@@ -2,7 +2,9 @@
 /* eslint-disable no-undef */
 
 import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { createKeysStore, type KeysStore, type KeysStorage } from './keyStore.js';
+
+import { createKeysStore, type KeysStore, type KeysStorage } from '../keyStore';
+import { TFHE_RS_KEY_VERSION } from 'core/consts';
 
 // Mock the storage module
 const mockStorage = {
@@ -11,7 +13,7 @@ const mockStorage = {
   removeItem: vi.fn(),
 };
 
-vi.mock('../src/storage', () => ({
+vi.mock('../../src/storage', () => ({
   getStorage: () => mockStorage,
 }));
 
@@ -124,7 +126,7 @@ describe('KeyStore', () => {
     it('should clear keys storage', async () => {
       await keysStorage.clearKeysStorage();
 
-      expect(mockStorage.removeItem).toHaveBeenCalledWith('cofhesdk-keys');
+      expect(mockStorage.removeItem).toHaveBeenCalledWith(`cofhesdk-keys-v${TFHE_RS_KEY_VERSION}`);
     });
 
     it('should rehydrate keys store', async () => {

package/core/{permits.test.ts → test/permits.test.ts}

@@ -7,7 +7,7 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { createPublicClient, createWalletClient, http, type PublicClient, type WalletClient } from 'viem';
 import { arbitrumSepolia } from 'viem/chains';
 import { privateKeyToAccount } from 'viem/accounts';
-import { permits } from './permits.js';
+import { permits } from '../permits.js';
 
 // Type declarations for happy-dom environment
 declare const localStorage: {
@@ -435,6 +435,47 @@ describe('Core Permits Tests', () => {
     });
   });
 
+  describe('Export', () => {
+    it('should export self permit data without sensitive fields', async () => {
+      const permit = await permits.createSelf(
+        { name: 'Test Self Permit', issuer: bobAddress },
+        publicClient,
+        bobWalletClient
+      );
+
+      const exported = permits.export(permit);
+      const parsed = JSON.parse(exported);
+
+      expect(parsed.name).toBe('Test Self Permit');
+      expect(parsed.issuer).toBe(bobAddress);
+      expect(parsed).not.toHaveProperty('sealingPair');
+      expect(parsed).not.toHaveProperty('issuerSignature');
+    });
+
+    it('should export sharing permit data with recipient and issuerSignature', async () => {
+      const permit = await permits.createSharing(
+        {
+          name: 'Test Sharing Permit',
+          issuer: bobAddress,
+          recipient: aliceAddress,
+        },
+        publicClient,
+        bobWalletClient
+      );
+
+      const exported = permits.export(permit);
+      const parsed = JSON.parse(exported);
+
+      expect(parsed.name).toBe('Test Sharing Permit');
+      expect(parsed.type).toBe('sharing');
+      expect(parsed.issuer).toBe(bobAddress);
+      expect(parsed.recipient).toBe(aliceAddress);
+      expect(parsed.issuerSignature).toBeDefined();
+      expect(parsed.issuerSignature).not.toBe('0x');
+      expect(parsed).not.toHaveProperty('sealingPair');
+    });
+  });
+
   describe('getOrCreate - Multiple Types Scenarios', () => {
     it('should handle switching between self and sharing permits', async () => {
       // Create self permit