@cofhe/sdk 0.5.1 → 0.6.0

package/dist/core.cjs

@@ -16,51 +16,51 @@ var nacl__default = /*#__PURE__*/_interopDefault(nacl);
 // core/client.ts
 
 // core/error.ts
-var CofheErrorCode = /* @__PURE__ */ ((CofheErrorCode2) => {
-  CofheErrorCode2["InternalError"] = "INTERNAL_ERROR";
-  CofheErrorCode2["UnknownEnvironment"] = "UNKNOWN_ENVIRONMENT";
-  CofheErrorCode2["InitTfheFailed"] = "INIT_TFHE_FAILED";
-  CofheErrorCode2["InitViemFailed"] = "INIT_VIEM_FAILED";
-  CofheErrorCode2["InitEthersFailed"] = "INIT_ETHERS_FAILED";
-  CofheErrorCode2["NotConnected"] = "NOT_CONNECTED";
-  CofheErrorCode2["MissingPublicClient"] = "MISSING_PUBLIC_CLIENT";
-  CofheErrorCode2["MissingWalletClient"] = "MISSING_WALLET_CLIENT";
-  CofheErrorCode2["MissingProviderParam"] = "MISSING_PROVIDER_PARAM";
-  CofheErrorCode2["EmptySecurityZonesParam"] = "EMPTY_SECURITY_ZONES_PARAM";
-  CofheErrorCode2["InvalidPermitData"] = "INVALID_PERMIT_DATA";
-  CofheErrorCode2["InvalidPermitDomain"] = "INVALID_PERMIT_DOMAIN";
-  CofheErrorCode2["PermitNotFound"] = "PERMIT_NOT_FOUND";
-  CofheErrorCode2["CannotRemoveLastPermit"] = "CANNOT_REMOVE_LAST_PERMIT";
-  CofheErrorCode2["AccountUninitialized"] = "ACCOUNT_UNINITIALIZED";
-  CofheErrorCode2["ChainIdUninitialized"] = "CHAIN_ID_UNINITIALIZED";
-  CofheErrorCode2["SealOutputFailed"] = "SEAL_OUTPUT_FAILED";
-  CofheErrorCode2["SealOutputReturnedNull"] = "SEAL_OUTPUT_RETURNED_NULL";
-  CofheErrorCode2["InvalidUtype"] = "INVALID_UTYPE";
-  CofheErrorCode2["DecryptFailed"] = "DECRYPT_FAILED";
-  CofheErrorCode2["DecryptReturnedNull"] = "DECRYPT_RETURNED_NULL";
-  CofheErrorCode2["ZkMocksInsertCtHashesFailed"] = "ZK_MOCKS_INSERT_CT_HASHES_FAILED";
-  CofheErrorCode2["ZkMocksCalcCtHashesFailed"] = "ZK_MOCKS_CALC_CT_HASHES_FAILED";
-  CofheErrorCode2["ZkMocksVerifySignFailed"] = "ZK_MOCKS_VERIFY_SIGN_FAILED";
-  CofheErrorCode2["ZkMocksCreateProofSignatureFailed"] = "ZK_MOCKS_CREATE_PROOF_SIGNATURE_FAILED";
-  CofheErrorCode2["ZkVerifyFailed"] = "ZK_VERIFY_FAILED";
-  CofheErrorCode2["ZkPackFailed"] = "ZK_PACK_FAILED";
-  CofheErrorCode2["ZkProveFailed"] = "ZK_PROVE_FAILED";
-  CofheErrorCode2["EncryptRemainingInItems"] = "ENCRYPT_REMAINING_IN_ITEMS";
-  CofheErrorCode2["ZkUninitialized"] = "ZK_UNINITIALIZED";
-  CofheErrorCode2["ZkVerifierUrlUninitialized"] = "ZK_VERIFIER_URL_UNINITIALIZED";
-  CofheErrorCode2["ThresholdNetworkUrlUninitialized"] = "THRESHOLD_NETWORK_URL_UNINITIALIZED";
-  CofheErrorCode2["MissingConfig"] = "MISSING_CONFIG";
-  CofheErrorCode2["UnsupportedChain"] = "UNSUPPORTED_CHAIN";
-  CofheErrorCode2["MissingZkBuilderAndCrsGenerator"] = "MISSING_ZK_BUILDER_AND_CRS_GENERATOR";
-  CofheErrorCode2["MissingTfhePublicKeyDeserializer"] = "MISSING_TFHE_PUBLIC_KEY_DESERIALIZER";
-  CofheErrorCode2["MissingCompactPkeCrsDeserializer"] = "MISSING_COMPACT_PKE_CRS_DESERIALIZER";
-  CofheErrorCode2["MissingFheKey"] = "MISSING_FHE_KEY";
-  CofheErrorCode2["MissingCrs"] = "MISSING_CRS";
-  CofheErrorCode2["FetchKeysFailed"] = "FETCH_KEYS_FAILED";
-  CofheErrorCode2["PublicWalletGetChainIdFailed"] = "PUBLIC_WALLET_GET_CHAIN_ID_FAILED";
-  CofheErrorCode2["PublicWalletGetAddressesFailed"] = "PUBLIC_WALLET_GET_ADDRESSES_FAILED";
-  CofheErrorCode2["RehydrateKeysStoreFailed"] = "REHYDRATE_KEYS_STORE_FAILED";
-  return CofheErrorCode2;
+var CofheErrorCode = /* @__PURE__ */ ((CofheErrorCode3) => {
+  CofheErrorCode3["InternalError"] = "INTERNAL_ERROR";
+  CofheErrorCode3["UnknownEnvironment"] = "UNKNOWN_ENVIRONMENT";
+  CofheErrorCode3["InitTfheFailed"] = "INIT_TFHE_FAILED";
+  CofheErrorCode3["InitViemFailed"] = "INIT_VIEM_FAILED";
+  CofheErrorCode3["InitEthersFailed"] = "INIT_ETHERS_FAILED";
+  CofheErrorCode3["NotConnected"] = "NOT_CONNECTED";
+  CofheErrorCode3["MissingPublicClient"] = "MISSING_PUBLIC_CLIENT";
+  CofheErrorCode3["MissingWalletClient"] = "MISSING_WALLET_CLIENT";
+  CofheErrorCode3["MissingProviderParam"] = "MISSING_PROVIDER_PARAM";
+  CofheErrorCode3["EmptySecurityZonesParam"] = "EMPTY_SECURITY_ZONES_PARAM";
+  CofheErrorCode3["InvalidPermitData"] = "INVALID_PERMIT_DATA";
+  CofheErrorCode3["InvalidPermitDomain"] = "INVALID_PERMIT_DOMAIN";
+  CofheErrorCode3["PermitNotFound"] = "PERMIT_NOT_FOUND";
+  CofheErrorCode3["CannotRemoveLastPermit"] = "CANNOT_REMOVE_LAST_PERMIT";
+  CofheErrorCode3["AccountUninitialized"] = "ACCOUNT_UNINITIALIZED";
+  CofheErrorCode3["ChainIdUninitialized"] = "CHAIN_ID_UNINITIALIZED";
+  CofheErrorCode3["SealOutputFailed"] = "SEAL_OUTPUT_FAILED";
+  CofheErrorCode3["SealOutputReturnedNull"] = "SEAL_OUTPUT_RETURNED_NULL";
+  CofheErrorCode3["InvalidUtype"] = "INVALID_UTYPE";
+  CofheErrorCode3["DecryptFailed"] = "DECRYPT_FAILED";
+  CofheErrorCode3["DecryptReturnedNull"] = "DECRYPT_RETURNED_NULL";
+  CofheErrorCode3["ZkMocksInsertCtHashesFailed"] = "ZK_MOCKS_INSERT_CT_HASHES_FAILED";
+  CofheErrorCode3["ZkMocksCalcCtHashesFailed"] = "ZK_MOCKS_CALC_CT_HASHES_FAILED";
+  CofheErrorCode3["ZkMocksVerifySignFailed"] = "ZK_MOCKS_VERIFY_SIGN_FAILED";
+  CofheErrorCode3["ZkMocksCreateProofSignatureFailed"] = "ZK_MOCKS_CREATE_PROOF_SIGNATURE_FAILED";
+  CofheErrorCode3["ZkVerifyFailed"] = "ZK_VERIFY_FAILED";
+  CofheErrorCode3["ZkPackFailed"] = "ZK_PACK_FAILED";
+  CofheErrorCode3["ZkProveFailed"] = "ZK_PROVE_FAILED";
+  CofheErrorCode3["EncryptRemainingInItems"] = "ENCRYPT_REMAINING_IN_ITEMS";
+  CofheErrorCode3["ZkUninitialized"] = "ZK_UNINITIALIZED";
+  CofheErrorCode3["ZkVerifierUrlUninitialized"] = "ZK_VERIFIER_URL_UNINITIALIZED";
+  CofheErrorCode3["ThresholdNetworkUrlUninitialized"] = "THRESHOLD_NETWORK_URL_UNINITIALIZED";
+  CofheErrorCode3["MissingConfig"] = "MISSING_CONFIG";
+  CofheErrorCode3["UnsupportedChain"] = "UNSUPPORTED_CHAIN";
+  CofheErrorCode3["MissingZkBuilderAndCrsGenerator"] = "MISSING_ZK_BUILDER_AND_CRS_GENERATOR";
+  CofheErrorCode3["MissingTfhePublicKeyDeserializer"] = "MISSING_TFHE_PUBLIC_KEY_DESERIALIZER";
+  CofheErrorCode3["MissingCompactPkeCrsDeserializer"] = "MISSING_COMPACT_PKE_CRS_DESERIALIZER";
+  CofheErrorCode3["MissingFheKey"] = "MISSING_FHE_KEY";
+  CofheErrorCode3["MissingCrs"] = "MISSING_CRS";
+  CofheErrorCode3["FetchKeysFailed"] = "FETCH_KEYS_FAILED";
+  CofheErrorCode3["PublicWalletGetChainIdFailed"] = "PUBLIC_WALLET_GET_CHAIN_ID_FAILED";
+  CofheErrorCode3["PublicWalletGetAddressesFailed"] = "PUBLIC_WALLET_GET_ADDRESSES_FAILED";
+  CofheErrorCode3["RehydrateKeysStoreFailed"] = "REHYDRATE_KEYS_STORE_FAILED";
+  return CofheErrorCode3;
 })(CofheErrorCode || {});
 var CofheError = class _CofheError extends Error {
   code;
@@ -154,7 +154,6 @@ var isCofheError = (error) => error instanceof CofheError;
 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";
@@ -546,7 +545,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
@@ -878,9 +877,9 @@ var hardhat2 = 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"
 });
 var CofheConfigSchema = zod.z.object({
@@ -1269,6 +1268,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
   securityZone;
   stepCallback;
   inputItems;
+  hpp = false;
   zkvWalletClient;
   tfhePublicKeyDeserializer;
   compactPkeCrsDeserializer;
@@ -1398,6 +1398,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.
    *
@@ -1679,6 +1693,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.
    *
@@ -1699,9 +1722,14 @@ var EncryptInputsBuilder = class extends BaseBuilder {
    * @returns The encrypted inputs.
    */
   async execute() {
+    let items;
     if (this.chainId === chains.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;
   }
 };
 
@@ -3000,6 +3028,96 @@ function computeMinuteRampPollIntervalMs(elapsedMs, params) {
   return Math.min(params.maxIntervalMs, Math.max(params.minIntervalMs, intervalMs));
 }
 
+// core/decrypt/submitRetry.ts
+var DEFAULT_404_RETRY_TIMEOUT_MS = 1e4;
+function isRetryableSubmitStatus(status) {
+  return status === 204 || status === 404;
+}
+function normalize404RetryTimeoutMs(params) {
+  const { timeoutMs, operationLabel, errorCode } = params;
+  if (timeoutMs === void 0)
+    return DEFAULT_404_RETRY_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+    throw new CofheError({
+      code: errorCode,
+      message: `${operationLabel} submit 404 retry timeout must be a finite number greater than or equal to 0`,
+      context: {
+        timeoutMs
+      }
+    });
+  }
+  return timeoutMs;
+}
+async function classifySubmitResponse(params) {
+  const { response, extractErrorMessage } = params;
+  if (isRetryableSubmitStatus(response.status)) {
+    return { kind: "retryable", status: response.status };
+  }
+  if (response.ok) {
+    return { kind: "parse-json" };
+  }
+  let errorMessage = `HTTP ${response.status}`;
+  try {
+    const errorBody = await response.json();
+    const maybeErrorMessage = extractErrorMessage?.(errorBody);
+    if (typeof maybeErrorMessage === "string" && maybeErrorMessage.length > 0) {
+      errorMessage = maybeErrorMessage;
+    } else if (errorBody && typeof errorBody === "object") {
+      const defaultMessage = errorBody.error_message;
+      const fallbackMessage = errorBody.message;
+      if (typeof defaultMessage === "string" && defaultMessage.length > 0) {
+        errorMessage = defaultMessage;
+      } else if (typeof fallbackMessage === "string" && fallbackMessage.length > 0) {
+        errorMessage = fallbackMessage;
+      }
+    }
+  } catch {
+    errorMessage = response.statusText || errorMessage;
+  }
+  return { kind: "fatal-http", errorMessage };
+}
+function throwIfSubmitRetryTimedOut(params) {
+  const {
+    operationLabel,
+    errorCode,
+    status,
+    elapsedMs,
+    retry404TimeoutMs,
+    overallTimeoutMs,
+    thresholdNetworkUrl,
+    body,
+    attemptIndex
+  } = params;
+  if (status === 404 && elapsedMs > retry404TimeoutMs) {
+    throw new CofheError({
+      code: errorCode,
+      message: `${operationLabel} submit retried 404 responses without receiving request_id for ${retry404TimeoutMs}ms`,
+      hint: "The ciphertext may not be indexed yet. Increase set404RetryTimeout(...) if the backend is slow to index ciphertexts.",
+      context: {
+        thresholdNetworkUrl,
+        body,
+        attemptIndex,
+        timeoutMs: retry404TimeoutMs,
+        status
+      }
+    });
+  }
+  if (elapsedMs > overallTimeoutMs) {
+    throw new CofheError({
+      code: errorCode,
+      message: `${operationLabel} submit retried without receiving request_id for ${overallTimeoutMs}ms`,
+      hint: "The ciphertext may still be propagating. Try again later.",
+      context: {
+        thresholdNetworkUrl,
+        body,
+        attemptIndex,
+        timeoutMs: overallTimeoutMs,
+        status
+      }
+    });
+  }
+}
+
 // core/decrypt/tnSealOutputV2.ts
 var POLL_INTERVAL_MS = 1e3;
 var POLL_MAX_INTERVAL_MS = 1e4;
@@ -3061,7 +3179,7 @@ function parseCompletedSealOutputResponse(params) {
   }
   return convertSealedData(sealed);
 }
-async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, permission, overallStartTime, onPoll) {
+async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, permission, overallStartTime, retry404TimeoutMs, onPoll) {
   const body = {
     ct_tempkey: BigInt(ctHash).toString(16).padStart(64, "0"),
     host_chain_id: chainId,
@@ -3091,17 +3209,11 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, per
         }
       });
     }
-    if (!response.ok) {
-      let errorMessage = `HTTP ${response.status}`;
-      try {
-        const errorBody = await response.json();
-        errorMessage = errorBody.error_message || errorBody.message || errorMessage;
-      } catch {
-        errorMessage = response.statusText || errorMessage;
-      }
+    const responseClassification = await classifySubmitResponse({ response });
+    if (responseClassification.kind === "fatal-http") {
       throw new CofheError({
         code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
-        message: `sealOutput request failed: ${errorMessage}`,
+        message: `sealOutput request failed: ${responseClassification.errorMessage}`,
         hint: "Check the threshold network URL and request parameters.",
         context: {
           thresholdNetworkUrl,
@@ -3112,8 +3224,8 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, per
         }
       });
     }
-    let submitResponse;
-    if (response.status !== 204) {
+    if (responseClassification.kind === "parse-json") {
+      let submitResponse;
       try {
         submitResponse = await response.json();
       } catch (e) {
@@ -3141,46 +3253,39 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, per
       if (submitResponse.request_id) {
         return { kind: "request_id", requestId: submitResponse.request_id };
       }
-    }
-    if (response.status === 204) {
-      const elapsedMs = Date.now() - overallStartTime;
-      if (elapsedMs > SEAL_OUTPUT_TIMEOUT_MS) {
-        throw new CofheError({
-          code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
-          message: `sealOutput submit retried without receiving request_id for ${SEAL_OUTPUT_TIMEOUT_MS}ms`,
-          hint: "The ciphertext may still be propagating. Try again later.",
-          context: {
-            thresholdNetworkUrl,
-            body,
-            attemptIndex,
-            timeoutMs: SEAL_OUTPUT_TIMEOUT_MS,
-            submitResponse,
-            status: response.status
-          }
-        });
-      }
-      onPoll?.({
-        operation: "sealoutput",
-        requestId: "",
-        attemptIndex,
-        elapsedMs,
-        intervalMs: SUBMIT_RETRY_INTERVAL_MS,
-        timeoutMs: SEAL_OUTPUT_TIMEOUT_MS
+      throw new CofheError({
+        code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
+        message: `sealOutput submit response missing request_id`,
+        context: {
+          thresholdNetworkUrl,
+          body,
+          submitResponse,
+          attemptIndex
+        }
       });
-      await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS));
-      attemptIndex += 1;
-      continue;
     }
-    throw new CofheError({
-      code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
-      message: `sealOutput submit response missing request_id`,
-      context: {
-        thresholdNetworkUrl,
-        body,
-        submitResponse,
-        attemptIndex
-      }
+    const elapsedMs = Date.now() - overallStartTime;
+    throwIfSubmitRetryTimedOut({
+      operationLabel: "sealOutput",
+      errorCode: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
+      status: responseClassification.status,
+      elapsedMs,
+      retry404TimeoutMs,
+      overallTimeoutMs: SEAL_OUTPUT_TIMEOUT_MS,
+      thresholdNetworkUrl,
+      body,
+      attemptIndex
     });
+    onPoll?.({
+      operation: "sealoutput",
+      requestId: "",
+      attemptIndex,
+      elapsedMs,
+      intervalMs: SUBMIT_RETRY_INTERVAL_MS,
+      timeoutMs: SEAL_OUTPUT_TIMEOUT_MS
+    });
+    await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS));
+    attemptIndex += 1;
   }
 }
 async function pollSealOutputStatus(thresholdNetworkUrl, requestId, overallStartTime, onPoll) {
@@ -3295,7 +3400,12 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId, overallStart
   });
 }
 async function tnSealOutputV2(params) {
-  const { thresholdNetworkUrl, ctHash, chainId, permission, onPoll } = params;
+  const { thresholdNetworkUrl, ctHash, chainId, permission, retry404TimeoutMs, onPoll } = params;
+  const normalized404RetryTimeoutMs = normalize404RetryTimeoutMs({
+    timeoutMs: retry404TimeoutMs,
+    operationLabel: "sealOutput",
+    errorCode: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */
+  });
   const overallStartTime = Date.now();
   const submitResult = await submitSealOutputRequest(
     thresholdNetworkUrl,
@@ -3303,6 +3413,7 @@ async function tnSealOutputV2(params) {
     chainId,
     permission,
     overallStartTime,
+    normalized404RetryTimeoutMs,
     onPoll
   );
   if (submitResult.kind === "completed") {
@@ -3312,12 +3423,14 @@ async function tnSealOutputV2(params) {
 }
 
 // core/decrypt/decryptForViewBuilder.ts
+var DEFAULT_404_RETRY_TIMEOUT_MS2 = 1e4;
 var DecryptForViewBuilder = class extends BaseBuilder {
   ctHash;
   utype;
   permitHash;
   permit;
   pollCallback;
+  retry404TimeoutMs = DEFAULT_404_RETRY_TIMEOUT_MS2;
   constructor(params) {
     super({
       config: params.config,
@@ -3378,6 +3491,19 @@ var DecryptForViewBuilder = class extends BaseBuilder {
     this.pollCallback = callback;
     return this;
   }
+  set404RetryTimeout(timeoutMs) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+      throw new CofheError({
+        code: "INTERNAL_ERROR" /* InternalError */,
+        message: "decryptForView: set404RetryTimeout(timeoutMs) expects a finite number greater than or equal to 0.",
+        context: {
+          timeoutMs
+        }
+      });
+    }
+    this.retry404TimeoutMs = timeoutMs;
+    return this;
+  }
   withPermit(permitOrPermitHash) {
     if (typeof permitOrPermitHash === "string") {
       this.permitHash = permitOrPermitHash;
@@ -3506,6 +3632,7 @@ var DecryptForViewBuilder = class extends BaseBuilder {
       chainId: this.chainId,
       permission,
       thresholdNetworkUrl,
+      retry404TimeoutMs: this.retry404TimeoutMs,
       onPoll: this.pollCallback
     });
     return PermitUtils.unseal(permit, sealed);
@@ -3781,7 +3908,7 @@ function assertDecryptStatusResponseV2(value) {
   }
   return value;
 }
-async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, permission, overallStartTime, onPoll) {
+async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, permission, overallStartTime, retry404TimeoutMs, onPoll) {
   const body = {
     ct_tempkey: BigInt(ctHash).toString(16).padStart(64, "0"),
     host_chain_id: chainId
@@ -3813,19 +3940,11 @@ async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, perm
         }
       });
     }
-    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;
-      }
+    const responseClassification = await classifySubmitResponse({ response });
+    if (responseClassification.kind === "fatal-http") {
       throw new CofheError({
         code: "DECRYPT_FAILED" /* DecryptFailed */,
-        message: `decrypt request failed: ${errorMessage}`,
+        message: `decrypt request failed: ${responseClassification.errorMessage}`,
         hint: "Check the threshold network URL and request parameters.",
         context: {
           thresholdNetworkUrl,
@@ -3836,8 +3955,8 @@ async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, perm
         }
       });
     }
-    let submitResponse;
-    if (response.status !== 204) {
+    if (responseClassification.kind === "parse-json") {
+      let submitResponse;
       let rawJson;
       try {
         rawJson = await response.json();
@@ -3867,46 +3986,39 @@ async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, perm
       if (submitResponse.request_id) {
         return { kind: "request_id", requestId: submitResponse.request_id };
       }
-    }
-    if (response.status === 204) {
-      const elapsedMs = Date.now() - overallStartTime;
-      if (elapsedMs > DECRYPT_TIMEOUT_MS) {
-        throw new CofheError({
-          code: "DECRYPT_FAILED" /* DecryptFailed */,
-          message: `decrypt submit retried without receiving request_id for ${DECRYPT_TIMEOUT_MS}ms`,
-          hint: "The ciphertext may still be propagating. Try again later.",
-          context: {
-            thresholdNetworkUrl,
-            body,
-            attemptIndex,
-            timeoutMs: DECRYPT_TIMEOUT_MS,
-            submitResponse,
-            status: response.status
-          }
-        });
-      }
-      onPoll?.({
-        operation: "decrypt",
-        requestId: "",
-        attemptIndex,
-        elapsedMs,
-        intervalMs: SUBMIT_RETRY_INTERVAL_MS2,
-        timeoutMs: DECRYPT_TIMEOUT_MS
+      throw new CofheError({
+        code: "DECRYPT_FAILED" /* DecryptFailed */,
+        message: `decrypt submit response missing request_id`,
+        context: {
+          thresholdNetworkUrl,
+          body,
+          submitResponse,
+          attemptIndex
+        }
       });
-      await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS2));
-      attemptIndex += 1;
-      continue;
     }
-    throw new CofheError({
-      code: "DECRYPT_FAILED" /* DecryptFailed */,
-      message: `decrypt submit response missing request_id`,
-      context: {
-        thresholdNetworkUrl,
-        body,
-        submitResponse,
-        attemptIndex
-      }
+    const elapsedMs = Date.now() - overallStartTime;
+    throwIfSubmitRetryTimedOut({
+      operationLabel: "decrypt",
+      errorCode: "DECRYPT_FAILED" /* DecryptFailed */,
+      status: responseClassification.status,
+      elapsedMs,
+      retry404TimeoutMs,
+      overallTimeoutMs: DECRYPT_TIMEOUT_MS,
+      thresholdNetworkUrl,
+      body,
+      attemptIndex
     });
+    onPoll?.({
+      operation: "decrypt",
+      requestId: "",
+      attemptIndex,
+      elapsedMs,
+      intervalMs: SUBMIT_RETRY_INTERVAL_MS2,
+      timeoutMs: DECRYPT_TIMEOUT_MS
+    });
+    await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS2));
+    attemptIndex += 1;
   }
 }
 async function pollDecryptStatusV2(thresholdNetworkUrl, requestId, overallStartTime, onPoll) {
@@ -4024,7 +4136,12 @@ async function pollDecryptStatusV2(thresholdNetworkUrl, requestId, overallStartT
   });
 }
 async function tnDecryptV2(params) {
-  const { thresholdNetworkUrl, ctHash, chainId, permission, onPoll } = params;
+  const { thresholdNetworkUrl, ctHash, chainId, permission, retry404TimeoutMs, onPoll } = params;
+  const normalized404RetryTimeoutMs = normalize404RetryTimeoutMs({
+    timeoutMs: retry404TimeoutMs,
+    operationLabel: "decrypt",
+    errorCode: "DECRYPT_FAILED" /* DecryptFailed */
+  });
   const overallStartTime = Date.now();
   const submitResult = await submitDecryptRequestV2(
     thresholdNetworkUrl,
@@ -4032,6 +4149,7 @@ async function tnDecryptV2(params) {
     chainId,
     permission,
     overallStartTime,
+    normalized404RetryTimeoutMs,
     onPoll
   );
   if (submitResult.kind === "completed") {
@@ -4041,12 +4159,14 @@ async function tnDecryptV2(params) {
 }
 
 // core/decrypt/decryptForTxBuilder.ts
+var DEFAULT_404_RETRY_TIMEOUT_MS3 = 1e4;
 var DecryptForTxBuilder = class extends BaseBuilder {
   ctHash;
   permitHash;
   permit;
   permitSelection = "unset";
   pollCallback;
+  retry404TimeoutMs = DEFAULT_404_RETRY_TIMEOUT_MS3;
   constructor(params) {
     super({
       config: params.config,
@@ -4076,6 +4196,19 @@ var DecryptForTxBuilder = class extends BaseBuilder {
     this.pollCallback = callback;
     return this;
   }
+  set404RetryTimeout(timeoutMs) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+      throw new CofheError({
+        code: "INTERNAL_ERROR" /* InternalError */,
+        message: "decryptForTx: set404RetryTimeout(timeoutMs) expects a finite number greater than or equal to 0.",
+        context: {
+          timeoutMs
+        }
+      });
+    }
+    this.retry404TimeoutMs = timeoutMs;
+    return this;
+  }
   withPermit(permitOrPermitHash) {
     if (this.permitSelection === "with-permit") {
       throw new CofheError({
@@ -4208,6 +4341,7 @@ var DecryptForTxBuilder = class extends BaseBuilder {
       chainId: this.chainId,
       permission,
       thresholdNetworkUrl,
+      retry404TimeoutMs: this.retry404TimeoutMs,
       onPoll: this.pollCallback
     });
     return {
@@ -4538,7 +4672,6 @@ exports.MOCKS_ZK_VERIFIER_ADDRESS = MOCKS_ZK_VERIFIER_ADDRESS;
 exports.MOCKS_ZK_VERIFIER_SIGNER_ADDRESS = MOCKS_ZK_VERIFIER_SIGNER_ADDRESS;
 exports.MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY = MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY;
 exports.TASK_MANAGER_ADDRESS = TASK_MANAGER_ADDRESS;
-exports.TEST_BED_ADDRESS = TEST_BED_ADDRESS;
 exports.TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT = TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT;
 exports.TFHE_RS_ZK_MAX_BITS = TFHE_RS_ZK_MAX_BITS;
 exports.assertCorrectEncryptedItemInput = assertCorrectEncryptedItemInput;