@cofhe/sdk 0.2.1 → 0.3.0

package/dist/node.cjs

@@ -35,7 +35,7 @@ var nacl__namespace = /*#__PURE__*/_interopNamespace(nacl);
 // core/client.ts
 
 // core/error.ts
-var CofhesdkError = class _CofhesdkError extends Error {
+var CofheError = class _CofheError extends Error {
   code;
   cause;
   hint;
@@ -43,25 +43,25 @@ var CofhesdkError = class _CofhesdkError extends Error {
   constructor({ code, message, cause, hint, context }) {
     const fullMessage = cause ? `${message} | Caused by: ${cause.message}` : message;
     super(fullMessage);
-    this.name = "CofhesdkError";
+    this.name = "CofheError";
     this.code = code;
     this.cause = cause;
     this.hint = hint;
     this.context = context;
     if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _CofhesdkError);
+      Error.captureStackTrace(this, _CofheError);
     }
   }
   /**
-   * Creates a CofhesdkError from an unknown error
-   * If the error is a CofhesdkError, it is returned unchanged, else a new CofhesdkError is created
-   * If a wrapperError is provided, it is used to create the new CofhesdkError, else a default is used
+   * Creates a CofheError from an unknown error
+   * If the error is a CofheError, it is returned unchanged, else a new CofheError is created
+   * If a wrapperError is provided, it is used to create the new CofheError, else a default is used
    */
   static fromError(error, wrapperError) {
-    if (isCofhesdkError(error))
+    if (isCofheError(error))
       return error;
     const cause = error instanceof Error ? error : new Error(`${error}`);
-    return new _CofhesdkError({
+    return new _CofheError({
       code: wrapperError?.code ?? "INTERNAL_ERROR" /* InternalError */,
       message: wrapperError?.message ?? "An internal error occurred",
       hint: wrapperError?.hint,
@@ -121,7 +121,7 @@ var bigintSafeJsonStringify = (value) => {
     return value2;
   });
 };
-var isCofhesdkError = (error) => error instanceof CofhesdkError;
+var isCofheError = (error) => error instanceof CofheError;
 
 // core/types.ts
 var FheUintUTypes = [
@@ -165,14 +165,14 @@ async function getPublicClientChainID(publicClient) {
   try {
     chainId = publicClient.chain?.id ?? await publicClient.getChainId();
   } catch (e) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "PUBLIC_WALLET_GET_CHAIN_ID_FAILED" /* PublicWalletGetChainIdFailed */,
       message: "getting chain ID from public client failed",
       cause: e instanceof Error ? e : void 0
     });
   }
   if (chainId === null) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "PUBLIC_WALLET_GET_CHAIN_ID_FAILED" /* PublicWalletGetChainIdFailed */,
       message: "chain ID from public client is null"
     });
@@ -187,14 +187,14 @@ async function getWalletClientAccount(walletClient) {
       address = (await walletClient.getAddresses())?.[0];
     }
   } catch (e) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "PUBLIC_WALLET_GET_ADDRESSES_FAILED" /* PublicWalletGetAddressesFailed */,
       message: "getting address from wallet client failed",
       cause: e instanceof Error ? e : void 0
     });
   }
   if (!address) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "PUBLIC_WALLET_GET_ADDRESSES_FAILED" /* PublicWalletGetAddressesFailed */,
       message: "address from wallet client is null"
     });
@@ -262,7 +262,7 @@ var zkPack = (items, builder) => {
         break;
       }
       default: {
-        throw new CofhesdkError({
+        throw new CofheError({
           code: "ZK_PACK_FAILED" /* ZkPackFailed */,
           message: `Invalid utype: ${item.utype}`,
           hint: `Ensure that the utype is valid, using the Encryptable type, for example: Encryptable.uint128(100n)`,
@@ -274,7 +274,7 @@ var zkPack = (items, builder) => {
     }
   }
   if (totalBits > MAX_ENCRYPTABLE_BITS) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "ZK_PACK_FAILED" /* 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}`,
@@ -338,14 +338,14 @@ var zkVerify = async (verifierUrl, serializedBytes, address, securityZone, chain
     });
     if (!response.ok) {
       const errorBody = await response.text();
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "ZK_VERIFY_FAILED" /* ZkVerifyFailed */,
         message: `HTTP error! ZK proof verification failed - ${errorBody}`
       });
     }
     const json = await response.json();
     if (json.status !== "success") {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "ZK_VERIFY_FAILED" /* ZkVerifyFailed */,
         message: `ZK proof verification response malformed - ${json.error}`
       });
@@ -357,7 +357,7 @@ var zkVerify = async (verifierUrl, serializedBytes, address, securityZone, chain
       };
     });
   } catch (e) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "ZK_VERIFY_FAILED" /* ZkVerifyFailed */,
       message: `ZK proof verification failed`,
       cause: e instanceof Error ? e : void 0
@@ -479,8 +479,9 @@ var MockZkVerifierAbi = [
 // core/consts.ts
 var TASK_MANAGER_ADDRESS = "0xeA30c4B8b44078Bbf8a6ef5b9f1eC1626C7848D9";
 var MOCKS_ZK_VERIFIER_ADDRESS = "0x0000000000000000000000000000000000005001";
-var MOCKS_QUERY_DECRYPTER_ADDRESS = "0x0000000000000000000000000000000000005002";
+var MOCKS_THRESHOLD_NETWORK_ADDRESS = "0x0000000000000000000000000000000000005002";
 var MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY = "0x6C8D7F768A6BB4AAFE85E8A2F5A9680355239C7E14646ED62B044E39DE154512";
+var MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY = "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d";
 
 // core/encrypt/cofheMocksZkVerifySign.ts
 function createMockZkVerifierSigner() {
@@ -525,7 +526,7 @@ async function cofheMocksCheckEncryptableBits(items) {
     }
   }
   if (totalBits > MAX_ENCRYPTABLE_BITS) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "ZK_PACK_FAILED" /* 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}`,
@@ -554,7 +555,7 @@ async function calcCtHashes(items, account, securityZone, publicClient) {
       args: calcCtHashesArgs
     });
   } catch (err) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "ZK_MOCKS_CALC_CT_HASHES_FAILED" /* ZkMocksCalcCtHashesFailed */,
       message: `mockZkVerifySign calcCtHashes failed while calling zkVerifyCalcCtHashesPacked`,
       cause: err instanceof Error ? err : void 0,
@@ -569,7 +570,7 @@ async function calcCtHashes(items, account, securityZone, publicClient) {
     });
   }
   if (ctHashes.length !== items.length) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "ZK_MOCKS_CALC_CT_HASHES_FAILED" /* ZkMocksCalcCtHashesFailed */,
       message: `mockZkVerifySign calcCtHashes returned incorrect number of ctHashes`,
       context: {
@@ -600,7 +601,7 @@ async function insertCtHashes(items, walletClient) {
       account
     });
   } catch (err) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "ZK_MOCKS_INSERT_CT_HASHES_FAILED" /* ZkMocksInsertCtHashesFailed */,
       message: `mockZkVerifySign insertPackedCtHashes failed while calling insertPackedCtHashes`,
       cause: err instanceof Error ? err : void 0,
@@ -618,7 +619,7 @@ async function createProofSignatures(items, securityZone) {
   try {
     encInputSignerClient = createMockZkVerifierSigner();
   } catch (err) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "ZK_MOCKS_CREATE_PROOF_SIGNATURE_FAILED" /* ZkMocksCreateProofSignatureFailed */,
       message: `mockZkVerifySign createProofSignatures failed while creating wallet client`,
       cause: err instanceof Error ? err : void 0,
@@ -639,7 +640,7 @@ async function createProofSignatures(items, securityZone) {
       signatures.push(signature);
     }
   } catch (err) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "ZK_MOCKS_CREATE_PROOF_SIGNATURE_FAILED" /* ZkMocksCreateProofSignatureFailed */,
       message: `mockZkVerifySign createProofSignatures failed while calling signMessage`,
       cause: err instanceof Error ? err : void 0,
@@ -650,7 +651,7 @@ async function createProofSignatures(items, securityZone) {
     });
   }
   if (signatures.length !== items.length) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "ZK_MOCKS_CREATE_PROOF_SIGNATURE_FAILED" /* ZkMocksCreateProofSignatureFailed */,
       message: `mockZkVerifySign createProofSignatures returned incorrect number of signatures`,
       context: {
@@ -707,13 +708,11 @@ var hardhat2 = defineChain({
   thresholdNetworkUrl: "http://127.0.0.1:3000",
   environment: "MOCK"
 });
-var CofhesdkConfigSchema = zod.z.object({
+var CofheConfigSchema = zod.z.object({
   /** Environment that the SDK is running in */
   environment: zod.z.enum(["node", "hardhat", "web", "react"]).optional().default("node"),
   /** List of supported chain configurations */
   supportedChains: zod.z.array(zod.z.custom()),
-  /** How permits are generated */
-  permitGeneration: zod.z.enum(["ON_CONNECT", "ON_DECRYPT_HANDLES", "MANUAL"]).optional().default("ON_CONNECT"),
   /** Default permit expiration in seconds, default is 30 days */
   defaultPermitExpiration: zod.z.number().optional().default(60 * 60 * 24 * 30),
   /** Storage method for fhe keys (defaults to indexedDB on web, filesystem on node) */
@@ -732,24 +731,25 @@ var CofhesdkConfigSchema = zod.z.object({
   useWorkers: zod.z.boolean().optional().default(true),
   /** Mocks configs */
   mocks: zod.z.object({
-    sealOutputDelay: zod.z.number().optional().default(0)
-  }).optional().default({ sealOutputDelay: 0 }),
+    decryptDelay: zod.z.number().optional().default(0),
+    encryptDelay: zod.z.union([zod.z.number(), zod.z.tuple([zod.z.number(), zod.z.number(), zod.z.number(), zod.z.number(), zod.z.number()])]).optional().default([100, 100, 100, 500, 500])
+  }).optional().default({ decryptDelay: 0, encryptDelay: [100, 100, 100, 500, 500] }),
   /** Internal configuration */
   _internal: zod.z.object({
     zkvWalletClient: zod.z.any().optional()
   }).optional()
 });
-function createCofhesdkConfigBase(config) {
-  const result = CofhesdkConfigSchema.safeParse(config);
+function createCofheConfigBase(config) {
+  const result = CofheConfigSchema.safeParse(config);
   if (!result.success) {
-    throw new Error(`Invalid cofhesdk configuration: ${zod.z.prettifyError(result.error)}`, { cause: result.error });
+    throw new Error(`Invalid cofhe configuration: ${zod.z.prettifyError(result.error)}`, { cause: result.error });
   }
   return result.data;
 }
 function getSupportedChainOrThrow(config, chainId) {
   const supportedChain = config.supportedChains.find((chain) => chain.id === chainId);
   if (!supportedChain) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "UNSUPPORTED_CHAIN" /* UnsupportedChain */,
       message: `Config does not support chain <${chainId}>`,
       hint: "Ensure config passed to client has been created with this chain in the config.supportedChains array.",
@@ -765,7 +765,7 @@ function getCoFheUrlOrThrow(config, chainId) {
   const supportedChain = getSupportedChainOrThrow(config, chainId);
   const url = supportedChain.coFheUrl;
   if (!url) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "MISSING_CONFIG" /* MissingConfig */,
       message: `CoFHE URL is not configured for chain <${chainId}>`,
       hint: "Ensure this chain config includes a coFheUrl property.",
@@ -778,7 +778,7 @@ function getZkVerifierUrlOrThrow(config, chainId) {
   const supportedChain = getSupportedChainOrThrow(config, chainId);
   const url = supportedChain.verifierUrl;
   if (!url) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "ZK_VERIFIER_URL_UNINITIALIZED" /* ZkVerifierUrlUninitialized */,
       message: `ZK verifier URL is not configured for chain <${chainId}>`,
       hint: "Ensure this chain config includes a verifierUrl property.",
@@ -791,7 +791,7 @@ function getThresholdNetworkUrlOrThrow(config, chainId) {
   const supportedChain = getSupportedChainOrThrow(config, chainId);
   const url = supportedChain.thresholdNetworkUrl;
   if (!url) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "THRESHOLD_NETWORK_URL_UNINITIALIZED" /* ThresholdNetworkUrlUninitialized */,
       message: `Threshold network URL is not configured for chain <${chainId}>`,
       hint: "Ensure this chain config includes a thresholdNetworkUrl property.",
@@ -1003,7 +1003,7 @@ var BaseBuilder = class {
   account;
   constructor(params) {
     if (!params.config) {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "MISSING_CONFIG" /* MissingConfig */,
         message: "Builder config is undefined",
         hint: "Ensure client has been created with a config.",
@@ -1021,12 +1021,12 @@ var BaseBuilder = class {
   }
   /**
    * Asserts that this.chainId is populated
-   * @throws {CofhesdkError} If chainId is not set
+   * @throws {CofheError} If chainId is not set
    */
   assertChainId() {
     if (this.chainId)
       return;
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "CHAIN_ID_UNINITIALIZED" /* ChainIdUninitialized */,
       message: "Chain ID is not set",
       hint: "Ensure client.connect() has been called and awaited, or use setChainId(...) to set the chainId explicitly.",
@@ -1037,12 +1037,12 @@ var BaseBuilder = class {
   }
   /**
    * Asserts that this.account is populated
-   * @throws {CofhesdkError} If account is not set
+   * @throws {CofheError} If account is not set
    */
   assertAccount() {
     if (this.account)
       return;
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "ACCOUNT_UNINITIALIZED" /* AccountUninitialized */,
       message: "Account is not set",
       hint: "Ensure client.connect() has been called and awaited, or use setAccount(...) to set the account explicitly.",
@@ -1053,12 +1053,12 @@ var BaseBuilder = class {
   }
   /**
    * Asserts that this.publicClient is populated
-   * @throws {CofhesdkError} If publicClient is not set
+   * @throws {CofheError} If publicClient is not set
    */
   assertPublicClient() {
     if (this.publicClient)
       return;
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "MISSING_PUBLIC_CLIENT" /* MissingPublicClient */,
       message: "Public client not found",
       hint: "Ensure client.connect() has been called with a publicClient.",
@@ -1069,12 +1069,12 @@ var BaseBuilder = class {
   }
   /**
    * Asserts that this.walletClient is populated
-   * @throws {CofhesdkError} If walletClient is not set
+   * @throws {CofheError} If walletClient is not set
    */
   assertWalletClient() {
     if (this.walletClient)
       return;
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "MISSING_WALLET_CLIENT" /* MissingWalletClient */,
       message: "Wallet client not found",
       hint: "Ensure client.connect() has been called with a walletClient.",
@@ -1119,7 +1119,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     this.securityZone = params.securityZone ?? 0;
     this.zkvWalletClient = params.zkvWalletClient;
     if (!params.tfhePublicKeyDeserializer) {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "MISSING_TFHE_PUBLIC_KEY_DESERIALIZER" /* MissingTfhePublicKeyDeserializer */,
         message: "EncryptInputsBuilder tfhePublicKeyDeserializer is undefined",
         hint: "Ensure client has been created with a tfhePublicKeyDeserializer.",
@@ -1130,7 +1130,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     }
     this.tfhePublicKeyDeserializer = params.tfhePublicKeyDeserializer;
     if (!params.compactPkeCrsDeserializer) {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "MISSING_COMPACT_PKE_CRS_DESERIALIZER" /* MissingCompactPkeCrsDeserializer */,
         message: "EncryptInputsBuilder compactPkeCrsDeserializer is undefined",
         hint: "Ensure client has been created with a compactPkeCrsDeserializer.",
@@ -1141,7 +1141,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     }
     this.compactPkeCrsDeserializer = params.compactPkeCrsDeserializer;
     if (!params.zkBuilderAndCrsGenerator) {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "MISSING_ZK_BUILDER_AND_CRS_GENERATOR" /* MissingZkBuilderAndCrsGenerator */,
         message: "EncryptInputsBuilder zkBuilderAndCrsGenerator is undefined",
         hint: "Ensure client has been created with a zkBuilderAndCrsGenerator.",
@@ -1165,7 +1165,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
    * ```typescript
    * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
    *   .setAccount("0x123")
-   *   .encrypt();
+   *   .execute();
    * ```
    *
    * @returns The chainable EncryptInputsBuilder instance.
@@ -1186,7 +1186,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
    * ```typescript
    * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
    *   .setChainId(11155111)
-   *   .encrypt();
+   *   .execute();
    * ```
    *
    * @returns The chainable EncryptInputsBuilder instance.
@@ -1207,7 +1207,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
    * ```typescript
    * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
    *   .setSecurityZone(1)
-   *   .encrypt();
+   *   .execute();
    * ```
    *
    * @returns The chainable EncryptInputsBuilder instance.
@@ -1228,7 +1228,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
    * ```typescript
    * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
    *   .setUseWorker(false)
-   *   .encrypt();
+   *   .execute();
    * ```
    *
    * @returns The chainable EncryptInputsBuilder instance.
@@ -1262,13 +1262,13 @@ var EncryptInputsBuilder = class extends BaseBuilder {
    * 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) {
+  onStep(callback) {
     this.stepCallback = callback;
     return this;
   }
@@ -1291,7 +1291,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     this.stepCallback(step, { ...context, isStart: false, isEnd: true, duration });
   }
   /**
-   * 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.
    */
   async getZkVerifierUrl() {
@@ -1299,7 +1299,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     return getZkVerifierUrlOrThrow(this.config, this.chainId);
   }
   /**
-   * 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.
@@ -1310,7 +1310,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     try {
       return await this.initTfhe();
     } catch (error) {
-      throw CofhesdkError.fromError(error, {
+      throw CofheError.fromError(error, {
         code: "INIT_TFHE_FAILED" /* InitTfheFailed */,
         message: `Failed to initialize TFHE`,
         context: {
@@ -1329,7 +1329,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     try {
       await this.keysStorage?.rehydrateKeysStore();
     } catch (error) {
-      throw CofhesdkError.fromError(error, {
+      throw CofheError.fromError(error, {
         code: "REHYDRATE_KEYS_STORE_FAILED" /* RehydrateKeysStoreFailed */,
         message: `Failed to rehydrate keys store`,
         context: {
@@ -1351,7 +1351,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
         this.keysStorage
       );
     } catch (error) {
-      throw CofhesdkError.fromError(error, {
+      throw CofheError.fromError(error, {
         code: "FETCH_KEYS_FAILED" /* FetchKeysFailed */,
         message: `Failed to fetch FHE key and CRS`,
         context: {
@@ -1364,7 +1364,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
       });
     }
     if (!fheKey) {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "MISSING_FHE_KEY" /* MissingFheKey */,
         message: `FHE key not found`,
         context: {
@@ -1374,7 +1374,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
       });
     }
     if (!crs) {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "MISSING_CRS" /* MissingCrs */,
         message: `CRS not found for chainId <${this.chainId}>`,
         context: {
@@ -1384,6 +1384,17 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     }
     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.
+   */
+  resolveEncryptDelays() {
+    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
    *
@@ -1391,25 +1402,35 @@ var EncryptInputsBuilder = class extends BaseBuilder {
    * 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.
    */
-  async mocksEncrypt() {
+  async mocksExecute() {
     this.assertAccount();
     this.assertPublicClient();
     this.assertWalletClient();
+    const [initTfheDelay, fetchKeysDelay, packDelay, proveDelay, verifyDelay] = this.resolveEncryptDelays();
     this.fireStepStart("initTfhe" /* InitTfhe */);
-    await sleep(100);
-    this.fireStepEnd("initTfhe" /* InitTfhe */, { tfheInitializationExecuted: false });
+    await sleep(initTfheDelay);
+    this.fireStepEnd("initTfhe" /* InitTfhe */, {
+      tfheInitializationExecuted: false,
+      isMocks: true,
+      mockSleep: initTfheDelay
+    });
     this.fireStepStart("fetchKeys" /* FetchKeys */);
-    await sleep(100);
-    this.fireStepEnd("fetchKeys" /* FetchKeys */, { fheKeyFetchedFromCoFHE: false, crsFetchedFromCoFHE: false });
+    await sleep(fetchKeysDelay);
+    this.fireStepEnd("fetchKeys" /* FetchKeys */, {
+      fheKeyFetchedFromCoFHE: false,
+      crsFetchedFromCoFHE: false,
+      isMocks: true,
+      mockSleep: fetchKeysDelay
+    });
     this.fireStepStart("pack" /* Pack */);
     await cofheMocksCheckEncryptableBits(this.inputItems);
-    await sleep(100);
-    this.fireStepEnd("pack" /* Pack */);
+    await sleep(packDelay);
+    this.fireStepEnd("pack" /* Pack */, { isMocks: true, mockSleep: packDelay });
     this.fireStepStart("prove" /* Prove */);
-    await sleep(500);
-    this.fireStepEnd("prove" /* Prove */);
+    await sleep(proveDelay);
+    this.fireStepEnd("prove" /* Prove */, { isMocks: true, mockSleep: proveDelay });
     this.fireStepStart("verify" /* Verify */);
-    await sleep(500);
+    await sleep(verifyDelay);
     const signedResults = await cofheMocksZkVerifySign(
       this.inputItems,
       this.account,
@@ -1424,13 +1445,13 @@ var EncryptInputsBuilder = class extends BaseBuilder {
       utype: this.inputItems[index].utype,
       signature
     }));
-    this.fireStepEnd("verify" /* Verify */);
+    this.fireStepEnd("verify" /* Verify */, { isMocks: true, mockSleep: verifyDelay });
     return encryptedInputs;
   }
   /**
    * In the production context, perform a true encryption with the CoFHE coprocessor.
    */
-  async productionEncrypt() {
+  async productionExecute() {
     this.assertAccount();
     this.assertChainId();
     this.fireStepStart("initTfhe" /* InitTfhe */);
@@ -1493,15 +1514,15 @@ var EncryptInputsBuilder = class extends BaseBuilder {
    * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
    *   .setAccount('0x123...890') // optional
    *   .setChainId(11155111)      // optional
-   *   .encrypt();                // execute
+   *   .execute();                // execute
    * ```
    *
    * @returns The encrypted inputs.
    */
-  async encrypt() {
+  async execute() {
     if (this.chainId === chains.hardhat.id)
-      return this.mocksEncrypt();
-    return this.productionEncrypt();
+      return this.mocksExecute();
+    return this.productionExecute();
   }
 };
 
@@ -2523,8 +2544,8 @@ var convertViaUtype = (utype, value) => {
   }
 };
 
-// core/decrypt/MockQueryDecrypterAbi.ts
-var MockQueryDecrypterAbi = [
+// core/decrypt/MockThresholdNetworkAbi.ts
+var MockThresholdNetworkAbi = [
   {
     type: "function",
     name: "acl",
@@ -2571,11 +2592,7 @@ var MockQueryDecrypterAbi = [
           { name: "expiration", type: "uint64", internalType: "uint64" },
           { name: "recipient", type: "address", internalType: "address" },
           { name: "validatorId", type: "uint256", internalType: "uint256" },
-          {
-            name: "validatorContract",
-            type: "address",
-            internalType: "address"
-          },
+          { name: "validatorContract", type: "address", internalType: "address" },
           { name: "sealingKey", type: "bytes32", internalType: "bytes32" },
           { name: "issuerSignature", type: "bytes", internalType: "bytes" },
           { name: "recipientSignature", type: "bytes", internalType: "bytes" }
@@ -2604,11 +2621,7 @@ var MockQueryDecrypterAbi = [
           { name: "expiration", type: "uint64", internalType: "uint64" },
           { name: "recipient", type: "address", internalType: "address" },
           { name: "validatorId", type: "uint256", internalType: "uint256" },
-          {
-            name: "validatorContract",
-            type: "address",
-            internalType: "address"
-          },
+          { name: "validatorContract", type: "address", internalType: "address" },
           { name: "sealingKey", type: "bytes32", internalType: "bytes32" },
           { name: "issuerSignature", type: "bytes", internalType: "bytes" },
           { name: "recipientSignature", type: "bytes", internalType: "bytes" }
@@ -2632,13 +2645,6 @@ var MockQueryDecrypterAbi = [
     outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
     stateMutability: "pure"
   },
-  {
-    type: "function",
-    name: "taskManager",
-    inputs: [],
-    outputs: [{ name: "", type: "address", internalType: "contract TaskManager" }],
-    stateMutability: "view"
-  },
   {
     type: "function",
     name: "unseal",
@@ -2649,15 +2655,80 @@ var MockQueryDecrypterAbi = [
     outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "pure"
   },
-  { type: "error", name: "NotAllowed", inputs: [] },
-  { type: "error", name: "SealingKeyInvalid", inputs: [] },
-  { type: "error", name: "SealingKeyMissing", inputs: [] }
+  {
+    type: "function",
+    name: "mockAcl",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "contract MockACL" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "mockTaskManager",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "contract MockTaskManager" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "mockQueryDecrypt",
+    inputs: [
+      { name: "ctHash", type: "uint256", internalType: "uint256" },
+      { name: "", type: "uint256", internalType: "uint256" },
+      { name: "issuer", type: "address", internalType: "address" }
+    ],
+    outputs: [
+      { name: "allowed", type: "bool", internalType: "bool" },
+      { name: "error", type: "string", internalType: "string" },
+      { name: "", type: "uint256", internalType: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "decryptForTxWithPermit",
+    inputs: [
+      { name: "ctHash", type: "uint256", internalType: "uint256" },
+      {
+        name: "permission",
+        type: "tuple",
+        internalType: "struct Permission",
+        components: [
+          { name: "issuer", type: "address", internalType: "address" },
+          { name: "expiration", type: "uint64", internalType: "uint64" },
+          { name: "recipient", type: "address", internalType: "address" },
+          { name: "validatorId", type: "uint256", internalType: "uint256" },
+          { name: "validatorContract", type: "address", internalType: "address" },
+          { name: "sealingKey", type: "bytes32", internalType: "bytes32" },
+          { name: "issuerSignature", type: "bytes", internalType: "bytes" },
+          { name: "recipientSignature", type: "bytes", internalType: "bytes" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "allowed", type: "bool", internalType: "bool" },
+      { name: "error", type: "string", internalType: "string" },
+      { name: "decryptedValue", type: "uint256", internalType: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "decryptForTxWithoutPermit",
+    inputs: [{ name: "ctHash", type: "uint256", internalType: "uint256" }],
+    outputs: [
+      { name: "allowed", type: "bool", internalType: "bool" },
+      { name: "error", type: "string", internalType: "string" },
+      { name: "decryptedValue", type: "uint256", internalType: "uint256" }
+    ],
+    stateMutability: "view"
+  }
 ];
 
-// core/decrypt/cofheMocksSealOutput.ts
-async function cofheMocksSealOutput(ctHash, utype, permit, publicClient, mocksSealOutputDelay) {
-  if (mocksSealOutputDelay > 0)
-    await sleep(mocksSealOutputDelay);
+// core/decrypt/cofheMocksDecryptForView.ts
+async function cofheMocksDecryptForView(ctHash, utype, permit, publicClient, mocksDecryptDelay) {
+  if (mocksDecryptDelay > 0)
+    await sleep(mocksDecryptDelay);
   const permission = PermitUtils.getPermission(permit, true);
   const permissionWithBigInts = {
     ...permission,
@@ -2665,19 +2736,19 @@ async function cofheMocksSealOutput(ctHash, utype, permit, publicClient, mocksSe
     validatorId: BigInt(permission.validatorId)
   };
   const [allowed, error, result] = await publicClient.readContract({
-    address: MOCKS_QUERY_DECRYPTER_ADDRESS,
-    abi: MockQueryDecrypterAbi,
+    address: MOCKS_THRESHOLD_NETWORK_ADDRESS,
+    abi: MockThresholdNetworkAbi,
     functionName: "querySealOutput",
     args: [ctHash, BigInt(utype), permissionWithBigInts]
   });
   if (error != "") {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
       message: `mocks querySealOutput call failed: ${error}`
     });
   }
   if (allowed == false) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
       message: `mocks querySealOutput call failed: ACL Access Denied (NotAllowed)`
     });
@@ -2696,7 +2767,7 @@ function numberArrayToUint8Array(arr) {
 }
 function convertSealedData(sealed) {
   if (!sealed) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "SEAL_OUTPUT_RETURNED_NULL" /* SealOutputReturnedNull */,
       message: "Sealed data is missing from completed response"
     });
@@ -2723,7 +2794,7 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, per
       body: JSON.stringify(body)
     });
   } catch (e) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
       message: `sealOutput request failed`,
       hint: "Ensure the threshold network URL is valid and reachable.",
@@ -2742,7 +2813,7 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, per
     } catch {
       errorMessage = response.statusText || errorMessage;
     }
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
       message: `sealOutput request failed: ${errorMessage}`,
       hint: "Check the threshold network URL and request parameters.",
@@ -2758,7 +2829,7 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, per
   try {
     submitResponse = await response.json();
   } catch (e) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
       message: `Failed to parse sealOutput submit response`,
       cause: e instanceof Error ? e : void 0,
@@ -2769,7 +2840,7 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, per
     });
   }
   if (!submitResponse.request_id) {
-    throw new CofhesdkError({
+    throw new CofheError({
       code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
       message: `sealOutput submit response missing request_id`,
       context: {
@@ -2786,7 +2857,7 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId) {
   let completed = false;
   while (!completed) {
     if (Date.now() - startTime > POLL_TIMEOUT_MS) {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
         message: `sealOutput polling timed out after ${POLL_TIMEOUT_MS}ms`,
         hint: "The request may still be processing. Try again later.",
@@ -2806,7 +2877,7 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId) {
         }
       });
     } catch (e) {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
         message: `sealOutput status poll failed`,
         hint: "Ensure the threshold network URL is valid and reachable.",
@@ -2818,7 +2889,7 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId) {
       });
     }
     if (response.status === 404) {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
         message: `sealOutput request not found: ${requestId}`,
         hint: "The request may have expired or been invalid.",
@@ -2836,7 +2907,7 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId) {
       } catch {
         errorMessage = response.statusText || errorMessage;
       }
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
         message: `sealOutput status poll failed: ${errorMessage}`,
         context: {
@@ -2851,7 +2922,7 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId) {
     try {
       statusResponse = await response.json();
     } catch (e) {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
         message: `Failed to parse sealOutput status response`,
         cause: e instanceof Error ? e : void 0,
@@ -2864,7 +2935,7 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId) {
     if (statusResponse.status === "COMPLETED") {
       if (statusResponse.is_succeed === false) {
         const errorMessage = statusResponse.error_message || "Unknown error";
-        throw new CofhesdkError({
+        throw new CofheError({
           code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
           message: `sealOutput request failed: ${errorMessage}`,
           context: {
@@ -2875,7 +2946,7 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId) {
         });
       }
       if (!statusResponse.sealed) {
-        throw new CofhesdkError({
+        throw new CofheError({
           code: "SEAL_OUTPUT_RETURNED_NULL" /* SealOutputReturnedNull */,
           message: `sealOutput request completed but returned no sealed data`,
           context: {
@@ -2889,7 +2960,7 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId) {
     }
     await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
   }
-  throw new CofhesdkError({
+  throw new CofheError({
     code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
     message: "Polling loop exited unexpectedly",
     context: {
@@ -2902,9 +2973,99 @@ async function tnSealOutputV2(ctHash, chainId, permission, thresholdNetworkUrl)
   const requestId = await submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, permission);
   return await pollSealOutputStatus(thresholdNetworkUrl, requestId);
 }
+async function cofheMocksDecryptForTx(ctHash, utype, permit, publicClient, mocksDecryptForTxDelay) {
+  if (mocksDecryptForTxDelay > 0)
+    await sleep(mocksDecryptForTxDelay);
+  if (permit !== null) {
+    let permission = PermitUtils.getPermission(permit, true);
+    const permissionWithBigInts = {
+      ...permission,
+      expiration: BigInt(permission.expiration),
+      validatorId: BigInt(permission.validatorId)
+    };
+    const [allowed2, error2, result2] = await publicClient.readContract({
+      address: MOCKS_THRESHOLD_NETWORK_ADDRESS,
+      abi: MockThresholdNetworkAbi,
+      functionName: "decryptForTxWithPermit",
+      args: [ctHash, permissionWithBigInts]
+    });
+    if (error2 != "") {
+      throw new CofheError({
+        code: "DECRYPT_FAILED" /* DecryptFailed */,
+        message: `mocks decryptForTx call failed: ${error2}`
+      });
+    }
+    if (allowed2 == false) {
+      throw new CofheError({
+        code: "DECRYPT_FAILED" /* DecryptFailed */,
+        message: `mocks decryptForTx call failed: ACL Access Denied (NotAllowed)`
+      });
+    }
+    const chainId2 = await publicClient.getChainId();
+    const ctHashBigInt2 = BigInt(ctHash);
+    const resultBigInt2 = BigInt(result2);
+    const encryptionType2 = Number((ctHashBigInt2 & 0x7fn << 8n) >> 8n);
+    const ctHashBytes322 = viem.pad(viem.toHex(ctHashBigInt2), { size: 32 });
+    const packed2 = viem.encodePacked(
+      ["uint256", "uint32", "uint64", "bytes32"],
+      [resultBigInt2, encryptionType2, BigInt(chainId2), ctHashBytes322]
+    );
+    const messageHash2 = viem.keccak256(packed2);
+    const signatureHex2 = await accounts.sign({
+      hash: messageHash2,
+      privateKey: MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY,
+      to: "hex"
+    });
+    const signature2 = signatureHex2.slice(2);
+    return {
+      ctHash,
+      decryptedValue: BigInt(result2),
+      signature: signature2
+    };
+  }
+  const [allowed, error, result] = await publicClient.readContract({
+    address: MOCKS_THRESHOLD_NETWORK_ADDRESS,
+    abi: MockThresholdNetworkAbi,
+    functionName: "decryptForTxWithoutPermit",
+    args: [ctHash]
+  });
+  if (error != "") {
+    throw new CofheError({
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: `mocks decryptForTx call failed: ${error}`
+    });
+  }
+  if (allowed == false) {
+    throw new CofheError({
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: `mocks decryptForTx call failed: ACL Access Denied (NotAllowed)`
+    });
+  }
+  const chainId = await publicClient.getChainId();
+  const ctHashBigInt = BigInt(ctHash);
+  const resultBigInt = BigInt(result);
+  const encryptionType = Number((ctHashBigInt & 0x7fn << 8n) >> 8n);
+  const ctHashBytes32 = viem.pad(viem.toHex(ctHashBigInt), { size: 32 });
+  const packed = viem.encodePacked(
+    ["uint256", "uint32", "uint64", "bytes32"],
+    [resultBigInt, encryptionType, BigInt(chainId), ctHashBytes32]
+  );
+  const messageHash = viem.keccak256(packed);
+  const signatureHex = await accounts.sign({
+    hash: messageHash,
+    privateKey: MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY,
+    to: "hex"
+  });
+  const signature = signatureHex.slice(2);
+  return {
+    ctHash,
+    decryptedValue: BigInt(result),
+    signature
+  };
+}
 
-// core/decrypt/decryptHandleBuilder.ts
-var DecryptHandlesBuilder = class extends BaseBuilder {
+// core/decrypt/decryptForViewBuilder.ts
+var DecryptForViewBuilder = class extends BaseBuilder {
   ctHash;
   utype;
   permitHash;
@@ -2930,12 +3091,12 @@ var DecryptHandlesBuilder = class extends BaseBuilder {
    *
    * Example:
    * ```typescript
-   * const unsealed = await decryptHandle(ctHash, utype)
+   * const unsealed = await client.decryptForView(ctHash, utype)
    *   .setChainId(11155111)
-   *   .decrypt();
+   *   .execute();
    * ```
    *
-   * @returns The chainable DecryptHandlesBuilder instance.
+   * @returns The chainable DecryptForViewBuilder instance.
    */
   setChainId(chainId) {
     this.chainId = chainId;
@@ -2951,12 +3112,12 @@ var DecryptHandlesBuilder = class extends BaseBuilder {
    *
    * Example:
    * ```typescript
-   * const unsealed = await decryptHandle(ctHash, utype)
+   * const unsealed = await client.decryptForView(ctHash, utype)
    *   .setAccount('0x1234567890123456789012345678901234567890')
-   *   .decrypt();
+   *   .execute();
    * ```
    *
-   * @returns The chainable DecryptHandlesBuilder instance.
+   * @returns The chainable DecryptForViewBuilder instance.
    */
   setAccount(account) {
     this.account = account;
@@ -2965,6 +3126,19 @@ var DecryptHandlesBuilder = class extends BaseBuilder {
   getAccount() {
     return this.account;
   }
+  withPermit(permitOrPermitHash) {
+    if (typeof permitOrPermitHash === "string") {
+      this.permitHash = permitOrPermitHash;
+      this.permit = void 0;
+    } else if (permitOrPermitHash === void 0) {
+      this.permitHash = void 0;
+      this.permit = void 0;
+    } else {
+      this.permit = permitOrPermitHash;
+      this.permitHash = void 0;
+    }
+    return this;
+  }
   /**
    * @param permitHash - Permit hash to decrypt values from. Used to fetch the correct permit.
    *
@@ -2973,16 +3147,16 @@ var DecryptHandlesBuilder = class extends BaseBuilder {
    *
    * Example:
    * ```typescript
-   * const unsealed = await decryptHandle(ctHash, utype)
+   * const unsealed = await client.decryptForView(ctHash, utype)
    *   .setPermitHash('0x1234567890123456789012345678901234567890')
-   *   .decrypt();
+   *   .execute();
    * ```
    *
-   * @returns The chainable DecryptHandlesBuilder instance.
+   * @returns The chainable DecryptForViewBuilder instance.
    */
+  /** @deprecated Use `withPermit(permitHash)` instead. */
   setPermitHash(permitHash) {
-    this.permitHash = permitHash;
-    return this;
+    return this.withPermit(permitHash);
   }
   getPermitHash() {
     return this.permitHash;
@@ -2994,16 +3168,16 @@ var DecryptHandlesBuilder = class extends BaseBuilder {
    *
    * Example:
    * ```typescript
-   * const unsealed = await decryptHandle(ctHash, utype)
+   * const unsealed = await client.decryptForView(ctHash, utype)
    *   .setPermit(permit)
-   *   .decrypt();
+   *   .execute();
    * ```
    *
-   * @returns The chainable DecryptHandlesBuilder instance.
+   * @returns The chainable DecryptForViewBuilder instance.
    */
+  /** @deprecated Use `withPermit(permit)` instead. */
   setPermit(permit) {
-    this.permit = permit;
-    return this;
+    return this.withPermit(permit);
   }
   getPermit() {
     return this.permit;
@@ -3014,7 +3188,7 @@ var DecryptHandlesBuilder = class extends BaseBuilder {
   }
   validateUtypeOrThrow() {
     if (!isValidUtype(this.utype))
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "INVALID_UTYPE" /* InvalidUtype */,
         message: `Invalid utype to decrypt to`,
         context: {
@@ -3030,7 +3204,7 @@ var DecryptHandlesBuilder = class extends BaseBuilder {
     if (this.permitHash) {
       const permit2 = await permits.getPermit(this.chainId, this.account, this.permitHash);
       if (!permit2) {
-        throw new CofhesdkError({
+        throw new CofheError({
           code: "PERMIT_NOT_FOUND" /* PermitNotFound */,
           message: `Permit with hash <${this.permitHash}> not found for account <${this.account}> and chainId <${this.chainId}>`,
           hint: "Ensure the permit exists and is valid.",
@@ -3045,7 +3219,7 @@ var DecryptHandlesBuilder = class extends BaseBuilder {
     }
     const permit = await permits.getActivePermit(this.chainId, this.account);
     if (!permit) {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "PERMIT_NOT_FOUND" /* PermitNotFound */,
         message: `Active permit not found for chainId <${this.chainId}> and account <${this.account}>`,
         hint: "Ensure a permit exists for this account on this chain.",
@@ -3062,8 +3236,8 @@ var DecryptHandlesBuilder = class extends BaseBuilder {
    */
   async mocksSealOutput(permit) {
     this.assertPublicClient();
-    const mocksSealOutputDelay = this.config.mocks.sealOutputDelay;
-    return cofheMocksSealOutput(this.ctHash, this.utype, permit, this.publicClient, mocksSealOutputDelay);
+    const mocksDecryptDelay = this.config.mocks.decryptDelay;
+    return cofheMocksDecryptForView(this.ctHash, this.utype, permit, this.publicClient, mocksDecryptDelay);
   }
   /**
    * In the production context, perform a true decryption with the CoFHE coprocessor.
@@ -3088,15 +3262,16 @@ var DecryptHandlesBuilder = class extends BaseBuilder {
    *
    * Example:
    * ```typescript
-   * const unsealed = await decryptHandle(ctHash, utype)
+   * const unsealed = await client.decryptForView(ctHash, utype)
    *   .setChainId(11155111)      // optional
    *   .setAccount('0x123...890') // optional
-   *   .decrypt();                // execute
+   *   .withPermit()              // optional
+   *   .execute();                // execute
    * ```
    *
    * @returns The unsealed item.
    */
-  async decrypt() {
+  async execute() {
     this.validateUtypeOrThrow();
     const permit = await this.getResolvedPermit();
     PermitUtils.validate(permit);
@@ -3112,6 +3287,394 @@ var DecryptHandlesBuilder = class extends BaseBuilder {
   }
 };
 
+// core/decrypt/tnDecrypt.ts
+function normalizeSignature(signature) {
+  if (typeof signature !== "string") {
+    throw new CofheError({
+      code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
+      message: "decrypt response missing signature",
+      context: {
+        signature
+      }
+    });
+  }
+  const trimmed = signature.trim();
+  if (trimmed.length === 0) {
+    throw new CofheError({
+      code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
+      message: "decrypt response returned empty signature"
+    });
+  }
+  return trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed;
+}
+function parseDecryptedBytesToBigInt(decrypted) {
+  if (!Array.isArray(decrypted)) {
+    throw new CofheError({
+      code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
+      message: "decrypt response field <decrypted> must be a byte array",
+      context: {
+        decrypted
+      }
+    });
+  }
+  if (decrypted.length === 0) {
+    throw new CofheError({
+      code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
+      message: "decrypt response field <decrypted> was an empty byte array",
+      context: {
+        decrypted
+      }
+    });
+  }
+  let hex = "";
+  for (const b of decrypted) {
+    if (typeof b !== "number" || !Number.isInteger(b) || b < 0 || b > 255) {
+      throw new CofheError({
+        code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
+        message: "decrypt response field <decrypted> contained a non-byte value",
+        context: {
+          badElement: b,
+          decrypted
+        }
+      });
+    }
+    hex += b.toString(16).padStart(2, "0");
+  }
+  return BigInt(`0x${hex}`);
+}
+function assertTnDecryptResponse(value) {
+  if (value == null || typeof value !== "object") {
+    throw new CofheError({
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: "decrypt response must be a JSON object",
+      context: {
+        value
+      }
+    });
+  }
+  const v = value;
+  const decrypted = v.decrypted;
+  const signature = v.signature;
+  const encryptionType = v.encryption_type;
+  const errorMessage = v.error_message;
+  if (!Array.isArray(decrypted)) {
+    throw new CofheError({
+      code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
+      message: "decrypt response missing <decrypted> byte array",
+      context: { decryptResponse: value }
+    });
+  }
+  if (typeof signature !== "string") {
+    throw new CofheError({
+      code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
+      message: "decrypt response missing <signature> string",
+      context: { decryptResponse: value }
+    });
+  }
+  if (typeof encryptionType !== "number") {
+    throw new CofheError({
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: "decrypt response missing <encryption_type> number",
+      context: { decryptResponse: value }
+    });
+  }
+  if (!(typeof errorMessage === "string" || errorMessage === null)) {
+    throw new CofheError({
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: "decrypt response field <error_message> must be string or null",
+      context: { decryptResponse: value }
+    });
+  }
+  return {
+    decrypted,
+    signature,
+    encryption_type: encryptionType,
+    error_message: errorMessage
+  };
+}
+async function tnDecrypt(ctHash, chainId, permission, thresholdNetworkUrl) {
+  const body = {
+    ct_tempkey: ctHash.toString(16).padStart(64, "0"),
+    host_chain_id: chainId
+  };
+  if (permission) {
+    body.permit = permission;
+  }
+  let response;
+  try {
+    response = await fetch(`${thresholdNetworkUrl}/decrypt`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+  } catch (e) {
+    throw new CofheError({
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: `decrypt request failed`,
+      hint: "Ensure the threshold network URL is valid and reachable.",
+      cause: e instanceof Error ? e : void 0,
+      context: {
+        thresholdNetworkUrl,
+        body
+      }
+    });
+  }
+  const responseText = await response.text();
+  if (!response.ok) {
+    let errorMessage = response.statusText || `HTTP ${response.status}`;
+    try {
+      const errorBody = JSON.parse(responseText);
+      const maybeMessage = errorBody.error_message || errorBody.message;
+      if (typeof maybeMessage === "string" && maybeMessage.length > 0)
+        errorMessage = maybeMessage;
+    } catch {
+      const trimmed = responseText.trim();
+      if (trimmed.length > 0)
+        errorMessage = trimmed;
+    }
+    throw new CofheError({
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: `decrypt request failed: ${errorMessage}`,
+      hint: "Check the threshold network URL and request parameters.",
+      context: {
+        thresholdNetworkUrl,
+        status: response.status,
+        statusText: response.statusText,
+        body,
+        responseText
+      }
+    });
+  }
+  let rawJson;
+  try {
+    rawJson = JSON.parse(responseText);
+  } catch (e) {
+    throw new CofheError({
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: `Failed to parse decrypt response`,
+      cause: e instanceof Error ? e : void 0,
+      context: {
+        thresholdNetworkUrl,
+        body,
+        responseText
+      }
+    });
+  }
+  const decryptResponse = assertTnDecryptResponse(rawJson);
+  if (decryptResponse.error_message) {
+    throw new CofheError({
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: `decrypt request failed: ${decryptResponse.error_message}`,
+      context: {
+        thresholdNetworkUrl,
+        body,
+        decryptResponse
+      }
+    });
+  }
+  const decryptedValue = parseDecryptedBytesToBigInt(decryptResponse.decrypted);
+  const signature = normalizeSignature(decryptResponse.signature);
+  return { decryptedValue, signature };
+}
+
+// core/decrypt/decryptForTxBuilder.ts
+var DecryptForTxBuilder = class extends BaseBuilder {
+  ctHash;
+  permitHash;
+  permit;
+  permitSelection = "unset";
+  constructor(params) {
+    super({
+      config: params.config,
+      publicClient: params.publicClient,
+      walletClient: params.walletClient,
+      chainId: params.chainId,
+      account: params.account,
+      requireConnected: params.requireConnected
+    });
+    this.ctHash = params.ctHash;
+  }
+  setChainId(chainId) {
+    this.chainId = chainId;
+    return this;
+  }
+  getChainId() {
+    return this.chainId;
+  }
+  setAccount(account) {
+    this.account = account;
+    return this;
+  }
+  getAccount() {
+    return this.account;
+  }
+  withPermit(permitOrPermitHash) {
+    if (this.permitSelection === "with-permit") {
+      throw new CofheError({
+        code: "INTERNAL_ERROR" /* InternalError */,
+        message: "decryptForTx: withPermit() can only be selected once.",
+        hint: "Choose the permit mode once. If you need a different permit, start a new decryptForTx() builder chain."
+      });
+    }
+    if (this.permitSelection === "without-permit") {
+      throw new CofheError({
+        code: "INTERNAL_ERROR" /* InternalError */,
+        message: "decryptForTx: cannot call withPermit() after withoutPermit() has been selected.",
+        hint: "Choose exactly one permit mode: either call .withPermit(...) or .withoutPermit(), but not both."
+      });
+    }
+    this.permitSelection = "with-permit";
+    if (typeof permitOrPermitHash === "string") {
+      this.permitHash = permitOrPermitHash;
+      this.permit = void 0;
+    } else if (permitOrPermitHash === void 0) {
+      this.permitHash = void 0;
+      this.permit = void 0;
+    } else {
+      this.permit = permitOrPermitHash;
+      this.permitHash = void 0;
+    }
+    return this;
+  }
+  /**
+   * Select "no permit" mode.
+   *
+   * This uses global allowance (no permit required) and sends an empty permission payload to `/decrypt`.
+   */
+  withoutPermit() {
+    if (this.permitSelection === "without-permit") {
+      throw new CofheError({
+        code: "INTERNAL_ERROR" /* InternalError */,
+        message: "decryptForTx: withoutPermit() can only be selected once.",
+        hint: "Choose the permit mode once. If you need a different mode, start a new decryptForTx() builder chain."
+      });
+    }
+    if (this.permitSelection === "with-permit") {
+      throw new CofheError({
+        code: "INTERNAL_ERROR" /* InternalError */,
+        message: "decryptForTx: cannot call withoutPermit() after withPermit() has been selected.",
+        hint: "Choose exactly one permit mode: either call .withPermit(...) or .withoutPermit(), but not both."
+      });
+    }
+    this.permitSelection = "without-permit";
+    this.permitHash = void 0;
+    this.permit = void 0;
+    return this;
+  }
+  getPermit() {
+    return this.permit;
+  }
+  getPermitHash() {
+    return this.permitHash;
+  }
+  async getThresholdNetworkUrl() {
+    this.assertChainId();
+    return getThresholdNetworkUrlOrThrow(this.config, this.chainId);
+  }
+  async getResolvedPermit() {
+    if (this.permitSelection === "unset") {
+      throw new CofheError({
+        code: "INTERNAL_ERROR" /* InternalError */,
+        message: "decryptForTx: missing permit selection; call withPermit(...) or withoutPermit() before execute().",
+        hint: "Call .withPermit() to use the active permit, or .withoutPermit() for global allowance."
+      });
+    }
+    if (this.permitSelection === "without-permit") {
+      return null;
+    }
+    if (this.permit)
+      return this.permit;
+    this.assertChainId();
+    this.assertAccount();
+    if (this.permitHash) {
+      const permit2 = await permits.getPermit(this.chainId, this.account, this.permitHash);
+      if (!permit2) {
+        throw new CofheError({
+          code: "PERMIT_NOT_FOUND" /* PermitNotFound */,
+          message: `Permit with hash <${this.permitHash}> not found for account <${this.account}> and chainId <${this.chainId}>`,
+          hint: "Ensure the permit exists and is valid.",
+          context: {
+            chainId: this.chainId,
+            account: this.account,
+            permitHash: this.permitHash
+          }
+        });
+      }
+      return permit2;
+    }
+    const permit = await permits.getActivePermit(this.chainId, this.account);
+    if (!permit) {
+      throw new CofheError({
+        code: "PERMIT_NOT_FOUND" /* PermitNotFound */,
+        message: `Active permit not found for chainId <${this.chainId}> and account <${this.account}>`,
+        hint: "Create a permit (e.g. client.permits.createSelf(...)) and/or set it active (client.permits.selectActivePermit(hash)).",
+        context: {
+          chainId: this.chainId,
+          account: this.account
+        }
+      });
+    }
+    return permit;
+  }
+  /**
+   * On hardhat, interact with MockThresholdNetwork contract
+   */
+  async mocksDecryptForTx(permit) {
+    this.assertPublicClient();
+    const delay = this.config.mocks.decryptDelay;
+    const result = await cofheMocksDecryptForTx(this.ctHash, 0, permit, this.publicClient, delay);
+    return result;
+  }
+  /**
+   * In the production context, perform a true decryption with the CoFHE coprocessor.
+   */
+  async productionDecryptForTx(permit) {
+    this.assertChainId();
+    this.assertPublicClient();
+    const thresholdNetworkUrl = await this.getThresholdNetworkUrl();
+    const permission = permit ? PermitUtils.getPermission(permit, true) : null;
+    const { decryptedValue, signature } = await tnDecrypt(this.ctHash, this.chainId, permission, thresholdNetworkUrl);
+    return {
+      ctHash: this.ctHash,
+      decryptedValue,
+      signature
+    };
+  }
+  /**
+   * Final step of the decryptForTx process. MUST BE CALLED LAST IN THE CHAIN.
+   *
+   * You must explicitly choose one permit mode before calling `execute()`:
+   * - `withPermit(permit)` / `withPermit(permitHash)` / `withPermit()` (active permit)
+   * - `withoutPermit()` (global allowance)
+   */
+  async execute() {
+    const permit = await this.getResolvedPermit();
+    if (permit !== null) {
+      PermitUtils.validate(permit);
+      PermitUtils.isValid(permit);
+      const chainId = permit._signedDomain.chainId;
+      if (chainId === hardhat2.id) {
+        return await this.mocksDecryptForTx(permit);
+      } else {
+        return await this.productionDecryptForTx(permit);
+      }
+    } else {
+      if (!this.chainId) {
+        this.assertPublicClient();
+        this.chainId = await getPublicClientChainID(this.publicClient);
+      }
+      this.assertChainId();
+      if (this.chainId === hardhat2.id) {
+        return await this.mocksDecryptForTx(null);
+      } else {
+        return await this.productionDecryptForTx(null);
+      }
+    }
+  }
+};
+
 // core/client.ts
 var InitialConnectStore = {
   connected: false,
@@ -3122,7 +3685,7 @@ var InitialConnectStore = {
   publicClient: void 0,
   walletClient: void 0
 };
-function createCofhesdkClientBase(opts) {
+function createCofheClientBase(opts) {
   const keysStorage = createKeysStore(opts.config.fheKeyStorage);
   const connectStore = vanilla.createStore(() => InitialConnectStore);
   let connectAttemptId = 0;
@@ -3133,7 +3696,7 @@ function createCofhesdkClientBase(opts) {
     const state = connectStore.getState();
     const notConnected = !state.connected || !state.account || !state.chainId || !state.publicClient || !state.walletClient;
     if (notConnected) {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "NOT_CONNECTED" /* NotConnected */,
         message: "Client must be connected, account and chainId must be initialized",
         hint: "Ensure client.connect() has been called and awaited.",
@@ -3204,16 +3767,28 @@ function createCofhesdkClientBase(opts) {
       requireConnected: _requireConnected
     });
   }
-  function decryptHandle(ctHash, utype) {
+  function decryptForView(ctHash, utype) {
     const state = connectStore.getState();
-    return new DecryptHandlesBuilder({
+    return new DecryptForViewBuilder({
       ctHash,
       utype,
-      chainId: state.chainId ?? void 0,
-      account: state.account ?? void 0,
+      chainId: state.chainId,
+      account: state.account,
       config: opts.config,
-      publicClient: state.publicClient ?? void 0,
-      walletClient: state.walletClient ?? void 0,
+      publicClient: state.publicClient,
+      walletClient: state.walletClient,
+      requireConnected: _requireConnected
+    });
+  }
+  function decryptForTx(ctHash) {
+    const state = connectStore.getState();
+    return new DecryptForTxBuilder({
+      ctHash,
+      chainId: state.chainId,
+      account: state.account,
+      config: opts.config,
+      publicClient: state.publicClient,
+      walletClient: state.walletClient,
       requireConnected: _requireConnected
     });
   }
@@ -3222,7 +3797,7 @@ function createCofhesdkClientBase(opts) {
     const _chainId = chainId ?? state.chainId;
     const _account = account ?? state.account;
     if (_chainId == null || _account == null) {
-      throw new CofhesdkError({
+      throw new CofheError({
         code: "NOT_CONNECTED" /* NotConnected */,
         message: "ChainId or account not available.",
         hint: "Ensure client.connect() has been called, or provide chainId and account explicitly.",
@@ -3307,6 +3882,9 @@ function createCofhesdkClientBase(opts) {
     getSnapshot: connectStore.getState,
     subscribe: connectStore.subscribe,
     // flags (read-only: reflect snapshot)
+    get connection() {
+      return connectStore.getState();
+    },
     get connected() {
       return connectStore.getState().connected;
     },
@@ -3318,7 +3896,12 @@ function createCofhesdkClientBase(opts) {
     connect,
     disconnect,
     encryptInputs,
-    decryptHandle,
+    decryptForView,
+    /**
+     * @deprecated Use `decryptForView` instead. Kept for backward compatibility.
+     */
+    decryptHandle: decryptForView,
+    decryptForTx,
     permits: clientPermits
     // Add SDK-specific methods below that require connection
     // Example:
@@ -3394,15 +3977,15 @@ var zkBuilderAndCrsGenerator = (fhe, crs) => {
   const zkCrs = nodeTfhe.CompactPkeCrs.deserialize(fromHexString2(crs));
   return { zkBuilder, zkCrs };
 };
-function createCofhesdkConfig(config) {
-  return createCofhesdkConfigBase({
+function createCofheConfig(config) {
+  return createCofheConfigBase({
     environment: "node",
     ...config,
     fheKeyStorage: config.fheKeyStorage === null ? null : config.fheKeyStorage ?? createNodeStorage()
   });
 }
-function createCofhesdkClient(config) {
-  return createCofhesdkClientBase({
+function createCofheClient(config) {
+  return createCofheClientBase({
     config,
     zkBuilderAndCrsGenerator,
     tfhePublicKeyDeserializer,
@@ -3411,5 +3994,5 @@ function createCofhesdkClient(config) {
   });
 }
 
-exports.createCofhesdkClient = createCofhesdkClient;
-exports.createCofhesdkConfig = createCofhesdkConfig;
+exports.createCofheClient = createCofheClient;
+exports.createCofheConfig = createCofheConfig;