@cofhe/sdk 1.1.0-alpha.0 → 1.1.0-alpha.1

package/core/decrypt/decryptForTxBuilder.ts

@@ -11,6 +11,7 @@ import { cofheMocksDecryptForTx } from './cofheMocksDecryptForTx';
 import { getPublicClientChainID, sleep } from '../utils';
 import { type DecryptPollCallbackFunction } from '../types';
 import { tnDecryptV2 } from './tnDecryptV2';
+import { assertDecryptTimeoutMs } from './submitRetry';
 
 const DEFAULT_404_RETRY_TIMEOUT_MS = 10_000;
 
@@ -65,6 +66,7 @@ export class DecryptForTxBuilder extends BaseBuilder {
   private acpSelection: DecryptForTxACPSelection = 'unset';
   private pollCallback?: DecryptPollCallbackFunction;
   private retry404TimeoutMs = DEFAULT_404_RETRY_TIMEOUT_MS;
+  private timeoutMs?: number;
 
   constructor(params: DecryptForTxBuilderParams) {
     super({
@@ -153,6 +155,19 @@ export class DecryptForTxBuilder extends BaseBuilder {
     return this;
   }
 
+  /**
+   * The whole budget of this decrypt in milliseconds, submit retries and status polling together
+   * (5 minutes by default). Past it, `execute()` rejects with `DecryptFailed`; a request still
+   * processing on the threshold network is not cancelled.
+   */
+  setTimeout(this: DecryptForTxBuilderUnset, timeoutMs: number): DecryptForTxBuilderUnset;
+  setTimeout(this: DecryptForTxBuilderSelected, timeoutMs: number): DecryptForTxBuilderSelected;
+  setTimeout(timeoutMs: number): DecryptForTxBuilder {
+    assertDecryptTimeoutMs(timeoutMs, 'decryptForTx');
+    this.timeoutMs = timeoutMs;
+    return this;
+  }
+
   /**
    * Select "use acp" mode.
    *
@@ -326,6 +341,7 @@ export class DecryptForTxBuilder extends BaseBuilder {
       acp: wireAcp,
       thresholdNetworkUrl,
       retry404TimeoutMs: this.retry404TimeoutMs,
+      timeoutMs: this.timeoutMs,
       onPoll: this.pollCallback,
     });
 

package/core/decrypt/decryptForViewBuilder.ts

@@ -13,6 +13,7 @@ import { cofheMocksDecryptForView } from './cofheMocksDecryptForView.js';
 import { tnSealOutputV2 } from './tnSealOutputV2.js';
 import { sleep } from '../utils.js';
 import { type DecryptPollCallbackFunction } from '../types.js';
+import { assertDecryptTimeoutMs } from './submitRetry.js';
 
 const DEFAULT_404_RETRY_TIMEOUT_MS = 10_000;
 
@@ -51,6 +52,7 @@ export class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
   private acp?: ACP;
   private pollCallback?: DecryptPollCallbackFunction;
   private retry404TimeoutMs = DEFAULT_404_RETRY_TIMEOUT_MS;
+  private timeoutMs?: number;
 
   constructor(params: DecryptForViewBuilderParams<U>) {
     super({
@@ -134,6 +136,17 @@ export class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
     return this;
   }
 
+  /**
+   * The whole budget of this decrypt in milliseconds, submit retries and status polling together
+   * (5 minutes by default). Past it, `execute()` rejects with `SealOutputFailed`; a request still
+   * processing on the threshold network is not cancelled.
+   */
+  setTimeout(timeoutMs: number): DecryptForViewBuilder<U> {
+    assertDecryptTimeoutMs(timeoutMs, 'decryptForView');
+    this.timeoutMs = timeoutMs;
+    return this;
+  }
+
   /**
    * Select "use acp" mode (optional).
    *
@@ -295,6 +308,7 @@ export class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
       acp: wireAcp,
       thresholdNetworkUrl,
       retry404TimeoutMs: this.retry404TimeoutMs,
+      timeoutMs: this.timeoutMs,
       onPoll: this.pollCallback,
     });
     return ACPUtils.unseal(acp, sealed);

package/core/decrypt/submitRetry.ts

@@ -2,6 +2,22 @@ import { CofheError, CofheErrorCode } from '../error.js';
 import { mapApiErrorCodeToCofheErrorCode, parseApiErrorResponseBody } from './apiError.js';
 
 export const DEFAULT_404_RETRY_TIMEOUT_MS = 10_000;
+/** The default budget of one decrypt, submit retries and status polling together. */
+export const DEFAULT_DECRYPT_TIMEOUT_MS = 5 * 60 * 1000;
+
+/**
+ * Validates a builder's `setTimeout(timeoutMs)` argument: the overall budget must be a positive,
+ * finite number of milliseconds (0 would time out before the first attempt).
+ */
+export function assertDecryptTimeoutMs(timeoutMs: number, operationLabel: string): void {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new CofheError({
+      code: CofheErrorCode.InternalError,
+      message: `${operationLabel}: setTimeout(timeoutMs) expects a finite number greater than 0.`,
+      context: { timeoutMs },
+    });
+  }
+}
 
 export type SubmitRetryableStatus = 204 | 404;
 

package/core/decrypt/tnDecryptV2.ts

@@ -6,12 +6,16 @@ import { type DecryptPollCallbackFunction } from '../types';
 import { normalizeTnSignature, parseDecryptedBytesToBigInt } from './tnDecryptUtils';
 import { computeMinuteRampPollIntervalMs } from './polling.js';
 import { mapApiErrorCodeToCofheErrorCode, parseApiErrorResponseBody } from './apiError.js';
-import { classifySubmitResponse, normalize404RetryTimeoutMs, throwIfSubmitRetryTimedOut } from './submitRetry.js';
+import {
+  DEFAULT_DECRYPT_TIMEOUT_MS,
+  classifySubmitResponse,
+  normalize404RetryTimeoutMs,
+  throwIfSubmitRetryTimedOut,
+} from './submitRetry.js';
 
 // Polling configuration
 const POLL_INTERVAL_MS = 1000; // 1 second
 const POLL_MAX_INTERVAL_MS = 10_000; // 10 seconds
-const DECRYPT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes total across submit + poll
 const SUBMIT_RETRY_INTERVAL_MS = 1000; // 1 second
 
 type DecryptSubmitResponseV2 = {
@@ -182,6 +186,7 @@ async function submitDecryptRequestV2(
   acp: ACPPublic | null,
   overallStartTime: number,
   retry404TimeoutMs: number,
+  timeoutMs: number,
   onPoll?: DecryptPollCallbackFunction
 ): Promise<DecryptSubmitResultV2> {
   const body: {
@@ -306,7 +311,7 @@ async function submitDecryptRequestV2(
       status: responseClassification.status,
       elapsedMs,
       retry404TimeoutMs,
-      overallTimeoutMs: DECRYPT_TIMEOUT_MS,
+      overallTimeoutMs: timeoutMs,
       thresholdNetworkUrl,
       body,
       attemptIndex,
@@ -319,7 +324,7 @@ async function submitDecryptRequestV2(
       attemptIndex,
       elapsedMs,
       intervalMs: SUBMIT_RETRY_INTERVAL_MS,
-      timeoutMs: DECRYPT_TIMEOUT_MS,
+      timeoutMs,
     });
 
     await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS));
@@ -331,6 +336,7 @@ async function pollDecryptStatusV2(
   thresholdNetworkUrl: string,
   requestId: string,
   overallStartTime: number,
+  timeoutMs: number,
   onPoll?: DecryptPollCallbackFunction
 ): Promise<{ decryptedValue: bigint; signature: `0x${string}` }> {
   let attemptIndex = 0;
@@ -348,18 +354,18 @@ async function pollDecryptStatusV2(
       attemptIndex,
       elapsedMs,
       intervalMs,
-      timeoutMs: DECRYPT_TIMEOUT_MS,
+      timeoutMs,
     });
 
-    if (elapsedMs > DECRYPT_TIMEOUT_MS) {
+    if (elapsedMs > timeoutMs) {
       throw new CofheError({
         code: CofheErrorCode.DecryptFailed,
-        message: `decrypt polling timed out after ${DECRYPT_TIMEOUT_MS}ms`,
+        message: `decrypt polling timed out after ${timeoutMs}ms`,
         hint: 'The request may still be processing. Try again later.',
         context: {
           thresholdNetworkUrl,
           requestId,
-          timeoutMs: DECRYPT_TIMEOUT_MS,
+          timeoutMs,
         },
       });
     }
@@ -462,9 +468,12 @@ export async function tnDecryptV2(params: {
   acp: ACPPublic | null;
   thresholdNetworkUrl: string;
   retry404TimeoutMs?: number;
+  /** The whole budget, submit retries and status polling together; `DEFAULT_DECRYPT_TIMEOUT_MS` by default. */
+  timeoutMs?: number;
   onPoll?: DecryptPollCallbackFunction;
 }): Promise<{ decryptedValue: bigint; signature: `0x${string}` }> {
   const { thresholdNetworkUrl, ctHash, chainId, acp, retry404TimeoutMs, onPoll } = params;
+  const timeoutMs = params.timeoutMs ?? DEFAULT_DECRYPT_TIMEOUT_MS;
   const normalized404RetryTimeoutMs = normalize404RetryTimeoutMs({
     timeoutMs: retry404TimeoutMs,
     operationLabel: 'decrypt',
@@ -478,6 +487,7 @@ export async function tnDecryptV2(params: {
     acp,
     overallStartTime,
     normalized404RetryTimeoutMs,
+    timeoutMs,
     onPoll
   );
 
@@ -485,5 +495,5 @@ export async function tnDecryptV2(params: {
     return submitResult;
   }
 
-  return await pollDecryptStatusV2(thresholdNetworkUrl, submitResult.requestId, overallStartTime, onPoll);
+  return await pollDecryptStatusV2(thresholdNetworkUrl, submitResult.requestId, overallStartTime, timeoutMs, onPoll);
 }

package/core/decrypt/tnSealOutputV2.ts

@@ -5,13 +5,17 @@ import { CofheError, CofheErrorCode } from '../error.js';
 import { type DecryptPollCallbackFunction } from '../types.js';
 import { computeMinuteRampPollIntervalMs } from './polling.js';
 import { mapApiErrorCodeToCofheErrorCode, parseApiErrorResponseBody } from './apiError.js';
-import { classifySubmitResponse, normalize404RetryTimeoutMs, throwIfSubmitRetryTimedOut } from './submitRetry.js';
+import {
+  DEFAULT_DECRYPT_TIMEOUT_MS,
+  classifySubmitResponse,
+  normalize404RetryTimeoutMs,
+  throwIfSubmitRetryTimedOut,
+} from './submitRetry.js';
 import {} from './tnDecryptUtils.js';
 
 // Polling configuration
 const POLL_INTERVAL_MS = 1000; // 1 second
 const POLL_MAX_INTERVAL_MS = 10_000; // 10 seconds
-const SEAL_OUTPUT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes total across submit + poll
 const SUBMIT_RETRY_INTERVAL_MS = 1000; // 1 second
 
 // V2 API response types
@@ -141,6 +145,7 @@ async function submitSealOutputRequest(
   acp: ACPPublic,
   overallStartTime: number,
   retry404TimeoutMs: number,
+  timeoutMs: number,
   onPoll?: DecryptPollCallbackFunction
 ): Promise<SealOutputSubmitResult> {
   const body = {
@@ -254,7 +259,7 @@ async function submitSealOutputRequest(
       status: responseClassification.status,
       elapsedMs,
       retry404TimeoutMs,
-      overallTimeoutMs: SEAL_OUTPUT_TIMEOUT_MS,
+      overallTimeoutMs: timeoutMs,
       thresholdNetworkUrl,
       body,
       attemptIndex,
@@ -267,7 +272,7 @@ async function submitSealOutputRequest(
       attemptIndex,
       elapsedMs,
       intervalMs: SUBMIT_RETRY_INTERVAL_MS,
-      timeoutMs: SEAL_OUTPUT_TIMEOUT_MS,
+      timeoutMs,
     });
 
     await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS));
@@ -282,6 +287,7 @@ async function pollSealOutputStatus(
   thresholdNetworkUrl: string,
   requestId: string,
   overallStartTime: number,
+  timeoutMs: number,
   onPoll?: DecryptPollCallbackFunction
 ): Promise<EthEncryptedData> {
   let attemptIndex = 0;
@@ -299,19 +305,19 @@ async function pollSealOutputStatus(
       attemptIndex,
       elapsedMs,
       intervalMs,
-      timeoutMs: SEAL_OUTPUT_TIMEOUT_MS,
+      timeoutMs,
     });
 
     // Check timeout
-    if (elapsedMs > SEAL_OUTPUT_TIMEOUT_MS) {
+    if (elapsedMs > timeoutMs) {
       throw new CofheError({
         code: CofheErrorCode.SealOutputFailed,
-        message: `sealOutput polling timed out after ${SEAL_OUTPUT_TIMEOUT_MS}ms`,
+        message: `sealOutput polling timed out after ${timeoutMs}ms`,
         hint: 'The request may still be processing. Try again later.',
         context: {
           thresholdNetworkUrl,
           requestId,
-          timeoutMs: SEAL_OUTPUT_TIMEOUT_MS,
+          timeoutMs,
         },
       });
     }
@@ -416,9 +422,12 @@ export async function tnSealOutputV2(params: {
   acp: ACPPublic;
   thresholdNetworkUrl: string;
   retry404TimeoutMs?: number;
+  /** The whole budget, submit retries and status polling together; `DEFAULT_DECRYPT_TIMEOUT_MS` by default. */
+  timeoutMs?: number;
   onPoll?: DecryptPollCallbackFunction;
 }): Promise<EthEncryptedData> {
   const { thresholdNetworkUrl, ctHash, chainId, acp, retry404TimeoutMs, onPoll } = params;
+  const timeoutMs = params.timeoutMs ?? DEFAULT_DECRYPT_TIMEOUT_MS;
   const normalized404RetryTimeoutMs = normalize404RetryTimeoutMs({
     timeoutMs: retry404TimeoutMs,
     operationLabel: 'sealOutput',
@@ -434,6 +443,7 @@ export async function tnSealOutputV2(params: {
     acp,
     overallStartTime,
     normalized404RetryTimeoutMs,
+    timeoutMs,
     onPoll
   );
 
@@ -442,5 +452,5 @@ export async function tnSealOutputV2(params: {
   }
 
   // Step 2: Poll for status until completed
-  return await pollSealOutputStatus(thresholdNetworkUrl, submitResult.requestId, overallStartTime, onPoll);
+  return await pollSealOutputStatus(thresholdNetworkUrl, submitResult.requestId, overallStartTime, timeoutMs, onPoll);
 }

package/core/test/decryptBuilders.test.ts

@@ -224,6 +224,21 @@ describe('DecryptForTxBuilder', () => {
 
       expect(() => builder.set404RetryTimeout(-1)).toThrow('set404RetryTimeout(timeoutMs) expects');
     });
+
+    it('should allow configuring the overall timeout', () => {
+      const builder = createTxBuilder();
+      const result = builder.setTimeout(20_000);
+
+      expect(result).toBe(builder);
+      expect((builder as any).timeoutMs).toBe(20_000);
+    });
+
+    it('should throw for an overall timeout that is not a positive number', () => {
+      const builder = createTxBuilder();
+
+      expect(() => builder.setTimeout(0)).toThrow('setTimeout(timeoutMs) expects');
+      expect(() => builder.setTimeout(Number.NaN)).toThrow('setTimeout(timeoutMs) expects');
+    });
   });
 
   // --- execute error paths ---
@@ -367,6 +382,21 @@ describe('DecryptForViewBuilder', () => {
 
       expect(() => builder.set404RetryTimeout(-1)).toThrow('set404RetryTimeout(timeoutMs) expects');
     });
+
+    it('should allow configuring the overall timeout', () => {
+      const builder = createViewBuilder(FheTypes.Uint32);
+      const result = builder.setTimeout(20_000);
+
+      expect(result).toBe(builder);
+      expect((builder as any).timeoutMs).toBe(20_000);
+    });
+
+    it('should throw for an overall timeout that is not a positive number', () => {
+      const builder = createViewBuilder(FheTypes.Uint32);
+
+      expect(() => builder.setTimeout(0)).toThrow('setTimeout(timeoutMs) expects');
+      expect(() => builder.setTimeout(-5)).toThrow('setTimeout(timeoutMs) expects');
+    });
   });
 
   // --- execute error paths ---
@@ -503,6 +533,16 @@ describe('execute – expired acp (regression, issue #272)', () => {
       expect(result.decryptedValue).toBe(7n);
       expect(tnDecryptV2).toHaveBeenCalledOnce();
     });
+
+    it('passes the overall timeout to the threshold network call', async () => {
+      vi.mocked(tnDecryptV2).mockResolvedValue({ decryptedValue: 7n, signature: '0x1234' });
+      const acp = createSignedSelfACP(now() + 3600);
+      seedACP(acp);
+
+      await selectTxACP('active acp', acp).setTimeout(20_000).execute();
+
+      expect(tnDecryptV2).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 20_000 }));
+    });
   });
 
   describe('decryptForView', () => {
@@ -522,5 +562,16 @@ describe('execute – expired acp (regression, issue #272)', () => {
       await expect(selectViewACP('active acp', acp).execute()).rejects.toThrow('stubbed threshold network');
       expect(tnSealOutputV2).toHaveBeenCalledOnce();
     });
+
+    it('passes the overall timeout to the threshold network call', async () => {
+      vi.mocked(tnSealOutputV2).mockRejectedValue(new Error('stubbed threshold network'));
+      const acp = createSignedSelfACP(now() + 3600);
+      seedACP(acp);
+
+      await expect(selectViewACP('active acp', acp).setTimeout(20_000).execute()).rejects.toThrow(
+        'stubbed threshold network'
+      );
+      expect(tnSealOutputV2).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 20_000 }));
+    });
   });
 });

package/dist/{chunk-2EO4JSR7.js → chunk-VE7DKXSF.js}

@@ -1929,6 +1929,16 @@ function mapApiErrorCodeToCofheErrorCode(apiErrorCode, fallback) {
 
 // core/decrypt/submitRetry.ts
 var DEFAULT_404_RETRY_TIMEOUT_MS = 1e4;
+var DEFAULT_DECRYPT_TIMEOUT_MS = 5 * 60 * 1e3;
+function assertDecryptTimeoutMs(timeoutMs, operationLabel) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new CofheError({
+      code: "INTERNAL_ERROR" /* InternalError */,
+      message: `${operationLabel}: setTimeout(timeoutMs) expects a finite number greater than 0.`,
+      context: { timeoutMs }
+    });
+  }
+}
 function normalize404RetryTimeoutMs(params) {
   const { timeoutMs, operationLabel, errorCode } = params;
   if (timeoutMs === void 0)
@@ -2067,7 +2077,6 @@ function parseDecryptedBytesToBigInt(decrypted) {
 // core/decrypt/tnSealOutputV2.ts
 var POLL_INTERVAL_MS = 1e3;
 var POLL_MAX_INTERVAL_MS = 1e4;
-var SEAL_OUTPUT_TIMEOUT_MS = 5 * 60 * 1e3;
 var SUBMIT_RETRY_INTERVAL_MS = 1e3;
 function numberArrayToUint8Array(arr) {
   return new Uint8Array(arr);
@@ -2125,7 +2134,7 @@ function parseCompletedSealOutputResponse(params) {
   }
   return convertSealedData(sealed);
 }
-async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, acp, overallStartTime, retry404TimeoutMs, onPoll) {
+async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, acp, overallStartTime, retry404TimeoutMs, timeoutMs, onPoll) {
   const body = {
     ct_tempkey: BigInt(ctHash).toString(16).padStart(64, "0"),
     host_chain_id: chainId,
@@ -2228,7 +2237,7 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, acp
       status: responseClassification.status,
       elapsedMs,
       retry404TimeoutMs,
-      overallTimeoutMs: SEAL_OUTPUT_TIMEOUT_MS,
+      overallTimeoutMs: timeoutMs,
       thresholdNetworkUrl,
       body,
       attemptIndex,
@@ -2240,13 +2249,13 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, acp
       attemptIndex,
       elapsedMs,
       intervalMs: SUBMIT_RETRY_INTERVAL_MS,
-      timeoutMs: SEAL_OUTPUT_TIMEOUT_MS
+      timeoutMs
     });
     await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS));
     attemptIndex += 1;
   }
 }
-async function pollSealOutputStatus(thresholdNetworkUrl, requestId, overallStartTime, onPoll) {
+async function pollSealOutputStatus(thresholdNetworkUrl, requestId, overallStartTime, timeoutMs, onPoll) {
   let attemptIndex = 0;
   while (true) {
     const elapsedMs = Date.now() - overallStartTime;
@@ -2260,17 +2269,17 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId, overallStart
       attemptIndex,
       elapsedMs,
       intervalMs,
-      timeoutMs: SEAL_OUTPUT_TIMEOUT_MS
+      timeoutMs
     });
-    if (elapsedMs > SEAL_OUTPUT_TIMEOUT_MS) {
+    if (elapsedMs > timeoutMs) {
       throw new CofheError({
         code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
-        message: `sealOutput polling timed out after ${SEAL_OUTPUT_TIMEOUT_MS}ms`,
+        message: `sealOutput polling timed out after ${timeoutMs}ms`,
         hint: "The request may still be processing. Try again later.",
         context: {
           thresholdNetworkUrl,
           requestId,
-          timeoutMs: SEAL_OUTPUT_TIMEOUT_MS
+          timeoutMs
         }
       });
     }
@@ -2358,6 +2367,7 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId, overallStart
 }
 async function tnSealOutputV2(params) {
   const { thresholdNetworkUrl, ctHash, chainId, acp, retry404TimeoutMs, onPoll } = params;
+  const timeoutMs = params.timeoutMs ?? DEFAULT_DECRYPT_TIMEOUT_MS;
   const normalized404RetryTimeoutMs = normalize404RetryTimeoutMs({
     timeoutMs: retry404TimeoutMs,
     operationLabel: "sealOutput",
@@ -2371,12 +2381,13 @@ async function tnSealOutputV2(params) {
     acp,
     overallStartTime,
     normalized404RetryTimeoutMs,
+    timeoutMs,
     onPoll
   );
   if (submitResult.kind === "completed") {
     return submitResult.sealed;
   }
-  return await pollSealOutputStatus(thresholdNetworkUrl, submitResult.requestId, overallStartTime, onPoll);
+  return await pollSealOutputStatus(thresholdNetworkUrl, submitResult.requestId, overallStartTime, timeoutMs, onPoll);
 }
 
 // core/decrypt/decryptForViewBuilder.ts
@@ -2388,6 +2399,7 @@ var DecryptForViewBuilder = class extends BaseBuilder {
   acp;
   pollCallback;
   retry404TimeoutMs = DEFAULT_404_RETRY_TIMEOUT_MS2;
+  timeoutMs;
   constructor(params) {
     super({
       config: params.config,
@@ -2461,6 +2473,16 @@ var DecryptForViewBuilder = class extends BaseBuilder {
     this.retry404TimeoutMs = timeoutMs;
     return this;
   }
+  /**
+   * The whole budget of this decrypt in milliseconds, submit retries and status polling together
+   * (5 minutes by default). Past it, `execute()` rejects with `SealOutputFailed`; a request still
+   * processing on the threshold network is not cancelled.
+   */
+  setTimeout(timeoutMs) {
+    assertDecryptTimeoutMs(timeoutMs, "decryptForView");
+    this.timeoutMs = timeoutMs;
+    return this;
+  }
   withACP(acpOrACPHash) {
     if (typeof acpOrACPHash === "string") {
       this.acpHash = acpOrACPHash;
@@ -2590,6 +2612,7 @@ var DecryptForViewBuilder = class extends BaseBuilder {
       acp: wireAcp,
       thresholdNetworkUrl,
       retry404TimeoutMs: this.retry404TimeoutMs,
+      timeoutMs: this.timeoutMs,
       onPoll: this.pollCallback
     });
     return ACPUtils.unseal(acp, sealed);
@@ -2692,7 +2715,6 @@ async function cofheMocksDecryptForTx(ctHash, utype, acp, publicClient) {
 // core/decrypt/tnDecryptV2.ts
 var POLL_INTERVAL_MS2 = 1e3;
 var POLL_MAX_INTERVAL_MS2 = 1e4;
-var DECRYPT_TIMEOUT_MS = 5 * 60 * 1e3;
 var SUBMIT_RETRY_INTERVAL_MS2 = 1e3;
 function assertDecryptSubmitResponseV2(value) {
   if (value == null || typeof value !== "object") {
@@ -2809,7 +2831,7 @@ function assertDecryptStatusResponseV2(value) {
   }
   return value;
 }
-async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, acp, overallStartTime, retry404TimeoutMs, onPoll) {
+async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, acp, overallStartTime, retry404TimeoutMs, timeoutMs, onPoll) {
   const body = {
     ct_tempkey: BigInt(ctHash).toString(16).padStart(64, "0"),
     host_chain_id: chainId
@@ -2916,7 +2938,7 @@ async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, acp,
       status: responseClassification.status,
       elapsedMs,
       retry404TimeoutMs,
-      overallTimeoutMs: DECRYPT_TIMEOUT_MS,
+      overallTimeoutMs: timeoutMs,
       thresholdNetworkUrl,
       body,
       attemptIndex,
@@ -2928,13 +2950,13 @@ async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, acp,
       attemptIndex,
       elapsedMs,
       intervalMs: SUBMIT_RETRY_INTERVAL_MS2,
-      timeoutMs: DECRYPT_TIMEOUT_MS
+      timeoutMs
     });
     await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS2));
     attemptIndex += 1;
   }
 }
-async function pollDecryptStatusV2(thresholdNetworkUrl, requestId, overallStartTime, onPoll) {
+async function pollDecryptStatusV2(thresholdNetworkUrl, requestId, overallStartTime, timeoutMs, onPoll) {
   let attemptIndex = 0;
   while (true) {
     const elapsedMs = Date.now() - overallStartTime;
@@ -2948,17 +2970,17 @@ async function pollDecryptStatusV2(thresholdNetworkUrl, requestId, overallStartT
       attemptIndex,
       elapsedMs,
       intervalMs,
-      timeoutMs: DECRYPT_TIMEOUT_MS
+      timeoutMs
     });
-    if (elapsedMs > DECRYPT_TIMEOUT_MS) {
+    if (elapsedMs > timeoutMs) {
       throw new CofheError({
         code: "DECRYPT_FAILED" /* DecryptFailed */,
-        message: `decrypt polling timed out after ${DECRYPT_TIMEOUT_MS}ms`,
+        message: `decrypt polling timed out after ${timeoutMs}ms`,
         hint: "The request may still be processing. Try again later.",
         context: {
           thresholdNetworkUrl,
           requestId,
-          timeoutMs: DECRYPT_TIMEOUT_MS
+          timeoutMs
         }
       });
     }
@@ -3047,6 +3069,7 @@ async function pollDecryptStatusV2(thresholdNetworkUrl, requestId, overallStartT
 }
 async function tnDecryptV2(params) {
   const { thresholdNetworkUrl, ctHash, chainId, acp, retry404TimeoutMs, onPoll } = params;
+  const timeoutMs = params.timeoutMs ?? DEFAULT_DECRYPT_TIMEOUT_MS;
   const normalized404RetryTimeoutMs = normalize404RetryTimeoutMs({
     timeoutMs: retry404TimeoutMs,
     operationLabel: "decrypt",
@@ -3060,12 +3083,13 @@ async function tnDecryptV2(params) {
     acp,
     overallStartTime,
     normalized404RetryTimeoutMs,
+    timeoutMs,
     onPoll
   );
   if (submitResult.kind === "completed") {
     return submitResult;
   }
-  return await pollDecryptStatusV2(thresholdNetworkUrl, submitResult.requestId, overallStartTime, onPoll);
+  return await pollDecryptStatusV2(thresholdNetworkUrl, submitResult.requestId, overallStartTime, timeoutMs, onPoll);
 }
 
 // core/decrypt/decryptForTxBuilder.ts
@@ -3077,6 +3101,7 @@ var DecryptForTxBuilder = class extends BaseBuilder {
   acpSelection = "unset";
   pollCallback;
   retry404TimeoutMs = DEFAULT_404_RETRY_TIMEOUT_MS3;
+  timeoutMs;
   constructor(params) {
     super({
       config: params.config,
@@ -3119,6 +3144,11 @@ var DecryptForTxBuilder = class extends BaseBuilder {
     this.retry404TimeoutMs = timeoutMs;
     return this;
   }
+  setTimeout(timeoutMs) {
+    assertDecryptTimeoutMs(timeoutMs, "decryptForTx");
+    this.timeoutMs = timeoutMs;
+    return this;
+  }
   withACP(acpOrACPHash) {
     if (this.acpSelection === "with-acp") {
       throw new CofheError({
@@ -3252,6 +3282,7 @@ var DecryptForTxBuilder = class extends BaseBuilder {
       acp: wireAcp,
       thresholdNetworkUrl,
       retry404TimeoutMs: this.retry404TimeoutMs,
+      timeoutMs: this.timeoutMs,
       onPoll: this.pollCallback
     });
     return {

package/dist/{clientTypes-CnslFzxB.d.ts → clientTypes-B-qOZCx0.d.ts}

@@ -465,6 +465,7 @@ declare class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
     private acp?;
     private pollCallback?;
     private retry404TimeoutMs;
+    private timeoutMs?;
     constructor(params: DecryptForViewBuilderParams<U>);
     /**
      * @param chainId - Chain to decrypt values from. Used to fetch the threshold network URL and use the correct acp.
@@ -500,6 +501,12 @@ declare class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
     getAccount(): string | undefined;
     onPoll(callback: DecryptPollCallbackFunction): DecryptForViewBuilder<U>;
     set404RetryTimeout(timeoutMs: number): DecryptForViewBuilder<U>;
+    /**
+     * The whole budget of this decrypt in milliseconds, submit retries and status polling together
+     * (5 minutes by default). Past it, `execute()` rejects with `SealOutputFailed`; a request still
+     * processing on the threshold network is not cancelled.
+     */
+    setTimeout(timeoutMs: number): DecryptForViewBuilder<U>;
     /**
      * Select "use acp" mode (optional).
      *
@@ -603,6 +610,7 @@ declare class DecryptForTxBuilder extends BaseBuilder {
     private acpSelection;
     private pollCallback?;
     private retry404TimeoutMs;
+    private timeoutMs?;
     constructor(params: DecryptForTxBuilderParams);
     /**
      * @param chainId - Chain to decrypt values from. Used to fetch the threshold network URL and use the correct acp.
@@ -642,6 +650,13 @@ declare class DecryptForTxBuilder extends BaseBuilder {
     onPoll(this: DecryptForTxBuilderSelected, callback: DecryptPollCallbackFunction): DecryptForTxBuilderSelected;
     set404RetryTimeout(this: DecryptForTxBuilderUnset, timeoutMs: number): DecryptForTxBuilderUnset;
     set404RetryTimeout(this: DecryptForTxBuilderSelected, timeoutMs: number): DecryptForTxBuilderSelected;
+    /**
+     * The whole budget of this decrypt in milliseconds, submit retries and status polling together
+     * (5 minutes by default). Past it, `execute()` rejects with `DecryptFailed`; a request still
+     * processing on the threshold network is not cancelled.
+     */
+    setTimeout(this: DecryptForTxBuilderUnset, timeoutMs: number): DecryptForTxBuilderUnset;
+    setTimeout(this: DecryptForTxBuilderSelected, timeoutMs: number): DecryptForTxBuilderSelected;
     /**
      * Select "use acp" mode.
      *