@cofhe/sdk 0.3.1 → 0.4.0

package/dist/{chunk-2TPSCOW3.js → chunk-MXND5SVN.js}

@@ -1,7 +1,7 @@
 import { hardhat as hardhat$1 } from './chunk-TBLR7NNE.js';
 import { permitStore, PermitUtils, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_ADDRESS } from './chunk-NWDKXBIP.js';
 import { createStore } from 'zustand/vanilla';
-import { pad, toHex, encodePacked, keccak256, createWalletClient, http, toBytes, hashMessage, getAddress } from 'viem';
+import { encodePacked, keccak256, createWalletClient, http, getAddress, parseSignature, serializeSignature } from 'viem';
 import { hardhat } from 'viem/chains';
 import { sign, privateKeyToAccount } from 'viem/accounts';
 import { z } from 'zod';
@@ -767,7 +767,7 @@ async function insertCtHashes(items, walletClient) {
     });
   }
 }
-async function createProofSignatures(items, securityZone) {
+async function createProofSignatures(items, securityZone, account) {
   let signatures = [];
   let encInputSignerClient;
   try {
@@ -784,12 +784,15 @@ async function createProofSignatures(items, securityZone) {
   }
   try {
     for (const item of items) {
-      const packedData = encodePacked(["uint256", "int32", "uint8"], [BigInt(item.data), securityZone, item.utype]);
+      const packedData = encodePacked(
+        ["uint256", "uint8", "uint8", "address", "uint256"],
+        [BigInt(item.ctHash), item.utype, securityZone, account, BigInt(hardhat.id)]
+      );
       const messageHash = keccak256(packedData);
-      const ethSignedHash = hashMessage({ raw: toBytes(messageHash) });
-      const signature = await encInputSignerClient.signMessage({
-        message: { raw: toBytes(ethSignedHash) },
-        account: encInputSignerClient.account
+      const signature = await sign({
+        hash: messageHash,
+        privateKey: MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY,
+        to: "hex"
       });
       signatures.push(signature);
     }
@@ -820,7 +823,7 @@ async function cofheMocksZkVerifySign(items, account, securityZone, publicClient
   const _walletClient = zkvWalletClient ?? createMockZkVerifierSigner();
   const encryptableItems = await calcCtHashes(items, account, securityZone, publicClient);
   await insertCtHashes(encryptableItems, _walletClient);
-  const signatures = await createProofSignatures(encryptableItems, securityZone);
+  const signatures = await createProofSignatures(encryptableItems, securityZone, account);
   return encryptableItems.map((item, index) => ({
     ct_hash: item.ctHash.toString(),
     signature: signatures[index]
@@ -1675,13 +1678,13 @@ var serialize = (permit) => {
 var deserialize = (serialized) => {
   return PermitUtils.deserialize(serialized);
 };
-var getPermit = async (chainId, account, hash) => {
+var getPermit = (chainId, account, hash) => {
   return permitStore.getPermit(chainId, account, hash);
 };
-var getPermits = async (chainId, account) => {
+var getPermits = (chainId, account) => {
   return permitStore.getPermits(chainId, account);
 };
-var getActivePermit = async (chainId, account) => {
+var getActivePermit = (chainId, account) => {
   return permitStore.getActivePermit(chainId, account);
 };
 var getActivePermitHash = (chainId, account) => {
@@ -1930,9 +1933,7 @@ var MockThresholdNetworkAbi = [
 ];
 
 // core/decrypt/cofheMocksDecryptForView.ts
-async function cofheMocksDecryptForView(ctHash, utype, permit, publicClient, mocksDecryptDelay) {
-  if (mocksDecryptDelay > 0)
-    await sleep(mocksDecryptDelay);
+async function cofheMocksDecryptForView(ctHash, utype, permit, publicClient) {
   const permission = PermitUtils.getPermission(permit, true);
   const permissionWithBigInts = {
     ...permission,
@@ -1943,7 +1944,7 @@ async function cofheMocksDecryptForView(ctHash, utype, permit, publicClient, moc
     address: MOCKS_THRESHOLD_NETWORK_ADDRESS,
     abi: MockThresholdNetworkAbi,
     functionName: "querySealOutput",
-    args: [ctHash, BigInt(utype), permissionWithBigInts]
+    args: [BigInt(ctHash), BigInt(utype), permissionWithBigInts]
   });
   if (error != "") {
     throw new CofheError({
@@ -1984,7 +1985,7 @@ function convertSealedData(sealed) {
 }
 async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, permission) {
   const body = {
-    ct_tempkey: ctHash.toString(16).padStart(64, "0"),
+    ct_tempkey: BigInt(ctHash).toString(16).padStart(64, "0"),
     host_chain_id: chainId,
     permit: permission
   };
@@ -2177,96 +2178,6 @@ 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 = pad(toHex(ctHashBigInt2), { size: 32 });
-    const packed2 = encodePacked(
-      ["uint256", "uint32", "uint64", "bytes32"],
-      [resultBigInt2, encryptionType2, BigInt(chainId2), ctHashBytes322]
-    );
-    const messageHash2 = keccak256(packed2);
-    const signatureHex2 = await 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 = pad(toHex(ctHashBigInt), { size: 32 });
-  const packed = encodePacked(
-    ["uint256", "uint32", "uint64", "bytes32"],
-    [resultBigInt, encryptionType, BigInt(chainId), ctHashBytes32]
-  );
-  const messageHash = keccak256(packed);
-  const signatureHex = await 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/decryptForViewBuilder.ts
 var DecryptForViewBuilder = class extends BaseBuilder {
@@ -2441,7 +2352,9 @@ var DecryptForViewBuilder = class extends BaseBuilder {
   async mocksSealOutput(permit) {
     this.assertPublicClient();
     const mocksDecryptDelay = this.config.mocks.decryptDelay;
-    return cofheMocksDecryptForView(this.ctHash, this.utype, permit, this.publicClient, mocksDecryptDelay);
+    if (mocksDecryptDelay > 0)
+      await sleep(mocksDecryptDelay);
+    return cofheMocksDecryptForView(this.ctHash, this.utype, permit, this.publicClient);
   }
   /**
    * In the production context, perform a true decryption with the CoFHE coprocessor.
@@ -2490,9 +2403,57 @@ var DecryptForViewBuilder = class extends BaseBuilder {
     return convertViaUtype(this.utype, unsealed);
   }
 };
-
-// core/decrypt/tnDecrypt.ts
-function normalizeSignature(signature) {
+async function cofheMocksDecryptForTx(ctHash, utype, permit, publicClient) {
+  let allowed;
+  let error;
+  let decryptedValue;
+  if (permit !== null) {
+    let permission = PermitUtils.getPermission(permit, true);
+    const permissionWithBigInts = {
+      ...permission,
+      expiration: BigInt(permission.expiration),
+      validatorId: BigInt(permission.validatorId)
+    };
+    [allowed, error, decryptedValue] = await publicClient.readContract({
+      address: MOCKS_THRESHOLD_NETWORK_ADDRESS,
+      abi: MockThresholdNetworkAbi,
+      functionName: "decryptForTxWithPermit",
+      args: [BigInt(ctHash), permissionWithBigInts]
+    });
+  } else {
+    [allowed, error, decryptedValue] = await publicClient.readContract({
+      address: MOCKS_THRESHOLD_NETWORK_ADDRESS,
+      abi: MockThresholdNetworkAbi,
+      functionName: "decryptForTxWithoutPermit",
+      args: [BigInt(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 packed = encodePacked(["uint256", "uint256"], [BigInt(ctHash), decryptedValue]);
+  const messageHash = keccak256(packed);
+  const signature = await sign({
+    hash: messageHash,
+    privateKey: MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY,
+    to: "hex"
+  });
+  return {
+    ctHash,
+    decryptedValue,
+    signature
+  };
+}
+function normalizeTnSignature(signature) {
   if (typeof signature !== "string") {
     throw new CofheError({
       code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
@@ -2509,7 +2470,9 @@ function normalizeSignature(signature) {
       message: "decrypt response returned empty signature"
     });
   }
-  return trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed;
+  const prefixed = trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
+  const parsed = parseSignature(prefixed);
+  return serializeSignature(parsed);
 }
 function parseDecryptedBytesToBigInt(decrypted) {
   if (!Array.isArray(decrypted)) {
@@ -2546,59 +2509,79 @@ function parseDecryptedBytesToBigInt(decrypted) {
   }
   return BigInt(`0x${hex}`);
 }
-function assertTnDecryptResponse(value) {
+
+// core/decrypt/tnDecryptV2.ts
+var POLL_INTERVAL_MS2 = 1e3;
+var POLL_TIMEOUT_MS2 = 5 * 60 * 1e3;
+function assertDecryptSubmitResponseV2(value) {
   if (value == null || typeof value !== "object") {
     throw new CofheError({
       code: "DECRYPT_FAILED" /* DecryptFailed */,
-      message: "decrypt response must be a JSON object",
+      message: "decrypt submit 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)) {
+  if (typeof v.request_id !== "string" || v.request_id.trim().length === 0) {
     throw new CofheError({
-      code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
-      message: "decrypt response missing <decrypted> byte array",
-      context: { decryptResponse: value }
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: "decrypt submit response missing request_id",
+      context: {
+        value
+      }
     });
   }
-  if (typeof signature !== "string") {
+  return { request_id: v.request_id };
+}
+function assertDecryptStatusResponseV2(value) {
+  if (value == null || typeof value !== "object") {
     throw new CofheError({
-      code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
-      message: "decrypt response missing <signature> string",
-      context: { decryptResponse: value }
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: "decrypt status response must be a JSON object",
+      context: {
+        value
+      }
     });
   }
-  if (typeof encryptionType !== "number") {
+  const v = value;
+  const requestId = v.request_id;
+  const status = v.status;
+  const submittedAt = v.submitted_at;
+  if (typeof requestId !== "string" || requestId.trim().length === 0) {
     throw new CofheError({
       code: "DECRYPT_FAILED" /* DecryptFailed */,
-      message: "decrypt response missing <encryption_type> number",
-      context: { decryptResponse: value }
+      message: "decrypt status response missing request_id",
+      context: {
+        value
+      }
     });
   }
-  if (!(typeof errorMessage === "string" || errorMessage === null)) {
+  if (status !== "PROCESSING" && status !== "COMPLETED") {
     throw new CofheError({
       code: "DECRYPT_FAILED" /* DecryptFailed */,
-      message: "decrypt response field <error_message> must be string or null",
-      context: { decryptResponse: value }
+      message: "decrypt status response has invalid status",
+      context: {
+        value,
+        status
+      }
     });
   }
-  return {
-    decrypted,
-    signature,
-    encryption_type: encryptionType,
-    error_message: errorMessage
-  };
+  if (typeof submittedAt !== "string" || submittedAt.trim().length === 0) {
+    throw new CofheError({
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: "decrypt status response missing submitted_at",
+      context: {
+        value
+      }
+    });
+  }
+  return value;
 }
-async function tnDecrypt(ctHash, chainId, permission, thresholdNetworkUrl) {
+async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, permission) {
   const body = {
-    ct_tempkey: ctHash.toString(16).padStart(64, "0"),
+    ct_tempkey: BigInt(ctHash).toString(16).padStart(64, "0"),
     host_chain_id: chainId
   };
   if (permission) {
@@ -2606,7 +2589,7 @@ async function tnDecrypt(ctHash, chainId, permission, thresholdNetworkUrl) {
   }
   let response;
   try {
-    response = await fetch(`${thresholdNetworkUrl}/decrypt`, {
+    response = await fetch(`${thresholdNetworkUrl}/v2/decrypt`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
@@ -2625,18 +2608,15 @@ async function tnDecrypt(ctHash, chainId, permission, thresholdNetworkUrl) {
       }
     });
   }
-  const responseText = await response.text();
   if (!response.ok) {
-    let errorMessage = response.statusText || `HTTP ${response.status}`;
+    let errorMessage = `HTTP ${response.status}`;
     try {
-      const errorBody = JSON.parse(responseText);
+      const errorBody = await response.json();
       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;
+      errorMessage = response.statusText || errorMessage;
     }
     throw new CofheError({
       code: "DECRYPT_FAILED" /* DecryptFailed */,
@@ -2646,41 +2626,163 @@ async function tnDecrypt(ctHash, chainId, permission, thresholdNetworkUrl) {
         thresholdNetworkUrl,
         status: response.status,
         statusText: response.statusText,
-        body,
-        responseText
+        body
       }
     });
   }
   let rawJson;
   try {
-    rawJson = JSON.parse(responseText);
+    rawJson = await response.json();
   } catch (e) {
     throw new CofheError({
       code: "DECRYPT_FAILED" /* DecryptFailed */,
-      message: `Failed to parse decrypt response`,
+      message: `Failed to parse decrypt submit response`,
       cause: e instanceof Error ? e : void 0,
       context: {
         thresholdNetworkUrl,
-        body,
-        responseText
+        body
       }
     });
   }
-  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 submitResponse = assertDecryptSubmitResponseV2(rawJson);
+  return submitResponse.request_id;
+}
+async function pollDecryptStatusV2(thresholdNetworkUrl, requestId) {
+  const startTime = Date.now();
+  let completed = false;
+  while (!completed) {
+    if (Date.now() - startTime > POLL_TIMEOUT_MS2) {
+      throw new CofheError({
+        code: "DECRYPT_FAILED" /* DecryptFailed */,
+        message: `decrypt polling timed out after ${POLL_TIMEOUT_MS2}ms`,
+        hint: "The request may still be processing. Try again later.",
+        context: {
+          thresholdNetworkUrl,
+          requestId,
+          timeoutMs: POLL_TIMEOUT_MS2
+        }
+      });
+    }
+    let response;
+    try {
+      response = await fetch(`${thresholdNetworkUrl}/v2/decrypt/${requestId}`, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (e) {
+      throw new CofheError({
+        code: "DECRYPT_FAILED" /* DecryptFailed */,
+        message: `decrypt status poll failed`,
+        hint: "Ensure the threshold network URL is valid and reachable.",
+        cause: e instanceof Error ? e : void 0,
+        context: {
+          thresholdNetworkUrl,
+          requestId
+        }
+      });
+    }
+    if (response.status === 404) {
+      throw new CofheError({
+        code: "DECRYPT_FAILED" /* DecryptFailed */,
+        message: `decrypt request not found: ${requestId}`,
+        hint: "The request may have expired or been invalid.",
+        context: {
+          thresholdNetworkUrl,
+          requestId
+        }
+      });
+    }
+    if (!response.ok) {
+      let errorMessage = `HTTP ${response.status}`;
+      try {
+        const errorBody = await response.json();
+        const maybeMessage = errorBody.error_message || errorBody.message;
+        if (typeof maybeMessage === "string" && maybeMessage.length > 0)
+          errorMessage = maybeMessage;
+      } catch {
+        errorMessage = response.statusText || errorMessage;
       }
-    });
+      throw new CofheError({
+        code: "DECRYPT_FAILED" /* DecryptFailed */,
+        message: `decrypt status poll failed: ${errorMessage}`,
+        context: {
+          thresholdNetworkUrl,
+          requestId,
+          status: response.status,
+          statusText: response.statusText
+        }
+      });
+    }
+    let rawJson;
+    try {
+      rawJson = await response.json();
+    } catch (e) {
+      throw new CofheError({
+        code: "DECRYPT_FAILED" /* DecryptFailed */,
+        message: `Failed to parse decrypt status response`,
+        cause: e instanceof Error ? e : void 0,
+        context: {
+          thresholdNetworkUrl,
+          requestId
+        }
+      });
+    }
+    const statusResponse = assertDecryptStatusResponseV2(rawJson);
+    if (statusResponse.status === "COMPLETED") {
+      if (statusResponse.is_succeed === false) {
+        const errorMessage = statusResponse.error_message || "Unknown error";
+        throw new CofheError({
+          code: "DECRYPT_FAILED" /* DecryptFailed */,
+          message: `decrypt request failed: ${errorMessage}`,
+          context: {
+            thresholdNetworkUrl,
+            requestId,
+            statusResponse
+          }
+        });
+      }
+      if (statusResponse.error_message) {
+        throw new CofheError({
+          code: "DECRYPT_FAILED" /* DecryptFailed */,
+          message: `decrypt request failed: ${statusResponse.error_message}`,
+          context: {
+            thresholdNetworkUrl,
+            requestId,
+            statusResponse
+          }
+        });
+      }
+      if (!Array.isArray(statusResponse.decrypted)) {
+        throw new CofheError({
+          code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
+          message: "decrypt completed but response missing <decrypted> byte array",
+          context: {
+            thresholdNetworkUrl,
+            requestId,
+            statusResponse
+          }
+        });
+      }
+      const decryptedValue = parseDecryptedBytesToBigInt(statusResponse.decrypted);
+      const signature = normalizeTnSignature(statusResponse.signature);
+      return { decryptedValue, signature };
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS2));
   }
-  const decryptedValue = parseDecryptedBytesToBigInt(decryptResponse.decrypted);
-  const signature = normalizeSignature(decryptResponse.signature);
-  return { decryptedValue, signature };
+  throw new CofheError({
+    code: "DECRYPT_FAILED" /* DecryptFailed */,
+    message: "Polling loop exited unexpectedly",
+    context: {
+      thresholdNetworkUrl,
+      requestId
+    }
+  });
+}
+async function tnDecryptV2(ctHash, chainId, permission, thresholdNetworkUrl) {
+  const requestId = await submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, permission);
+  return await pollDecryptStatusV2(thresholdNetworkUrl, requestId);
 }
 
 // core/decrypt/decryptForTxBuilder.ts
@@ -2828,7 +2930,9 @@ var DecryptForTxBuilder = class extends BaseBuilder {
   async mocksDecryptForTx(permit) {
     this.assertPublicClient();
     const delay = this.config.mocks.decryptDelay;
-    const result = await cofheMocksDecryptForTx(this.ctHash, 0, permit, this.publicClient, delay);
+    if (delay > 0)
+      await sleep(delay);
+    const result = await cofheMocksDecryptForTx(this.ctHash, 0, permit, this.publicClient);
     return result;
   }
   /**
@@ -2839,7 +2943,7 @@ var DecryptForTxBuilder = class extends BaseBuilder {
     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);
+    const { decryptedValue, signature } = await tnDecryptV2(this.ctHash, this.chainId, permission, thresholdNetworkUrl);
     return {
       ctHash: this.ctHash,
       decryptedValue,
@@ -3047,19 +3151,19 @@ function createCofheClientBase(opts) {
       return permits.getOrCreateSharingPermit(publicClient, walletClient, options, _chainId, _account);
     },
     // Retrieval methods (auto-fill chainId/account)
-    getPermit: async (hash, chainId, account) => {
+    getPermit: (hash, chainId, account) => {
       const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
       return permits.getPermit(_chainId, _account, hash);
     },
-    getPermits: async (chainId, account) => {
+    getPermits: (chainId, account) => {
       const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
       return permits.getPermits(_chainId, _account);
     },
-    getActivePermit: async (chainId, account) => {
+    getActivePermit: (chainId, account) => {
       const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
       return permits.getActivePermit(_chainId, _account);
     },
-    getActivePermitHash: async (chainId, account) => {
+    getActivePermitHash: (chainId, account) => {
       const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
       return permits.getActivePermitHash(_chainId, _account);
     },