@cofhe/sdk 0.5.2 → 0.6.1

package/dist/{clientTypes-CEno_BEf.d.ts → clientTypes-CyUvRRzA.d.ts}

@@ -59,13 +59,13 @@ type EncryptedNumber = {
     data: Uint8Array;
     securityZone: number;
 };
-type EncryptedItemInput<TSignature = string> = {
+type EncryptedItemInput = {
     ctHash: bigint;
     securityZone: number;
     utype: FheTypes;
-    signature: TSignature;
+    signature: `0x${string}`;
 };
-declare function assertCorrectEncryptedItemInput(input: EncryptedItemInput): asserts input is EncryptedItemInput<`0x${string}`>;
+declare function assertCorrectEncryptedItemInput(input: EncryptedItemInput): asserts input is EncryptedItemInput;
 type EncryptedBoolInput = EncryptedItemInput & {
     utype: FheTypes.Bool;
 };
@@ -165,6 +165,55 @@ type EncryptStepCallbackContext = Record<string, any> & {
     duration: number;
 };
 type EncryptStepCallbackFunction = (state: EncryptStep, context?: EncryptStepCallbackContext) => void;
+/**
+ * Branded bytes32 types for external encrypted inputs (Solidity: externalEbool, externalEuint*, externalEaddress).
+ * The readonly `utype` field brands each hash so it can't be accidentally passed to the wrong asE* function.
+ */
+type ExternalBoolHash = `0x${string}` & {
+    readonly utype: FheTypes.Bool;
+};
+type ExternalUint8Hash = `0x${string}` & {
+    readonly utype: FheTypes.Uint8;
+};
+type ExternalUint16Hash = `0x${string}` & {
+    readonly utype: FheTypes.Uint16;
+};
+type ExternalUint32Hash = `0x${string}` & {
+    readonly utype: FheTypes.Uint32;
+};
+type ExternalUint64Hash = `0x${string}` & {
+    readonly utype: FheTypes.Uint64;
+};
+type ExternalUint128Hash = `0x${string}` & {
+    readonly utype: FheTypes.Uint128;
+};
+type ExternalAddressHash = `0x${string}` & {
+    readonly utype: FheTypes.Uint160;
+};
+/** Branded bytes proof blob (Solidity: bytes memory proof). */
+type ExternalHashProof = `0x${string}` & {
+    readonly _kind: 'ExternalHashProof';
+};
+/** Union of all External*Hash types — useful for utilities that operate on any hash without caring about the specific FHE type. */
+type AnyExternalHash = ExternalBoolHash | ExternalUint8Hash | ExternalUint16Hash | ExternalUint32Hash | ExternalUint64Hash | ExternalUint128Hash | ExternalAddressHash;
+/**
+ * Maps a single EncryptableItem to its corresponding External*Hash type.
+ * Mirrors EncryptableToEncryptedItemInputMap.
+ */
+type EncryptableToExternalHashMap<E extends EncryptableItem> = E extends EncryptableBool ? ExternalBoolHash : E extends EncryptableUint8 ? ExternalUint8Hash : E extends EncryptableUint16 ? ExternalUint16Hash : E extends EncryptableUint32 ? ExternalUint32Hash : E extends EncryptableUint64 ? ExternalUint64Hash : E extends EncryptableUint128 ? ExternalUint128Hash : E extends EncryptableAddress ? ExternalAddressHash : never;
+/**
+ * Maps an EncryptableItem[] tuple to a tuple of corresponding External*Hash types,
+ * preserving index positions. e.g. [EncryptableBool, EncryptableUint32] → [ExternalBoolHash, ExternalUint32Hash]
+ */
+type ExternalItemHashes<T extends EncryptableItem[]> = {
+    [K in keyof T]: T[K] extends EncryptableItem ? EncryptableToExternalHashMap<T[K]> : never;
+};
+/**
+ * Return type of EncryptInputsBuilder.execute() when asHashPlusProof() is set.
+ * Tuple of per-input hashes in input order, followed by a single proof blob.
+ * e.g. [Encryptable.bool(true), Encryptable.uint32(5)] → [ExternalBoolHash, ExternalUint32Hash, ExternalHashProof]
+ */
+type HashPlusProofResult<T extends EncryptableItem[]> = [...ExternalItemHashes<T>, ExternalHashProof];
 type DecryptEndpoint = 'decrypt' | 'sealoutput';
 type DecryptPollCallbackContext = {
     operation: DecryptEndpoint;
@@ -702,10 +751,11 @@ type EncryptInputsBuilderParams<T extends EncryptableItem[]> = BaseBuilderParams
  * account, securityZone, and chainId can be overridden in the builder.
  * config, tfhePublicKeyDeserializer, compactPkeCrsDeserializer, and zkBuilderAndCrsGenerator are required to be set in the builder.
  */
-declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuilder {
+declare class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boolean = false> extends BaseBuilder {
     private securityZone;
     private stepCallback?;
     private inputItems;
+    private hpp;
     private zkvWalletClient;
     private tfhePublicKeyDeserializer;
     private compactPkeCrsDeserializer;
@@ -730,7 +780,7 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      *
      * @returns The chainable EncryptInputsBuilder instance.
      */
-    setAccount(account: string): EncryptInputsBuilder<T>;
+    setAccount(account: string): EncryptInputsBuilder<T, HPP>;
     getAccount(): string | undefined;
     /**
      * @param chainId - Chain that will consume the encrypted inputs.
@@ -746,7 +796,7 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      *
      * @returns The chainable EncryptInputsBuilder instance.
      */
-    setChainId(chainId: number): EncryptInputsBuilder<T>;
+    setChainId(chainId: number): EncryptInputsBuilder<T, HPP>;
     getChainId(): number | undefined;
     /**
      * @param securityZone - Security zone to encrypt the inputs for.
@@ -762,8 +812,19 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      *
      * @returns The chainable EncryptInputsBuilder instance.
      */
-    setSecurityZone(securityZone: number): EncryptInputsBuilder<T>;
+    setSecurityZone(securityZone: number): EncryptInputsBuilder<T, HPP>;
     getSecurityZone(): number;
+    /**
+     * Example:
+     * ```typescript
+     * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
+     *   .asHashPlusProof()
+     *   .execute();
+     * ```
+     *
+     * @returns Chainable EncryptInputsBuilder instance that will return a HashPlusProofResult instead of an array of EncryptedItemInputs.
+     */
+    asHashPlusProof(): EncryptInputsBuilder<T, true>;
     /**
      * @param useWorker - Whether to use Web Workers for ZK proof generation.
      *
@@ -778,7 +839,7 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      *
      * @returns The chainable EncryptInputsBuilder instance.
      */
-    setUseWorker(useWorker: boolean): EncryptInputsBuilder<T>;
+    setUseWorker(useWorker: boolean): EncryptInputsBuilder<T, HPP>;
     /**
      * Gets the current worker configuration.
      *
@@ -808,7 +869,7 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      *
      * @returns The EncryptInputsBuilder instance.
      */
-    onStep(callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T>;
+    onStep(callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T, HPP>;
     getStepCallback(): EncryptStepCallbackFunction | undefined;
     /**
      * Fires the step callback if set
@@ -849,6 +910,7 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      * In the production context, perform a true encryption with the CoFHE coprocessor.
      */
     private productionExecute;
+    private structsToHashPlusProof;
     /**
      * Final step of the encryption process. MUST BE CALLED LAST IN THE CHAIN.
      *
@@ -868,7 +930,7 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
      *
      * @returns The encrypted inputs.
      */
-    execute(): Promise<[...EncryptedItemInputs<T>]>;
+    execute(): Promise<HPP extends true ? HashPlusProofResult<T> : [...EncryptedItemInputs<T>]>;
 }
 
 declare const permits: {
@@ -1001,4 +1063,4 @@ type CofheClientParams<TConfig extends CofheConfig> = {
     zkProveWorkerFn?: ZkProveWorkerFunction;
 };
 
-export { DecryptForTxBuilder as $, type FheTypeValue as A, type DecryptPollCallbackContext as B, type CofheInputConfig as C, type DecryptPollCallbackFunction as D, type EncryptableItem as E, FheTypes as F, type DecryptEndpoint as G, type EncryptStepCallbackFunction as H, type IStorage as I, type EncryptStepCallbackContext as J, FheUintUTypes as K, type LiteralToPrimitive as L, FheAllUTypes as M, Encryptable as N, isEncryptableItem as O, type Primitive as P, EncryptStep as Q, isLastEncryptionStep as R, assertCorrectEncryptedItemInput as S, fetchKeys as T, type UnsealedItem as U, type FheKeyDeserializer as V, createKeysStore as W, type KeysStorage as X, type KeysStore as Y, EncryptInputsBuilder as Z, DecryptForViewBuilder as _, type CofheConfig as a, type DecryptForTxResult as a0, type ZkBuilderAndCrsGenerator as a1, type ZkProveWorkerFunction as a2, type ZkProveWorkerRequest as a3, type ZkProveWorkerResponse as a4, zkProveWithWorker as a5, type CofheClient as b, type CofheClientParams as c, type CofheClientConnectionState as d, createCofheConfigBase as e, type CofheInternalConfig as f, getCofheConfigItem as g, type CofheClientPermits as h, type EncryptableBool as i, type EncryptableUint8 as j, type EncryptableUint16 as k, type EncryptableUint32 as l, type EncryptableUint64 as m, type EncryptableUint128 as n, type EncryptableAddress as o, type EncryptedNumber as p, type EncryptedItemInput as q, type EncryptedBoolInput as r, type EncryptedUint8Input as s, type EncryptedUint16Input as t, type EncryptedUint32Input as u, type EncryptedUint64Input as v, type EncryptedUint128Input as w, type EncryptedAddressInput as x, type EncryptedItemInputs as y, type EncryptableToEncryptedItemInputMap as z };
+export { Encryptable as $, type FheTypeValue as A, type ExternalBoolHash as B, type CofheInputConfig as C, type ExternalUint8Hash as D, type EncryptableItem as E, FheTypes as F, type ExternalUint16Hash as G, type ExternalUint32Hash as H, type IStorage as I, type ExternalUint64Hash as J, type ExternalUint128Hash as K, type LiteralToPrimitive as L, type ExternalAddressHash as M, type ExternalHashProof as N, type AnyExternalHash as O, type Primitive as P, type EncryptableToExternalHashMap as Q, type ExternalItemHashes as R, type HashPlusProofResult as S, type DecryptPollCallbackFunction as T, type UnsealedItem as U, type DecryptPollCallbackContext as V, type DecryptEndpoint as W, type EncryptStepCallbackFunction as X, type EncryptStepCallbackContext as Y, FheUintUTypes as Z, FheAllUTypes as _, type CofheConfig as a, isEncryptableItem as a0, EncryptStep as a1, isLastEncryptionStep as a2, assertCorrectEncryptedItemInput as a3, fetchKeys as a4, type FheKeyDeserializer as a5, createKeysStore as a6, type KeysStorage as a7, type KeysStore as a8, EncryptInputsBuilder as a9, DecryptForViewBuilder as aa, DecryptForTxBuilder as ab, type DecryptForTxResult as ac, type ZkBuilderAndCrsGenerator as ad, type ZkProveWorkerFunction as ae, type ZkProveWorkerRequest as af, type ZkProveWorkerResponse as ag, zkProveWithWorker as ah, type CofheClient as b, type CofheClientParams as c, type CofheClientConnectionState as d, createCofheConfigBase as e, type CofheInternalConfig as f, getCofheConfigItem as g, type CofheClientPermits as h, type EncryptableBool as i, type EncryptableUint8 as j, type EncryptableUint16 as k, type EncryptableUint32 as l, type EncryptableUint64 as m, type EncryptableUint128 as n, type EncryptableAddress as o, type EncryptedNumber as p, type EncryptedItemInput as q, type EncryptedBoolInput as r, type EncryptedUint8Input as s, type EncryptedUint16Input as t, type EncryptedUint32Input as u, type EncryptedUint64Input as v, type EncryptedUint128Input as w, type EncryptedAddressInput as x, type EncryptedItemInputs as y, type EncryptableToEncryptedItemInputMap as z };

package/dist/core.cjs

@@ -154,7 +154,6 @@ var isCofheError = (error) => error instanceof CofheError;
 var TASK_MANAGER_ADDRESS = "0xeA30c4B8b44078Bbf8a6ef5b9f1eC1626C7848D9";
 var MOCKS_ZK_VERIFIER_ADDRESS = "0x0000000000000000000000000000000000005001";
 var MOCKS_THRESHOLD_NETWORK_ADDRESS = "0x0000000000000000000000000000000000005002";
-var TEST_BED_ADDRESS = "0x0000000000000000000000000000000000005003";
 var MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY = "0x6C8D7F768A6BB4AAFE85E8A2F5A9680355239C7E14646ED62B044E39DE154512";
 var MOCKS_ZK_VERIFIER_SIGNER_ADDRESS = "0x6E12D8C87503D4287c294f2Fdef96ACd9DFf6bd2";
 var MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY = "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d";
@@ -546,7 +545,7 @@ var zkVerify = async (verifierUrl, serializedBytes, address, securityZone, chain
   }
 };
 var concatSigRecid = (signature, recid) => {
-  return signature + (recid + 27).toString(16).padStart(2, "0");
+  return `${signature}${(recid + 27).toString(16).padStart(2, "0")}`;
 };
 
 // core/encrypt/MockZkVerifierAbi.ts
@@ -878,9 +877,9 @@ var hardhat2 = defineChain({
   name: "Hardhat",
   network: "localhost",
   // These are unused in the mock environment
-  coFheUrl: "http://127.0.0.1:8448",
-  verifierUrl: "http://127.0.0.1:3001",
-  thresholdNetworkUrl: "http://127.0.0.1:3000",
+  coFheUrl: "http://ignored-in-mock-environment",
+  verifierUrl: "http://ignored-in-mock-environment",
+  thresholdNetworkUrl: "http://ignored-in-mock-environment",
   environment: "MOCK"
 });
 var CofheConfigSchema = zod.z.object({
@@ -1269,6 +1268,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
   securityZone;
   stepCallback;
   inputItems;
+  hpp = false;
   zkvWalletClient;
   tfhePublicKeyDeserializer;
   compactPkeCrsDeserializer;
@@ -1398,6 +1398,20 @@ var EncryptInputsBuilder = class extends BaseBuilder {
   getSecurityZone() {
     return this.securityZone;
   }
+  /**
+   * Example:
+   * ```typescript
+   * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
+   *   .asHashPlusProof()
+   *   .execute();
+   * ```
+   *
+   * @returns Chainable EncryptInputsBuilder instance that will return a HashPlusProofResult instead of an array of EncryptedItemInputs.
+   */
+  asHashPlusProof() {
+    this.hpp = true;
+    return this;
+  }
   /**
    * @param useWorker - Whether to use Web Workers for ZK proof generation.
    *
@@ -1679,6 +1693,15 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     this.fireStepEnd("verify" /* Verify */);
     return encryptedInputs;
   }
+  structsToHashPlusProof(inItems) {
+    let hashes = [];
+    let proof = "";
+    for (const item of inItems) {
+      hashes.push("0x" + item.ctHash.toString(16).padStart(64, "0"));
+      proof += item.signature;
+    }
+    return [...hashes, proof];
+  }
   /**
    * Final step of the encryption process. MUST BE CALLED LAST IN THE CHAIN.
    *
@@ -1699,9 +1722,14 @@ var EncryptInputsBuilder = class extends BaseBuilder {
    * @returns The encrypted inputs.
    */
   async execute() {
+    let items;
     if (this.chainId === chains.hardhat.id)
-      return this.mocksExecute();
-    return this.productionExecute();
+      items = await this.mocksExecute();
+    else
+      items = await this.productionExecute();
+    if (this.hpp)
+      return this.structsToHashPlusProof(items);
+    return items;
   }
 };
 
@@ -2724,7 +2752,7 @@ var getOrCreateSelfPermit = async (publicClient, walletClient, chainId, account,
   const _chainId = chainId ?? await publicClient.getChainId();
   const _account = account ?? walletClient.account.address;
   const activePermit = await getActivePermit2(_chainId, _account);
-  if (activePermit && activePermit.type === "self") {
+  if (activePermit && activePermit.type === "self" && PermitUtils.isValid(activePermit).valid) {
     return activePermit;
   }
   return createSelf(options ?? { issuer: _account, name: "Autogenerated Self Permit" }, publicClient, walletClient);
@@ -2733,7 +2761,7 @@ var getOrCreateSharingPermit = async (publicClient, walletClient, options, chain
   const _chainId = chainId ?? await publicClient.getChainId();
   const _account = account ?? walletClient.account.address;
   const activePermit = await getActivePermit2(_chainId, _account);
-  if (activePermit && activePermit.type === "sharing") {
+  if (activePermit && activePermit.type === "sharing" && PermitUtils.isValid(activePermit).valid) {
     return activePermit;
   }
   return createSharing(options, publicClient, walletClient);
@@ -2992,6 +3020,36 @@ async function cofheMocksDecryptForView(ctHash, utype, permit, publicClient) {
   return unsealed;
 }
 
+// core/debug.ts
+var interceptors = {};
+function setCofheDebugInterceptors(next) {
+  interceptors.onRequest = next?.onRequest;
+  interceptors.onResponse = next?.onResponse;
+}
+function getCofheDebugInterceptors() {
+  return interceptors;
+}
+async function cofheFetch(url, init, ctx = { op: "request" }) {
+  let finalUrl = url;
+  let finalInit = init;
+  if (interceptors.onRequest) {
+    const override = await interceptors.onRequest(finalUrl, finalInit, ctx);
+    if (override) {
+      if (override.url !== void 0)
+        finalUrl = override.url;
+      if (override.init !== void 0)
+        finalInit = override.init;
+    }
+  }
+  let response = await fetch(finalUrl, finalInit);
+  if (interceptors.onResponse) {
+    const replaced = await interceptors.onResponse(response, ctx);
+    if (replaced)
+      response = replaced;
+  }
+  return response;
+}
+
 // core/decrypt/polling.ts
 function computeMinuteRampPollIntervalMs(elapsedMs, params) {
   const elapsedSeconds = Math.floor(elapsedMs / 1e3);
@@ -3161,13 +3219,17 @@ async function submitSealOutputRequest(thresholdNetworkUrl, ctHash, chainId, per
   for (; ; ) {
     let response;
     try {
-      response = await fetch(`${thresholdNetworkUrl}/v2/sealoutput`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body)
-      });
+      response = await cofheFetch(
+        `${thresholdNetworkUrl}/v2/sealoutput`,
+        /*op:sealoutput*/
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(body)
+        }
+      );
     } catch (e) {
       throw new CofheError({
         code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
@@ -3290,12 +3352,16 @@ async function pollSealOutputStatus(thresholdNetworkUrl, requestId, overallStart
     }
     let response;
     try {
-      response = await fetch(`${thresholdNetworkUrl}/v2/sealoutput/${requestId}`, {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json"
+      response = await cofheFetch(
+        `${thresholdNetworkUrl}/v2/sealoutput/${requestId}`,
+        /*op:sealoutput-poll*/
+        {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          }
         }
-      });
+      );
     } catch (e) {
       throw new CofheError({
         code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
@@ -3892,13 +3958,17 @@ async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, perm
   for (; ; ) {
     let response;
     try {
-      response = await fetch(`${thresholdNetworkUrl}/v2/decrypt`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body)
-      });
+      response = await cofheFetch(
+        `${thresholdNetworkUrl}/v2/decrypt`,
+        /*op:decrypt*/
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(body)
+        }
+      );
     } catch (e) {
       throw new CofheError({
         code: "DECRYPT_FAILED" /* DecryptFailed */,
@@ -4023,12 +4093,16 @@ async function pollDecryptStatusV2(thresholdNetworkUrl, requestId, overallStartT
     }
     let response;
     try {
-      response = await fetch(`${thresholdNetworkUrl}/v2/decrypt/${requestId}`, {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json"
+      response = await cofheFetch(
+        `${thresholdNetworkUrl}/v2/decrypt/${requestId}`,
+        /*op:decrypt-poll*/
+        {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          }
         }
-      });
+      );
     } catch (e) {
       throw new CofheError({
         code: "DECRYPT_FAILED" /* DecryptFailed */,
@@ -4644,18 +4718,20 @@ exports.MOCKS_ZK_VERIFIER_ADDRESS = MOCKS_ZK_VERIFIER_ADDRESS;
 exports.MOCKS_ZK_VERIFIER_SIGNER_ADDRESS = MOCKS_ZK_VERIFIER_SIGNER_ADDRESS;
 exports.MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY = MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY;
 exports.TASK_MANAGER_ADDRESS = TASK_MANAGER_ADDRESS;
-exports.TEST_BED_ADDRESS = TEST_BED_ADDRESS;
 exports.TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT = TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT;
 exports.TFHE_RS_ZK_MAX_BITS = TFHE_RS_ZK_MAX_BITS;
 exports.assertCorrectEncryptedItemInput = assertCorrectEncryptedItemInput;
+exports.cofheFetch = cofheFetch;
 exports.createCofheClientBase = createCofheClientBase;
 exports.createCofheConfigBase = createCofheConfigBase;
 exports.createKeysStore = createKeysStore;
 exports.fetchKeys = fetchKeys;
 exports.fheTypeToString = fheTypeToString;
 exports.getCofheConfigItem = getCofheConfigItem;
+exports.getCofheDebugInterceptors = getCofheDebugInterceptors;
 exports.isCofheError = isCofheError;
 exports.isEncryptableItem = isEncryptableItem;
 exports.isLastEncryptionStep = isLastEncryptionStep;
+exports.setCofheDebugInterceptors = setCofheDebugInterceptors;
 exports.verifyDecryptResult = verifyDecryptResult;
 exports.zkProveWithWorker = zkProveWithWorker;

package/dist/core.d.cts

@@ -1,5 +1,5 @@
-import { a as CofheConfig, c as CofheClientParams, b as CofheClient, d as CofheClientConnectionState, F as FheTypes } from './clientTypes-BJbFeeno.cjs';
-export { h as CofheClientPermits, C as CofheInputConfig, f as CofheInternalConfig, G as DecryptEndpoint, $ as DecryptForTxBuilder, a0 as DecryptForTxResult, _ as DecryptForViewBuilder, B as DecryptPollCallbackContext, D as DecryptPollCallbackFunction, Z as EncryptInputsBuilder, H as EncryptSetStateFn, Q as EncryptStep, J as EncryptStepCallbackContext, N as Encryptable, o as EncryptableAddress, i as EncryptableBool, E as EncryptableItem, z as EncryptableToEncryptedItemInputMap, n as EncryptableUint128, k as EncryptableUint16, l as EncryptableUint32, m as EncryptableUint64, j as EncryptableUint8, x as EncryptedAddressInput, r as EncryptedBoolInput, q as EncryptedItemInput, y as EncryptedItemInputs, p as EncryptedNumber, w as EncryptedUint128Input, t as EncryptedUint16Input, u as EncryptedUint32Input, v as EncryptedUint64Input, s as EncryptedUint8Input, M as FheAllUTypes, V as FheKeyDeserializer, A as FheTypeValue, K as FheUintUTypes, I as IStorage, X as KeysStorage, Y as KeysStore, L as LiteralToPrimitive, P as Primitive, U as UnsealedItem, a1 as ZkBuilderAndCrsGenerator, a2 as ZkProveWorkerFunction, a3 as ZkProveWorkerRequest, a4 as ZkProveWorkerResponse, S as assertCorrectEncryptedItemInput, e as createCofheConfigBase, W as createKeysStore, T as fetchKeys, g as getCofheConfigItem, O as isEncryptableItem, R as isLastEncryptionStep, a5 as zkProveWithWorker } from './clientTypes-BJbFeeno.cjs';
+import { a as CofheConfig, c as CofheClientParams, b as CofheClient, d as CofheClientConnectionState, F as FheTypes } from './clientTypes-BDy1qIBu.cjs';
+export { O as AnyExternalHash, h as CofheClientPermits, C as CofheInputConfig, f as CofheInternalConfig, W as DecryptEndpoint, ab as DecryptForTxBuilder, ac as DecryptForTxResult, aa as DecryptForViewBuilder, V as DecryptPollCallbackContext, T as DecryptPollCallbackFunction, a9 as EncryptInputsBuilder, X as EncryptSetStateFn, a1 as EncryptStep, Y as EncryptStepCallbackContext, $ as Encryptable, o as EncryptableAddress, i as EncryptableBool, E as EncryptableItem, z as EncryptableToEncryptedItemInputMap, Q as EncryptableToExternalHashMap, n as EncryptableUint128, k as EncryptableUint16, l as EncryptableUint32, m as EncryptableUint64, j as EncryptableUint8, x as EncryptedAddressInput, r as EncryptedBoolInput, q as EncryptedItemInput, y as EncryptedItemInputs, p as EncryptedNumber, w as EncryptedUint128Input, t as EncryptedUint16Input, u as EncryptedUint32Input, v as EncryptedUint64Input, s as EncryptedUint8Input, M as ExternalAddressHash, B as ExternalBoolHash, N as ExternalHashProof, R as ExternalItemHashes, K as ExternalUint128Hash, G as ExternalUint16Hash, H as ExternalUint32Hash, J as ExternalUint64Hash, D as ExternalUint8Hash, _ as FheAllUTypes, a5 as FheKeyDeserializer, A as FheTypeValue, Z as FheUintUTypes, S as HashPlusProofResult, I as IStorage, a7 as KeysStorage, a8 as KeysStore, L as LiteralToPrimitive, P as Primitive, U as UnsealedItem, ad as ZkBuilderAndCrsGenerator, ae as ZkProveWorkerFunction, af as ZkProveWorkerRequest, ag as ZkProveWorkerResponse, a3 as assertCorrectEncryptedItemInput, e as createCofheConfigBase, a6 as createKeysStore, a4 as fetchKeys, g as getCofheConfigItem, a0 as isEncryptableItem, a2 as isLastEncryptionStep, ah as zkProveWithWorker } from './clientTypes-BDy1qIBu.cjs';
 import { Hex, PublicClient } from 'viem';
 import './types-C07FK-cL.cjs';
 import 'zod';
@@ -14,6 +14,29 @@ declare const InitialConnectStore: CofheClientConnectionState;
  */
 declare function createCofheClientBase<TConfig extends CofheConfig>(opts: CofheClientParams<TConfig>): CofheClient<TConfig>;
 
+interface CofheRequestContext {
+    /** Coarse label for the call site, e.g. 'decrypt' | 'sealoutput' | 'fetchKeys'. */
+    op: string;
+}
+interface CofheRequestOverride {
+    url?: string;
+    init?: RequestInit;
+}
+type CofheOnRequest = (url: string, init: RequestInit | undefined, ctx: CofheRequestContext) => CofheRequestOverride | void | Promise<CofheRequestOverride | void>;
+type CofheOnResponse = (response: Response, ctx: CofheRequestContext) => Response | void | Promise<Response | void>;
+interface CofheDebugInterceptors {
+    onRequest?: CofheOnRequest;
+    onResponse?: CofheOnResponse;
+}
+/** Register (or clear, with null) the debug interceptors. */
+declare function setCofheDebugInterceptors(next: CofheDebugInterceptors | null): void;
+declare function getCofheDebugInterceptors(): CofheDebugInterceptors;
+/**
+ * fetch() wrapper used by all low-level SDK network ops. Applies the registered
+ * debug interceptors when present; otherwise behaves exactly like fetch().
+ */
+declare function cofheFetch(url: string, init?: RequestInit, ctx?: CofheRequestContext): Promise<Response>;
+
 declare enum CofheErrorCode {
     InternalError = "INTERNAL_ERROR",
     UnknownEnvironment = "UNKNOWN_ENVIRONMENT",
@@ -106,8 +129,6 @@ declare const TASK_MANAGER_ADDRESS: "0xeA30c4B8b44078Bbf8a6ef5b9f1eC1626C7848D9"
 declare const MOCKS_ZK_VERIFIER_ADDRESS: "0x0000000000000000000000000000000000005001";
 /** Mock Threshold Network contract address (used for testing) */
 declare const MOCKS_THRESHOLD_NETWORK_ADDRESS: "0x0000000000000000000000000000000000005002";
-/** Test Bed contract address (used for testing) */
-declare const TEST_BED_ADDRESS: "0x0000000000000000000000000000000000005003";
 /** Private key for the Mock ZK Verifier signer account */
 declare const MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY: "0x6C8D7F768A6BB4AAFE85E8A2F5A9680355239C7E14646ED62B044E39DE154512";
 /** Address for the Mock ZK Verifier signer account */
@@ -139,4 +160,4 @@ declare function verifyDecryptResult(handle: bigint | string, cleartext: bigint,
  */
 declare function fheTypeToString(utype: FheTypes): string;
 
-export { InitialConnectStore as CONNECT_STORE_DEFAULTS, CofheClient, CofheClientConnectionState, CofheClientParams, CofheConfig, CofheError, CofheErrorCode, type CofheErrorParams, FheTypes, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, TASK_MANAGER_ADDRESS, TEST_BED_ADDRESS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, TFHE_RS_ZK_MAX_BITS, createCofheClientBase, fheTypeToString, isCofheError, verifyDecryptResult };
+export { InitialConnectStore as CONNECT_STORE_DEFAULTS, CofheClient, CofheClientConnectionState, CofheClientParams, CofheConfig, type CofheDebugInterceptors, CofheError, CofheErrorCode, type CofheErrorParams, type CofheOnRequest, type CofheOnResponse, type CofheRequestContext, type CofheRequestOverride, FheTypes, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, TASK_MANAGER_ADDRESS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, TFHE_RS_ZK_MAX_BITS, cofheFetch, createCofheClientBase, fheTypeToString, getCofheDebugInterceptors, isCofheError, setCofheDebugInterceptors, verifyDecryptResult };

package/dist/core.d.ts

@@ -1,5 +1,5 @@
-import { a as CofheConfig, c as CofheClientParams, b as CofheClient, d as CofheClientConnectionState, F as FheTypes } from './clientTypes-CEno_BEf.js';
-export { h as CofheClientPermits, C as CofheInputConfig, f as CofheInternalConfig, G as DecryptEndpoint, $ as DecryptForTxBuilder, a0 as DecryptForTxResult, _ as DecryptForViewBuilder, B as DecryptPollCallbackContext, D as DecryptPollCallbackFunction, Z as EncryptInputsBuilder, H as EncryptSetStateFn, Q as EncryptStep, J as EncryptStepCallbackContext, N as Encryptable, o as EncryptableAddress, i as EncryptableBool, E as EncryptableItem, z as EncryptableToEncryptedItemInputMap, n as EncryptableUint128, k as EncryptableUint16, l as EncryptableUint32, m as EncryptableUint64, j as EncryptableUint8, x as EncryptedAddressInput, r as EncryptedBoolInput, q as EncryptedItemInput, y as EncryptedItemInputs, p as EncryptedNumber, w as EncryptedUint128Input, t as EncryptedUint16Input, u as EncryptedUint32Input, v as EncryptedUint64Input, s as EncryptedUint8Input, M as FheAllUTypes, V as FheKeyDeserializer, A as FheTypeValue, K as FheUintUTypes, I as IStorage, X as KeysStorage, Y as KeysStore, L as LiteralToPrimitive, P as Primitive, U as UnsealedItem, a1 as ZkBuilderAndCrsGenerator, a2 as ZkProveWorkerFunction, a3 as ZkProveWorkerRequest, a4 as ZkProveWorkerResponse, S as assertCorrectEncryptedItemInput, e as createCofheConfigBase, W as createKeysStore, T as fetchKeys, g as getCofheConfigItem, O as isEncryptableItem, R as isLastEncryptionStep, a5 as zkProveWithWorker } from './clientTypes-CEno_BEf.js';
+import { a as CofheConfig, c as CofheClientParams, b as CofheClient, d as CofheClientConnectionState, F as FheTypes } from './clientTypes-CyUvRRzA.js';
+export { O as AnyExternalHash, h as CofheClientPermits, C as CofheInputConfig, f as CofheInternalConfig, W as DecryptEndpoint, ab as DecryptForTxBuilder, ac as DecryptForTxResult, aa as DecryptForViewBuilder, V as DecryptPollCallbackContext, T as DecryptPollCallbackFunction, a9 as EncryptInputsBuilder, X as EncryptSetStateFn, a1 as EncryptStep, Y as EncryptStepCallbackContext, $ as Encryptable, o as EncryptableAddress, i as EncryptableBool, E as EncryptableItem, z as EncryptableToEncryptedItemInputMap, Q as EncryptableToExternalHashMap, n as EncryptableUint128, k as EncryptableUint16, l as EncryptableUint32, m as EncryptableUint64, j as EncryptableUint8, x as EncryptedAddressInput, r as EncryptedBoolInput, q as EncryptedItemInput, y as EncryptedItemInputs, p as EncryptedNumber, w as EncryptedUint128Input, t as EncryptedUint16Input, u as EncryptedUint32Input, v as EncryptedUint64Input, s as EncryptedUint8Input, M as ExternalAddressHash, B as ExternalBoolHash, N as ExternalHashProof, R as ExternalItemHashes, K as ExternalUint128Hash, G as ExternalUint16Hash, H as ExternalUint32Hash, J as ExternalUint64Hash, D as ExternalUint8Hash, _ as FheAllUTypes, a5 as FheKeyDeserializer, A as FheTypeValue, Z as FheUintUTypes, S as HashPlusProofResult, I as IStorage, a7 as KeysStorage, a8 as KeysStore, L as LiteralToPrimitive, P as Primitive, U as UnsealedItem, ad as ZkBuilderAndCrsGenerator, ae as ZkProveWorkerFunction, af as ZkProveWorkerRequest, ag as ZkProveWorkerResponse, a3 as assertCorrectEncryptedItemInput, e as createCofheConfigBase, a6 as createKeysStore, a4 as fetchKeys, g as getCofheConfigItem, a0 as isEncryptableItem, a2 as isLastEncryptionStep, ah as zkProveWithWorker } from './clientTypes-CyUvRRzA.js';
 import { Hex, PublicClient } from 'viem';
 import './types-C07FK-cL.js';
 import 'zod';
@@ -14,6 +14,29 @@ declare const InitialConnectStore: CofheClientConnectionState;
  */
 declare function createCofheClientBase<TConfig extends CofheConfig>(opts: CofheClientParams<TConfig>): CofheClient<TConfig>;
 
+interface CofheRequestContext {
+    /** Coarse label for the call site, e.g. 'decrypt' | 'sealoutput' | 'fetchKeys'. */
+    op: string;
+}
+interface CofheRequestOverride {
+    url?: string;
+    init?: RequestInit;
+}
+type CofheOnRequest = (url: string, init: RequestInit | undefined, ctx: CofheRequestContext) => CofheRequestOverride | void | Promise<CofheRequestOverride | void>;
+type CofheOnResponse = (response: Response, ctx: CofheRequestContext) => Response | void | Promise<Response | void>;
+interface CofheDebugInterceptors {
+    onRequest?: CofheOnRequest;
+    onResponse?: CofheOnResponse;
+}
+/** Register (or clear, with null) the debug interceptors. */
+declare function setCofheDebugInterceptors(next: CofheDebugInterceptors | null): void;
+declare function getCofheDebugInterceptors(): CofheDebugInterceptors;
+/**
+ * fetch() wrapper used by all low-level SDK network ops. Applies the registered
+ * debug interceptors when present; otherwise behaves exactly like fetch().
+ */
+declare function cofheFetch(url: string, init?: RequestInit, ctx?: CofheRequestContext): Promise<Response>;
+
 declare enum CofheErrorCode {
     InternalError = "INTERNAL_ERROR",
     UnknownEnvironment = "UNKNOWN_ENVIRONMENT",
@@ -106,8 +129,6 @@ declare const TASK_MANAGER_ADDRESS: "0xeA30c4B8b44078Bbf8a6ef5b9f1eC1626C7848D9"
 declare const MOCKS_ZK_VERIFIER_ADDRESS: "0x0000000000000000000000000000000000005001";
 /** Mock Threshold Network contract address (used for testing) */
 declare const MOCKS_THRESHOLD_NETWORK_ADDRESS: "0x0000000000000000000000000000000000005002";
-/** Test Bed contract address (used for testing) */
-declare const TEST_BED_ADDRESS: "0x0000000000000000000000000000000000005003";
 /** Private key for the Mock ZK Verifier signer account */
 declare const MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY: "0x6C8D7F768A6BB4AAFE85E8A2F5A9680355239C7E14646ED62B044E39DE154512";
 /** Address for the Mock ZK Verifier signer account */
@@ -139,4 +160,4 @@ declare function verifyDecryptResult(handle: bigint | string, cleartext: bigint,
  */
 declare function fheTypeToString(utype: FheTypes): string;
 
-export { InitialConnectStore as CONNECT_STORE_DEFAULTS, CofheClient, CofheClientConnectionState, CofheClientParams, CofheConfig, CofheError, CofheErrorCode, type CofheErrorParams, FheTypes, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, TASK_MANAGER_ADDRESS, TEST_BED_ADDRESS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, TFHE_RS_ZK_MAX_BITS, createCofheClientBase, fheTypeToString, isCofheError, verifyDecryptResult };
+export { InitialConnectStore as CONNECT_STORE_DEFAULTS, CofheClient, CofheClientConnectionState, CofheClientParams, CofheConfig, type CofheDebugInterceptors, CofheError, CofheErrorCode, type CofheErrorParams, type CofheOnRequest, type CofheOnResponse, type CofheRequestContext, type CofheRequestOverride, FheTypes, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, TASK_MANAGER_ADDRESS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, TFHE_RS_ZK_MAX_BITS, cofheFetch, createCofheClientBase, fheTypeToString, getCofheDebugInterceptors, isCofheError, setCofheDebugInterceptors, verifyDecryptResult };

package/dist/core.js

@@ -1,4 +1,4 @@
-export { InitialConnectStore as CONNECT_STORE_DEFAULTS, CofheError, CofheErrorCode, DecryptForTxBuilder, DecryptForViewBuilder, EncryptInputsBuilder, EncryptStep, Encryptable, FheAllUTypes, FheTypes, FheUintUTypes, assertCorrectEncryptedItemInput, createCofheClientBase, createCofheConfigBase, createKeysStore, fetchKeys, fheTypeToString, getCofheConfigItem, isCofheError, isEncryptableItem, isLastEncryptionStep, verifyDecryptResult, zkProveWithWorker } from './chunk-YDOK4BDL.js';
-import './chunk-TBLR7NNE.js';
-import './chunk-MRCKUMOS.js';
-export { MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, TASK_MANAGER_ADDRESS, TEST_BED_ADDRESS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, TFHE_RS_ZK_MAX_BITS } from './chunk-4FP4V35O.js';
+export { InitialConnectStore as CONNECT_STORE_DEFAULTS, CofheError, CofheErrorCode, DecryptForTxBuilder, DecryptForViewBuilder, EncryptInputsBuilder, EncryptStep, Encryptable, FheAllUTypes, FheTypes, FheUintUTypes, assertCorrectEncryptedItemInput, cofheFetch, createCofheClientBase, createCofheConfigBase, createKeysStore, fetchKeys, fheTypeToString, getCofheConfigItem, getCofheDebugInterceptors, isCofheError, isEncryptableItem, isLastEncryptionStep, setCofheDebugInterceptors, verifyDecryptResult, zkProveWithWorker } from './chunk-NOC3PYB7.js';
+import './chunk-MTRAXQXC.js';
+import './chunk-VB62WYPL.js';
+export { MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, TASK_MANAGER_ADDRESS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, TFHE_RS_ZK_MAX_BITS } from './chunk-ESMZCFJY.js';