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

package/core/client.ts

@@ -9,6 +9,7 @@ import { createKeysStore } from './keyStore.js';
 import { acps } from './acps.js';
 import { DecryptForViewBuilder } from './decrypt/decryptForViewBuilder.js';
 import { DecryptForTxBuilder, type DecryptForTxBuilderUnset } from './decrypt/decryptForTxBuilder.js';
+import { createDecryptLimiter } from './decrypt/decryptLimiter.js';
 import { verifyDecryptResult as verifyDecryptResultStandalone } from './decrypt/verifyDecryptResult.js';
 import { getPublicClientChainID, getWalletClientAccount } from './utils.js';
 import type { CofheClientConnectionState, CofheClientParams, CofheClient, CofheClientACPs } from './clientTypes.js';
@@ -177,12 +178,16 @@ export function createCofheClientBase<TConfig extends CofheConfig>(
     });
   }
 
+  // One cap for every decrypt this client sends, whatever hook or loop asks for it.
+  const decryptLimiter = createDecryptLimiter(opts.config.decryptConcurrency);
+
   function decryptForView<U extends FheTypes>(ctHash: bigint | string, utype: U): DecryptForViewBuilder<U> {
     const state = connectStore.getState();
 
     return new DecryptForViewBuilder({
       ctHash,
       utype,
+      limit: decryptLimiter,
       chainId: state.chainId,
       account: state.account,
 
@@ -199,6 +204,7 @@ export function createCofheClientBase<TConfig extends CofheConfig>(
 
     return new DecryptForTxBuilder({
       ctHash,
+      limit: decryptLimiter,
       chainId: state.chainId,
       account: state.account,
 

package/core/config.ts

@@ -17,6 +17,12 @@ export type CofheConfig = {
   supportedChains: CofheChain[];
   /** Default acp expiration in seconds, default is 30 days */
   defaultACPExpiration: number;
+  /**
+   * How many decrypts (`decryptForView` / `decryptForTx`) this client sends to the threshold
+   * network at a time; the rest wait their turn. A list of values decrypted at once stays within
+   * it without a limiter of its own. `Infinity` disables the cap. Default: 8
+   */
+  decryptConcurrency: number;
   /**
    * Storage scheme for the fetched fhe keys
    * FHE keys are large, and caching prevents re-fetching them on each encryptInputs call
@@ -117,6 +123,11 @@ export const CofheConfigSchema = z.object({
     .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({

package/core/decrypt/decryptForTxBuilder.ts

@@ -12,6 +12,7 @@ import { getPublicClientChainID, sleep } from '../utils';
 import { type DecryptPollCallbackFunction } from '../types';
 import { tnDecryptV2 } from './tnDecryptV2';
 import { assertDecryptTimeoutMs } from './submitRetry';
+import type { DecryptLimiter } from './decryptLimiter';
 
 const DEFAULT_404_RETRY_TIMEOUT_MS = 10_000;
 
@@ -41,6 +42,8 @@ type DecryptForTxACPSelection = 'unset' | 'with-acp' | 'without-acp';
 
 type DecryptForTxBuilderParams = BaseBuilderParams & {
   ctHash: bigint | string;
+  /** The client's decrypt cap; a builder made without one runs unlimited. */
+  limit?: DecryptLimiter;
 };
 
 export type DecryptForTxResult = {
@@ -67,6 +70,8 @@ export class DecryptForTxBuilder extends BaseBuilder {
   private pollCallback?: DecryptPollCallbackFunction;
   private retry404TimeoutMs = DEFAULT_404_RETRY_TIMEOUT_MS;
   private timeoutMs?: number;
+  private signal?: AbortSignal;
+  private limit: DecryptLimiter;
 
   constructor(params: DecryptForTxBuilderParams) {
     super({
@@ -79,6 +84,7 @@ export class DecryptForTxBuilder extends BaseBuilder {
     });
 
     this.ctHash = params.ctHash;
+    this.limit = params.limit ?? ((task) => task());
   }
 
   /**
@@ -168,6 +174,18 @@ export class DecryptForTxBuilder extends BaseBuilder {
     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(this: DecryptForTxBuilderUnset, signal: AbortSignal): DecryptForTxBuilderUnset;
+  setSignal(this: DecryptForTxBuilderSelected, signal: AbortSignal): DecryptForTxBuilderSelected;
+  setSignal(signal: AbortSignal): DecryptForTxBuilder {
+    this.signal = signal;
+    return this;
+  }
+
   /**
    * Select "use acp" mode.
    *
@@ -335,15 +353,21 @@ export class DecryptForTxBuilder extends BaseBuilder {
     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,

package/core/decrypt/decryptForViewBuilder.ts

@@ -14,6 +14,7 @@ import { tnSealOutputV2 } from './tnSealOutputV2.js';
 import { sleep } from '../utils.js';
 import { type DecryptPollCallbackFunction } from '../types.js';
 import { assertDecryptTimeoutMs } from './submitRetry.js';
+import type { DecryptLimiter } from './decryptLimiter.js';
 
 const DEFAULT_404_RETRY_TIMEOUT_MS = 10_000;
 
@@ -43,6 +44,8 @@ type DecryptForViewBuilderParams<U extends FheTypes> = BaseBuilderParams & {
   utype: U;
   acpHash?: string;
   acp?: ACP;
+  /** The client's decrypt cap; a builder made without one runs unlimited. */
+  limit?: DecryptLimiter;
 };
 
 export class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
@@ -53,6 +56,8 @@ export class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
   private pollCallback?: DecryptPollCallbackFunction;
   private retry404TimeoutMs = DEFAULT_404_RETRY_TIMEOUT_MS;
   private timeoutMs?: number;
+  private signal?: AbortSignal;
+  private limit: DecryptLimiter;
 
   constructor(params: DecryptForViewBuilderParams<U>) {
     super({
@@ -68,6 +73,7 @@ export class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
     this.utype = params.utype;
     this.acpHash = params.acpHash;
     this.acp = params.acp;
+    this.limit = params.limit ?? ((task) => task());
   }
 
   /**
@@ -147,6 +153,16 @@ export class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
     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: AbortSignal): DecryptForViewBuilder<U> {
+    this.signal = signal;
+    return this;
+  }
+
   /**
    * Select "use acp" mode (optional).
    *
@@ -302,15 +318,21 @@ export class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
     const thresholdNetworkUrl = await this.getThresholdNetworkUrl();
     const wireAcp = ACPUtils.getPublic(acp, true);
     // const sealed = await tnSealOutputV1(this.ctHash, this.chainId, permission, thresholdNetworkUrl);
-    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);
   }
 

package/core/decrypt/decryptLimiter.ts

@@ -0,0 +1,39 @@
+import { decryptAbortedError } from './submitRetry.js';
+
+/** Runs a threshold-network call when a slot is free; see `createDecryptLimiter`. */
+export type DecryptLimiter = <T>(task: () => Promise<T>, operationLabel: string, signal?: AbortSignal) => Promise<T>;
+
+/**
+ * One limiter per client: at most `max` decrypts talk to the threshold network at a time, the
+ * rest wait their turn in call order. A call whose `signal` fires while it waits leaves the queue
+ * and rejects with `Aborted` without ever starting. `Infinity` disables the cap.
+ */
+export function createDecryptLimiter(max: number): DecryptLimiter {
+  let active = 0;
+  const waiting: Array<() => void> = [];
+  return async (task, operationLabel, signal) => {
+    if (signal?.aborted) throw decryptAbortedError(operationLabel, signal);
+    if (active >= max) {
+      await new Promise<void>((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()?.();
+    }
+  };
+}

package/core/decrypt/submitRetry.ts

@@ -148,3 +148,33 @@ export function throwIfSubmitRetryTimedOut(params: {
     });
   }
 }
+
+/** The error a decrypt rejects with once its `AbortSignal` has fired. */
+export function decryptAbortedError(operationLabel: string, signal: AbortSignal): CofheError {
+  return new CofheError({
+    code: CofheErrorCode.Aborted,
+    message: `${operationLabel} aborted by the caller`,
+    cause: signal.reason instanceof Error ? signal.reason : undefined,
+  });
+}
+
+/** Rejects at once when `signal` has already fired, so an aborted call sends nothing more. */
+export function throwIfAborted(signal: AbortSignal | undefined, operationLabel: string): void {
+  if (signal?.aborted) throw decryptAbortedError(operationLabel, signal);
+}
+
+/** Waits `ms`, or rejects the moment `signal` fires: the wait between two attempts honours an abort. */
+export function sleepUnlessAborted(ms: number, signal: AbortSignal | undefined, operationLabel: string): Promise<void> {
+  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 });
+  });
+}

package/core/decrypt/tnDecryptV2.ts

@@ -11,6 +11,9 @@ import {
   classifySubmitResponse,
   normalize404RetryTimeoutMs,
   throwIfSubmitRetryTimedOut,
+  decryptAbortedError,
+  sleepUnlessAborted,
+  throwIfAborted,
 } from './submitRetry.js';
 
 // Polling configuration
@@ -187,7 +190,8 @@ async function submitDecryptRequestV2(
   overallStartTime: number,
   retry404TimeoutMs: number,
   timeoutMs: number,
-  onPoll?: DecryptPollCallbackFunction
+  onPoll?: DecryptPollCallbackFunction,
+  signal?: AbortSignal
 ): Promise<DecryptSubmitResultV2> {
   const body: {
     ct_tempkey: string;
@@ -206,6 +210,7 @@ async function submitDecryptRequestV2(
   let last404ApiErrorMessage: string | undefined;
 
   for (;;) {
+    throwIfAborted(signal, 'decrypt');
     let response: Response;
     try {
       response = await cofheFetch(
@@ -216,9 +221,11 @@ async function submitDecryptRequestV2(
             'Content-Type': 'application/json',
           },
           body: JSON.stringify(body),
+          signal,
         }
       );
     } catch (e) {
+      throwIfAborted(signal, 'decrypt');
       throw new CofheError({
         code: CofheErrorCode.DecryptFailed,
         message: `decrypt request failed`,
@@ -327,7 +334,7 @@ async function submitDecryptRequestV2(
       timeoutMs,
     });
 
-    await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS));
+    await sleepUnlessAborted(SUBMIT_RETRY_INTERVAL_MS, signal, 'decrypt');
     attemptIndex += 1;
   }
 }
@@ -337,12 +344,14 @@ async function pollDecryptStatusV2(
   requestId: string,
   overallStartTime: number,
   timeoutMs: number,
-  onPoll?: DecryptPollCallbackFunction
+  onPoll?: DecryptPollCallbackFunction,
+  signal?: AbortSignal
 ): Promise<{ decryptedValue: bigint; signature: `0x${string}` }> {
   let attemptIndex = 0;
   let completed = false;
 
   while (!completed) {
+    throwIfAborted(signal, 'decrypt');
     const elapsedMs = Date.now() - overallStartTime;
     const intervalMs = computeMinuteRampPollIntervalMs(elapsedMs, {
       minIntervalMs: POLL_INTERVAL_MS,
@@ -379,6 +388,7 @@ async function pollDecryptStatusV2(
           headers: {
             'Content-Type': 'application/json',
           },
+          signal,
         }
       );
     } catch (e) {
@@ -447,7 +457,7 @@ async function pollDecryptStatusV2(
       });
     }
 
-    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    await sleepUnlessAborted(intervalMs, signal, 'decrypt');
     attemptIndex += 1;
   }
 
@@ -471,8 +481,10 @@ export async function tnDecryptV2(params: {
   /** The whole budget, submit retries and status polling together; `DEFAULT_DECRYPT_TIMEOUT_MS` by default. */
   timeoutMs?: number;
   onPoll?: DecryptPollCallbackFunction;
+  /** Stops the decrypt at its next await: the pending fetch is aborted, and `execute()` rejects with `Aborted`. */
+  signal?: AbortSignal;
 }): Promise<{ decryptedValue: bigint; signature: `0x${string}` }> {
-  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,
@@ -488,12 +500,20 @@ export 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
+  );
 }

package/core/decrypt/tnSealOutputV2.ts

@@ -10,6 +10,9 @@ import {
   classifySubmitResponse,
   normalize404RetryTimeoutMs,
   throwIfSubmitRetryTimedOut,
+  decryptAbortedError,
+  sleepUnlessAborted,
+  throwIfAborted,
 } from './submitRetry.js';
 import {} from './tnDecryptUtils.js';
 
@@ -146,7 +149,8 @@ async function submitSealOutputRequest(
   overallStartTime: number,
   retry404TimeoutMs: number,
   timeoutMs: number,
-  onPoll?: DecryptPollCallbackFunction
+  onPoll?: DecryptPollCallbackFunction,
+  signal?: AbortSignal
 ): Promise<SealOutputSubmitResult> {
   const body = {
     ct_tempkey: BigInt(ctHash).toString(16).padStart(64, '0'),
@@ -157,6 +161,7 @@ async function submitSealOutputRequest(
   let last404ApiErrorMessage: string | undefined;
 
   for (;;) {
+    throwIfAborted(signal, 'sealOutput');
     let response: Response;
     try {
       response = await cofheFetch(
@@ -167,9 +172,11 @@ async function submitSealOutputRequest(
             'Content-Type': 'application/json',
           },
           body: JSON.stringify(body),
+          signal,
         }
       );
     } catch (e) {
+      throwIfAborted(signal, 'sealOutput');
       throw new CofheError({
         code: CofheErrorCode.SealOutputFailed,
         message: `sealOutput request failed`,
@@ -275,7 +282,7 @@ async function submitSealOutputRequest(
       timeoutMs,
     });
 
-    await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS));
+    await sleepUnlessAborted(SUBMIT_RETRY_INTERVAL_MS, signal, 'sealOutput');
     attemptIndex += 1;
   }
 }
@@ -288,12 +295,14 @@ async function pollSealOutputStatus(
   requestId: string,
   overallStartTime: number,
   timeoutMs: number,
-  onPoll?: DecryptPollCallbackFunction
+  onPoll?: DecryptPollCallbackFunction,
+  signal?: AbortSignal
 ): Promise<EthEncryptedData> {
   let attemptIndex = 0;
   let completed = false;
 
   while (!completed) {
+    throwIfAborted(signal, 'sealOutput');
     const elapsedMs = Date.now() - overallStartTime;
     const intervalMs = computeMinuteRampPollIntervalMs(elapsedMs, {
       minIntervalMs: POLL_INTERVAL_MS,
@@ -331,6 +340,7 @@ async function pollSealOutputStatus(
           headers: {
             'Content-Type': 'application/json',
           },
+          signal,
         }
       );
     } catch (e) {
@@ -401,7 +411,7 @@ async function pollSealOutputStatus(
     }
 
     // Still processing, wait before next poll
-    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    await sleepUnlessAborted(intervalMs, signal, 'sealOutput');
     attemptIndex += 1;
   }
 
@@ -425,8 +435,10 @@ export async function tnSealOutputV2(params: {
   /** The whole budget, submit retries and status polling together; `DEFAULT_DECRYPT_TIMEOUT_MS` by default. */
   timeoutMs?: number;
   onPoll?: DecryptPollCallbackFunction;
+  /** Stops the decrypt at its next await: the pending fetch is aborted, and `execute()` rejects with `Aborted`. */
+  signal?: AbortSignal;
 }): Promise<EthEncryptedData> {
-  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,
@@ -444,7 +456,8 @@ export async function tnSealOutputV2(params: {
     overallStartTime,
     normalized404RetryTimeoutMs,
     timeoutMs,
-    onPoll
+    onPoll,
+    signal
   );
 
   if (submitResult.kind === 'completed') {
@@ -452,5 +465,12 @@ export async function tnSealOutputV2(params: {
   }
 
   // Step 2: Poll for status until completed
-  return await pollSealOutputStatus(thresholdNetworkUrl, submitResult.requestId, overallStartTime, timeoutMs, onPoll);
+  return await pollSealOutputStatus(
+    thresholdNetworkUrl,
+    submitResult.requestId,
+    overallStartTime,
+    timeoutMs,
+    onPoll,
+    signal
+  );
 }

package/core/error.ts

@@ -65,6 +65,8 @@ export enum CofheErrorCode {
   ACPVerifierTimeout = 'ACP_VERIFIER_TIMEOUT',
   ACPRequired = 'ACP_REQUIRED',
   SealFailed = 'SEAL_FAILED',
+  /** The caller's `AbortSignal` fired; the operation stopped at its next await. */
+  Aborted = 'ABORTED',
 }
 
 export type CofheErrorParams = {

package/core/test/config.test.ts

@@ -284,3 +284,18 @@ describe('createCofheConfigBase - stale key rejection', () => {
     expect(() => createCofheConfigBase({ ...validBaseConfig, defaultACPExpiration: 60 })).not.toThrow();
   });
 });
+
+describe('decryptConcurrency', () => {
+  it('defaults to 8 and accepts Infinity', () => {
+    expect(createCofheConfigBase({ supportedChains: [] }).decryptConcurrency).toBe(8);
+    expect(createCofheConfigBase({ supportedChains: [], decryptConcurrency: Infinity }).decryptConcurrency).toBe(
+      Infinity
+    );
+  });
+
+  it('rejects a cap below 1', () => {
+    expect(() => createCofheConfigBase({ supportedChains: [], decryptConcurrency: 0 })).toThrow(
+      'Invalid cofhe configuration'
+    );
+  });
+});

package/core/test/decryptBuilders.test.ts

@@ -4,6 +4,7 @@ import { privateKeyToAccount } from 'viem/accounts';
 import { arbitrumSepolia } from 'viem/chains';
 import { ACPUtils, acpStore, type ACP } from '@/acps';
 import { DecryptForTxBuilder } from '../decrypt/decryptForTxBuilder.js';
+import type { DecryptLimiter } from '../decrypt/decryptLimiter.js';
 import { DecryptForViewBuilder } from '../decrypt/decryptForViewBuilder.js';
 import { tnDecryptV2 } from '../decrypt/tnDecryptV2';
 import { tnSealOutputV2 } from '../decrypt/tnSealOutputV2';
@@ -239,6 +240,15 @@ describe('DecryptForTxBuilder', () => {
       expect(() => builder.setTimeout(0)).toThrow('setTimeout(timeoutMs) expects');
       expect(() => builder.setTimeout(Number.NaN)).toThrow('setTimeout(timeoutMs) expects');
     });
+
+    it('should allow configuring an abort signal', () => {
+      const builder = createTxBuilder();
+      const { signal } = new AbortController();
+      const result = builder.setSignal(signal);
+
+      expect(result).toBe(builder);
+      expect((builder as any).signal).toBe(signal);
+    });
   });
 
   // --- execute error paths ---
@@ -397,6 +407,15 @@ describe('DecryptForViewBuilder', () => {
       expect(() => builder.setTimeout(0)).toThrow('setTimeout(timeoutMs) expects');
       expect(() => builder.setTimeout(-5)).toThrow('setTimeout(timeoutMs) expects');
     });
+
+    it('should allow configuring an abort signal', () => {
+      const builder = createViewBuilder(FheTypes.Uint32);
+      const { signal } = new AbortController();
+      const result = builder.setSignal(signal);
+
+      expect(result).toBe(builder);
+      expect((builder as any).signal).toBe(signal);
+    });
   });
 
   // --- execute error paths ---
@@ -543,6 +562,43 @@ describe('execute – expired acp (regression, issue #272)', () => {
 
       expect(tnDecryptV2).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 20_000 }));
     });
+
+    it('runs the threshold network call through the client limiter it was given', async () => {
+      vi.mocked(tnDecryptV2).mockResolvedValue({ decryptedValue: 7n, signature: '0x1234' });
+      const acp = createSignedSelfACP(now() + 3600);
+      seedACP(acp);
+      const labels: string[] = [];
+      const limit: DecryptLimiter = (task, label) => {
+        labels.push(label);
+        return task();
+      };
+      const builder = new DecryptForTxBuilder({
+        config: mockConfig,
+        publicClient,
+        walletClient,
+        chainId: TEST_CHAIN_ID,
+        account: account.address,
+        ctHash: TEST_CT_HASH,
+        requireConnected: undefined,
+        limit,
+      });
+
+      await builder.withACP(acp).execute();
+
+      expect(labels).toEqual(['decrypt']);
+      expect(tnDecryptV2).toHaveBeenCalledOnce();
+    });
+
+    it('passes the abort signal to the threshold network call', async () => {
+      vi.mocked(tnDecryptV2).mockResolvedValue({ decryptedValue: 7n, signature: '0x1234' });
+      const acp = createSignedSelfACP(now() + 3600);
+      seedACP(acp);
+      const { signal } = new AbortController();
+
+      await selectTxACP('active acp', acp).setSignal(signal).execute();
+
+      expect(tnDecryptV2).toHaveBeenCalledWith(expect.objectContaining({ signal }));
+    });
   });
 
   describe('decryptForView', () => {