@cofhe/sdk 0.5.1 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cofhe/sdk",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "type": "module",
   "description": "SDK for Fhenix COFHE coprocessor interaction",
   "main": "./dist/core.cjs",
@@ -64,7 +64,7 @@
     "tweetnacl": "1.0.3",
     "viem": "2.38.6",
     "zod": "4.0.0",
-    "zustand": "5.0.1"
+    "zustand": "5.0.13"
   },
   "peerDependencies": {
     "@nomicfoundation/hardhat-ethers": "^3.0.0",

package/permits/store.ts

@@ -19,6 +19,7 @@ export const PERMIT_STORE_DEFAULTS: PermitsStore = {
   permits: {},
   activePermitHash: {},
 };
+
 export const _permitStore = createStore<PermitsStore>()(
   persist(() => PERMIT_STORE_DEFAULTS, { name: 'cofhesdk-permits' })
 );

package/web/test/ssr.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it, vi, afterEach } from 'vitest';
+
+describe('@cofhe/sdk/web SSR smoke', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('imports and creates config in a Node SSR environment', async () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    expect((globalThis as { window?: unknown }).window).toBeUndefined();
+    expect((globalThis as { document?: unknown }).document).toBeUndefined();
+
+    const web = await import('../index');
+    const config = web.createCofheConfig({ supportedChains: [] });
+
+    expect(web.hasDOM).toBe(false);
+    expect(config.environment).toBe('web');
+    expect(config.fheKeyStorage).not.toBeNull();
+    expect(() => web.createCofheClient(config)).not.toThrow();
+    expect(warnSpy).toHaveBeenCalledWith('using no-op server-side SSR storage');
+  });
+});

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

@@ -1,5 +1,5 @@
 import { arbSepolia as cofheArbSepolia } from '@/chains';
-import { Encryptable, FheTypes, type CofheClient, CofheErrorCode, CofheError } from '@/core';
+import { Encryptable, type CofheClient } from '@/core';
 
 import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
 import type { PublicClient, WalletClient } from 'viem';
@@ -11,6 +11,39 @@ import { createCofheClient, createCofheConfig } from '../index.js';
 // Real test setup - runs in browser with real tfhe
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 
+// 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) {
+  const runs: Array<Record<string, number>> = [];
+  let current: Record<string, number> = {};
+
+  function onStep(step: string, context?: Record<string, unknown>) {
+    if (!context?.isEnd) return;
+    current[step] = (context.duration as number) ?? 0;
+  }
+
+  function nextRun() {
+    if (Object.keys(current).length > 0) runs.push(current);
+    current = {};
+  }
+
+  function log() {
+    if (Object.keys(current).length > 0) runs.push(current);
+    console.log(`\n[TFHE Timing] ${testName}`);
+    runs.forEach((run, i) => {
+      const label = runs.length > 1 ? ` run ${i + 1}` : '';
+      const total = Object.values(run).reduce((a, b) => a + b, 0);
+      for (const [step, ms] of Object.entries(run)) {
+        console.log(`  [${label.trim() || 'run'}] ${step}: ${ms}ms`);
+      }
+      console.log(`  [${label.trim() || 'run'}] total: ${total}ms`);
+    });
+    console.log('');
+  }
+
+  return { onStep, nextRun, log };
+}
+
 describe('@cofhe/web - TFHE Initialization Browser Tests', () => {
   let cofheClient: CofheClient;
   let publicClient: PublicClient;
@@ -42,21 +75,64 @@ describe('@cofhe/web - TFHE Initialization Browser Tests', () => {
     it('should initialize tfhe on first encryption', async () => {
       await cofheClient.connect(publicClient, walletClient);
 
+      const logger = makeStepLogger('should initialize tfhe on first encryption');
+      let initTfheContext: Record<string, unknown> | undefined;
+
       // This will trigger real TFHE initialization in browser
-      const result = await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
+      const result = await cofheClient
+        .encryptInputs([Encryptable.uint128(100n)])
+        .onStep((step, context) => {
+          logger.onStep(step, context);
+          if (step === 'initTfhe' && context?.isEnd) {
+            initTfheContext = context;
+          }
+        })
+        .execute();
+
+      logger.log();
 
       // If we get here, TFHE was initialized successfully
       expect(result).toBeDefined();
+      expect(initTfheContext).toBeDefined();
+      expect(initTfheContext?.tfheInitializationExecuted).toBe(true);
     }, 60000); // Longer timeout for real operations
 
     it('should handle multiple encryptions without re-initializing', async () => {
       await cofheClient.connect(publicClient, walletClient);
 
+      const logger = makeStepLogger('should handle multiple encryptions without re-initializing');
+      const initTfheContexts: Array<Record<string, unknown>> = [];
+
       // First encryption
-      expect(cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute()).resolves.not.toThrow();
+      const firstResult = await cofheClient
+        .encryptInputs([Encryptable.uint128(100n)])
+        .onStep((step, context) => {
+          logger.onStep(step, context);
+          if (step === 'initTfhe' && context?.isEnd) {
+            initTfheContexts.push(context);
+          }
+        })
+        .execute();
+
+      logger.nextRun();
 
       // Second encryption should reuse initialization
-      expect(cofheClient.encryptInputs([Encryptable.uint64(50n)]).execute()).resolves.not.toThrow();
-    }, 60000);
+      const secondResult = await cofheClient
+        .encryptInputs([Encryptable.uint64(50n)])
+        .onStep((step, context) => {
+          logger.onStep(step, context);
+          if (step === 'initTfhe' && context?.isEnd) {
+            initTfheContexts.push(context);
+          }
+        })
+        .execute();
+
+      logger.log();
+
+      expect(firstResult).toBeDefined();
+      expect(secondResult).toBeDefined();
+      expect(initTfheContexts).toHaveLength(2);
+      expect(initTfheContexts[1].tfheInitializationExecuted).toBe(false);
+    }, 120000); // Two full encryptions on real network; CI runners can be slow
   });
 });