@cofhe/sdk 0.5.2 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @cofhe/sdk Changelog
 
+## 0.6.0
+
+### Minor Changes
+
+- 566f126: Remove the legacy `TestBed` mock surface and stop auto-deploying `SimpleTest` through the Hardhat plugins. Core mock contracts still deploy automatically, while tests that need `SimpleTest` should deploy it explicitly from their own artifacts.
+
+  This also removes `TEST_BED_ADDRESS` and cleans up duplicate `SimpleTest` exports from `@cofhe/mock-contracts`.
+
+### Patch Changes
+
+- bf23270: Upgrade `zustand` to 5.0.13 to pick up the upstream persist storage fix used by the SDK and React package.
+- 2711f9b: Add hash-plus-proof (HPP) support to `EncryptInputsBuilder`.
+
+  Calling `.asHashPlusProof()` on the builder transitions its type parameter to `HPP = true`, causing `.execute()` to return `HashPlusProofResult<T>` — a typed tuple of per-input `External*Hash` values followed by a single `ExternalHashProof`, matching the Solidity `externalEbool` / `externalEuint*` / `externalEaddress` type aliases.
+
+  New public types exported from `@cofhe/sdk`:
+
+  - `ExternalBoolHash`, `ExternalUint8Hash`, `ExternalUint16Hash`, `ExternalUint32Hash`, `ExternalUint64Hash`, `ExternalUint128Hash`, `ExternalAddressHash` — branded `0x${string}` types discriminated by `utype`
+  - `ExternalHashProof` — branded `0x${string}` proof blob
+  - `AnyExternalHash` — union of all `External*Hash` types
+  - `EncryptableToExternalHashMap<E>` — maps a single `EncryptableItem` to its `External*Hash`
+  - `ExternalItemHashes<T>` — maps an `EncryptableItem[]` tuple to the corresponding hash tuple
+  - `HashPlusProofResult<T>` — `[...ExternalItemHashes<T>, ExternalHashProof]`
+
 ## 0.5.2
 
 ### Patch Changes

package/chains/chains/hardhat.ts

@@ -8,8 +8,8 @@ export const hardhat = defineChain({
   name: 'Hardhat',
   network: 'localhost',
   // These are unused in the mock environment
-  coFheUrl: 'http://127.0.0.1:8448',
-  verifierUrl: 'http://127.0.0.1:3001',
-  thresholdNetworkUrl: 'http://127.0.0.1:3000',
+  coFheUrl: 'http://ignored-in-mock-environment',
+  verifierUrl: 'http://ignored-in-mock-environment',
+  thresholdNetworkUrl: 'http://ignored-in-mock-environment',
   environment: 'MOCK',
 });

package/core/consts.ts

@@ -7,9 +7,6 @@ export const MOCKS_ZK_VERIFIER_ADDRESS = '0x000000000000000000000000000000000000
 /** Mock Threshold Network contract address (used for testing) */
 export const MOCKS_THRESHOLD_NETWORK_ADDRESS = '0x0000000000000000000000000000000000005002' as const;
 
-/** Test Bed contract address (used for testing) */
-export const TEST_BED_ADDRESS = '0x0000000000000000000000000000000000005003' as const;
-
 /** Private key for the Mock ZK Verifier signer account */
 export const MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY =
   '0x6C8D7F768A6BB4AAFE85E8A2F5A9680355239C7E14646ED62B044E39DE154512' as const;

package/core/encrypt/cofheMocksZkVerifySign.ts

@@ -185,8 +185,8 @@ async function createProofSignatures(
   items: EncryptableItemWithCtHash[],
   securityZone: number,
   account: string
-): Promise<string[]> {
-  let signatures: string[] = [];
+): Promise<`0x${string}`[]> {
+  let signatures: `0x${string}`[] = [];
 
   // Create wallet client for the encrypted input signer
   // This wallet won't send a transaction, so gas isn't needed

package/core/encrypt/encryptInputsBuilder.ts

@@ -16,6 +16,7 @@ import {
   type EncryptedItemInputs,
   type TfheInitializer,
   type EncryptStepCallbackContext,
+  type HashPlusProofResult,
 } from '../types.js';
 import { cofheMocksCheckEncryptableBits, cofheMocksZkVerifySign } from './cofheMocksZkVerifySign.js';
 import { hardhat } from 'viem/chains';
@@ -47,10 +48,11 @@ type EncryptInputsBuilderParams<T extends EncryptableItem[]> = BaseBuilderParams
  * config, tfhePublicKeyDeserializer, compactPkeCrsDeserializer, and zkBuilderAndCrsGenerator are required to be set in the builder.
  */
 
-export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuilder {
+export class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boolean = false> extends BaseBuilder {
   private securityZone: number;
   private stepCallback?: EncryptStepCallbackFunction;
   private inputItems: [...T];
+  private hpp: boolean = false;
 
   private zkvWalletClient: WalletClient | undefined;
 
@@ -154,7 +156,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    *
    * @returns The chainable EncryptInputsBuilder instance.
    */
-  setAccount(account: string): EncryptInputsBuilder<T> {
+  setAccount(account: string): EncryptInputsBuilder<T, HPP> {
     this.account = account;
     return this;
   }
@@ -177,7 +179,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    *
    * @returns The chainable EncryptInputsBuilder instance.
    */
-  setChainId(chainId: number): EncryptInputsBuilder<T> {
+  setChainId(chainId: number): EncryptInputsBuilder<T, HPP> {
     this.chainId = chainId;
     return this;
   }
@@ -200,7 +202,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    *
    * @returns The chainable EncryptInputsBuilder instance.
    */
-  setSecurityZone(securityZone: number): EncryptInputsBuilder<T> {
+  setSecurityZone(securityZone: number): EncryptInputsBuilder<T, HPP> {
     this.securityZone = securityZone;
     return this;
   }
@@ -209,6 +211,21 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     return this.securityZone;
   }
 
+  /**
+   * Example:
+   * ```typescript
+   * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
+   *   .asHashPlusProof()
+   *   .execute();
+   * ```
+   *
+   * @returns Chainable EncryptInputsBuilder instance that will return a HashPlusProofResult instead of an array of EncryptedItemInputs.
+   */
+  asHashPlusProof(): EncryptInputsBuilder<T, true> {
+    this.hpp = true;
+    return this as unknown as EncryptInputsBuilder<T, true>;
+  }
+
   /**
    * @param useWorker - Whether to use Web Workers for ZK proof generation.
    *
@@ -223,7 +240,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    *
    * @returns The chainable EncryptInputsBuilder instance.
    */
-  setUseWorker(useWorker: boolean): EncryptInputsBuilder<T> {
+  setUseWorker(useWorker: boolean): EncryptInputsBuilder<T, HPP> {
     this.useWorker = useWorker;
     return this;
   }
@@ -260,7 +277,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    *
    * @returns The EncryptInputsBuilder instance.
    */
-  onStep(callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T> {
+  onStep(callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T, HPP> {
     this.stepCallback = callback;
     return this;
   }
@@ -541,7 +558,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     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) => ({
+      ({ ct_hash, signature }: { ct_hash: string; signature: `0x${string}` }, index: number) => ({
         ctHash: BigInt(ct_hash),
         securityZone: this.securityZone,
         utype: this.inputItems[index].utype,
@@ -554,6 +571,18 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     return encryptedInputs as [...EncryptedItemInputs<T>];
   }
 
+  private structsToHashPlusProof(inItems: [...EncryptedItemInputs<T>]): HashPlusProofResult<T> {
+    let hashes: string[] = [];
+    let proof: string = '';
+
+    for (const item of inItems) {
+      hashes.push('0x' + item.ctHash.toString(16).padStart(64, '0'));
+      proof += item.signature;
+    }
+
+    return [...hashes, proof] as unknown as HashPlusProofResult<T>;
+  }
+
   /**
    * Final step of the encryption process. MUST BE CALLED LAST IN THE CHAIN.
    *
@@ -573,11 +602,17 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    *
    * @returns The encrypted inputs.
    */
-  async execute(): Promise<[...EncryptedItemInputs<T>]> {
-    // On hardhat chain, interact with MockZkVerifier contract instead of CoFHE
-    if (this.chainId === hardhat.id) return this.mocksExecute();
+  async execute(): Promise<HPP extends true ? HashPlusProofResult<T> : [...EncryptedItemInputs<T>]> {
+    type Result = HPP extends true ? HashPlusProofResult<T> : [...EncryptedItemInputs<T>];
+
+    let items: [...EncryptedItemInputs<T>];
 
+    // On hardhat chain, interact with MockZkVerifier contract instead of CoFHE
+    if (this.chainId === hardhat.id) items = await this.mocksExecute();
     // On other chains, interact with CoFHE coprocessor
-    return this.productionExecute();
+    else items = await this.productionExecute();
+
+    if (this.hpp) return this.structsToHashPlusProof(items) as unknown as Result;
+    return items as unknown as Result;
   }
 }

package/core/encrypt/zkPackProveVerify.ts

@@ -49,7 +49,7 @@ export type VerifyResultRaw = {
 
 export type VerifyResult = {
   ct_hash: string;
-  signature: string;
+  signature: `0x${string}`;
 };
 
 export type ZkProvenCiphertextList = {
@@ -321,6 +321,6 @@ export const zkVerify = async (
   }
 };
 
-const concatSigRecid = (signature: string, recid: number): string => {
-  return signature + (recid + 27).toString(16).padStart(2, '0');
+const concatSigRecid = (signature: string, recid: number): `0x${string}` => {
+  return `${signature}${(recid + 27).toString(16).padStart(2, '0')}` as `0x${string}`;
 };

package/core/index.ts

@@ -41,6 +41,19 @@ export type {
   EncryptedItemInputs,
   EncryptableToEncryptedItemInputMap,
   FheTypeValue,
+  // Hash-plus-proof external types
+  ExternalBoolHash,
+  ExternalUint8Hash,
+  ExternalUint16Hash,
+  ExternalUint32Hash,
+  ExternalUint64Hash,
+  ExternalUint128Hash,
+  ExternalAddressHash,
+  ExternalHashProof,
+  AnyExternalHash,
+  EncryptableToExternalHashMap,
+  ExternalItemHashes,
+  HashPlusProofResult,
   // Decryption types
   UnsealedItem,
   DecryptPollCallbackFunction,
@@ -96,7 +109,6 @@ export {
   MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY,
   MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY,
   MOCKS_THRESHOLD_NETWORK_ADDRESS,
-  TEST_BED_ADDRESS,
   TFHE_RS_ZK_MAX_BITS,
   TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT,
 } from './consts.js';

package/core/test/encryptInputsBuilder.test.ts

@@ -744,6 +744,41 @@ describe('EncryptInputsBuilder', () => {
     });
   });
 
+  describe('asHashPlusProof', () => {
+    it('should return the same builder instance for chaining', () => {
+      expect(builder.asHashPlusProof()).toBe(builder);
+    });
+
+    it('execute() returns [hash, proof] for a single input', async () => {
+      const result = await builder.asHashPlusProof().execute();
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(2); // 1 hash + 1 proof
+    });
+
+    it('execute() returns [hash1, hash2, proof] for two inputs', async () => {
+      const result = await new EncryptInputsBuilder({
+        ...createDefaultParams(),
+        inputs: [Encryptable.uint128(100n), Encryptable.bool(true)] as [
+          ReturnType<typeof Encryptable.uint128>,
+          ReturnType<typeof Encryptable.bool>,
+        ],
+      })
+        .asHashPlusProof()
+        .execute();
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(3); // 2 hashes + 1 proof
+    });
+
+    it('should be composable with other builder methods', async () => {
+      const overriddenSender = '0x5555555555555555555555555555555555555555';
+      const result = await builder.asHashPlusProof().setAccount(overriddenSender).execute();
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(2);
+    });
+  });
+
   describe('setUseWorker and getUseWorker', () => {
     it('should have setUseWorker method', () => {
       expect(builder).toHaveProperty('setUseWorker');

package/core/types.ts

@@ -111,16 +111,14 @@ export type EncryptedNumber = {
   securityZone: number;
 };
 
-export type EncryptedItemInput<TSignature = string> = {
+export type EncryptedItemInput = {
   ctHash: bigint;
   securityZone: number;
   utype: FheTypes;
-  signature: TSignature;
+  signature: `0x${string}`;
 };
 
-export function assertCorrectEncryptedItemInput(
-  input: EncryptedItemInput
-): asserts input is EncryptedItemInput<`0x${string}`> {
+export function assertCorrectEncryptedItemInput(input: EncryptedItemInput): asserts input is EncryptedItemInput {
   if (!input.signature.startsWith('0x')) throw new Error('Signature must be a hex string starting with 0x');
 }
 
@@ -387,6 +385,68 @@ export type EncryptStepCallbackContext = Record<string, any> & {
 };
 export type EncryptStepCallbackFunction = (state: EncryptStep, context?: EncryptStepCallbackContext) => void;
 
+// HASH PLUS PROOF ENCRYPTED INPUTS
+
+/**
+ * Branded bytes32 types for external encrypted inputs (Solidity: externalEbool, externalEuint*, externalEaddress).
+ * The readonly `utype` field brands each hash so it can't be accidentally passed to the wrong asE* function.
+ */
+export type ExternalBoolHash = `0x${string}` & { readonly utype: FheTypes.Bool };
+export type ExternalUint8Hash = `0x${string}` & { readonly utype: FheTypes.Uint8 };
+export type ExternalUint16Hash = `0x${string}` & { readonly utype: FheTypes.Uint16 };
+export type ExternalUint32Hash = `0x${string}` & { readonly utype: FheTypes.Uint32 };
+export type ExternalUint64Hash = `0x${string}` & { readonly utype: FheTypes.Uint64 };
+export type ExternalUint128Hash = `0x${string}` & { readonly utype: FheTypes.Uint128 };
+export type ExternalAddressHash = `0x${string}` & { readonly utype: FheTypes.Uint160 };
+
+/** Branded bytes proof blob (Solidity: bytes memory proof). */
+export type ExternalHashProof = `0x${string}` & { readonly _kind: 'ExternalHashProof' };
+
+/** Union of all External*Hash types — useful for utilities that operate on any hash without caring about the specific FHE type. */
+export type AnyExternalHash =
+  | ExternalBoolHash
+  | ExternalUint8Hash
+  | ExternalUint16Hash
+  | ExternalUint32Hash
+  | ExternalUint64Hash
+  | ExternalUint128Hash
+  | ExternalAddressHash;
+
+/**
+ * Maps a single EncryptableItem to its corresponding External*Hash type.
+ * Mirrors EncryptableToEncryptedItemInputMap.
+ */
+export type EncryptableToExternalHashMap<E extends EncryptableItem> = E extends EncryptableBool
+  ? ExternalBoolHash
+  : E extends EncryptableUint8
+    ? ExternalUint8Hash
+    : E extends EncryptableUint16
+      ? ExternalUint16Hash
+      : E extends EncryptableUint32
+        ? ExternalUint32Hash
+        : E extends EncryptableUint64
+          ? ExternalUint64Hash
+          : E extends EncryptableUint128
+            ? ExternalUint128Hash
+            : E extends EncryptableAddress
+              ? ExternalAddressHash
+              : never;
+
+/**
+ * Maps an EncryptableItem[] tuple to a tuple of corresponding External*Hash types,
+ * preserving index positions. e.g. [EncryptableBool, EncryptableUint32] → [ExternalBoolHash, ExternalUint32Hash]
+ */
+export type ExternalItemHashes<T extends EncryptableItem[]> = {
+  [K in keyof T]: T[K] extends EncryptableItem ? EncryptableToExternalHashMap<T[K]> : never;
+};
+
+/**
+ * Return type of EncryptInputsBuilder.execute() when asHashPlusProof() is set.
+ * Tuple of per-input hashes in input order, followed by a single proof blob.
+ * e.g. [Encryptable.bool(true), Encryptable.uint32(5)] → [ExternalBoolHash, ExternalUint32Hash, ExternalHashProof]
+ */
+export type HashPlusProofResult<T extends EncryptableItem[]> = [...ExternalItemHashes<T>, ExternalHashProof];
+
 // DECRYPT
 
 export type DecryptEndpoint = 'decrypt' | 'sealoutput';

package/dist/chains.cjs

@@ -67,9 +67,9 @@ var hardhat = defineChain({
   name: "Hardhat",
   network: "localhost",
   // These are unused in the mock environment
-  coFheUrl: "http://127.0.0.1:8448",
-  verifierUrl: "http://127.0.0.1:3001",
-  thresholdNetworkUrl: "http://127.0.0.1:3000",
+  coFheUrl: "http://ignored-in-mock-environment",
+  verifierUrl: "http://ignored-in-mock-environment",
+  thresholdNetworkUrl: "http://ignored-in-mock-environment",
   environment: "MOCK"
 });
 

package/dist/chains.js

@@ -1 +1 @@
-export { arbSepolia, baseSepolia, chains, getChainById, getChainByName, hardhat, localcofhe, sepolia } from './chunk-TBLR7NNE.js';
+export { arbSepolia, baseSepolia, chains, getChainById, getChainByName, hardhat, localcofhe, sepolia } from './chunk-MTRAXQXC.js';

package/dist/{chunk-4FP4V35O.js → chunk-ESMZCFJY.js}

@@ -2,7 +2,6 @@
 var TASK_MANAGER_ADDRESS = "0xeA30c4B8b44078Bbf8a6ef5b9f1eC1626C7848D9";
 var MOCKS_ZK_VERIFIER_ADDRESS = "0x0000000000000000000000000000000000005001";
 var MOCKS_THRESHOLD_NETWORK_ADDRESS = "0x0000000000000000000000000000000000005002";
-var TEST_BED_ADDRESS = "0x0000000000000000000000000000000000005003";
 var MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY = "0x6C8D7F768A6BB4AAFE85E8A2F5A9680355239C7E14646ED62B044E39DE154512";
 var MOCKS_ZK_VERIFIER_SIGNER_ADDRESS = "0x6E12D8C87503D4287c294f2Fdef96ACd9DFf6bd2";
 var MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY = "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d";
@@ -10,4 +9,4 @@ var TFHE_RS_ZK_MAX_BITS = 2048;
 var TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT = BigInt(1 << 30);
 var TFHE_RS_KEY_VERSION = 2;
 
-export { MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, TASK_MANAGER_ADDRESS, TEST_BED_ADDRESS, TFHE_RS_KEY_VERSION, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, TFHE_RS_ZK_MAX_BITS };
+export { MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, TASK_MANAGER_ADDRESS, TFHE_RS_KEY_VERSION, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, TFHE_RS_ZK_MAX_BITS };

package/dist/{chunk-TBLR7NNE.js → chunk-MTRAXQXC.js}

@@ -65,9 +65,9 @@ var hardhat = defineChain({
   name: "Hardhat",
   network: "localhost",
   // These are unused in the mock environment
-  coFheUrl: "http://127.0.0.1:8448",
-  verifierUrl: "http://127.0.0.1:3001",
-  thresholdNetworkUrl: "http://127.0.0.1:3000",
+  coFheUrl: "http://ignored-in-mock-environment",
+  verifierUrl: "http://ignored-in-mock-environment",
+  thresholdNetworkUrl: "http://ignored-in-mock-environment",
   environment: "MOCK"
 });
 

package/dist/{chunk-YDOK4BDL.js → chunk-PE5V5CCV.js}

@@ -1,6 +1,6 @@
-import { hardhat as hardhat$1 } from './chunk-TBLR7NNE.js';
-import { permitStore, PermitUtils } from './chunk-MRCKUMOS.js';
-import { TFHE_RS_KEY_VERSION, TASK_MANAGER_ADDRESS, TFHE_RS_ZK_MAX_BITS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_ADDRESS } from './chunk-4FP4V35O.js';
+import { hardhat as hardhat$1 } from './chunk-MTRAXQXC.js';
+import { permitStore, PermitUtils } from './chunk-VB62WYPL.js';
+import { TFHE_RS_KEY_VERSION, TASK_MANAGER_ADDRESS, TFHE_RS_ZK_MAX_BITS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_ADDRESS } from './chunk-ESMZCFJY.js';
 import { createStore } from 'zustand/vanilla';
 import { parseAbi, isAddressEqual, zeroAddress, recoverAddress, encodePacked, keccak256, createWalletClient, http, getAddress, parseSignature, serializeSignature } from 'viem';
 import { hardhat } from 'viem/chains';
@@ -528,7 +528,7 @@ var zkVerify = async (verifierUrl, serializedBytes, address, securityZone, chain
   }
 };
 var concatSigRecid = (signature, recid) => {
-  return signature + (recid + 27).toString(16).padStart(2, "0");
+  return `${signature}${(recid + 27).toString(16).padStart(2, "0")}`;
 };
 
 // core/encrypt/MockZkVerifierAbi.ts
@@ -1215,6 +1215,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
   securityZone;
   stepCallback;
   inputItems;
+  hpp = false;
   zkvWalletClient;
   tfhePublicKeyDeserializer;
   compactPkeCrsDeserializer;
@@ -1344,6 +1345,20 @@ var EncryptInputsBuilder = class extends BaseBuilder {
   getSecurityZone() {
     return this.securityZone;
   }
+  /**
+   * Example:
+   * ```typescript
+   * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
+   *   .asHashPlusProof()
+   *   .execute();
+   * ```
+   *
+   * @returns Chainable EncryptInputsBuilder instance that will return a HashPlusProofResult instead of an array of EncryptedItemInputs.
+   */
+  asHashPlusProof() {
+    this.hpp = true;
+    return this;
+  }
   /**
    * @param useWorker - Whether to use Web Workers for ZK proof generation.
    *
@@ -1625,6 +1640,15 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     this.fireStepEnd("verify" /* Verify */);
     return encryptedInputs;
   }
+  structsToHashPlusProof(inItems) {
+    let hashes = [];
+    let proof = "";
+    for (const item of inItems) {
+      hashes.push("0x" + item.ctHash.toString(16).padStart(64, "0"));
+      proof += item.signature;
+    }
+    return [...hashes, proof];
+  }
   /**
    * Final step of the encryption process. MUST BE CALLED LAST IN THE CHAIN.
    *
@@ -1645,9 +1669,14 @@ var EncryptInputsBuilder = class extends BaseBuilder {
    * @returns The encrypted inputs.
    */
   async execute() {
+    let items;
     if (this.chainId === hardhat.id)
-      return this.mocksExecute();
-    return this.productionExecute();
+      items = await this.mocksExecute();
+    else
+      items = await this.productionExecute();
+    if (this.hpp)
+      return this.structsToHashPlusProof(items);
+    return items;
   }
 };
 var storeActivePermit = async (permit, publicClient, walletClient) => {

package/dist/{chunk-MRCKUMOS.js → chunk-VB62WYPL.js}

@@ -1,4 +1,4 @@
-import { TASK_MANAGER_ADDRESS } from './chunk-4FP4V35O.js';
+import { TASK_MANAGER_ADDRESS } from './chunk-ESMZCFJY.js';
 import { isAddress, getAddress, zeroAddress, isHex, keccak256, toHex, BaseError, ContractFunctionRevertedError, decodeErrorResult, parseAbi } from 'viem';
 import nacl from 'tweetnacl';
 import { z } from 'zod';