@cofhe/sdk 0.2.1 → 0.3.1

package/core/encrypt/encryptInputsBuilder.test.ts

@@ -8,12 +8,12 @@ import {
   EncryptStep,
   type TfheInitializer,
 } from '../types.js';
-import { CofhesdkError, CofhesdkErrorCode } from '../error.js';
+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 } from 'viem/chains';
-import { type CofhesdkConfig, createCofhesdkConfigBase } from '../config.js';
+import { arbitrumSepolia, hardhat } from 'viem/chains';
+import { type CofheConfig, createCofheConfigBase } from '../config.js';
 import { type ZkBuilderAndCrsGenerator } from './zkPackProveVerify.js';
 import { type KeysStorage, createKeysStore } from '../keyStore.js';
 import { type FheKeyDeserializer } from '../fetchKeys.js';
@@ -56,8 +56,8 @@ export const deconstructZkPoKMetadata = (
 ): { accountAddr: string; securityZone: number; chainId: number } => {
   if (metadata.length < 53) {
     // 1 + 20 + 32 = 53 bytes minimum
-    throw new CofhesdkError({
-      code: CofhesdkErrorCode.InternalError,
+    throw new CofheError({
+      code: CofheErrorCode.InternalError,
       message: 'Invalid metadata: insufficient length',
     });
   }
@@ -198,8 +198,8 @@ const mockZkBuilderAndCrsGenerator: ZkBuilderAndCrsGenerator = (fhe: string, crs
   };
 };
 
-const createMockCofhesdkConfig = (chainId: number, zkVerifierUrl: string) => {
-  return createCofhesdkConfigBase({
+const createMockCofheConfig = (chainId: number, zkVerifierUrl: string) => {
+  return createCofheConfigBase({
     supportedChains: [
       {
         id: chainId,
@@ -239,7 +239,7 @@ describe('EncryptInputsBuilder', () => {
       account: defaultSender,
       chainId: defaultChainId,
 
-      config: createMockCofhesdkConfig(defaultChainId, MockZkVerifierUrl),
+      config: createMockCofheConfig(defaultChainId, MockZkVerifierUrl),
       publicClient: publicClient,
       walletClient: bobWalletClient,
 
@@ -278,41 +278,41 @@ describe('EncryptInputsBuilder', () => {
     });
 
     it('should throw an error if config is not set', async () => {
-      // Should throw before .encrypt() is called
+      // Should throw before .execute() is called
       try {
         new EncryptInputsBuilder({
           ...createDefaultParams(),
-          config: undefined as unknown as CofhesdkConfig,
+          config: undefined as unknown as CofheConfig,
         });
       } catch (error) {
-        expect(error).toBeInstanceOf(CofhesdkError);
-        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.MissingConfig);
+        expect(error).toBeInstanceOf(CofheError);
+        expect((error as CofheError).code).toBe(CofheErrorCode.MissingConfig);
       }
     });
 
     it('should throw an error if tfhePublicKeyDeserializer is not set', async () => {
-      // Should throw before .encrypt() is called
+      // Should throw before .execute() 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);
+        expect(error).toBeInstanceOf(CofheError);
+        expect((error as CofheError).code).toBe(CofheErrorCode.MissingTfhePublicKeyDeserializer);
       }
     });
 
     it('should throw an error if compactPkeCrsDeserializer is not set', async () => {
-      // Should throw before .encrypt() is called
+      // Should throw before .execute() 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);
+        expect(error).toBeInstanceOf(CofheError);
+        expect((error as CofheError).code).toBe(CofheErrorCode.MissingCompactPkeCrsDeserializer);
       }
     });
 
@@ -321,10 +321,10 @@ describe('EncryptInputsBuilder', () => {
         await new EncryptInputsBuilder({
           ...createDefaultParams(),
           initTfhe: vi.fn().mockRejectedValue(new Error('Failed to initialize TFHE')),
-        }).encrypt();
+        }).execute();
       } catch (error) {
-        expect(error).toBeInstanceOf(CofhesdkError);
-        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.InitTfheFailed);
+        expect(error).toBeInstanceOf(CofheError);
+        expect((error as CofheError).code).toBe(CofheErrorCode.InitTfheFailed);
       }
     });
 
@@ -332,7 +332,7 @@ describe('EncryptInputsBuilder', () => {
       const result = await new EncryptInputsBuilder({
         ...createDefaultParams(),
         initTfhe: mockInitTfhe,
-      }).encrypt();
+      }).execute();
       expect(result).toBeDefined();
     });
   });
@@ -354,7 +354,7 @@ describe('EncryptInputsBuilder', () => {
       const result = builder
         .setAccount(sender)
         .setSecurityZone(securityZone)
-        .setStepCallback(() => {});
+        .onStep(() => {});
 
       expect(result).toBe(builder);
       expect(result.getAccount()).toBe(sender);
@@ -366,10 +366,10 @@ describe('EncryptInputsBuilder', () => {
         await new EncryptInputsBuilder({
           ...createDefaultParams(),
           account: undefined,
-        }).encrypt();
+        }).execute();
       } catch (error) {
-        expect(error).toBeInstanceOf(CofhesdkError);
-        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.AccountUninitialized);
+        expect(error).toBeInstanceOf(CofheError);
+        expect((error as CofheError).code).toBe(CofheErrorCode.AccountUninitialized);
       }
     });
   });
@@ -389,7 +389,7 @@ describe('EncryptInputsBuilder', () => {
       const result = builder
         .setSecurityZone(securityZone)
         .setAccount(sender)
-        .setStepCallback(() => {});
+        .onStep(() => {});
 
       expect(result).toBe(builder);
       expect(result.getAccount()).toBe(sender);
@@ -410,10 +410,10 @@ describe('EncryptInputsBuilder', () => {
         await new EncryptInputsBuilder({
           ...createDefaultParams(),
           chainId: undefined,
-        }).encrypt();
+        }).execute();
       } catch (error) {
-        expect(error).toBeInstanceOf(CofhesdkError);
-        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.ChainIdUninitialized);
+        expect(error).toBeInstanceOf(CofheError);
+        expect((error as CofheError).code).toBe(CofheErrorCode.ChainIdUninitialized);
       }
     });
   });
@@ -426,25 +426,25 @@ describe('EncryptInputsBuilder', () => {
           inputs: [Encryptable.uint128(100n)] as [EncryptableUint128],
           account: '0x1234567890123456789012345678901234567890',
           chainId: 1,
-          config: createMockCofhesdkConfig(defaultChainId, undefined as unknown as string),
-        }).encrypt();
+          config: createMockCofheConfig(defaultChainId, undefined as unknown as string),
+        }).execute();
       } catch (error) {
-        expect(error).toBeInstanceOf(CofhesdkError);
-        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.ZkVerifierUrlUninitialized);
+        expect(error).toBeInstanceOf(CofheError);
+        expect((error as CofheError).code).toBe(CofheErrorCode.ZkVerifierUrlUninitialized);
       }
     });
   });
 
-  describe('setStepCallback', () => {
+  describe('onStep', () => {
     it('should set step callback and return builder for chaining', () => {
       const callback = vi.fn();
-      const result = builder.setStepCallback(callback);
+      const result = builder.onStep(callback);
       expect(result).toBe(builder);
     });
 
     it('should allow chaining with other methods', () => {
       const callback = vi.fn();
-      const result = builder.setStepCallback(callback).setSecurityZone(15);
+      const result = builder.onStep(callback).setSecurityZone(15);
 
       expect(result).toBe(builder);
     });
@@ -453,9 +453,9 @@ describe('EncryptInputsBuilder', () => {
   describe('encrypt', () => {
     it('should execute the full encryption flow with step callbacks', async () => {
       const stepCallback = vi.fn();
-      builder.setStepCallback(stepCallback);
+      builder.onStep(stepCallback);
 
-      const result = await builder.encrypt();
+      const result = await builder.execute();
 
       // Verify step callbacks were called in order
       expect(stepCallback).toHaveBeenCalledTimes(10);
@@ -568,7 +568,7 @@ describe('EncryptInputsBuilder', () => {
       const overriddenSender = '0x5555555555555555555555555555555555555555';
       builder.setAccount(overriddenSender);
 
-      const result = await builder.encrypt();
+      const result = await builder.execute();
 
       // Verify result embedded metadata
       const [encrypted] = result;
@@ -585,7 +585,7 @@ describe('EncryptInputsBuilder', () => {
 
       insertMockKeys(defaultChainId, overriddenZone);
 
-      const result = await builder.encrypt();
+      const result = await builder.execute();
 
       // Verify result embedded metadata
       const [encrypted] = result;
@@ -598,7 +598,7 @@ describe('EncryptInputsBuilder', () => {
 
     it('should work without step callback', async () => {
       // No step callback set
-      const result = await builder.encrypt();
+      const result = await builder.execute();
 
       expect(result).toBeDefined();
       expect(Array.isArray(result)).toBe(true);
@@ -614,7 +614,7 @@ describe('EncryptInputsBuilder', () => {
         ],
       });
 
-      const result = await multiInputBuilder.encrypt();
+      const result = await multiInputBuilder.execute();
 
       expect(result).toBeDefined();
       expect(Array.isArray(result)).toBe(true);
@@ -646,10 +646,10 @@ describe('EncryptInputsBuilder', () => {
             Encryptable.uint128(100n),
             Encryptable.uint128(100n),
           ],
-        }).encrypt();
+        }).execute();
       } catch (error) {
-        expect(error).toBeInstanceOf(CofhesdkError);
-        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.ZkPackFailed);
+        expect(error).toBeInstanceOf(CofheError);
+        expect((error as CofheError).code).toBe(CofheErrorCode.ZkPackFailed);
       }
     });
 
@@ -665,8 +665,8 @@ describe('EncryptInputsBuilder', () => {
           ] as unknown as [EncryptableItem],
         });
       } catch (error) {
-        expect(error).toBeInstanceOf(CofhesdkError);
-        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.ZkPackFailed);
+        expect(error).toBeInstanceOf(CofheError);
+        expect((error as CofheError).code).toBe(CofheErrorCode.ZkPackFailed);
       }
     });
   });
@@ -674,18 +674,18 @@ describe('EncryptInputsBuilder', () => {
   // TODO: Implement error handling tests
   // describe('error handling', () => {
   //   it('should handle ZK pack errors gracefully', async () => {
-  //     const result = await builder.encrypt();
-  //     expectResultError(result, CofhesdkErrorCode.InternalError, 'ZK pack failed');
+  //     const result = await builder.execute();
+  //     expectResultError(result, CofheErrorCode.InternalError, 'ZK pack failed');
   //   });
 
   //   it('should handle ZK prove errors gracefully', async () => {
-  //     const result = await builder.encrypt();
-  //     expectResultError(result, CofhesdkErrorCode.InternalError, 'ZK prove failed');
+  //     const result = await builder.execute();
+  //     expectResultError(result, CofheErrorCode.InternalError, 'ZK prove failed');
   //   });
 
   //   it('should handle ZK verify errors gracefully', async () => {
-  //     const result = await builder.encrypt();
-  //     expectResultError(result, CofhesdkErrorCode.InternalError, 'ZK verify failed');
+  //     const result = await builder.execute();
+  //     expectResultError(result, CofheErrorCode.InternalError, 'ZK verify failed');
   //   });
   // });
 
@@ -697,11 +697,7 @@ describe('EncryptInputsBuilder', () => {
       insertMockKeys(defaultChainId, securityZone);
 
       const stepCallback = vi.fn();
-      const result = await builder
-        .setAccount(sender)
-        .setSecurityZone(securityZone)
-        .setStepCallback(stepCallback)
-        .encrypt();
+      const result = await builder.setAccount(sender).setSecurityZone(securityZone).onStep(stepCallback).execute();
 
       expect(result).toBeDefined();
       expect(stepCallback).toHaveBeenCalledTimes(10);
@@ -725,8 +721,8 @@ describe('EncryptInputsBuilder', () => {
       builder.setSecurityZone(securityZone);
 
       // Call encrypt multiple times to ensure state is maintained
-      const result1 = await builder.encrypt();
-      const result2 = await builder.encrypt();
+      const result1 = await builder.execute();
+      const result2 = await builder.execute();
 
       expect(result1).toBeDefined();
       expect(result2).toBeDefined();

package/core/encrypt/encryptInputsBuilder.ts

@@ -7,7 +7,7 @@ import {
   zkVerify,
   constructZkPoKMetadata,
 } from './zkPackProveVerify.js';
-import { CofhesdkError, CofhesdkErrorCode } from '../error.js';
+import { CofheError, CofheErrorCode } from '../error.js';
 import {
   type EncryptStepCallbackFunction,
   EncryptStep,
@@ -90,8 +90,8 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
 
     // Check that tfhePublicKeyDeserializer is provided
     if (!params.tfhePublicKeyDeserializer) {
-      throw new CofhesdkError({
-        code: CofhesdkErrorCode.MissingTfhePublicKeyDeserializer,
+      throw new CofheError({
+        code: CofheErrorCode.MissingTfhePublicKeyDeserializer,
         message: 'EncryptInputsBuilder tfhePublicKeyDeserializer is undefined',
         hint: 'Ensure client has been created with a tfhePublicKeyDeserializer.',
         context: {
@@ -103,8 +103,8 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
 
     // Check that compactPkeCrsDeserializer is provided
     if (!params.compactPkeCrsDeserializer) {
-      throw new CofhesdkError({
-        code: CofhesdkErrorCode.MissingCompactPkeCrsDeserializer,
+      throw new CofheError({
+        code: CofheErrorCode.MissingCompactPkeCrsDeserializer,
         message: 'EncryptInputsBuilder compactPkeCrsDeserializer is undefined',
         hint: 'Ensure client has been created with a compactPkeCrsDeserializer.',
         context: {
@@ -116,8 +116,8 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
 
     // Check that zkBuilderAndCrsGenerator is provided
     if (!params.zkBuilderAndCrsGenerator) {
-      throw new CofhesdkError({
-        code: CofhesdkErrorCode.MissingZkBuilderAndCrsGenerator,
+      throw new CofheError({
+        code: CofheErrorCode.MissingZkBuilderAndCrsGenerator,
         message: 'EncryptInputsBuilder zkBuilderAndCrsGenerator is undefined',
         hint: 'Ensure client has been created with a zkBuilderAndCrsGenerator.',
         context: {
@@ -149,7 +149,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    * ```typescript
    * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
    *   .setAccount("0x123")
-   *   .encrypt();
+   *   .execute();
    * ```
    *
    * @returns The chainable EncryptInputsBuilder instance.
@@ -172,7 +172,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    * ```typescript
    * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
    *   .setChainId(11155111)
-   *   .encrypt();
+   *   .execute();
    * ```
    *
    * @returns The chainable EncryptInputsBuilder instance.
@@ -195,7 +195,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    * ```typescript
    * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
    *   .setSecurityZone(1)
-   *   .encrypt();
+   *   .execute();
    * ```
    *
    * @returns The chainable EncryptInputsBuilder instance.
@@ -218,7 +218,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    * ```typescript
    * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
    *   .setUseWorker(false)
-   *   .encrypt();
+   *   .execute();
    * ```
    *
    * @returns The chainable EncryptInputsBuilder instance.
@@ -254,13 +254,13 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    * Example:
    * ```typescript
    * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
-   *   .setStepCallback((step: EncryptStep) => console.log(step))
-   *   .encrypt();
+   *   .onStep((step: EncryptStep) => console.log(step))
+   *   .execute();
    * ```
    *
    * @returns The EncryptInputsBuilder instance.
    */
-  setStepCallback(callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T> {
+  onStep(callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T> {
     this.stepCallback = callback;
     return this;
   }
@@ -290,7 +290,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
   }
 
   /**
-   * zkVerifierUrl is included in the chains exported from cofhesdk/chains for use in CofhesdkConfig.supportedChains
+   * zkVerifierUrl is included in the chains exported from @cofhe/sdk/chains for use in CofheConfig.supportedChains
    * Users should generally not set this manually.
    */
   private async getZkVerifierUrl(): Promise<string> {
@@ -299,7 +299,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
   }
 
   /**
-   * initTfhe is a platform-specific dependency injected into core/createCofhesdkClientBase by web/createCofhesdkClient and node/createCofhesdkClient
+   * initTfhe is a platform-specific dependency injected into core/createCofheClientBase by web/createCofheClient and node/createCofheClient
    * web/ uses zama "tfhe"
    * node/ uses zama "node-tfhe"
    * Users should not set this manually.
@@ -310,8 +310,8 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     try {
       return await this.initTfhe();
     } catch (error) {
-      throw CofhesdkError.fromError(error, {
-        code: CofhesdkErrorCode.InitTfheFailed,
+      throw CofheError.fromError(error, {
+        code: CofheErrorCode.InitTfheFailed,
         message: `Failed to initialize TFHE`,
         context: {
           initTfhe: this.initTfhe,
@@ -336,8 +336,8 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     try {
       await this.keysStorage?.rehydrateKeysStore();
     } catch (error) {
-      throw CofhesdkError.fromError(error, {
-        code: CofhesdkErrorCode.RehydrateKeysStoreFailed,
+      throw CofheError.fromError(error, {
+        code: CofheErrorCode.RehydrateKeysStoreFailed,
         message: `Failed to rehydrate keys store`,
         context: {
           keysStorage: this.keysStorage,
@@ -360,8 +360,8 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
         this.keysStorage
       );
     } catch (error) {
-      throw CofhesdkError.fromError(error, {
-        code: CofhesdkErrorCode.FetchKeysFailed,
+      throw CofheError.fromError(error, {
+        code: CofheErrorCode.FetchKeysFailed,
         message: `Failed to fetch FHE key and CRS`,
         context: {
           config: this.config,
@@ -374,8 +374,8 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     }
 
     if (!fheKey) {
-      throw new CofhesdkError({
-        code: CofhesdkErrorCode.MissingFheKey,
+      throw new CofheError({
+        code: CofheErrorCode.MissingFheKey,
         message: `FHE key not found`,
         context: {
           chainId: this.chainId,
@@ -385,8 +385,8 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     }
 
     if (!crs) {
-      throw new CofhesdkError({
-        code: CofhesdkErrorCode.MissingCrs,
+      throw new CofheError({
+        code: CofheErrorCode.MissingCrs,
         message: `CRS not found for chainId <${this.chainId}>`,
         context: {
           chainId: this.chainId,
@@ -397,6 +397,18 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     return { fheKey, fheKeyFetchedFromCoFHE, crs, crsFetchedFromCoFHE };
   }
 
+  /**
+   * Resolves the encryptDelay config into an array of 5 per-step delays.
+   * A single number is broadcast to all steps; a tuple is used as-is.
+   */
+  private resolveEncryptDelays(): [number, number, number, number, number] {
+    const encryptDelay = this.config?.mocks?.encryptDelay ?? [100, 100, 100, 500, 500];
+    if (typeof encryptDelay === 'number') {
+      return [encryptDelay, encryptDelay, encryptDelay, encryptDelay, encryptDelay];
+    }
+    return encryptDelay;
+  }
+
   /**
    * @dev Encrypt against the cofheMocks instead of CoFHE
    *
@@ -404,30 +416,41 @@ 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(): Promise<[...EncryptedItemInputs<T>]> {
+  private async mocksExecute(): Promise<[...EncryptedItemInputs<T>]> {
     this.assertAccount();
     this.assertPublicClient();
     this.assertWalletClient();
 
+    const [initTfheDelay, fetchKeysDelay, packDelay, proveDelay, verifyDelay] = this.resolveEncryptDelays();
+
     this.fireStepStart(EncryptStep.InitTfhe);
-    await sleep(100);
-    this.fireStepEnd(EncryptStep.InitTfhe, { tfheInitializationExecuted: false });
+    await sleep(initTfheDelay);
+    this.fireStepEnd(EncryptStep.InitTfhe, {
+      tfheInitializationExecuted: false,
+      isMocks: true,
+      mockSleep: initTfheDelay,
+    });
 
     this.fireStepStart(EncryptStep.FetchKeys);
-    await sleep(100);
-    this.fireStepEnd(EncryptStep.FetchKeys, { fheKeyFetchedFromCoFHE: false, crsFetchedFromCoFHE: false });
+    await sleep(fetchKeysDelay);
+    this.fireStepEnd(EncryptStep.FetchKeys, {
+      fheKeyFetchedFromCoFHE: false,
+      crsFetchedFromCoFHE: false,
+      isMocks: true,
+      mockSleep: fetchKeysDelay,
+    });
 
     this.fireStepStart(EncryptStep.Pack);
     await cofheMocksCheckEncryptableBits(this.inputItems);
-    await sleep(100);
-    this.fireStepEnd(EncryptStep.Pack);
+    await sleep(packDelay);
+    this.fireStepEnd(EncryptStep.Pack, { isMocks: true, mockSleep: packDelay });
 
     this.fireStepStart(EncryptStep.Prove);
-    await sleep(500);
-    this.fireStepEnd(EncryptStep.Prove);
+    await sleep(proveDelay);
+    this.fireStepEnd(EncryptStep.Prove, { isMocks: true, mockSleep: proveDelay });
 
     this.fireStepStart(EncryptStep.Verify);
-    await sleep(500);
+    await sleep(verifyDelay);
     const signedResults = await cofheMocksZkVerifySign(
       this.inputItems,
       this.account,
@@ -442,7 +465,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
       utype: this.inputItems[index].utype,
       signature,
     }));
-    this.fireStepEnd(EncryptStep.Verify);
+    this.fireStepEnd(EncryptStep.Verify, { isMocks: true, mockSleep: verifyDelay });
 
     return encryptedInputs as [...EncryptedItemInputs<T>];
   }
@@ -450,7 +473,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
   /**
    * In the production context, perform a true encryption with the CoFHE coprocessor.
    */
-  private async productionEncrypt(): Promise<[...EncryptedItemInputs<T>]> {
+  private async productionExecute(): Promise<[...EncryptedItemInputs<T>]> {
     this.assertAccount();
     this.assertChainId();
 
@@ -545,16 +568,16 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
    *   .setAccount('0x123...890') // optional
    *   .setChainId(11155111)      // optional
-   *   .encrypt();                // execute
+   *   .execute();                // execute
    * ```
    *
    * @returns The encrypted inputs.
    */
-  async encrypt(): Promise<[...EncryptedItemInputs<T>]> {
+  async execute(): Promise<[...EncryptedItemInputs<T>]> {
     // On hardhat chain, interact with MockZkVerifier contract instead of CoFHE
-    if (this.chainId === hardhat.id) return this.mocksEncrypt();
+    if (this.chainId === hardhat.id) return this.mocksExecute();
 
     // On other chains, interact with CoFHE coprocessor
-    return this.productionEncrypt();
+    return this.productionExecute();
   }
 }

package/core/encrypt/zkPackProveVerify.ts

@@ -1,4 +1,4 @@
-import { CofhesdkError, CofhesdkErrorCode } from '../error.js';
+import { CofheError, CofheErrorCode } from '../error.js';
 import { type EncryptableItem, FheTypes } from '../types.js';
 import { toBigIntOrThrow, validateBigIntInRange, toHexString, hexToBytes } from '../utils.js';
 
@@ -162,8 +162,8 @@ export const zkPack = (items: EncryptableItem[], builder: ZkCiphertextListBuilde
         break;
       }
       default: {
-        throw new CofhesdkError({
-          code: CofhesdkErrorCode.ZkPackFailed,
+        throw new CofheError({
+          code: CofheErrorCode.ZkPackFailed,
           message: `Invalid utype: ${(item as any).utype}`,
           hint: `Ensure that the utype is valid, using the Encryptable type, for example: Encryptable.uint128(100n)`,
           context: {
@@ -175,8 +175,8 @@ export const zkPack = (items: EncryptableItem[], builder: ZkCiphertextListBuilde
   }
 
   if (totalBits > MAX_ENCRYPTABLE_BITS) {
-    throw new CofhesdkError({
-      code: CofhesdkErrorCode.ZkPackFailed,
+    throw new CofheError({
+      code: CofheErrorCode.ZkPackFailed,
       message: `Total bits ${totalBits} exceeds ${MAX_ENCRYPTABLE_BITS}`,
       hint: `Ensure that the total bits of the items to encrypt does not exceed ${MAX_ENCRYPTABLE_BITS}`,
       context: {
@@ -300,8 +300,8 @@ export const zkVerify = async (
     if (!response.ok) {
       // Get the response body as text for better error details
       const errorBody = await response.text();
-      throw new CofhesdkError({
-        code: CofhesdkErrorCode.ZkVerifyFailed,
+      throw new CofheError({
+        code: CofheErrorCode.ZkVerifyFailed,
         message: `HTTP error! ZK proof verification failed - ${errorBody}`,
       });
     }
@@ -309,8 +309,8 @@ export const zkVerify = async (
     const json = (await response.json()) as { status: string; data: VerifyResultRaw[]; error: string };
 
     if (json.status !== 'success') {
-      throw new CofhesdkError({
-        code: CofhesdkErrorCode.ZkVerifyFailed,
+      throw new CofheError({
+        code: CofheErrorCode.ZkVerifyFailed,
         message: `ZK proof verification response malformed - ${json.error}`,
       });
     }
@@ -322,8 +322,8 @@ export const zkVerify = async (
       };
     });
   } catch (e) {
-    throw new CofhesdkError({
-      code: CofhesdkErrorCode.ZkVerifyFailed,
+    throw new CofheError({
+      code: CofheErrorCode.ZkVerifyFailed,
       message: `ZK proof verification failed`,
       cause: e instanceof Error ? e : undefined,
     });