@cofhe/sdk 0.5.1 → 0.5.2

package/dist/web.cjs

@@ -2844,6 +2844,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;
@@ -2905,7 +2995,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,
@@ -2935,17 +3025,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,
@@ -2956,8 +3040,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) {
@@ -2985,46 +3069,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) {
@@ -3139,7 +3216,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,
@@ -3147,6 +3229,7 @@ async function tnSealOutputV2(params) {
     chainId,
     permission,
     overallStartTime,
+    normalized404RetryTimeoutMs,
     onPoll
   );
   if (submitResult.kind === "completed") {
@@ -3156,12 +3239,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,
@@ -3222,6 +3307,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;
@@ -3350,6 +3448,7 @@ var DecryptForViewBuilder = class extends BaseBuilder {
       chainId: this.chainId,
       permission,
       thresholdNetworkUrl,
+      retry404TimeoutMs: this.retry404TimeoutMs,
       onPoll: this.pollCallback
     });
     return PermitUtils.unseal(permit, sealed);
@@ -3625,7 +3724,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
@@ -3657,19 +3756,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,
@@ -3680,8 +3771,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();
@@ -3711,46 +3802,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) {
@@ -3868,7 +3952,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,
@@ -3876,6 +3965,7 @@ async function tnDecryptV2(params) {
     chainId,
     permission,
     overallStartTime,
+    normalized404RetryTimeoutMs,
     onPoll
   );
   if (submitResult.kind === "completed") {
@@ -3885,12 +3975,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,
@@ -3920,6 +4012,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({
@@ -4052,6 +4157,7 @@ var DecryptForTxBuilder = class extends BaseBuilder {
       chainId: this.chainId,
       permission,
       thresholdNetworkUrl,
+      retry404TimeoutMs: this.retry404TimeoutMs,
       onPoll: this.pollCallback
     });
     return {

package/dist/web.d.cts

@@ -1,4 +1,4 @@
-import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-BSbwairE.cjs';
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-BJbFeeno.cjs';
 import 'viem';
 import './types-C07FK-cL.cjs';
 import 'zod';

package/dist/web.d.ts

@@ -1,4 +1,4 @@
-import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-DDmcgZ0a.js';
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-CEno_BEf.js';
 import 'viem';
 import './types-C07FK-cL.js';
 import 'zod';

package/dist/web.js

@@ -1,4 +1,4 @@
-import { createCofheConfigBase, createCofheClientBase, fheTypeToString } from './chunk-S7OKGLFD.js';
+import { createCofheConfigBase, createCofheClientBase, fheTypeToString } from './chunk-YDOK4BDL.js';
 import './chunk-TBLR7NNE.js';
 import './chunk-MRCKUMOS.js';
 import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-4FP4V35O.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cofhe/sdk",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "type": "module",
   "description": "SDK for Fhenix COFHE coprocessor interaction",
   "main": "./dist/core.cjs",

package/web/test/tfheinit.web.test.ts

@@ -53,10 +53,10 @@ describe('@cofhe/web - TFHE Initialization Browser Tests', () => {
       await cofheClient.connect(publicClient, walletClient);
 
       // First encryption
-      expect(cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute()).resolves.not.toThrow();
+      await expect(cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute()).resolves.not.toThrow();
 
       // Second encryption should reuse initialization
-      expect(cofheClient.encryptInputs([Encryptable.uint64(50n)]).execute()).resolves.not.toThrow();
-    }, 60000);
+      await expect(cofheClient.encryptInputs([Encryptable.uint64(50n)]).execute()).resolves.not.toThrow();
+    }, 120000);
   });
 });