@cofhe/sdk 0.5.2 → 0.6.1

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-NOC3PYB7.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) => {
@@ -1701,7 +1730,7 @@ var getOrCreateSelfPermit = async (publicClient, walletClient, chainId, account,
   const _chainId = chainId ?? await publicClient.getChainId();
   const _account = account ?? walletClient.account.address;
   const activePermit = await getActivePermit(_chainId, _account);
-  if (activePermit && activePermit.type === "self") {
+  if (activePermit && activePermit.type === "self" && PermitUtils.isValid(activePermit).valid) {
     return activePermit;
   }
   return createSelf(options ?? { issuer: _account, name: "Autogenerated Self Permit" }, publicClient, walletClient);
@@ -1710,7 +1739,7 @@ var getOrCreateSharingPermit = async (publicClient, walletClient, options, chain
   const _chainId = chainId ?? await publicClient.getChainId();
   const _account = account ?? walletClient.account.address;
   const activePermit = await getActivePermit(_chainId, _account);
-  if (activePermit && activePermit.type === "sharing") {
+  if (activePermit && activePermit.type === "sharing" && PermitUtils.isValid(activePermit).valid) {
     return activePermit;
   }
   return createSharing(options, publicClient, walletClient);
@@ -1969,6 +1998,36 @@ async function cofheMocksDecryptForView(ctHash, utype, permit, publicClient) {
   return unsealed;
 }
 
+// core/debug.ts
+var interceptors = {};
+function setCofheDebugInterceptors(next) {
+  interceptors.onRequest = next?.onRequest;
+  interceptors.onResponse = next?.onResponse;
+}
+function getCofheDebugInterceptors() {
+  return interceptors;
+}
+async function cofheFetch(url, init, ctx = { op: "request" }) {
+  let finalUrl = url;
+  let finalInit = init;
+  if (interceptors.onRequest) {
+    const override = await interceptors.onRequest(finalUrl, finalInit, ctx);
+    if (override) {
+      if (override.url !== void 0)
+        finalUrl = override.url;
+      if (override.init !== void 0)
+        finalInit = override.init;
+    }
+  }
+  let response = await fetch(finalUrl, finalInit);
+  if (interceptors.onResponse) {
+    const replaced = await interceptors.onResponse(response, ctx);
+    if (replaced)
+      response = replaced;
+  }
+  return response;
+}
+
 // core/decrypt/polling.ts
 function computeMinuteRampPollIntervalMs(elapsedMs, params) {
   const elapsedSeconds = Math.floor(elapsedMs / 1e3);
@@ -2138,13 +2197,17 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, per
   for (; ; ) {
     let response;
     try {
-      response = await fetch(`${thresholdNetworkUrl}/v2/sealoutput`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body)
-      });
+      response = await cofheFetch(
+        `${thresholdNetworkUrl}/v2/sealoutput`,
+        /*op:sealoutput*/
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(body)
+        }
+      );
     } catch (e) {
       throw new CofheError({
         code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
@@ -2267,12 +2330,16 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId, overallStart
     }
     let response;
     try {
-      response = await fetch(`${thresholdNetworkUrl}/v2/sealoutput/${requestId}`, {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json"
+      response = await cofheFetch(
+        `${thresholdNetworkUrl}/v2/sealoutput/${requestId}`,
+        /*op:sealoutput-poll*/
+        {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          }
         }
-      });
+      );
     } catch (e) {
       throw new CofheError({
         code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
@@ -2869,13 +2936,17 @@ async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, perm
   for (; ; ) {
     let response;
     try {
-      response = await fetch(`${thresholdNetworkUrl}/v2/decrypt`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body)
-      });
+      response = await cofheFetch(
+        `${thresholdNetworkUrl}/v2/decrypt`,
+        /*op:decrypt*/
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(body)
+        }
+      );
     } catch (e) {
       throw new CofheError({
         code: "DECRYPT_FAILED" /* DecryptFailed */,
@@ -3000,12 +3071,16 @@ async function pollDecryptStatusV2(thresholdNetworkUrl, requestId, overallStartT
     }
     let response;
     try {
-      response = await fetch(`${thresholdNetworkUrl}/v2/decrypt/${requestId}`, {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json"
+      response = await cofheFetch(
+        `${thresholdNetworkUrl}/v2/decrypt/${requestId}`,
+        /*op:decrypt-poll*/
+        {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          }
         }
-      });
+      );
     } catch (e) {
       throw new CofheError({
         code: "DECRYPT_FAILED" /* DecryptFailed */,
@@ -3604,4 +3679,4 @@ function createCofheClientBase(opts) {
   };
 }
 
-export { CofheError, CofheErrorCode, DecryptForTxBuilder, DecryptForViewBuilder, EncryptInputsBuilder, EncryptStep, Encryptable, FheAllUTypes, FheTypes, FheUintUTypes, InitialConnectStore, assertCorrectEncryptedItemInput, createCofheClientBase, createCofheConfigBase, createKeysStore, fetchKeys, fheTypeToString, getCofheConfigItem, isCofheError, isEncryptableItem, isLastEncryptionStep, verifyDecryptResult, zkProveWithWorker };
+export { CofheError, CofheErrorCode, DecryptForTxBuilder, DecryptForViewBuilder, EncryptInputsBuilder, EncryptStep, Encryptable, FheAllUTypes, FheTypes, FheUintUTypes, InitialConnectStore, assertCorrectEncryptedItemInput, cofheFetch, createCofheClientBase, createCofheConfigBase, createKeysStore, fetchKeys, fheTypeToString, getCofheConfigItem, getCofheDebugInterceptors, isCofheError, isEncryptableItem, isLastEncryptionStep, setCofheDebugInterceptors, verifyDecryptResult, zkProveWithWorker };

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';

package/dist/{clientTypes-BJbFeeno.d.cts → clientTypes-BDy1qIBu.d.cts}

@@ -59,13 +59,13 @@ type EncryptedNumber = {
     data: Uint8Array;
     securityZone: number;
 };
-type EncryptedItemInput<TSignature = string> = {
+type EncryptedItemInput = {
     ctHash: bigint;
     securityZone: number;
     utype: FheTypes;
-    signature: TSignature;
+    signature: `0x${string}`;
 };
-declare function assertCorrectEncryptedItemInput(input: EncryptedItemInput): asserts input is EncryptedItemInput<`0x${string}`>;
+declare function assertCorrectEncryptedItemInput(input: EncryptedItemInput): asserts input is EncryptedItemInput;
 type EncryptedBoolInput = EncryptedItemInput & {
     utype: FheTypes.Bool;
 };
@@ -165,6 +165,55 @@ type EncryptStepCallbackContext = Record<string, any> & {
     duration: number;
 };
 type EncryptStepCallbackFunction = (state: EncryptStep, context?: EncryptStepCallbackContext) => void;
+/**
+ * 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.
+ */
+type ExternalBoolHash = `0x${string}` & {
+    readonly utype: FheTypes.Bool;
+};
+type ExternalUint8Hash = `0x${string}` & {
+    readonly utype: FheTypes.Uint8;
+};
+type ExternalUint16Hash = `0x${string}` & {
+    readonly utype: FheTypes.Uint16;
+};
+type ExternalUint32Hash = `0x${string}` & {
+    readonly utype: FheTypes.Uint32;
+};
+type ExternalUint64Hash = `0x${string}` & {
+    readonly utype: FheTypes.Uint64;
+};
+type ExternalUint128Hash = `0x${string}` & {
+    readonly utype: FheTypes.Uint128;
+};
+type ExternalAddressHash = `0x${string}` & {
+    readonly utype: FheTypes.Uint160;
+};
+/** Branded bytes proof blob (Solidity: bytes memory proof). */
+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. */
+type AnyExternalHash = ExternalBoolHash | ExternalUint8Hash | ExternalUint16Hash | ExternalUint32Hash | ExternalUint64Hash | ExternalUint128Hash | ExternalAddressHash;
+/**
+ * Maps a single EncryptableItem to its corresponding External*Hash type.
+ * Mirrors EncryptableToEncryptedItemInputMap.
+ */
+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]
+ */
+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]
+ */
+type HashPlusProofResult<T extends EncryptableItem[]> = [...ExternalItemHashes<T>, ExternalHashProof];
 type DecryptEndpoint = 'decrypt' | 'sealoutput';
 type DecryptPollCallbackContext = {
     operation: DecryptEndpoint;
@@ -702,10 +751,11 @@ type EncryptInputsBuilderParams<T extends EncryptableItem[]> = BaseBuilderParams
  * account, securityZone, and chainId can be overridden in the builder.
  * config, tfhePublicKeyDeserializer, compactPkeCrsDeserializer, and zkBuilderAndCrsGenerator are required to be set in the builder.
  */
-declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuilder {
+declare class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boolean = false> extends BaseBuilder {
     private securityZone;
     private stepCallback?;
     private inputItems;
+    private hpp;
     private zkvWalletClient;
     private tfhePublicKeyDeserializer;
     private compactPkeCrsDeserializer;
@@ -730,7 +780,7 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      *
      * @returns The chainable EncryptInputsBuilder instance.
      */
-    setAccount(account: string): EncryptInputsBuilder<T>;
+    setAccount(account: string): EncryptInputsBuilder<T, HPP>;
     getAccount(): string | undefined;
     /**
      * @param chainId - Chain that will consume the encrypted inputs.
@@ -746,7 +796,7 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      *
      * @returns The chainable EncryptInputsBuilder instance.
      */
-    setChainId(chainId: number): EncryptInputsBuilder<T>;
+    setChainId(chainId: number): EncryptInputsBuilder<T, HPP>;
     getChainId(): number | undefined;
     /**
      * @param securityZone - Security zone to encrypt the inputs for.
@@ -762,8 +812,19 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      *
      * @returns The chainable EncryptInputsBuilder instance.
      */
-    setSecurityZone(securityZone: number): EncryptInputsBuilder<T>;
+    setSecurityZone(securityZone: number): EncryptInputsBuilder<T, HPP>;
     getSecurityZone(): number;
+    /**
+     * 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>;
     /**
      * @param useWorker - Whether to use Web Workers for ZK proof generation.
      *
@@ -778,7 +839,7 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      *
      * @returns The chainable EncryptInputsBuilder instance.
      */
-    setUseWorker(useWorker: boolean): EncryptInputsBuilder<T>;
+    setUseWorker(useWorker: boolean): EncryptInputsBuilder<T, HPP>;
     /**
      * Gets the current worker configuration.
      *
@@ -808,7 +869,7 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      *
      * @returns The EncryptInputsBuilder instance.
      */
-    onStep(callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T>;
+    onStep(callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T, HPP>;
     getStepCallback(): EncryptStepCallbackFunction | undefined;
     /**
      * Fires the step callback if set
@@ -849,6 +910,7 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      * In the production context, perform a true encryption with the CoFHE coprocessor.
      */
     private productionExecute;
+    private structsToHashPlusProof;
     /**
      * Final step of the encryption process. MUST BE CALLED LAST IN THE CHAIN.
      *
@@ -868,7 +930,7 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      *
      * @returns The encrypted inputs.
      */
-    execute(): Promise<[...EncryptedItemInputs<T>]>;
+    execute(): Promise<HPP extends true ? HashPlusProofResult<T> : [...EncryptedItemInputs<T>]>;
 }
 
 declare const permits: {
@@ -1001,4 +1063,4 @@ type CofheClientParams<TConfig extends CofheConfig> = {
     zkProveWorkerFn?: ZkProveWorkerFunction;
 };
 
-export { DecryptForTxBuilder as $, type FheTypeValue as A, type DecryptPollCallbackContext as B, type CofheInputConfig as C, type DecryptPollCallbackFunction as D, type EncryptableItem as E, FheTypes as F, type DecryptEndpoint as G, type EncryptStepCallbackFunction as H, type IStorage as I, type EncryptStepCallbackContext as J, FheUintUTypes as K, type LiteralToPrimitive as L, FheAllUTypes as M, Encryptable as N, isEncryptableItem as O, type Primitive as P, EncryptStep as Q, isLastEncryptionStep as R, assertCorrectEncryptedItemInput as S, fetchKeys as T, type UnsealedItem as U, type FheKeyDeserializer as V, createKeysStore as W, type KeysStorage as X, type KeysStore as Y, EncryptInputsBuilder as Z, DecryptForViewBuilder as _, type CofheConfig as a, type DecryptForTxResult as a0, type ZkBuilderAndCrsGenerator as a1, type ZkProveWorkerFunction as a2, type ZkProveWorkerRequest as a3, type ZkProveWorkerResponse as a4, zkProveWithWorker as a5, type CofheClient as b, type CofheClientParams as c, type CofheClientConnectionState as d, createCofheConfigBase as e, type CofheInternalConfig as f, getCofheConfigItem as g, type CofheClientPermits as h, type EncryptableBool as i, type EncryptableUint8 as j, type EncryptableUint16 as k, type EncryptableUint32 as l, type EncryptableUint64 as m, type EncryptableUint128 as n, type EncryptableAddress as o, type EncryptedNumber as p, type EncryptedItemInput as q, type EncryptedBoolInput as r, type EncryptedUint8Input as s, type EncryptedUint16Input as t, type EncryptedUint32Input as u, type EncryptedUint64Input as v, type EncryptedUint128Input as w, type EncryptedAddressInput as x, type EncryptedItemInputs as y, type EncryptableToEncryptedItemInputMap as z };
+export { Encryptable as $, type FheTypeValue as A, type ExternalBoolHash as B, type CofheInputConfig as C, type ExternalUint8Hash as D, type EncryptableItem as E, FheTypes as F, type ExternalUint16Hash as G, type ExternalUint32Hash as H, type IStorage as I, type ExternalUint64Hash as J, type ExternalUint128Hash as K, type LiteralToPrimitive as L, type ExternalAddressHash as M, type ExternalHashProof as N, type AnyExternalHash as O, type Primitive as P, type EncryptableToExternalHashMap as Q, type ExternalItemHashes as R, type HashPlusProofResult as S, type DecryptPollCallbackFunction as T, type UnsealedItem as U, type DecryptPollCallbackContext as V, type DecryptEndpoint as W, type EncryptStepCallbackFunction as X, type EncryptStepCallbackContext as Y, FheUintUTypes as Z, FheAllUTypes as _, type CofheConfig as a, isEncryptableItem as a0, EncryptStep as a1, isLastEncryptionStep as a2, assertCorrectEncryptedItemInput as a3, fetchKeys as a4, type FheKeyDeserializer as a5, createKeysStore as a6, type KeysStorage as a7, type KeysStore as a8, EncryptInputsBuilder as a9, DecryptForViewBuilder as aa, DecryptForTxBuilder as ab, type DecryptForTxResult as ac, type ZkBuilderAndCrsGenerator as ad, type ZkProveWorkerFunction as ae, type ZkProveWorkerRequest as af, type ZkProveWorkerResponse as ag, zkProveWithWorker as ah, type CofheClient as b, type CofheClientParams as c, type CofheClientConnectionState as d, createCofheConfigBase as e, type CofheInternalConfig as f, getCofheConfigItem as g, type CofheClientPermits as h, type EncryptableBool as i, type EncryptableUint8 as j, type EncryptableUint16 as k, type EncryptableUint32 as l, type EncryptableUint64 as m, type EncryptableUint128 as n, type EncryptableAddress as o, type EncryptedNumber as p, type EncryptedItemInput as q, type EncryptedBoolInput as r, type EncryptedUint8Input as s, type EncryptedUint16Input as t, type EncryptedUint32Input as u, type EncryptedUint64Input as v, type EncryptedUint128Input as w, type EncryptedAddressInput as x, type EncryptedItemInputs as y, type EncryptableToEncryptedItemInputMap as z };