@cofhe/sdk 0.1.1 → 0.2.1

package/core/encrypt/cofheMocksZkVerifySign.ts

@@ -14,16 +14,19 @@ import { MockZkVerifierAbi } from './MockZkVerifierAbi.js';
 import { hardhat } from 'viem/chains';
 import { CofhesdkError, CofhesdkErrorCode } from '../error.js';
 import { privateKeyToAccount } from 'viem/accounts';
-
-// Address the Mock ZkVerifier contract is deployed to on the Hardhat chain
-export const MocksZkVerifierAddress = '0x0000000000000000000000000000000000000100';
-// Private key of the account expected to sign the encrypted inputs
-export const MocksEncryptedInputSignerPkey = '0x6c8d7f768a6bb4aafe85e8a2f5a9680355239c7e14646ed62b044e39de154512';
+import { MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_ADDRESS } from '../consts.js';
 
 type EncryptableItemWithCtHash = EncryptableItem & {
   ctHash: bigint;
 };
 
+function createMockZkVerifierSigner() {
+  return createWalletClient({
+    chain: hardhat,
+    transport: http(),
+    account: privateKeyToAccount(MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY),
+  });
+}
 /**
  * The mocks don't use a tfhe builder, so we check the encryptable bits here to preserve parity
  */
@@ -101,7 +104,7 @@ async function calcCtHashes(
 
   try {
     ctHashes = (await publicClient.readContract({
-      address: MocksZkVerifierAddress,
+      address: MOCKS_ZK_VERIFIER_ADDRESS,
       abi: MockZkVerifierAbi,
       functionName: 'zkVerifyCalcCtHashesPacked',
       args: calcCtHashesArgs,
@@ -112,7 +115,7 @@ async function calcCtHashes(
       message: `mockZkVerifySign calcCtHashes failed while calling zkVerifyCalcCtHashesPacked`,
       cause: err instanceof Error ? err : undefined,
       context: {
-        address: MocksZkVerifierAddress,
+        address: MOCKS_ZK_VERIFIER_ADDRESS,
         items,
         account,
         securityZone,
@@ -153,7 +156,7 @@ async function insertCtHashes(items: EncryptableItemWithCtHash[], walletClient:
     const account = walletClient.account!;
 
     await walletClient.writeContract({
-      address: MocksZkVerifierAddress,
+      address: MOCKS_ZK_VERIFIER_ADDRESS,
       abi: MockZkVerifierAbi,
       functionName: 'insertPackedCtHashes',
       args: insertPackedCtHashesArgs,
@@ -187,18 +190,14 @@ async function createProofSignatures(items: EncryptableItemWithCtHash[], securit
   let encInputSignerClient: WalletClient | undefined;
 
   try {
-    encInputSignerClient = createWalletClient({
-      chain: hardhat,
-      transport: http(),
-      account: privateKeyToAccount(MocksEncryptedInputSignerPkey),
-    });
+    encInputSignerClient = createMockZkVerifierSigner();
   } catch (err) {
     throw new CofhesdkError({
       code: CofhesdkErrorCode.ZkMocksCreateProofSignatureFailed,
       message: `mockZkVerifySign createProofSignatures failed while creating wallet client`,
       cause: err instanceof Error ? err : undefined,
       context: {
-        MocksEncryptedInputSignerPkey,
+        MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY,
       },
     });
   }
@@ -258,8 +257,8 @@ export async function cofheMocksZkVerifySign(
   walletClient: WalletClient,
   zkvWalletClient: WalletClient | undefined
 ): Promise<VerifyResult[]> {
-  // Use config.mocks.zkvWalletClient if provided, otherwise use connected walletClient
-  const _walletClient = zkvWalletClient ?? walletClient;
+  // Use config._internal?.zkvWalletClient if provided, otherwise use a mock zk verifier signer
+  const _walletClient = zkvWalletClient ?? createMockZkVerifierSigner();
 
   // Call MockZkVerifier contract to calculate the ctHashes
   const encryptableItems = await calcCtHashes(items, account, securityZone, publicClient);

package/core/encrypt/encryptInputsBuilder.test.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-unused-vars */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { EncryptInputsBuilder } from './encryptInputsBuilder.js';
 import {
@@ -18,7 +17,6 @@ import { type CofhesdkConfig, createCofhesdkConfigBase } from '../config.js';
 import { type ZkBuilderAndCrsGenerator } from './zkPackProveVerify.js';
 import { type KeysStorage, createKeysStore } from '../keyStore.js';
 import { type FheKeyDeserializer } from '../fetchKeys.js';
-import { expectResultSuccess, expectResultError } from '../test-utils.js';
 
 const MockZkVerifierUrl = 'http://localhost:3001';
 
@@ -93,25 +91,25 @@ class MockZkListBuilder {
     this.items = items;
   }
   push_boolean(data: boolean): void {
-    this.items.push({ utype: FheTypes.Bool, data });
+    this.items.push({ utype: FheTypes.Bool, data, securityZone: 0 });
   }
   push_u8(data: number): void {
-    this.items.push({ utype: FheTypes.Uint8, data: BigInt(data) });
+    this.items.push({ utype: FheTypes.Uint8, data: BigInt(data), securityZone: 0 });
   }
   push_u16(data: number): void {
-    this.items.push({ utype: FheTypes.Uint16, data: BigInt(data) });
+    this.items.push({ utype: FheTypes.Uint16, data: BigInt(data), securityZone: 0 });
   }
   push_u32(data: number): void {
-    this.items.push({ utype: FheTypes.Uint32, data: BigInt(data) });
+    this.items.push({ utype: FheTypes.Uint32, data: BigInt(data), securityZone: 0 });
   }
   push_u64(data: bigint): void {
-    this.items.push({ utype: FheTypes.Uint64, data });
+    this.items.push({ utype: FheTypes.Uint64, data, securityZone: 0 });
   }
   push_u128(data: bigint): void {
-    this.items.push({ utype: FheTypes.Uint128, data });
+    this.items.push({ utype: FheTypes.Uint128, data, securityZone: 0 });
   }
   push_u160(data: bigint): void {
-    this.items.push({ utype: FheTypes.Uint160, data });
+    this.items.push({ utype: FheTypes.Uint160, data, securityZone: 0 });
   }
   build_with_proof_packed(_crs: any, metadata: Uint8Array, _computeLoad: 1): MockZkProvenList {
     // Clear items to prevent persisting items between tests
@@ -249,6 +247,7 @@ describe('EncryptInputsBuilder', () => {
       compactPkeCrsDeserializer: mockCompactPkeCrsDeserializer,
       zkBuilderAndCrsGenerator: mockZkBuilderAndCrsGenerator,
       initTfhe: mockInitTfhe,
+      zkProveWorkerFn: undefined,
       keysStorage: keysStorage,
       requireConnected: vi.fn(),
     };
@@ -279,58 +278,62 @@ describe('EncryptInputsBuilder', () => {
     });
 
     it('should throw an error if config is not set', async () => {
-      const builder = new EncryptInputsBuilder({
-        ...createDefaultParams(),
-        config: undefined as unknown as CofhesdkConfig,
-      });
-      const result = await builder.encrypt();
-      expectResultError(result, CofhesdkErrorCode.MissingConfig);
+      // Should throw before .encrypt() is called
+      try {
+        new EncryptInputsBuilder({
+          ...createDefaultParams(),
+          config: undefined as unknown as CofhesdkConfig,
+        });
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.MissingConfig);
+      }
     });
 
     it('should throw an error if tfhePublicKeyDeserializer is not set', async () => {
-      const builder = new EncryptInputsBuilder({
-        ...createDefaultParams(),
-        tfhePublicKeyDeserializer: undefined as unknown as FheKeyDeserializer,
-      });
-      const result = await builder.encrypt();
-      expectResultError(result, CofhesdkErrorCode.MissingTfhePublicKeyDeserializer);
+      // Should throw before .encrypt() is called
+      try {
+        new EncryptInputsBuilder({
+          ...createDefaultParams(),
+          tfhePublicKeyDeserializer: undefined as unknown as FheKeyDeserializer,
+        });
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.MissingTfhePublicKeyDeserializer);
+      }
     });
 
     it('should throw an error if compactPkeCrsDeserializer is not set', async () => {
-      const builder = new EncryptInputsBuilder({
-        ...createDefaultParams(),
-        compactPkeCrsDeserializer: undefined as unknown as FheKeyDeserializer,
-      });
-      const result = await builder.encrypt();
-      expectResultError(result, CofhesdkErrorCode.MissingCompactPkeCrsDeserializer);
+      // Should throw before .encrypt() is called
+      try {
+        new EncryptInputsBuilder({
+          ...createDefaultParams(),
+          compactPkeCrsDeserializer: undefined as unknown as FheKeyDeserializer,
+        });
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.MissingCompactPkeCrsDeserializer);
+      }
     });
 
     it('should throw an error if initTfhe throws an error', async () => {
-      const builder = new EncryptInputsBuilder({
-        ...createDefaultParams(),
-        initTfhe: vi.fn().mockRejectedValue(new Error('Failed to initialize TFHE')),
-      });
-      const result = await builder.encrypt();
-      expectResultError(result, CofhesdkErrorCode.InitTfheFailed);
-    });
-
-    it('should throw an error if initTfhe throws', async () => {
-      const mockInitTfhe = vi.fn().mockRejectedValue(new Error('Failed to initialize TFHE'));
-      const builder = new EncryptInputsBuilder({
-        ...createDefaultParams(),
-        initTfhe: mockInitTfhe,
-      });
-      const result = await builder.encrypt();
-      expectResultError(result, CofhesdkErrorCode.InitTfheFailed);
+      try {
+        await new EncryptInputsBuilder({
+          ...createDefaultParams(),
+          initTfhe: vi.fn().mockRejectedValue(new Error('Failed to initialize TFHE')),
+        }).encrypt();
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.InitTfheFailed);
+      }
     });
 
     it('should not throw an error if initTfhe is set', async () => {
-      const builder = new EncryptInputsBuilder({
+      const result = await new EncryptInputsBuilder({
         ...createDefaultParams(),
         initTfhe: mockInitTfhe,
-      });
-      const result = await builder.encrypt();
-      expectResultSuccess(result);
+      }).encrypt();
+      expect(result).toBeDefined();
     });
   });
 
@@ -359,12 +362,15 @@ describe('EncryptInputsBuilder', () => {
     });
 
     it('should throw an error if account is not set', async () => {
-      const builder = new EncryptInputsBuilder({
-        ...createDefaultParams(),
-        account: undefined,
-      });
-      const result = await builder.encrypt();
-      expectResultError(result, CofhesdkErrorCode.AccountUninitialized);
+      try {
+        await new EncryptInputsBuilder({
+          ...createDefaultParams(),
+          account: undefined,
+        }).encrypt();
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.AccountUninitialized);
+      }
     });
   });
 
@@ -400,27 +406,32 @@ describe('EncryptInputsBuilder', () => {
     });
 
     it('should throw an error if chainId is not set', async () => {
-      const builder = new EncryptInputsBuilder({
-        ...createDefaultParams(),
-        chainId: undefined,
-      });
-      const result = await builder.encrypt();
-      expectResultError(result, CofhesdkErrorCode.ChainIdUninitialized);
+      try {
+        await new EncryptInputsBuilder({
+          ...createDefaultParams(),
+          chainId: undefined,
+        }).encrypt();
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.ChainIdUninitialized);
+      }
     });
   });
 
   describe('zkVerifierUrl', () => {
     it('should throw if zkVerifierUrl is not set', async () => {
-      builder = new EncryptInputsBuilder({
-        ...createDefaultParams(),
-        inputs: [Encryptable.uint128(100n)] as [EncryptableUint128],
-        account: '0x1234567890123456789012345678901234567890',
-        chainId: 1,
-        config: createMockCofhesdkConfig(defaultChainId, undefined as unknown as string),
-      });
-
-      const result = await builder.encrypt();
-      expectResultError(result, CofhesdkErrorCode.ZkVerifierUrlUninitialized);
+      try {
+        await new EncryptInputsBuilder({
+          ...createDefaultParams(),
+          inputs: [Encryptable.uint128(100n)] as [EncryptableUint128],
+          account: '0x1234567890123456789012345678901234567890',
+          chainId: 1,
+          config: createMockCofhesdkConfig(defaultChainId, undefined as unknown as string),
+        }).encrypt();
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.ZkVerifierUrlUninitialized);
+      }
     });
   });
 
@@ -444,7 +455,7 @@ describe('EncryptInputsBuilder', () => {
       const stepCallback = vi.fn();
       builder.setStepCallback(stepCallback);
 
-      const result = expectResultSuccess(await builder.encrypt());
+      const result = await builder.encrypt();
 
       // Verify step callbacks were called in order
       expect(stepCallback).toHaveBeenCalledTimes(10);
@@ -557,7 +568,7 @@ describe('EncryptInputsBuilder', () => {
       const overriddenSender = '0x5555555555555555555555555555555555555555';
       builder.setAccount(overriddenSender);
 
-      const result = expectResultSuccess(await builder.encrypt());
+      const result = await builder.encrypt();
 
       // Verify result embedded metadata
       const [encrypted] = result;
@@ -574,7 +585,7 @@ describe('EncryptInputsBuilder', () => {
 
       insertMockKeys(defaultChainId, overriddenZone);
 
-      const result = expectResultSuccess(await builder.encrypt());
+      const result = await builder.encrypt();
 
       // Verify result embedded metadata
       const [encrypted] = result;
@@ -587,7 +598,7 @@ describe('EncryptInputsBuilder', () => {
 
     it('should work without step callback', async () => {
       // No step callback set
-      const result = expectResultSuccess(await builder.encrypt());
+      const result = await builder.encrypt();
 
       expect(result).toBeDefined();
       expect(Array.isArray(result)).toBe(true);
@@ -603,54 +614,60 @@ describe('EncryptInputsBuilder', () => {
         ],
       });
 
-      const result = expectResultSuccess(await multiInputBuilder.encrypt());
+      const result = await multiInputBuilder.encrypt();
 
       expect(result).toBeDefined();
       expect(Array.isArray(result)).toBe(true);
     });
 
     it('should throw an error if total bits exceeds 2048', async () => {
-      const builder = new EncryptInputsBuilder({
-        ...createDefaultParams(),
-        inputs: [
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-          Encryptable.uint128(100n),
-        ],
-      });
-      const result = await builder.encrypt();
-      expectResultError(result, CofhesdkErrorCode.ZkPackFailed);
+      try {
+        await new EncryptInputsBuilder({
+          ...createDefaultParams(),
+          inputs: [
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+            Encryptable.uint128(100n),
+          ],
+        }).encrypt();
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.ZkPackFailed);
+      }
     });
 
     it('should throw an error if utype is invalid', async () => {
-      const builder = new EncryptInputsBuilder({
-        ...createDefaultParams(),
-        inputs: [
-          {
-            data: 10n,
-            utype: FheTypes.Uint10, // Invalid utype
-          },
-        ] as unknown as [EncryptableItem],
-      });
-      const result = await builder.encrypt();
-      expectResultError(result, CofhesdkErrorCode.ZkPackFailed);
+      try {
+        await new EncryptInputsBuilder({
+          ...createDefaultParams(),
+          inputs: [
+            {
+              data: 10n,
+              utype: FheTypes.Uint10, // Invalid utype
+            },
+          ] as unknown as [EncryptableItem],
+        });
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.ZkPackFailed);
+      }
     });
   });
 
@@ -685,13 +702,12 @@ describe('EncryptInputsBuilder', () => {
         .setSecurityZone(securityZone)
         .setStepCallback(stepCallback)
         .encrypt();
-      const resultData = expectResultSuccess(result);
 
       expect(result).toBeDefined();
       expect(stepCallback).toHaveBeenCalledTimes(10);
 
       // Verify result embedded metadata
-      const [encrypted] = resultData;
+      const [encrypted] = result;
       const encryptedMetadata = unpackMetadata(encrypted.signature);
       expect(encryptedMetadata).toBeDefined();
       expect(encryptedMetadata.signer).toBe(sender);
@@ -709,8 +725,8 @@ describe('EncryptInputsBuilder', () => {
       builder.setSecurityZone(securityZone);
 
       // Call encrypt multiple times to ensure state is maintained
-      const result1 = expectResultSuccess(await builder.encrypt());
-      const result2 = expectResultSuccess(await builder.encrypt());
+      const result1 = await builder.encrypt();
+      const result2 = await builder.encrypt();
 
       expect(result1).toBeDefined();
       expect(result2).toBeDefined();