@cofhe/sdk 1.0.1 → 1.1.0-alpha.1

package/dist/{chunk-GKEJHZ52.js → chunk-VE7DKXSF.js}

@@ -1,9 +1,9 @@
 import { hardhat as hardhat$1 } from './chunk-UKQAJK4N.js';
-import { acpStore, clearAclServedAddresses, getAclServedAddresses, computeShareId, ACPUtils, getTaskManagerAddress, verifyShareLabels, decodeShareMetadata, shareAppKey, ACP_SHARE_REGISTRY_ABI, 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-3L2IVPMI.js';
+import { sleep, getPublicClientChainID, getWalletClientAccount, validateBigIntInRange, toBigIntOrThrow, hexToBytes, toHexString, FheUintUTypes } from './chunk-WJGTPW7K.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-J23FYAI2.js';
 import { createStore } from 'zustand/vanilla';
-import { parseAbi, isAddress, isAddressEqual, zeroAddress, recoverAddress, encodePacked, keccak256, createWalletClient, http, getAddress, parseSignature, serializeSignature } from 'viem';
+import { parseAbi, isAddressEqual, zeroAddress, recoverAddress, encodePacked, keccak256, createWalletClient, http, getAddress, parseSignature, serializeSignature } from 'viem';
 import { hardhat } from 'viem/chains';
 import { sign, privateKeyToAccount } from 'viem/accounts';
 import { z } from 'zod';
@@ -110,22 +110,19 @@ var zkProve = async (builder, crs, metadata) => {
     }, 0);
   });
 };
-var constructZkPoKMetadata = (accountAddr, securityZone, chainId, consumingContract) => {
+var constructZkPoKMetadata = (accountAddr, securityZone, chainId) => {
   const accountAddrNoPrefix = accountAddr.startsWith("0x") ? accountAddr.slice(2) : accountAddr;
   const accountBytes = hexToBytes(accountAddrNoPrefix);
-  const contractNoPrefix = consumingContract.startsWith("0x") ? consumingContract.slice(2) : consumingContract;
-  const contractBytes = hexToBytes(contractNoPrefix);
   const chainIdBytes = new Uint8Array(32);
   let value = chainId;
   for (let i = 31; i >= 0 && value > 0; i--) {
     chainIdBytes[i] = value & 255;
     value = value >>> 8;
   }
-  const metadata = new Uint8Array(1 + accountBytes.length + 32 + contractBytes.length);
+  const metadata = new Uint8Array(1 + accountBytes.length + 32);
   metadata[0] = securityZone;
   metadata.set(accountBytes, 1);
   metadata.set(chainIdBytes, 1 + accountBytes.length);
-  metadata.set(contractBytes, 1 + accountBytes.length + 32);
   return metadata;
 };
 var zkVerifyBatch = async (verifierUrl, serializedBytes, address, securityZone, chainId, consumingContract) => {
@@ -1005,33 +1002,20 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     return this.consumingContract;
   }
   /**
-   * Asserts that this.consumingContract is populated and is an address.
-   * Runs before TFHE init, key fetching and proving, so a bad address costs
-   * nothing: the contract is bound into the proof, and a proof built for a
-   * non-address could only fail at the verifier, after the expensive step.
-   * @throws {CofheError} If consumingContract is not set or is not an address
+   * Asserts that this.consumingContract is populated
+   * @throws {CofheError} If consumingContract is not set
    */
   assertConsumingContract() {
-    if (!this.consumingContract) {
-      throw new CofheError({
-        code: "CONSUMING_CONTRACT_UNINITIALIZED" /* ConsumingContractUninitialized */,
-        message: "Consuming contract is not set",
-        hint: "Use setConsumingContract(...) to set the contract that will consume the encrypted inputs.",
-        context: {
-          consumingContract: this.consumingContract
-        }
-      });
-    }
-    if (!isAddress(this.consumingContract, { strict: false })) {
-      throw new CofheError({
-        code: "CONSUMING_CONTRACT_INVALID" /* ConsumingContractInvalid */,
-        message: "Consuming contract is not an address",
-        hint: "setConsumingContract(...) takes the 20-byte address of the contract that will consume the encrypted inputs.",
-        context: {
-          consumingContract: this.consumingContract
-        }
-      });
-    }
+    if (this.consumingContract)
+      return;
+    throw new CofheError({
+      code: "CONSUMING_CONTRACT_UNINITIALIZED" /* ConsumingContractUninitialized */,
+      message: "Consuming contract is not set",
+      hint: "Use setConsumingContract(...) to set the contract that will consume the encrypted inputs.",
+      context: {
+        consumingContract: this.consumingContract
+      }
+    });
   }
   setUseWorker(useWorker) {
     this.useWorker = useWorker;
@@ -1247,7 +1231,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     zkBuilder = zkPack(this.inputItems, zkBuilder);
     this.fireStepEnd("pack" /* Pack */);
     this.fireStepStart("prove" /* Prove */);
-    const metadata = constructZkPoKMetadata(this.account, this.securityZone, this.chainId, this.consumingContract);
+    const metadata = constructZkPoKMetadata(this.account, this.securityZone, this.chainId);
     let proof = null;
     let usedWorker = false;
     let workerFailedError;
@@ -1425,23 +1409,25 @@ var getBlockRevokerData = async (publicClient) => {
   }
   return revokerData;
 };
-var revokeACP = async (acp, walletClient) => {
+var prepareRevokeACP = (acp) => {
   if (acp.revokerContract === zeroAddress || acp.revokerData === 0) {
     throw new Error("ACP is not revocable: it has no revoker (revokerContract/revokerData unset)");
   }
+  return {
+    address: acp.revokerContract,
+    abi: ACP_REVOKER_ABI,
+    functionName: "revokeSingle",
+    args: [BigInt(acp.revokerData)]
+  };
+};
+var revokeACP = async (acp, walletClient) => {
+  const write = prepareRevokeACP(acp);
   if (walletClient.account == null)
     throw new Error("Missing walletClient account");
   if (walletClient.account.address.toLowerCase() !== acp.issuer.toLowerCase()) {
     throw new Error("Only the acp issuer can revoke it");
   }
-  return walletClient.writeContract({
-    address: acp.revokerContract,
-    abi: ACP_REVOKER_ABI,
-    functionName: "revokeSingle",
-    args: [BigInt(acp.revokerData)],
-    account: walletClient.account,
-    chain: walletClient.chain
-  });
+  return walletClient.writeContract({ ...write, account: walletClient.account, chain: walletClient.chain });
 };
 var revokeAllACPs = async (walletClient, publicClient, revokerContract) => {
   if (walletClient.account == null)
@@ -1492,28 +1478,36 @@ var metadataOf = (acp, { labels, metadata, appKey }) => {
   }
   return encodeShareMetadata(labels, { issuer: acp.issuer, appKey });
 };
-var shareOnChain = async (acp, walletClient, registry, options = {}) => {
+var prepareShareOnChain = (acp, registry, options = {}) => {
   if (acp.type !== "sharing") {
     throw new Error(`Cannot share a '${acp.type}' ACP on-chain \u2014 only 'sharing' ACPs are shareable.`);
   }
   if (acp.issuerSignature === "0x") {
     throw new Error("Cannot share an unsigned sharing ACP \u2014 sign it first.");
   }
+  return {
+    write: {
+      address: registry,
+      abi: ACP_SHARE_REGISTRY_ABI,
+      functionName: "share",
+      args: [toChainShare(acp), metadataOf(acp, options)]
+    },
+    shareId: computeShareId(acp)
+  };
+};
+var shareOnChain = async (acp, walletClient, registry, options = {}) => {
+  const { write, shareId } = prepareShareOnChain(acp, registry, options);
   if (walletClient.account == null)
     throw new Error("Missing walletClient account");
   if (walletClient.account.address.toLowerCase() !== acp.issuer.toLowerCase()) {
     throw new Error("Only the ACP issuer can share it on-chain");
   }
-  const metadata = metadataOf(acp, options);
   const txHash = await walletClient.writeContract({
-    address: registry,
-    abi: ACP_SHARE_REGISTRY_ABI,
-    functionName: "share",
-    args: [toChainShare(acp), metadata],
+    ...write,
     account: walletClient.account,
     chain: walletClient.chain ?? null
   });
-  return { txHash, shareId: computeShareId(acp) };
+  return { txHash, shareId };
 };
 var toIncomingShare = ({ shareId, share: s, metadata }) => ({
   shareId,
@@ -1548,14 +1542,17 @@ var importFromChain = async (share, publicClient, walletClient, importOptions =
   const { shareId: _shareId, appKey: _appKey, ...options } = share;
   return importShared({ ...options, type: "sharing" }, publicClient, walletClient, importOptions);
 };
+var prepareRemoveShare = (shareId, registry) => ({
+  address: registry,
+  abi: ACP_SHARE_REGISTRY_ABI,
+  functionName: "removeShare",
+  args: [shareId]
+});
 var removeShareOnChain = async (shareId, walletClient, registry) => {
   if (walletClient.account == null)
     throw new Error("Missing walletClient account");
   return walletClient.writeContract({
-    address: registry,
-    abi: ACP_SHARE_REGISTRY_ABI,
-    functionName: "removeShare",
-    args: [shareId],
+    ...prepareRemoveShare(shareId, registry),
     account: walletClient.account,
     chain: walletClient.chain ?? null
   });
@@ -1582,14 +1579,17 @@ var acps = {
   selectActiveACP,
   removeActiveACP,
   revokeACP,
+  prepareRevokeACP,
   revokeAllACPs,
   isACPRevoked,
   checkAccess,
   shareOnChain,
+  prepareShareOnChain,
   getIncomingShares,
   getShareFromChain,
   importFromChain,
   removeShareOnChain,
+  prepareRemoveShare,
   computeShareId,
   applyACPDefaultsFromChain,
   getAclServedAddresses,
@@ -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 {
@@ -3372,6 +3403,12 @@ function createCofheClientBase(opts) {
       });
     }
   };
+  const _requireIssuer = (acp, what) => {
+    const sender = connectStore.getState().walletClient?.account?.address;
+    if (sender == null || sender.toLowerCase() !== acp.issuer.toLowerCase()) {
+      throw new Error(`Only the acp issuer can ${what}`);
+    }
+  };
   async function connect(publicClient, walletClient) {
     const state = connectStore.getState();
     if (state.connected && state.publicClient === publicClient && state.walletClient === walletClient)
@@ -3539,6 +3576,11 @@ function createCofheClientBase(opts) {
       const { walletClient } = connectStore.getState();
       return acps.revokeACP(acp, walletClient);
     },
+    prepareRevokeACP: (acp) => {
+      _requireConnected();
+      _requireIssuer(acp, "revoke it");
+      return acps.prepareRevokeACP(acp);
+    },
     revokeAllACPs: async (revokerContract) => {
       _requireConnected();
       const { publicClient, walletClient } = connectStore.getState();
@@ -3562,6 +3604,21 @@ function createCofheClientBase(opts) {
       const sharingRegistry = await _resolveSharingRegistry(publicClient, chainId);
       return acps.shareOnChain(acp, walletClient, sharingRegistry, { ...withAppKey(), ...options });
     },
+    prepareShareOnChain: async (acp, options) => {
+      _requireConnected();
+      _requireIssuer(acp, "share it on-chain");
+      const { publicClient } = connectStore.getState();
+      const chainId = await publicClient.getChainId();
+      const sharingRegistry = await _resolveSharingRegistry(publicClient, chainId);
+      return acps.prepareShareOnChain(acp, sharingRegistry, { ...withAppKey(), ...options });
+    },
+    prepareRemoveShare: async (shareId) => {
+      _requireConnected();
+      const { publicClient } = connectStore.getState();
+      const chainId = await publicClient.getChainId();
+      const sharingRegistry = await _resolveSharingRegistry(publicClient, chainId);
+      return acps.prepareRemoveShare(shareId, sharingRegistry);
+    },
     getIncomingShares: async () => {
       _requireConnected();
       const { publicClient, walletClient } = connectStore.getState();

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

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

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

@@ -1,7 +1,7 @@
-import { WalletClient, PublicClient, Hex } from 'viem';
+import { WalletClient, PublicClient, Hex, ContractFunctionParameters } from 'viem';
 import { C as CofheChain } from './types-C07FK-cL.js';
 import { z } from 'zod';
-import { A as ACP, k as EIP712Domain, C as CreateSelfACPOptions, J as SelfACP, g as CreateSharingACPOptions, K as SharingACP, I as ImportSharedACPOptions, R as RecipientACP, P as ACPHashFields, f as SerializedACP, O as ACPAccessStatus, S as ShareLabel, j as IncomingShare, p as AclServedAddresses, L as LabelledShare, w as ShareLabelVerifyMode, x as ShareLabelCheck, l as ACPUtils } from './onchain-utils-CgOslubH.js';
+import { A as ACP, k as EIP712Domain, C as CreateSelfACPOptions, $ as SelfACP, g as CreateSharingACPOptions, a0 as SharingACP, I as ImportSharedACPOptions, a1 as RecipientACP, a5 as ACPHashFields, f as SerializedACP, t as ACP_REVOKER_ABI, a4 as ACPAccessStatus, S as ShareLabel, v as ACP_SHARE_REGISTRY_ABI, j as IncomingShare, p as AclServedAddresses, L as LabelledShare, Q as ShareLabelVerifyMode, R as ShareLabelCheck, l as ACPUtils } from './onchain-utils-Ns56cBm0.js';
 import { StoreApi } from 'zustand/vanilla';
 
 type TfheInitializer = () => Promise<boolean>;
@@ -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.
      *
@@ -896,11 +911,8 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
     setConsumingContract(address: string): EncryptInputsBuilder<T>;
     getConsumingContract(): string | undefined;
     /**
-     * Asserts that this.consumingContract is populated and is an address.
-     * Runs before TFHE init, key fetching and proving, so a bad address costs
-     * nothing: the contract is bound into the proof, and a proof built for a
-     * non-address could only fail at the verifier, after the expensive step.
-     * @throws {CofheError} If consumingContract is not set or is not an address
+     * Asserts that this.consumingContract is populated
+     * @throws {CofheError} If consumingContract is not set
      */
     private assertConsumingContract;
     /**
@@ -1034,6 +1046,21 @@ type ImportSharedOptions = ImportActivationOptions & {
      */
     name?: string;
 };
+/**
+ * Revoke a single acp on-chain via its revoker contract.
+ * Only the acp's issuer can revoke it (enforced by the revoker: revocations
+ * are keyed by msg.sender). The acp stays in local storage — on-chain
+ * validation will reject it from the next block onwards.
+ *
+ * @returns the revocation transaction hash
+ */
+/**
+ * A registry or revoker write built but not sent: what a simulation or `writeContract` takes,
+ * minus the sender. For a caller that sends through its own path (simulate first, record the
+ * transaction) instead of the plain `writeContract` the senders below do.
+ */
+type ShareRegistryWrite<functionName extends 'share' | 'removeShare'> = ContractFunctionParameters<typeof ACP_SHARE_REGISTRY_ABI, 'nonpayable', functionName>;
+type RevokerWrite = ContractFunctionParameters<typeof ACP_REVOKER_ABI, 'nonpayable', 'revokeSingle'>;
 /**
  * What `shareOnChain` posts with a share: the labels of its handles (one per handle, in order;
  * encoded with `encodeShareMetadata`), or an already encoded metadata blob. Written once, with the
@@ -1194,6 +1221,7 @@ declare const acps: {
     selectActiveACP: (chainId: number, account: string, hash: string) => void;
     removeActiveACP: (chainId: number, account: string) => Promise<void>;
     revokeACP: (acp: ACP, walletClient: WalletClient) => Promise<Hex>;
+    prepareRevokeACP: (acp: ACP) => RevokerWrite;
     revokeAllACPs: (walletClient: WalletClient, publicClient: PublicClient, revokerContract?: Hex) => Promise<Hex>;
     isACPRevoked: (acp: ACP, publicClient: PublicClient) => Promise<boolean>;
     checkAccess: (acp: ACP, publicClient: PublicClient, handle?: bigint | Hex) => Promise<ACPAccessStatus>;
@@ -1201,12 +1229,17 @@ declare const acps: {
         txHash: Hex;
         shareId: Hex;
     }>;
+    prepareShareOnChain: (acp: ACP, registry: Hex, options?: ShareOnChainOptions) => {
+        write: ShareRegistryWrite<"share">;
+        shareId: Hex;
+    };
     getIncomingShares: (publicClient: PublicClient, registry: Hex, recipient: Hex, { appKey }?: {
         appKey?: Hex;
     }) => Promise<IncomingShare[]>;
     getShareFromChain: (publicClient: PublicClient, registry: Hex, shareId: Hex) => Promise<IncomingShare | null>;
     importFromChain: (share: IncomingShare, publicClient: PublicClient, walletClient: WalletClient, importOptions?: ImportSharedOptions) => Promise<RecipientACP>;
     removeShareOnChain: (shareId: Hex, walletClient: WalletClient, registry: Hex) => Promise<Hex>;
+    prepareRemoveShare: (shareId: Hex, registry: Hex) => ShareRegistryWrite<"removeShare">;
     computeShareId: (acp: ACP) => Hex;
     applyACPDefaultsFromChain: <T extends {
         revokerData?: number;
@@ -1289,6 +1322,11 @@ type CofheClientACPs = {
     removeACP: (hash: string, chainId?: number, account?: string) => void;
     removeActiveACP: (chainId?: number, account?: string) => void;
     revokeACP: (acp: ACP) => Promise<`0x${string}`>;
+    /**
+     * The revoker write `revokeACP` sends, built but not sent — for an app that sends through its own
+     * path (a simulation first, a transaction store). Issuer only; throws for an acp without a revoker.
+     */
+    prepareRevokeACP: (acp: ACP) => RevokerWrite;
     revokeAllACPs: (revokerContract?: `0x${string}`) => Promise<`0x${string}`>;
     isACPRevoked: (acp: ACP) => Promise<boolean>;
     /**
@@ -1306,6 +1344,16 @@ type CofheClientACPs = {
         txHash: `0x${string}`;
         shareId: `0x${string}`;
     }>;
+    /**
+     * The registry write `shareOnChain` sends and the share id it gets, built but not sent — for an
+     * app that sends through its own path (a simulation first, a transaction store). Issuer only.
+     */
+    prepareShareOnChain: (acp: ACP, options?: ShareOnChainOptions) => Promise<{
+        write: ShareRegistryWrite<'share'>;
+        shareId: `0x${string}`;
+    }>;
+    /** The registry write `dismissShare` / `cancelShare` sends, built but not sent. */
+    prepareRemoveShare: (shareId: `0x${string}`) => Promise<ShareRegistryWrite<'removeShare'>>;
     /** Importable shares addressed to the connected account (unexpired, not revoked), with their metadata. */
     getIncomingShares: () => Promise<IncomingShare[]>;
     /** One share by id, as posted; null when unknown or removed. */