@cofhe/sdk 0.4.0 → 0.5.0

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

@@ -0,0 +1,245 @@
+import { Encryptable, FheTypes, type CofheClient } from '@/core';
+import { arbSepolia as cofheArbSepolia, getChainById } from '@/chains';
+import {
+  TEST_PRIVATE_KEY,
+  PRIMARY_TEST_CHAIN,
+  primaryTestChainRegistry,
+  isPrimaryTestChainReady,
+} from '@cofhe/test-setup';
+
+import { createCofheClient, createCofheConfig } from '../index.js';
+
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import type { Chain, PublicClient, WalletClient } from 'viem';
+import { createPublicClient, createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { arbitrumSepolia, baseSepolia, sepolia } from 'viem/chains';
+
+const DEFAULT_TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+const BOB_PRIVATE_KEY = (TEST_PRIVATE_KEY || DEFAULT_TEST_PRIVATE_KEY) as `0x${string}`;
+const ALICE_PRIVATE_KEY = '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d';
+
+const bobAccount = privateKeyToAccount(BOB_PRIVATE_KEY);
+const aliceAccount = privateKeyToAccount(ALICE_PRIVATE_KEY);
+
+const VIEM_CHAINS: Record<number, Chain> = {
+  421614: arbitrumSepolia,
+  84532: baseSepolia,
+  11155111: sepolia,
+};
+
+describe('@cofhe/web - Inherited Client Tests', () => {
+  let cofheClient: CofheClient;
+  let publicClient: PublicClient;
+  let bobWalletClient: WalletClient;
+  let aliceWalletClient: WalletClient;
+
+  beforeAll(() => {
+    publicClient = createPublicClient({
+      chain: arbitrumSepolia,
+      transport: http(),
+    });
+
+    bobWalletClient = createWalletClient({
+      chain: arbitrumSepolia,
+      transport: http(),
+      account: bobAccount,
+    });
+
+    aliceWalletClient = createWalletClient({
+      chain: arbitrumSepolia,
+      transport: http(),
+      account: aliceAccount,
+    });
+  });
+
+  beforeEach(() => {
+    const config = createCofheConfig({
+      supportedChains: [cofheArbSepolia],
+    });
+    cofheClient = createCofheClient(config);
+  });
+
+  describe('Client Creation', () => {
+    it('should create a client with expected surface', () => {
+      expect(cofheClient).toBeDefined();
+      expect(cofheClient.config).toBeDefined();
+      expect(cofheClient.connected).toBe(false);
+      expect(typeof cofheClient.connect).toBe('function');
+      expect(typeof cofheClient.disconnect).toBe('function');
+      expect(typeof cofheClient.encryptInputs).toBe('function');
+      expect(typeof cofheClient.decryptForView).toBe('function');
+      expect(typeof cofheClient.decryptForTx).toBe('function');
+      expect(typeof cofheClient.getSnapshot).toBe('function');
+      expect(typeof cofheClient.subscribe).toBe('function');
+      expect(cofheClient.permits).toBeDefined();
+    });
+  });
+
+  describe('Connection', () => {
+    it('should connect to a real chain', async () => {
+      await cofheClient.connect(publicClient, bobWalletClient);
+
+      expect(cofheClient.connected).toBe(true);
+
+      const snapshot = cofheClient.getSnapshot();
+      expect(snapshot.connected).toBe(true);
+      expect(snapshot.chainId).toBe(cofheArbSepolia.id);
+      expect(snapshot.account).toBe(bobAccount.address);
+    }, 30000);
+  });
+
+  describe('Encrypt Input', () => {
+    it('should encrypt a uint128 value', async () => {
+      await cofheClient.connect(publicClient, bobWalletClient);
+
+      const encrypted = await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
+
+      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);
+  });
+
+  describe('Self Permit', () => {
+    it('should create a self permit', async () => {
+      await cofheClient.connect(publicClient, bobWalletClient);
+
+      const permit = await cofheClient.permits.createSelf({
+        issuer: bobAccount.address,
+        name: 'Test Self Permit',
+      });
+
+      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);
+    }, 30000);
+  });
+
+  describe('Sharing Permit', () => {
+    it('should create a sharing permit, export it, and import it as another user', async () => {
+      await cofheClient.connect(publicClient, bobWalletClient);
+
+      const sharingPermit = await cofheClient.permits.createSharing({
+        issuer: bobAccount.address,
+        recipient: aliceAccount.address,
+        name: 'Test Sharing Permit',
+      });
+
+      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');
+
+      const exported = cofheClient.permits.export(sharingPermit);
+      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');
+
+      const aliceConfig = createCofheConfig({
+        supportedChains: [cofheArbSepolia],
+      });
+      const aliceClient = createCofheClient(aliceConfig);
+      await aliceClient.connect(publicClient, aliceWalletClient);
+
+      const importedPermit = await aliceClient.permits.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();
+    }, 30000);
+  });
+
+  describe('Decrypt (read-only, pre-stored values)', () => {
+    let decryptClient: CofheClient;
+    let decryptPublicClient: PublicClient;
+    let decryptWalletClient: WalletClient;
+
+    let privateCtHash: `0x${string}`;
+    let privateValue: bigint;
+    let publicCtHash: `0x${string}`;
+    let publicValue: bigint;
+
+    beforeAll(() => {
+      if (!isPrimaryTestChainReady(primaryTestChainRegistry)) {
+        throw new Error('Primary test chain registry not initialized. Run `pnpm test:setup` first.');
+      }
+
+      const reg = primaryTestChainRegistry;
+      const viemChain = VIEM_CHAINS[reg.chainId];
+      if (!viemChain) throw new Error(`No viem chain mapping for chain ${reg.chainId}`);
+
+      const cofheChain = getChainById(reg.chainId);
+      if (!cofheChain) throw new Error(`No cofhe chain config for chain ${reg.chainId}`);
+
+      privateCtHash = reg.privateValue.ctHash as `0x${string}`;
+      privateValue = BigInt(reg.privateValue.value);
+      publicCtHash = reg.publicValue.ctHash as `0x${string}`;
+      publicValue = BigInt(reg.publicValue.value);
+
+      decryptPublicClient = createPublicClient({ chain: viemChain, transport: http() });
+      decryptWalletClient = createWalletClient({ chain: viemChain, transport: http(), account: bobAccount });
+
+      const config = createCofheConfig({ supportedChains: [cofheChain] });
+      decryptClient = createCofheClient(config);
+    });
+
+    it('decryptForView — private value with permit', async () => {
+      await decryptClient.connect(decryptPublicClient, decryptWalletClient);
+
+      await decryptClient.permits.createSelf({
+        issuer: bobAccount.address,
+        name: 'Decrypt View Permit',
+      });
+
+      const result = await decryptClient.decryptForView(privateCtHash, FheTypes.Uint32).execute();
+      expect(result).toBe(privateValue);
+    }, 180000);
+
+    it('decryptForTx — public value without permit', async () => {
+      await decryptClient.connect(decryptPublicClient, decryptWalletClient);
+
+      const result = await decryptClient.decryptForTx(publicCtHash).withoutPermit().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 () => {
+      await decryptClient.connect(decryptPublicClient, decryptWalletClient);
+
+      const permit = await decryptClient.permits.createSelf({
+        issuer: bobAccount.address,
+        name: 'Decrypt Tx Permit',
+      });
+
+      const result = await decryptClient.decryptForTx(privateCtHash).withPermit(permit).execute();
+
+      expect(BigInt(result.ctHash)).toBe(BigInt(privateCtHash));
+      expect(result.decryptedValue).toBe(privateValue);
+      expect(result.signature).toBeDefined();
+    }, 180000);
+  });
+});

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

@@ -0,0 +1,62 @@
+import { arbSepolia as cofheArbSepolia } from '@/chains';
+import { Encryptable, FheTypes, type CofheClient, CofheErrorCode, CofheError } from '@/core';
+
+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 { createCofheClient, createCofheConfig } from '../index.js';
+
+// Real test setup - runs in browser with real tfhe
+const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+
+describe('@cofhe/web - TFHE Initialization Browser Tests', () => {
+  let cofheClient: CofheClient;
+  let publicClient: PublicClient;
+  let walletClient: WalletClient;
+
+  beforeAll(() => {
+    // Create real viem clients
+    publicClient = createPublicClient({
+      chain: viemArbitrumSepolia,
+      transport: http(),
+    });
+
+    const account = privateKeyToAccount(TEST_PRIVATE_KEY);
+    walletClient = createWalletClient({
+      chain: viemArbitrumSepolia,
+      transport: http(),
+      account,
+    });
+  });
+
+  beforeEach(() => {
+    const config = createCofheConfig({
+      supportedChains: [cofheArbSepolia],
+    });
+    cofheClient = createCofheClient(config);
+  });
+
+  describe('Browser TFHE Initialization', () => {
+    it('should initialize tfhe on first encryption', async () => {
+      await cofheClient.connect(publicClient, walletClient);
+
+      // This will trigger real TFHE initialization in browser
+      const result = await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
+
+      // If we get here, TFHE was initialized successfully
+      expect(result).toBeDefined();
+    }, 60000); // Longer timeout for real operations
+
+    it('should handle multiple encryptions without re-initializing', async () => {
+      await cofheClient.connect(publicClient, walletClient);
+
+      // First encryption
+      expect(cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute()).resolves.not.toThrow();
+
+      // Second encryption should reuse initialization
+      expect(cofheClient.encryptInputs([Encryptable.uint64(50n)]).execute()).resolves.not.toThrow();
+    }, 60000);
+  });
+});

package/web/{worker.config.web.test.ts → test/worker.config.web.test.ts}

@@ -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 { createCofheClient, createCofheConfig, createCofheClientWithCustomWorker } from './index.js';
+import { createCofheClient, createCofheConfig, createCofheClientWithCustomWorker } from '../index.js';
 
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 

package/web/{worker.output.web.test.ts → test/worker.output.web.test.ts}

@@ -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 { createCofheClient, createCofheConfig } from './index.js';
+import { createCofheClient, createCofheConfig } from '../index.js';
 
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 

package/web/{workerManager.test.ts → test/workerManager.test.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect, afterEach } from 'vitest';
-import { getWorkerManager, terminateWorker, areWorkersAvailable } from './workerManager.js';
+import { getWorkerManager, terminateWorker, areWorkersAvailable } from '../workerManager.js';
 
 describe('WorkerManager', () => {
   afterEach(() => {

package/web/{workerManager.web.test.ts → test/workerManager.web.test.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect, afterEach } from 'vitest';
-import { getWorkerManager, terminateWorker, areWorkersAvailable } from './workerManager.js';
+import { getWorkerManager, terminateWorker, areWorkersAvailable } from '../workerManager.js';
 
 describe('WorkerManager (Browser)', () => {
   afterEach(() => {

package/web/zkProve.worker.ts

@@ -6,6 +6,7 @@
 /// <reference lib="webworker" />
 /* eslint-disable no-undef */
 
+import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from '../core/consts';
 import type { ZkProveWorkerRequest, ZkProveWorkerResponse } from '../core/encrypt/zkPackProveVerify.js';
 
 // TFHE module (will be initialized on first use)
@@ -68,8 +69,8 @@ self.onmessage = async (event: MessageEvent) => {
     const fheKeyBytes = fromHexString(fheKeyHex);
     const crsBytes = fromHexString(crsHex);
 
-    const fheKey = tfheModule.TfheCompactPublicKey.deserialize(fheKeyBytes);
-    const crs = tfheModule.CompactPkeCrs.deserialize(crsBytes);
+    const fheKey = tfheModule.TfheCompactPublicKey.safe_deserialize(fheKeyBytes, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
+    const crs = tfheModule.CompactPkeCrs.safe_deserialize(crsBytes, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
 
     // Create builder
     const builder = tfheModule.ProvenCompactCiphertextList.builder(fheKey);
@@ -108,7 +109,7 @@ self.onmessage = async (event: MessageEvent) => {
     const compactList = builder.build_with_proof_packed(crs, metadataBytes, 1);
 
     // Serialize result
-    const result = compactList.serialize();
+    const result = compactList.safe_serialize(TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
 
     // Send success response
     self.postMessage({

package/node/client.test.ts

@@ -1,147 +0,0 @@
-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 { 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 cofheClient: CofheClient;
-  let publicClient: PublicClient;
-  let walletClient: WalletClient;
-
-  beforeAll(() => {
-    // Create real viem clients
-    publicClient = createPublicClient({
-      chain: viemArbitrumSepolia,
-      transport: http(),
-    });
-
-    const account = privateKeyToAccount(TEST_PRIVATE_KEY);
-    walletClient = createWalletClient({
-      chain: viemArbitrumSepolia,
-      transport: http(),
-      account,
-    });
-  });
-
-  beforeEach(() => {
-    const config = createCofheConfig({
-      supportedChains: [cofheArbSepolia],
-    });
-    cofheClient = createCofheClient(config);
-  });
-
-  describe('Real Client Initialization', () => {
-    it('should create a client with real node-tfhe', () => {
-      expect(cofheClient).toBeDefined();
-      expect(cofheClient.config).toBeDefined();
-      expect(cofheClient.connected).toBe(false);
-    });
-
-    it('should automatically use filesystem storage as default', () => {
-      expect(cofheClient.config.fheKeyStorage).toBeDefined();
-      expect(cofheClient.config.fheKeyStorage).not.toBeNull();
-    });
-
-    it('should have all expected methods', () => {
-      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(cofheClient.config.environment).toBe('node');
-    });
-  });
-
-  describe('Real Connection', () => {
-    it('should connect to real chain', async () => {
-      await cofheClient.connect(publicClient, walletClient);
-
-      expect(cofheClient.connected).toBe(true);
-
-      const snapshot = cofheClient.getSnapshot();
-      expect(snapshot.connected).toBe(true);
-      expect(snapshot.chainId).toBe(cofheArbSepolia.id);
-      expect(snapshot.account).toBe(TEST_ACCOUNT);
-    }, 30000);
-
-    it('should handle real network errors', async () => {
-      try {
-        await cofheClient.connect(
-          {
-            getChainId: vi.fn().mockRejectedValue(new Error('Network error')),
-          } as unknown as PublicClient,
-          walletClient
-        );
-      } catch (error) {
-        expect(error).toBeInstanceOf(CofheError);
-        expect((error as CofheError).code).toBe(CofheErrorCode.PublicWalletGetChainIdFailed);
-      }
-    }, 30000);
-  });
-
-  describe('State Management', () => {
-    it('should track connection state changes', async () => {
-      const states: any[] = [];
-      const unsubscribe = cofheClient.subscribe((snapshot) => {
-        states.push({ ...snapshot });
-      });
-
-      await cofheClient.connect(publicClient, walletClient);
-
-      unsubscribe();
-
-      expect(states.length).toBeGreaterThan(0);
-
-      // First state should be connecting
-      const firstState = states.find((s) => s.connecting);
-      expect(firstState).toBeDefined();
-      expect(firstState?.connecting).toBe(true);
-      expect(firstState?.connected).toBe(false);
-
-      // Last state should be connected
-      const lastState = states[states.length - 1];
-      expect(lastState.connected).toBe(true);
-      expect(lastState.connecting).toBe(false);
-      expect(lastState.chainId).toBe(cofheArbSepolia.id);
-    }, 30000);
-  });
-
-  describe('Builder Creation', () => {
-    it('should create encrypt builder after connection', async () => {
-      await cofheClient.connect(publicClient, walletClient);
-
-      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.execute).toBe('function');
-    }, 30000);
-
-    it('should create decrypt builder after connection', async () => {
-      await cofheClient.connect(publicClient, walletClient);
-
-      const builder = cofheClient.decryptForView('0x123', 2);
-
-      expect(builder).toBeDefined();
-      expect(typeof builder.setChainId).toBe('function');
-      expect(typeof builder.setAccount).toBe('function');
-      expect(typeof builder.execute).toBe('function');
-    }, 30000);
-  });
-});

package/node/config.test.ts

@@ -1,68 +0,0 @@
-import { arbSepolia } from '@/chains';
-
-import { describe, it, expect } from 'vitest';
-import { createCofheConfig, createCofheClient } from './index.js';
-
-describe('@cofhe/node - Config', () => {
-  describe('createCofheConfig', () => {
-    it('should automatically inject filesystem storage as default', () => {
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-      });
-
-      expect(config.fheKeyStorage).toBeDefined();
-      expect(config.fheKeyStorage).not.toBeNull();
-      expect(config.supportedChains).toEqual([arbSepolia]);
-    });
-
-    it('should allow overriding storage', async () => {
-      const customStorage = {
-        getItem: () => Promise.resolve(10),
-        setItem: () => Promise.resolve(),
-        removeItem: () => Promise.resolve(),
-      };
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-        fheKeyStorage: customStorage,
-      });
-
-      expect(await config.fheKeyStorage!.getItem('test')).toBe(10);
-    });
-
-    it('should allow null storage', () => {
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-        fheKeyStorage: null,
-      });
-
-      expect(config.fheKeyStorage).toBeNull();
-    });
-
-    it('should preserve all other config options', () => {
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-        mocks: {
-          decryptDelay: 0,
-        },
-      });
-
-      expect(config.supportedChains).toEqual([arbSepolia]);
-      expect(config.mocks.decryptDelay).toBe(0);
-      expect(config.fheKeyStorage).toBeDefined();
-    });
-  });
-
-  describe('createCofheClient with config', () => {
-    it('should create client with validated config', () => {
-      const config = createCofheConfig({
-        supportedChains: [arbSepolia],
-      });
-
-      const client = createCofheClient(config);
-
-      expect(client).toBeDefined();
-      expect(client.config).toBe(config);
-      expect(client.config.fheKeyStorage).toBeDefined();
-    });
-  });
-});