@cofhe/sdk 1.1.0-alpha.3 → 1.1.0-alpha.4

package/core/test/decryptLimiter.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createDecryptLimiter } from '../decrypt/decryptLimiter.js';
+import { CofheErrorCode } from '../error.js';
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((r) => (resolve = r));
+  return { promise, resolve };
+}
+
+describe('createDecryptLimiter', () => {
+  it('runs at most `max` tasks at a time, in call order', async () => {
+    const limit = createDecryptLimiter(2);
+    const gates = [deferred<number>(), deferred<number>(), deferred<number>()];
+    const started = vi.fn();
+    const run = (i: number) =>
+      limit(() => {
+        started(i);
+        return gates[i].promise;
+      }, 'decrypt');
+
+    const all = Promise.all([run(0), run(1), run(2)]);
+    await Promise.resolve();
+    expect(started.mock.calls.map(([i]) => i)).toEqual([0, 1]);
+
+    gates[0].resolve(10);
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(started.mock.calls.map(([i]) => i)).toEqual([0, 1, 2]);
+
+    gates[1].resolve(11);
+    gates[2].resolve(12);
+    await expect(all).resolves.toEqual([10, 11, 12]);
+  });
+
+  it('a task aborted while waiting never starts and frees its place in the queue', async () => {
+    const limit = createDecryptLimiter(1);
+    const gate = deferred<number>();
+    const controller = new AbortController();
+    const started = vi.fn();
+
+    const first = limit(() => gate.promise, 'decrypt');
+    const second = limit(async () => started('second'), 'decrypt', controller.signal);
+    const third = limit(async () => started('third'), 'decrypt');
+
+    controller.abort();
+    await expect(second).rejects.toMatchObject({ code: CofheErrorCode.Aborted });
+    expect(started).not.toHaveBeenCalled();
+
+    gate.resolve(1);
+    await expect(first).resolves.toBe(1);
+    await third;
+    expect(started).toHaveBeenCalledWith('third');
+    expect(started).not.toHaveBeenCalledWith('second');
+  });
+
+  it('a signal that already fired rejects before the task is queued', async () => {
+    const limit = createDecryptLimiter(1);
+    const controller = new AbortController();
+    controller.abort();
+    const task = vi.fn(async () => 1);
+
+    await expect(limit(task, 'sealOutput', controller.signal)).rejects.toMatchObject({ code: CofheErrorCode.Aborted });
+    expect(task).not.toHaveBeenCalled();
+  });
+
+  it('a failed task releases its slot', async () => {
+    const limit = createDecryptLimiter(1);
+    await expect(limit(async () => Promise.reject(new Error('boom')), 'decrypt')).rejects.toThrow('boom');
+    await expect(limit(async () => 2, 'decrypt')).resolves.toBe(2);
+  });
+});

package/core/test/submitRetry.test.ts

@@ -1,5 +1,10 @@
 import { describe, it, expect, vi } from 'vitest';
-import { classifySubmitResponse, throwIfSubmitRetryTimedOut } from '../decrypt/submitRetry.js';
+import {
+  classifySubmitResponse,
+  sleepUnlessAborted,
+  throwIfAborted,
+  throwIfSubmitRetryTimedOut,
+} from '../decrypt/submitRetry.js';
 import { CofheError, CofheErrorCode } from '../error.js';
 
 const makeResponse = (opts: {
@@ -180,3 +185,58 @@ describe('throwIfSubmitRetryTimedOut', () => {
     }
   });
 });
+
+describe('abort helpers', () => {
+  it('throwIfAborted is a no-op without a signal or before it fires, and throws Aborted after', () => {
+    const controller = new AbortController();
+    expect(() => throwIfAborted(undefined, 'decrypt')).not.toThrow();
+    expect(() => throwIfAborted(controller.signal, 'decrypt')).not.toThrow();
+
+    controller.abort(new Error('navigated away'));
+
+    let thrown: unknown;
+    try {
+      throwIfAborted(controller.signal, 'decrypt');
+    } catch (e) {
+      thrown = e;
+    }
+    expect(thrown).toBeInstanceOf(CofheError);
+    expect((thrown as CofheError).code).toBe(CofheErrorCode.Aborted);
+    expect((thrown as CofheError).message).toMatch(/^decrypt aborted by the caller/);
+    expect((thrown as CofheError).cause?.message).toBe('navigated away');
+  });
+
+  it('sleepUnlessAborted resolves after the wait, and rejects the moment the signal fires', async () => {
+    vi.useFakeTimers();
+    try {
+      const resolved = vi.fn();
+      sleepUnlessAborted(1_000, undefined, 'decrypt').then(resolved);
+      await vi.advanceTimersByTimeAsync(1_000);
+      expect(resolved).toHaveBeenCalledOnce();
+
+      const controller = new AbortController();
+      const waiting = sleepUnlessAborted(60_000, controller.signal, 'sealOutput');
+      const rejected = vi.fn();
+      waiting.catch(rejected);
+      await vi.advanceTimersByTimeAsync(10);
+      expect(rejected).not.toHaveBeenCalled();
+
+      controller.abort();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(rejected).toHaveBeenCalledOnce();
+      expect(rejected.mock.calls[0][0]).toMatchObject({ code: CofheErrorCode.Aborted });
+      expect(rejected.mock.calls[0][0].message).toMatch(/^sealOutput aborted by the caller/);
+      expect(vi.getTimerCount()).toBe(0);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('sleepUnlessAborted rejects at once for a signal that already fired', async () => {
+    const controller = new AbortController();
+    controller.abort();
+    await expect(sleepUnlessAborted(60_000, controller.signal, 'decrypt')).rejects.toMatchObject({
+      code: CofheErrorCode.Aborted,
+    });
+  });
+});

package/dist/acps.js

@@ -1,2 +1,2 @@
-export { ACPScope, ACPUtils, ACP_REVOKER_ABI, ACP_SHARE_REGISTRY_ABI, ACP_SHARE_TUPLE_ABI, ACP_STORE_DEFAULTS, ERC7984_ABI, GenerateSealingKey, ImportACPOptionsValidator, ImportACPValidator, LAYOUT_VERSION as SHARE_METADATA_VERSION, SelfACPOptionsValidator, SelfACPValidator, SharingACPOptionsValidator, SharingACPValidator, SignatureTypes, SignatureUtils, UNLABELLED, ValidationUtils, _acpStore, acpStore, addressNotZeroSchema, addressSchema, bytesNotEmptySchema, bytesSchema, clearAclServedAddresses, clearStaleStore, computeShareId, contractsSchema, decodeShareAppKey, decodeShareMetadata, decodeShareMetadataFull, describeShareLabels, describeShareMetadata, encodeShareMetadata, eventLogLabel, getACP, getACPs, getAclAddress, getAclServedAddresses, getActiveACP, getActiveACPHash, getSignatureTypesAndMessage, handlesSchema, readPostedShares, readShare, readSharesFor, removeACP, removeActiveACPHash, resetStore, seal, setACP, setActiveACPHash, shareAppKey, shareIdOfChainShare, toChainShare, unsealWithPrivateKey, validateImportACP, validateImportACPOptions, validateSelfACP, validateSelfACPOptions, validateSharingACP, validateSharingACPOptions, verifyShareLabel, verifyShareLabels, viewFunctionLabel } from './chunk-WAA2U7CT.js';
-import './chunk-OC5TGQGG.js';
+export { ACPScope, ACPUtils, ACP_REVOKER_ABI, ACP_SHARE_REGISTRY_ABI, ACP_SHARE_TUPLE_ABI, ACP_STORE_DEFAULTS, ERC7984_ABI, GenerateSealingKey, ImportACPOptionsValidator, ImportACPValidator, LAYOUT_VERSION as SHARE_METADATA_VERSION, SelfACPOptionsValidator, SelfACPValidator, SharingACPOptionsValidator, SharingACPValidator, SignatureTypes, SignatureUtils, UNLABELLED, ValidationUtils, _acpStore, acpStore, addressNotZeroSchema, addressSchema, bytesNotEmptySchema, bytesSchema, clearAclServedAddresses, clearStaleStore, computeShareId, contractsSchema, decodeShareAppKey, decodeShareMetadata, decodeShareMetadataFull, describeShareLabels, describeShareMetadata, encodeShareMetadata, eventLogLabel, getACP, getACPs, getAclAddress, getAclServedAddresses, getActiveACP, getActiveACPHash, getSignatureTypesAndMessage, handlesSchema, readPostedShares, readShare, readSharesFor, removeACP, removeActiveACPHash, resetStore, seal, setACP, setActiveACPHash, shareAppKey, shareIdOfChainShare, toChainShare, unsealWithPrivateKey, validateImportACP, validateImportACPOptions, validateSelfACP, validateSelfACPOptions, validateSharingACP, validateSharingACPOptions, verifyShareLabel, verifyShareLabels, viewFunctionLabel } from './chunk-37SG44CR.js';
+import './chunk-NJTYZ3CW.js';

package/dist/{chunk-WAA2U7CT.js → chunk-37SG44CR.js}

@@ -1,4 +1,4 @@
-import { CofheError, TASK_MANAGER_ID, COFHE_ADDRESS_BOOK_ADDRESS } from './chunk-OC5TGQGG.js';
+import { CofheError, TASK_MANAGER_ID, COFHE_ADDRESS_BOOK_ADDRESS } from './chunk-NJTYZ3CW.js';
 import { isAddress, getAddress, zeroAddress, isHex, parseAbi, keccak256, padHex, numberToHex, concatHex, toFunctionSelector, size, sliceHex, toHex, encodeAbiParameters, hexToBigInt, stringToHex, hexToNumber, toEventSignature, toFunctionSignature, decodeErrorResult, toEventSelector, decodeAbiParameters } from 'viem';
 import nacl from 'tweetnacl';
 import { z } from 'zod';

package/dist/{chunk-OC5TGQGG.js → chunk-NJTYZ3CW.js}

@@ -64,6 +64,7 @@ var CofheErrorCode = /* @__PURE__ */ ((CofheErrorCode2) => {
   CofheErrorCode2["ACPVerifierTimeout"] = "ACP_VERIFIER_TIMEOUT";
   CofheErrorCode2["ACPRequired"] = "ACP_REQUIRED";
   CofheErrorCode2["SealFailed"] = "SEAL_FAILED";
+  CofheErrorCode2["Aborted"] = "ABORTED";
   return CofheErrorCode2;
 })(CofheErrorCode || {});
 var CofheError = class _CofheError extends Error {

package/dist/{chunk-3SD2UCRE.js → chunk-PLHQYVND.js}

@@ -1,4 +1,4 @@
-import { CofheError } from './chunk-OC5TGQGG.js';
+import { CofheError } from './chunk-NJTYZ3CW.js';
 import 'viem';
 
 // core/types.ts

package/dist/{chunk-KHM6LYLU.js → chunk-ZYCIUX5C.js}

@@ -1,7 +1,7 @@
 import { hardhat as hardhat$1 } from './chunk-UKQAJK4N.js';
-import { acpStore, clearAclServedAddresses, getAclServedAddresses, computeShareId, ACP_SHARE_REGISTRY_ABI, ACPUtils, getTaskManagerAddress, verifyShareLabels, decodeShareMetadata, shareAppKey, readShare, readSharesFor, toChainShare, ACP_REVOKER_ABI, decodeShareAppKey, encodeShareMetadata } from './chunk-WAA2U7CT.js';
-import { sleep, getPublicClientChainID, getWalletClientAccount, validateBigIntInRange, toBigIntOrThrow, hexToBytes, toHexString, FheUintUTypes } from './chunk-3SD2UCRE.js';
-import { TFHE_RS_KEY_VERSION, CofheError, TFHE_RS_ZK_MAX_BITS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_ADDRESS } from './chunk-OC5TGQGG.js';
+import { acpStore, clearAclServedAddresses, getAclServedAddresses, computeShareId, ACP_SHARE_REGISTRY_ABI, ACPUtils, getTaskManagerAddress, verifyShareLabels, decodeShareMetadata, shareAppKey, readShare, readSharesFor, toChainShare, ACP_REVOKER_ABI, decodeShareAppKey, encodeShareMetadata } from './chunk-37SG44CR.js';
+import { sleep, getPublicClientChainID, getWalletClientAccount, validateBigIntInRange, toBigIntOrThrow, hexToBytes, toHexString, FheUintUTypes } from './chunk-PLHQYVND.js';
+import { TFHE_RS_KEY_VERSION, CofheError, TFHE_RS_ZK_MAX_BITS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_ADDRESS } from './chunk-NJTYZ3CW.js';
 import { createStore } from 'zustand/vanilla';
 import { parseAbi, isAddress, isAddressEqual, zeroAddress, recoverAddress, encodePacked, keccak256, createWalletClient, http, getAddress, parseSignature, serializeSignature } from 'viem';
 import { hardhat } from 'viem/chains';
@@ -481,6 +481,8 @@ var CofheConfigSchema = z.object({
   supportedChains: z.array(z.custom()),
   /** Default acp expiration in seconds, default is 30 days */
   defaultACPExpiration: z.number().optional().default(60 * 60 * 24 * 30),
+  /** Decrypts sent to the threshold network at a time per client; `Infinity` disables the cap (default 8) */
+  decryptConcurrency: z.union([z.number().min(1), z.literal(Infinity)]).optional().default(8),
   /** Storage method for fhe keys (defaults to indexedDB on web, filesystem on node) */
   fheKeyStorage: z.object({
     getItem: z.custom((val) => typeof val === "function", {
@@ -2033,6 +2035,32 @@ function throwIfSubmitRetryTimedOut(params) {
     });
   }
 }
+function decryptAbortedError(operationLabel, signal) {
+  return new CofheError({
+    code: "ABORTED" /* Aborted */,
+    message: `${operationLabel} aborted by the caller`,
+    cause: signal.reason instanceof Error ? signal.reason : void 0
+  });
+}
+function throwIfAborted(signal, operationLabel) {
+  if (signal?.aborted)
+    throw decryptAbortedError(operationLabel, signal);
+}
+function sleepUnlessAborted(ms, signal, operationLabel) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted)
+      return reject(decryptAbortedError(operationLabel, signal));
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(decryptAbortedError(operationLabel, signal));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
 function normalizeTnSignature(signature) {
   if (typeof signature !== "string") {
     throw new CofheError({
@@ -2150,7 +2178,7 @@ function parseCompletedSealOutputResponse(params) {
   }
   return convertSealedData(sealed);
 }
-async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, acp, overallStartTime, retry404TimeoutMs, timeoutMs, onPoll) {
+async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, acp, overallStartTime, retry404TimeoutMs, timeoutMs, onPoll, signal) {
   const body = {
     ct_tempkey: BigInt(ctHash).toString(16).padStart(64, "0"),
     host_chain_id: chainId,
@@ -2159,6 +2187,7 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, acp
   let attemptIndex = 0;
   let last404ApiErrorMessage;
   for (; ; ) {
+    throwIfAborted(signal, "sealOutput");
     let response;
     try {
       response = await cofheFetch(
@@ -2169,10 +2198,12 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, acp
           headers: {
             "Content-Type": "application/json"
           },
-          body: JSON.stringify(body)
+          body: JSON.stringify(body),
+          signal
         }
       );
     } catch (e) {
+      throwIfAborted(signal, "sealOutput");
       throw new CofheError({
         code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
         message: `sealOutput request failed`,
@@ -2267,13 +2298,14 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, acp
       intervalMs: SUBMIT_RETRY_INTERVAL_MS,
       timeoutMs
     });
-    await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS));
+    await sleepUnlessAborted(SUBMIT_RETRY_INTERVAL_MS, signal, "sealOutput");
     attemptIndex += 1;
   }
 }
-async function pollSealOutputStatus(thresholdNetworkUrl, requestId, overallStartTime, timeoutMs, onPoll) {
+async function pollSealOutputStatus(thresholdNetworkUrl, requestId, overallStartTime, timeoutMs, onPoll, signal) {
   let attemptIndex = 0;
   while (true) {
+    throwIfAborted(signal, "sealOutput");
     const elapsedMs = Date.now() - overallStartTime;
     const intervalMs = computeMinuteRampPollIntervalMs(elapsedMs, {
       minIntervalMs: POLL_INTERVAL_MS,
@@ -2308,7 +2340,8 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId, overallStart
           method: "GET",
           headers: {
             "Content-Type": "application/json"
-          }
+          },
+          signal
         }
       );
     } catch (e) {
@@ -2369,7 +2402,7 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId, overallStart
         requestId
       });
     }
-    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    await sleepUnlessAborted(intervalMs, signal, "sealOutput");
     attemptIndex += 1;
   }
   throw new CofheError({
@@ -2382,7 +2415,7 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId, overallStart
   });
 }
 async function tnSealOutputV2(params) {
-  const { thresholdNetworkUrl, ctHash, chainId, acp, retry404TimeoutMs, onPoll } = params;
+  const { thresholdNetworkUrl, ctHash, chainId, acp, retry404TimeoutMs, onPoll, signal } = params;
   const timeoutMs = params.timeoutMs ?? DEFAULT_DECRYPT_TIMEOUT_MS;
   const normalized404RetryTimeoutMs = normalize404RetryTimeoutMs({
     timeoutMs: retry404TimeoutMs,
@@ -2398,12 +2431,20 @@ async function tnSealOutputV2(params) {
     overallStartTime,
     normalized404RetryTimeoutMs,
     timeoutMs,
-    onPoll
+    onPoll,
+    signal
   );
   if (submitResult.kind === "completed") {
     return submitResult.sealed;
   }
-  return await pollSealOutputStatus(thresholdNetworkUrl, submitResult.requestId, overallStartTime, timeoutMs, onPoll);
+  return await pollSealOutputStatus(
+    thresholdNetworkUrl,
+    submitResult.requestId,
+    overallStartTime,
+    timeoutMs,
+    onPoll,
+    signal
+  );
 }
 
 // core/decrypt/decryptForViewBuilder.ts
@@ -2416,6 +2457,8 @@ var DecryptForViewBuilder = class extends BaseBuilder {
   pollCallback;
   retry404TimeoutMs = DEFAULT_404_RETRY_TIMEOUT_MS2;
   timeoutMs;
+  signal;
+  limit;
   constructor(params) {
     super({
       config: params.config,
@@ -2429,6 +2472,7 @@ var DecryptForViewBuilder = class extends BaseBuilder {
     this.utype = params.utype;
     this.acpHash = params.acpHash;
     this.acp = params.acp;
+    this.limit = params.limit ?? ((task) => task());
   }
   /**
    * @param chainId - Chain to decrypt values from. Used to fetch the threshold network URL and use the correct acp.
@@ -2499,6 +2543,15 @@ var DecryptForViewBuilder = class extends BaseBuilder {
     this.timeoutMs = timeoutMs;
     return this;
   }
+  /**
+   * Stops the decrypt when `signal` fires: the pending request is aborted, no further attempt is
+   * sent, and `execute()` rejects with `Aborted`. A request already processing on the threshold
+   * network is not cancelled.
+   */
+  setSignal(signal) {
+    this.signal = signal;
+    return this;
+  }
   withACP(acpOrACPHash) {
     if (typeof acpOrACPHash === "string") {
       this.acpHash = acpOrACPHash;
@@ -2622,15 +2675,20 @@ var DecryptForViewBuilder = class extends BaseBuilder {
     this.assertPublicClient();
     const thresholdNetworkUrl = await this.getThresholdNetworkUrl();
     const wireAcp = ACPUtils.getPublic(acp, true);
-    const sealed = await tnSealOutputV2({
-      ctHash: this.ctHash,
-      chainId: this.chainId,
-      acp: wireAcp,
-      thresholdNetworkUrl,
-      retry404TimeoutMs: this.retry404TimeoutMs,
-      timeoutMs: this.timeoutMs,
-      onPoll: this.pollCallback
-    });
+    const sealed = await this.limit(
+      () => tnSealOutputV2({
+        ctHash: this.ctHash,
+        chainId: this.chainId,
+        acp: wireAcp,
+        thresholdNetworkUrl,
+        retry404TimeoutMs: this.retry404TimeoutMs,
+        timeoutMs: this.timeoutMs,
+        onPoll: this.pollCallback,
+        signal: this.signal
+      }),
+      "sealOutput",
+      this.signal
+    );
     return ACPUtils.unseal(acp, sealed);
   }
   /**
@@ -2847,7 +2905,7 @@ function assertDecryptStatusResponseV2(value) {
   }
   return value;
 }
-async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, acp, overallStartTime, retry404TimeoutMs, timeoutMs, onPoll) {
+async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, acp, overallStartTime, retry404TimeoutMs, timeoutMs, onPoll, signal) {
   const body = {
     ct_tempkey: BigInt(ctHash).toString(16).padStart(64, "0"),
     host_chain_id: chainId
@@ -2858,6 +2916,7 @@ async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, acp,
   let attemptIndex = 0;
   let last404ApiErrorMessage;
   for (; ; ) {
+    throwIfAborted(signal, "decrypt");
     let response;
     try {
       response = await cofheFetch(
@@ -2868,10 +2927,12 @@ async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, acp,
           headers: {
             "Content-Type": "application/json"
           },
-          body: JSON.stringify(body)
+          body: JSON.stringify(body),
+          signal
         }
       );
     } catch (e) {
+      throwIfAborted(signal, "decrypt");
       throw new CofheError({
         code: "DECRYPT_FAILED" /* DecryptFailed */,
         message: `decrypt request failed`,
@@ -2968,13 +3029,14 @@ async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, acp,
       intervalMs: SUBMIT_RETRY_INTERVAL_MS2,
       timeoutMs
     });
-    await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS2));
+    await sleepUnlessAborted(SUBMIT_RETRY_INTERVAL_MS2, signal, "decrypt");
     attemptIndex += 1;
   }
 }
-async function pollDecryptStatusV2(thresholdNetworkUrl, requestId, overallStartTime, timeoutMs, onPoll) {
+async function pollDecryptStatusV2(thresholdNetworkUrl, requestId, overallStartTime, timeoutMs, onPoll, signal) {
   let attemptIndex = 0;
   while (true) {
+    throwIfAborted(signal, "decrypt");
     const elapsedMs = Date.now() - overallStartTime;
     const intervalMs = computeMinuteRampPollIntervalMs(elapsedMs, {
       minIntervalMs: POLL_INTERVAL_MS2,
@@ -3009,7 +3071,8 @@ async function pollDecryptStatusV2(thresholdNetworkUrl, requestId, overallStartT
           method: "GET",
           headers: {
             "Content-Type": "application/json"
-          }
+          },
+          signal
         }
       );
     } catch (e) {
@@ -3071,7 +3134,7 @@ async function pollDecryptStatusV2(thresholdNetworkUrl, requestId, overallStartT
         requestId
       });
     }
-    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    await sleepUnlessAborted(intervalMs, signal, "decrypt");
     attemptIndex += 1;
   }
   throw new CofheError({
@@ -3084,7 +3147,7 @@ async function pollDecryptStatusV2(thresholdNetworkUrl, requestId, overallStartT
   });
 }
 async function tnDecryptV2(params) {
-  const { thresholdNetworkUrl, ctHash, chainId, acp, retry404TimeoutMs, onPoll } = params;
+  const { thresholdNetworkUrl, ctHash, chainId, acp, retry404TimeoutMs, onPoll, signal } = params;
   const timeoutMs = params.timeoutMs ?? DEFAULT_DECRYPT_TIMEOUT_MS;
   const normalized404RetryTimeoutMs = normalize404RetryTimeoutMs({
     timeoutMs: retry404TimeoutMs,
@@ -3100,12 +3163,20 @@ async function tnDecryptV2(params) {
     overallStartTime,
     normalized404RetryTimeoutMs,
     timeoutMs,
-    onPoll
+    onPoll,
+    signal
   );
   if (submitResult.kind === "completed") {
     return submitResult;
   }
-  return await pollDecryptStatusV2(thresholdNetworkUrl, submitResult.requestId, overallStartTime, timeoutMs, onPoll);
+  return await pollDecryptStatusV2(
+    thresholdNetworkUrl,
+    submitResult.requestId,
+    overallStartTime,
+    timeoutMs,
+    onPoll,
+    signal
+  );
 }
 
 // core/decrypt/decryptForTxBuilder.ts
@@ -3118,6 +3189,8 @@ var DecryptForTxBuilder = class extends BaseBuilder {
   pollCallback;
   retry404TimeoutMs = DEFAULT_404_RETRY_TIMEOUT_MS3;
   timeoutMs;
+  signal;
+  limit;
   constructor(params) {
     super({
       config: params.config,
@@ -3128,6 +3201,7 @@ var DecryptForTxBuilder = class extends BaseBuilder {
       requireConnected: params.requireConnected
     });
     this.ctHash = params.ctHash;
+    this.limit = params.limit ?? ((task) => task());
   }
   setChainId(chainId) {
     this.chainId = chainId;
@@ -3165,6 +3239,10 @@ var DecryptForTxBuilder = class extends BaseBuilder {
     this.timeoutMs = timeoutMs;
     return this;
   }
+  setSignal(signal) {
+    this.signal = signal;
+    return this;
+  }
   withACP(acpOrACPHash) {
     if (this.acpSelection === "with-acp") {
       throw new CofheError({
@@ -3292,15 +3370,20 @@ var DecryptForTxBuilder = class extends BaseBuilder {
     this.assertPublicClient();
     const thresholdNetworkUrl = await this.getThresholdNetworkUrl();
     const wireAcp = acp ? ACPUtils.getPublic(acp, true) : null;
-    const { decryptedValue, signature } = await tnDecryptV2({
-      ctHash: this.ctHash,
-      chainId: this.chainId,
-      acp: wireAcp,
-      thresholdNetworkUrl,
-      retry404TimeoutMs: this.retry404TimeoutMs,
-      timeoutMs: this.timeoutMs,
-      onPoll: this.pollCallback
-    });
+    const { decryptedValue, signature } = await this.limit(
+      () => tnDecryptV2({
+        ctHash: this.ctHash,
+        chainId: this.chainId,
+        acp: wireAcp,
+        thresholdNetworkUrl,
+        retry404TimeoutMs: this.retry404TimeoutMs,
+        timeoutMs: this.timeoutMs,
+        onPoll: this.pollCallback,
+        signal: this.signal
+      }),
+      "decrypt",
+      this.signal
+    );
     return {
       ctHash: this.ctHash,
       decryptedValue,
@@ -3338,6 +3421,39 @@ var DecryptForTxBuilder = class extends BaseBuilder {
     }
   }
 };
+
+// core/decrypt/decryptLimiter.ts
+function createDecryptLimiter(max) {
+  let active = 0;
+  const waiting = [];
+  return async (task, operationLabel, signal) => {
+    if (signal?.aborted)
+      throw decryptAbortedError(operationLabel, signal);
+    if (active >= max) {
+      await new Promise((resume, reject) => {
+        const onAbort = () => {
+          const index = waiting.indexOf(start);
+          if (index >= 0)
+            waiting.splice(index, 1);
+          reject(decryptAbortedError(operationLabel, signal));
+        };
+        const start = () => {
+          signal?.removeEventListener("abort", onAbort);
+          resume();
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        waiting.push(start);
+      });
+    }
+    active += 1;
+    try {
+      return await task();
+    } finally {
+      active -= 1;
+      waiting.shift()?.();
+    }
+  };
+}
 var decryptResultSignerAbi = parseAbi(["function decryptResultSigner() view returns (address)"]);
 var UINT_TYPE_MASK2 = 0x7fn;
 var TYPE_BYTE_OFFSET2 = 8n;
@@ -3483,11 +3599,13 @@ function createCofheClientBase(opts) {
       requireConnected: _requireConnected
     });
   }
+  const decryptLimiter = createDecryptLimiter(opts.config.decryptConcurrency);
   function decryptForView(ctHash, utype) {
     const state = connectStore.getState();
     return new DecryptForViewBuilder({
       ctHash,
       utype,
+      limit: decryptLimiter,
       chainId: state.chainId,
       account: state.account,
       config: opts.config,
@@ -3500,6 +3618,7 @@ function createCofheClientBase(opts) {
     const state = connectStore.getState();
     return new DecryptForTxBuilder({
       ctHash,
+      limit: decryptLimiter,
       chainId: state.chainId,
       account: state.account,
       config: opts.config,