@cofhe/sdk 0.1.1 → 0.2.0

package/core/encrypt/encryptInputsBuilder.ts

@@ -1,8 +1,13 @@
-/* eslint-disable no-unused-vars */
-
-import { type ZkBuilderAndCrsGenerator, zkPack, zkProve, zkVerify } from './zkPackProveVerify.js';
+import {
+  type ZkBuilderAndCrsGenerator,
+  type ZkProveWorkerFunction,
+  zkPack,
+  zkProve,
+  zkProveWithWorker,
+  zkVerify,
+  constructZkPoKMetadata,
+} from './zkPackProveVerify.js';
 import { CofhesdkError, CofhesdkErrorCode } from '../error.js';
-import { type Result, resultWrapper } from '../result.js';
 import {
   type EncryptStepCallbackFunction,
   EncryptStep,
@@ -31,6 +36,7 @@ type EncryptInputsBuilderParams<T extends EncryptableItem[]> = BaseBuilderParams
   compactPkeCrsDeserializer: FheKeyDeserializer | undefined;
   zkBuilderAndCrsGenerator: ZkBuilderAndCrsGenerator | undefined;
   initTfhe: TfheInitializer | undefined;
+  zkProveWorkerFn: ZkProveWorkerFunction | undefined;
 
   keysStorage: KeysStorage | undefined;
 };
@@ -39,9 +45,6 @@ type EncryptInputsBuilderParams<T extends EncryptableItem[]> = BaseBuilderParams
  * EncryptInputsBuilder exposes a builder pattern for encrypting inputs.
  * account, securityZone, and chainId can be overridden in the builder.
  * config, tfhePublicKeyDeserializer, compactPkeCrsDeserializer, and zkBuilderAndCrsGenerator are required to be set in the builder.
- *
- * @dev All errors must be throw in `encrypt`, which wraps them in a Result.
- * Do not throw errors in the constructor or in the builder methods.
  */
 
 export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuilder {
@@ -51,13 +54,17 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
 
   private zkvWalletClient: WalletClient | undefined;
 
-  private tfhePublicKeyDeserializer: FheKeyDeserializer | undefined;
-  private compactPkeCrsDeserializer: FheKeyDeserializer | undefined;
-  private zkBuilderAndCrsGenerator: ZkBuilderAndCrsGenerator | undefined;
+  private tfhePublicKeyDeserializer: FheKeyDeserializer;
+  private compactPkeCrsDeserializer: FheKeyDeserializer;
+  private zkBuilderAndCrsGenerator: ZkBuilderAndCrsGenerator;
   private initTfhe: TfheInitializer | undefined;
+  private zkProveWorkerFn: ZkProveWorkerFunction | undefined;
 
   private keysStorage: KeysStorage | undefined;
 
+  // Worker configuration (from config, overrideable)
+  private useWorker: boolean;
+
   private stepTimestamps: Record<EncryptStep, number> = {
     [EncryptStep.InitTfhe]: 0,
     [EncryptStep.FetchKeys]: 0,
@@ -81,12 +88,56 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
 
     this.zkvWalletClient = params.zkvWalletClient;
 
+    // Check that tfhePublicKeyDeserializer is provided
+    if (!params.tfhePublicKeyDeserializer) {
+      throw new CofhesdkError({
+        code: CofhesdkErrorCode.MissingTfhePublicKeyDeserializer,
+        message: 'EncryptInputsBuilder tfhePublicKeyDeserializer is undefined',
+        hint: 'Ensure client has been created with a tfhePublicKeyDeserializer.',
+        context: {
+          tfhePublicKeyDeserializer: params.tfhePublicKeyDeserializer,
+        },
+      });
+    }
     this.tfhePublicKeyDeserializer = params.tfhePublicKeyDeserializer;
+
+    // Check that compactPkeCrsDeserializer is provided
+    if (!params.compactPkeCrsDeserializer) {
+      throw new CofhesdkError({
+        code: CofhesdkErrorCode.MissingCompactPkeCrsDeserializer,
+        message: 'EncryptInputsBuilder compactPkeCrsDeserializer is undefined',
+        hint: 'Ensure client has been created with a compactPkeCrsDeserializer.',
+        context: {
+          compactPkeCrsDeserializer: params.compactPkeCrsDeserializer,
+        },
+      });
+    }
     this.compactPkeCrsDeserializer = params.compactPkeCrsDeserializer;
+
+    // Check that zkBuilderAndCrsGenerator is provided
+    if (!params.zkBuilderAndCrsGenerator) {
+      throw new CofhesdkError({
+        code: CofhesdkErrorCode.MissingZkBuilderAndCrsGenerator,
+        message: 'EncryptInputsBuilder zkBuilderAndCrsGenerator is undefined',
+        hint: 'Ensure client has been created with a zkBuilderAndCrsGenerator.',
+        context: {
+          zkBuilderAndCrsGenerator: params.zkBuilderAndCrsGenerator,
+        },
+      });
+    }
     this.zkBuilderAndCrsGenerator = params.zkBuilderAndCrsGenerator;
+
+    // Optional tfhe initialization function, will be run if provided
     this.initTfhe = params.initTfhe;
 
+    // Optional zkProve worker function, will be used on web if useWorkers is true and worker function is provided
+    this.zkProveWorkerFn = params.zkProveWorkerFn;
+
+    // Keys storage is used to store the FHE key and CRS
     this.keysStorage = params.keysStorage;
+
+    // Initialize useWorker from config (can be overridden via setUseWorker) - default to true
+    this.useWorker = params.config?.useWorkers ?? true;
   }
 
   /**
@@ -158,6 +209,42 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     return this.securityZone;
   }
 
+  /**
+   * @param useWorker - Whether to use Web Workers for ZK proof generation.
+   *
+   * Overrides the config-level useWorkers setting for this specific encryption.
+   *
+   * Example:
+   * ```typescript
+   * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
+   *   .setUseWorker(false)
+   *   .encrypt();
+   * ```
+   *
+   * @returns The chainable EncryptInputsBuilder instance.
+   */
+  setUseWorker(useWorker: boolean): EncryptInputsBuilder<T> {
+    this.useWorker = useWorker;
+    return this;
+  }
+
+  /**
+   * Gets the current worker configuration.
+   *
+   * @returns Whether Web Workers are enabled for this encryption.
+   *
+   * Example:
+   * ```typescript
+   * const builder = encryptInputs([Encryptable.uint128(10n)]);
+   * console.log(builder.getUseWorker()); // true (from config)
+   * builder.setUseWorker(false);
+   * console.log(builder.getUseWorker()); // false (overridden)
+   * ```
+   */
+  getUseWorker(): boolean {
+    return this.useWorker;
+  }
+
   /**
    * @param callback - Function to be called with the encryption step.
    *
@@ -202,50 +289,13 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     this.stepCallback(step, { ...context, isStart: false, isEnd: true, duration });
   }
 
-  /**
-   * tfhePublicKeyDeserializer is a platform-specific dependency injected into core/createCofhesdkClientBase by web/createCofhesdkClient and node/createCofhesdkClient
-   * web/ uses zama "tfhe"
-   * node/ uses zama "node-tfhe"
-   * Users should not set this manually.
-   */
-  private getTfhePublicKeyDeserializerOrThrow(): FheKeyDeserializer {
-    if (this.tfhePublicKeyDeserializer) return this.tfhePublicKeyDeserializer;
-    throw new CofhesdkError({
-      code: CofhesdkErrorCode.MissingTfhePublicKeyDeserializer,
-      message: 'EncryptInputsBuilder tfhePublicKeyDeserializer is undefined',
-      hint: 'Ensure client has been created with a tfhePublicKeyDeserializer.',
-      context: {
-        tfhePublicKeyDeserializer: this.tfhePublicKeyDeserializer,
-      },
-    });
-  }
-
-  /**
-   * compactPkeCrsDeserializer is a platform-specific dependency injected into core/createCofhesdkClientBase by web/createCofhesdkClient and node/createCofhesdkClient
-   * web/ uses zama "tfhe"
-   * node/ uses zama "node-tfhe"
-   * Users should not set this manually.
-   */
-  private getCompactPkeCrsDeserializerOrThrow(): FheKeyDeserializer {
-    if (this.compactPkeCrsDeserializer) return this.compactPkeCrsDeserializer;
-    throw new CofhesdkError({
-      code: CofhesdkErrorCode.MissingCompactPkeCrsDeserializer,
-      message: 'EncryptInputsBuilder compactPkeCrsDeserializer is undefined',
-      hint: 'Ensure client has been created with a compactPkeCrsDeserializer.',
-      context: {
-        compactPkeCrsDeserializer: this.compactPkeCrsDeserializer,
-      },
-    });
-  }
-
   /**
    * zkVerifierUrl is included in the chains exported from cofhesdk/chains for use in CofhesdkConfig.supportedChains
    * Users should generally not set this manually.
    */
   private async getZkVerifierUrl(): Promise<string> {
-    const config = this.getConfigOrThrow();
-    const chainId = await this.getChainIdOrThrow();
-    return getZkVerifierUrlOrThrow(config, chainId);
+    this.assertChainId();
+    return getZkVerifierUrlOrThrow(this.config, this.chainId);
   }
 
   /**
@@ -280,10 +330,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     crs: string;
     crsFetchedFromCoFHE: boolean;
   }> {
-    const config = this.getConfigOrThrow();
-    const chainId = await this.getChainIdOrThrow();
-    const compactPkeCrsDeserializer = this.getCompactPkeCrsDeserializerOrThrow();
-    const tfhePublicKeyDeserializer = this.getTfhePublicKeyDeserializerOrThrow();
+    this.assertChainId();
     const securityZone = this.getSecurityZone();
 
     try {
@@ -305,11 +352,11 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
 
     try {
       [[fheKey, fheKeyFetchedFromCoFHE], [crs, crsFetchedFromCoFHE]] = await fetchKeys(
-        config,
-        chainId,
+        this.config,
+        this.chainId,
         securityZone,
-        tfhePublicKeyDeserializer,
-        compactPkeCrsDeserializer,
+        this.tfhePublicKeyDeserializer,
+        this.compactPkeCrsDeserializer,
         this.keysStorage
       );
     } catch (error) {
@@ -317,11 +364,11 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
         code: CofhesdkErrorCode.FetchKeysFailed,
         message: `Failed to fetch FHE key and CRS`,
         context: {
-          config,
-          chainId,
+          config: this.config,
+          chainId: this.chainId,
           securityZone,
-          compactPkeCrsDeserializer,
-          tfhePublicKeyDeserializer,
+          compactPkeCrsDeserializer: this.compactPkeCrsDeserializer,
+          tfhePublicKeyDeserializer: this.tfhePublicKeyDeserializer,
         },
       });
     }
@@ -331,7 +378,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
         code: CofhesdkErrorCode.MissingFheKey,
         message: `FHE key not found`,
         context: {
-          chainId,
+          chainId: this.chainId,
           securityZone,
         },
       });
@@ -342,7 +389,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
         code: CofhesdkErrorCode.MissingCrs,
         message: `CRS not found for chainId <${this.chainId}>`,
         context: {
-          chainId,
+          chainId: this.chainId,
         },
       });
     }
@@ -350,31 +397,6 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     return { fheKey, fheKeyFetchedFromCoFHE, crs, crsFetchedFromCoFHE };
   }
 
-  /**
-   * zkBuilderAndCrsGenerator is a platform-specific dependency injected into core/createCofhesdkClientBase by web/createCofhesdkClient and node/createCofhesdkClient
-   * web/ uses zama "tfhe"
-   * node/ uses zama "node-tfhe"
-   * Users should not set this manually.
-   *
-   * Generates the zkBuilder and zkCrs from the fheKey and crs
-   */
-  private generateZkBuilderAndCrs(fheKey: string, crs: string) {
-    const zkBuilderAndCrsGenerator = this.zkBuilderAndCrsGenerator;
-
-    if (!zkBuilderAndCrsGenerator) {
-      throw new CofhesdkError({
-        code: CofhesdkErrorCode.MissingZkBuilderAndCrsGenerator,
-        message: `zkBuilderAndCrsGenerator is undefined`,
-        hint: 'Ensure client has been created with a zkBuilderAndCrsGenerator.',
-        context: {
-          zkBuilderAndCrsGenerator: this.zkBuilderAndCrsGenerator,
-        },
-      });
-    }
-
-    return zkBuilderAndCrsGenerator(fheKey, crs);
-  }
-
   /**
    * @dev Encrypt against the cofheMocks instead of CoFHE
    *
@@ -382,7 +404,11 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    * cofheMocksInsertPackedHashes - stores the ctHashes and their plaintext values for on-chain mocking of FHE operations.
    * cofheMocksZkCreateProofSignatures - creates signatures to be included in the encrypted inputs. The signers address is known and verified in the mock contracts.
    */
-  private async mocksEncrypt(account: string): Promise<[...EncryptedItemInputs<T>]> {
+  private async mocksEncrypt(): Promise<[...EncryptedItemInputs<T>]> {
+    this.assertAccount();
+    this.assertPublicClient();
+    this.assertWalletClient();
+
     this.fireStepStart(EncryptStep.InitTfhe);
     await sleep(100);
     this.fireStepEnd(EncryptStep.InitTfhe, { tfheInitializationExecuted: false });
@@ -404,10 +430,10 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     await sleep(500);
     const signedResults = await cofheMocksZkVerifySign(
       this.inputItems,
-      account,
+      this.account,
       this.securityZone,
-      this.getPublicClientOrThrow(),
-      this.getWalletClientOrThrow(),
+      this.publicClient,
+      this.walletClient,
       this.zkvWalletClient
     );
     const encryptedInputs: EncryptedItemInput[] = signedResults.map(({ ct_hash, signature }, index) => ({
@@ -424,7 +450,10 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
   /**
    * In the production context, perform a true encryption with the CoFHE coprocessor.
    */
-  private async productionEncrypt(account: string, chainId: number): Promise<[...EncryptedItemInputs<T>]> {
+  private async productionEncrypt(): Promise<[...EncryptedItemInputs<T>]> {
+    this.assertAccount();
+    this.assertChainId();
+
     this.fireStepStart(EncryptStep.InitTfhe);
 
     // Deferred initialization of tfhe wasm until encrypt is called
@@ -438,7 +467,8 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     // Deferred fetching of fheKey and crs until encrypt is called
     // if the key/crs is already in the store, it is not fetched from the CoFHE API
     const { fheKey, fheKeyFetchedFromCoFHE, crs, crsFetchedFromCoFHE } = await this.fetchFheKeyAndCrs();
-    let { zkBuilder, zkCrs } = this.generateZkBuilderAndCrs(fheKey, crs);
+
+    let { zkBuilder, zkCrs } = this.zkBuilderAndCrsGenerator(fheKey, crs);
 
     this.fireStepEnd(EncryptStep.FetchKeys, { fheKeyFetchedFromCoFHE, crsFetchedFromCoFHE });
 
@@ -450,15 +480,42 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
 
     this.fireStepStart(EncryptStep.Prove);
 
-    const proof = await zkProve(zkBuilder, zkCrs, account, this.securityZone, chainId);
+    // Construct metadata once (used by both worker and main thread paths)
+    const metadata = constructZkPoKMetadata(this.account, this.securityZone, this.chainId);
+
+    let proof: Uint8Array | null = null;
+    let usedWorker = false;
+    let workerFailedError: string | undefined;
+
+    // Decision logic: try worker if enabled and available, fallback to main thread
+    if (this.useWorker && this.zkProveWorkerFn) {
+      try {
+        // Call worker function directly (no packing needed, worker does it)
+        proof = await zkProveWithWorker(this.zkProveWorkerFn, fheKey, crs, this.inputItems, metadata);
+        usedWorker = true;
+      } catch (error) {
+        // Worker failed - capture error for debugging
+        workerFailedError = error instanceof Error ? error.message : String(error);
+      }
+    }
 
-    this.fireStepEnd(EncryptStep.Prove);
+    if (proof == null) {
+      // Use main thread directly (workers disabled or unavailable)
+      proof = await zkProve(zkBuilder, zkCrs, metadata);
+      usedWorker = false;
+    }
+
+    this.fireStepEnd(EncryptStep.Prove, {
+      useWorker: this.useWorker,
+      usedWorker,
+      workerFailedError,
+    });
 
     this.fireStepStart(EncryptStep.Verify);
 
     const zkVerifierUrl = await this.getZkVerifierUrl();
 
-    const verifyResults = await zkVerify(zkVerifierUrl, proof, account, this.securityZone, chainId);
+    const verifyResults = await zkVerify(zkVerifierUrl, proof, this.account, this.securityZone, this.chainId);
     // Add securityZone and utype to the verify results
     const encryptedInputs: EncryptedItemInput[] = verifyResults.map(
       ({ ct_hash, signature }: { ct_hash: string; signature: string }, index: number) => ({
@@ -493,20 +550,11 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    *
    * @returns The encrypted inputs.
    */
-  async encrypt(): Promise<Result<[...EncryptedItemInputs<T>]>> {
-    return resultWrapper(async () => {
-      // Ensure cofhe client is connected
-      await this.requireConnectedOrThrow();
-
-      const account = await this.getAccountOrThrow();
-      const chainId = await this.getChainIdOrThrow();
+  async encrypt(): Promise<[...EncryptedItemInputs<T>]> {
+    // On hardhat chain, interact with MockZkVerifier contract instead of CoFHE
+    if (this.chainId === hardhat.id) return this.mocksEncrypt();
 
-      // On hardhat, interact with MockZkVerifier contract instead of CoFHE
-      if (chainId === hardhat.id) {
-        return await this.mocksEncrypt(account);
-      }
-
-      return await this.productionEncrypt(account, chainId);
-    });
+    // On other chains, interact with CoFHE coprocessor
+    return this.productionEncrypt();
   }
 }

package/core/encrypt/encryptUtils.ts

@@ -1,7 +1,10 @@
 /* eslint-disable no-redeclare */
-/* eslint-disable no-unused-vars */
-
-import { type EncryptableItem, isEncryptableItem, type EncryptedItemInput, type EncryptedItemInputs } from '../types.js';
+import {
+  type EncryptableItem,
+  isEncryptableItem,
+  type EncryptedItemInput,
+  type EncryptedItemInputs,
+} from '../types.js';
 
 export function encryptExtract<T>(item: T): EncryptableItem[];
 export function encryptExtract<T extends any[]>(item: [...T]): EncryptableItem[];

package/core/encrypt/zkPackProveVerify.ts

@@ -1,11 +1,45 @@
-/* eslint-disable no-unused-vars */
-
 import { CofhesdkError, CofhesdkErrorCode } from '../error.js';
 import { type EncryptableItem, FheTypes } from '../types.js';
 import { toBigIntOrThrow, validateBigIntInRange, toHexString, hexToBytes } from '../utils.js';
 
 // ===== TYPES =====
 
+/**
+ * Worker function type for ZK proof generation
+ * Platform-specific implementations (web) can provide this to enable worker-based proofs
+ */
+export type ZkProveWorkerFunction = (
+  fheKeyHex: string,
+  crsHex: string,
+  items: EncryptableItem[],
+  metadata: Uint8Array
+) => Promise<Uint8Array>;
+
+/**
+ * Message sent from main thread to worker to request proof generation
+ */
+export interface ZkProveWorkerRequest {
+  id: string;
+  type: 'zkProve';
+  fheKeyHex: string;
+  crsHex: string;
+  items: Array<{
+    utype: string;
+    data: any;
+  }>;
+  metadata: number[]; // Uint8Array serialized as array
+}
+
+/**
+ * Message sent from worker back to main thread with proof result
+ */
+export interface ZkProveWorkerResponse {
+  id: string;
+  type: 'success' | 'error' | 'ready';
+  result?: number[]; // Uint8Array serialized as array
+  error?: string;
+}
+
 export type VerifyResultRaw = {
   ct_hash: string;
   signature: string;
@@ -156,15 +190,39 @@ export const zkPack = (items: EncryptableItem[], builder: ZkCiphertextListBuilde
   return builder;
 };
 
+/**
+ * Generates ZK proof using Web Worker (offloads heavy WASM computation)
+ * Serializes items and calls the platform-specific worker function
+ * @param workerFn - Platform-specific worker function (provided by web/index.ts)
+ * @param fheKeyHex - Hex-encoded FHE public key for worker deserialization
+ * @param crsHex - Hex-encoded CRS for worker deserialization
+ * @param items - Encryptable items to pack in the worker
+ * @param metadata - Pre-constructed ZK PoK metadata
+ * @returns The serialized proven ciphertext list
+ */
+export const zkProveWithWorker = async (
+  workerFn: ZkProveWorkerFunction,
+  fheKeyHex: string,
+  crsHex: string,
+  items: EncryptableItem[],
+  metadata: Uint8Array
+): Promise<Uint8Array> => {
+  return await workerFn(fheKeyHex, crsHex, items, metadata);
+};
+
+/**
+ * Generates ZK proof using main thread (synchronous WASM)
+ * This is the fallback when workers are disabled or unavailable
+ * @param builder - The ZK ciphertext list builder with packed inputs
+ * @param crs - The Compact PKE CRS for proof generation
+ * @param metadata - Pre-constructed ZK PoK metadata
+ * @returns The serialized proven ciphertext list
+ */
 export const zkProve = async (
   builder: ZkCiphertextListBuilder,
   crs: ZkCompactPkeCrs,
-  address: string,
-  securityZone: number,
-  chainId: number
+  metadata: Uint8Array
 ): Promise<Uint8Array> => {
-  const metadata = constructZkPoKMetadata(address, securityZone, chainId);
-
   return new Promise((resolve) => {
     setTimeout(() => {
       const compactList = builder.build_with_proof_packed(
@@ -178,7 +236,11 @@ export const zkProve = async (
   });
 };
 
-const constructZkPoKMetadata = (accountAddr: string, securityZone: number, chainId: number): Uint8Array => {
+/**
+ * Constructs the ZK Proof of Knowledge metadata for the proof
+ * @internal - Used internally within the encrypt module
+ */
+export const constructZkPoKMetadata = (accountAddr: string, securityZone: number, chainId: number): Uint8Array => {
   // Decode the account address from hex
   const accountAddrNoPrefix = accountAddr.startsWith('0x') ? accountAddr.slice(2) : accountAddr;
   const accountBytes = hexToBytes(accountAddrNoPrefix);

package/core/error.ts

@@ -1,5 +1,3 @@
-/* eslint-disable no-unused-vars */
-
 export enum CofhesdkErrorCode {
   InternalError = 'INTERNAL_ERROR',
   UnknownEnvironment = 'UNKNOWN_ENVIRONMENT',

package/core/fetchKeys.test.ts

@@ -4,7 +4,7 @@
 import { sepolia, arbSepolia } from '@/chains';
 
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { fetchKeys, fetchMultichainKeys } from './fetchKeys.js';
+import { fetchKeys } from './fetchKeys.js';
 import { type CofhesdkConfig, createCofhesdkConfigBase } from './config.js';
 import { createKeysStore, type KeysStorage } from './keyStore.js';
 
@@ -192,21 +192,4 @@ describe('fetchKeys', () => {
       fetchKeys(config, sepolia.id, 0, mockTfhePublicKeyDeserializer, mockCompactPkeCrsDeserializer, keysStorage)
     ).rejects.toThrow('Error serializing CRS; Error: Serialization failed');
   });
-
-  it('should fetch and store FHE public key and CRS for all chains in the config', async () => {
-    await fetchMultichainKeys(config, 0, mockTfhePublicKeyDeserializer, mockCompactPkeCrsDeserializer, keysStorage);
-
-    // Verify keys were stored
-    const storedFheKey = keysStorage.getFheKey(sepolia.id, 0);
-    const storedCrs = keysStorage.getCrs(sepolia.id);
-    const storedFheKeyArb = keysStorage.getFheKey(arbSepolia.id, 0);
-    const storedCrsArb = keysStorage.getCrs(arbSepolia.id);
-
-    expect(storedFheKey).toBeDefined();
-    expect(storedCrs).toBeDefined();
-    expect(storedFheKeyArb).toBeDefined();
-    expect(storedCrsArb).toBeDefined();
-    expect(mockTfhePublicKeyDeserializer).toHaveBeenCalled();
-    expect(mockCompactPkeCrsDeserializer).toHaveBeenCalled();
-  });
 });

package/core/fetchKeys.ts

@@ -4,7 +4,6 @@ import { type CofhesdkConfig, getCoFheUrlOrThrow } from './config.js';
 import { type KeysStorage } from './keyStore.js';
 
 const PUBLIC_KEY_LENGTH_MIN = 15_000;
-// eslint-disable-next-line no-unused-vars
 export type FheKeyDeserializer = (buff: string) => void;
 
 const checkKeyValidity = (key: string | undefined, serializer: FheKeyDeserializer) => {
@@ -143,28 +142,3 @@ export const fetchKeys = async (
     fetchCrs(coFheUrl, chainId, securityZone, compactPkeCrsDeserializer, keysStorage),
   ]);
 };
-
-/**
- * Fetches the FHE public key and the CRS for all chains in the config
- * @param {CofhesdkConfig} config - The configuration object for the CoFHE SDK
- * @param {number} securityZone - The security zone for which to retrieve the key (default 0).
- * @param tfhePublicKeyDeserializer - The serializer for the FHE public key (used for validation).
- * @param compactPkeCrsDeserializer - The serializer for the CRS (used for validation).
- * @param keysStorage - The keys storage instance to use (optional)
- * @returns {Promise<void>} - A promise that resolves when the keys are fetched and stored.
- */
-export const fetchMultichainKeys = async (
-  config: CofhesdkConfig,
-  securityZone: number = 0,
-  tfhePublicKeyDeserializer: FheKeyDeserializer,
-  compactPkeCrsDeserializer: FheKeyDeserializer,
-  keysStorage?: KeysStorage | null
-): Promise<void> => {
-  await Promise.all(
-    config.supportedChains
-      .filter((chain) => chain.id !== hardhat.id)
-      .map((chain) =>
-        fetchKeys(config, chain.id, securityZone, tfhePublicKeyDeserializer, compactPkeCrsDeserializer, keysStorage)
-      )
-  );
-};