@zama-fhe/sdk 3.3.0 → 3.3.1-alpha.2

package/dist/esm/fhevm-relayer-B-lEKfPQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fhevm-relayer-B-lEKfPQ.js","names":["#chain","#base","#decrypt","#encrypt","#defaultOptions","#encryptInitPromise","#initEncrypt"],"sources":["../../src/chains/to-fhevm-chain.ts","../../src/relayer/fhevm-relayer.ts"],"sourcesContent":["import type { FhevmChain } from \"@fhevm/sdk/chains\";\nimport type { FheChain } from \"./types\";\n\n/**\n * Derive an `@fhevm/sdk` {@link FhevmChain} from zama-sdk's richer\n * {@link FheChain}.\n *\n * `FheChain` carries fields `@fhevm/sdk` does not model (RPC `network`,\n * `registryAddress`, `executorAddress`, cleartext signer keys); those stay on\n * `FheChain` for the token layer. This adapter projects only the subset the\n * FHE runtime needs: contract addresses, relayer URL, and gateway.\n */\nexport function toFhevmChain(chain: FheChain): FhevmChain {\n  return {\n    id: chain.id,\n    fhevm: {\n      contracts: {\n        acl: { address: chain.aclContractAddress },\n        inputVerifier: { address: chain.inputVerifierContractAddress },\n        kmsVerifier: { address: chain.kmsContractAddress },\n        protocolConfig: undefined,\n      },\n      relayerUrl: chain.relayerUrl,\n      gateway: {\n        id: chain.gatewayChainId,\n        contracts: {\n          decryption: { address: chain.verifyingContractAddressDecryption },\n          inputVerification: { address: chain.verifyingContractAddressInputVerification },\n        },\n      },\n    },\n  } satisfies FhevmChain;\n}\n","import {\n  createFhevmBaseClient,\n  createFhevmDecryptClient,\n  createFhevmEncryptClient,\n} from \"@fhevm/sdk/viem\";\nimport {\n  createFhevmCleartextBaseClient,\n  createFhevmCleartextDecryptClient,\n  createFhevmCleartextEncryptClient,\n} from \"@fhevm/sdk/viem/cleartext\";\nimport { createPublicClient, custom, http } from \"viem\";\nimport { toFhevmChain } from \"../chains/to-fhevm-chain\";\nimport type { FheChain } from \"../chains/types\";\nimport type {\n  FhevmBaseClient,\n  FhevmClient,\n  FhevmDecryptClient,\n  FhevmEncryptClient,\n  FhevmRelayerOptions,\n  FhevmRelayerSDK,\n  RelayerOptions,\n} from \"./types\";\nimport { ConfigurationError } from \"../errors\";\n\n/** Construction config for {@link FhevmRelayer}. */\nexport interface FhevmRelayerConfig {\n  /** FHE chain configuration. */\n  chain: FheChain;\n  /**\n   * Cleartext mode for local dev/test chains without FHE infrastructure — reads\n   * mock cleartexts from the on-chain executor (discovered automatically)\n   * instead of calling the relayer.\n   */\n  cleartext?: boolean;\n  /**\n   * Per-transport {@link RelayerOptions}: `@fhevm/sdk` client options plus a\n   * default request `timeout` applied to every relayer round-trip on the chain.\n   */\n  options?: RelayerOptions;\n}\n\n/**\n * Single-chain FHE backend that drives `@fhevm/sdk` on the calling thread with\n * capability-scoped lazy initialization.\n * EIP-712 signing is done by the signer layer; this backend builds the typed\n * data and, on decrypt, reassembles the new SDK's signed permit from the\n * interface's params + the previously returned signature.\n *\n * @remarks\n * Each method delegates to the narrowest base, decrypt, or encrypt client,\n * adding two cross-cutting behaviors that the delegated signatures don't\n * express:\n *\n * - **Lazy init.** Each operation initializes only the capability it requires.\n *   Public decrypt avoids WASM, private decrypt loads TKMS only, and encryption\n *   alone loads TFHE and the FHE encryption key.\n * - **Option merging.** The chain's default options (`auth`, `timeout`, `debug`)\n *   are spread in first, then the per-call `options`, so a per-call value always\n *   wins over the chain default. Serialization helpers make no relayer\n *   round-trip, so they inject no options.\n */\nexport class FhevmRelayer implements FhevmRelayerSDK {\n  readonly #chain: FheChain;\n  readonly #base: FhevmBaseClient;\n  readonly #decrypt: FhevmDecryptClient;\n  readonly #encrypt: FhevmEncryptClient;\n  readonly #defaultOptions: Partial<FhevmRelayerOptions>;\n  #encryptInitPromise: Promise<void> | undefined;\n\n  /**\n   * Builds capability-scoped `@fhevm/sdk` clients for the chain and captures\n   * the chain's `auth`/`timeout`/`debug` as request defaults. Construction is\n   * cheap; each client's one-time init is deferred to its first operation.\n   */\n  constructor(config: FhevmRelayerConfig) {\n    this.#chain = config.chain;\n    const { timeout, debug, batchRpcCalls, moduleVersions, fheEncryptionKey } =\n      config.options ?? {};\n    const params = {\n      publicClient: createPublicClient({\n        transport:\n          typeof this.#chain.network === \"string\"\n            ? http(this.#chain.network)\n            : custom(this.#chain.network),\n      }),\n      chain: toFhevmChain(this.#chain),\n      options: { batchRpcCalls, moduleVersions, fheEncryptionKey },\n    };\n    if (config.cleartext) {\n      this.#base = createFhevmCleartextBaseClient(params);\n      this.#decrypt = createFhevmCleartextDecryptClient(params);\n      this.#encrypt = createFhevmCleartextEncryptClient(params);\n    } else {\n      this.#base = createFhevmBaseClient(params);\n      this.#decrypt = createFhevmDecryptClient(params);\n      this.#encrypt = createFhevmEncryptClient(params);\n    }\n    this.#defaultOptions = {\n      ...(this.#chain.auth !== undefined && { auth: toFhevmAuth(this.#chain.auth) }),\n      ...(timeout !== undefined && { timeout }),\n      ...(debug !== undefined && { debug }),\n    };\n  }\n\n  /** The FHE chain this backend is bound to. */\n  get chain() {\n    return this.#chain;\n  }\n\n  #initEncrypt = (): Promise<void> => {\n    this.#encryptInitPromise ??= this.#encrypt\n      .fetchFheEncryptionKeyBytes({ options: this.#defaultOptions })\n      .then(() => this.#encrypt.init());\n    return this.#encryptInitPromise;\n  };\n\n  /**\n   * Decrypts a single publicly-decryptable value — one whose contract granted\n   * public access, so no permit or key pair is needed — into its typed clear\n   * value.\n   *\n   * @example\n   * ```ts\n   * const { type, value } = await relayer.decryptPublicValue({\n   *   encryptedValue: handle, // a bytes32 ciphertext reference\n   * });\n   * ```\n   */\n  decryptPublicValue: FhevmClient[\"decryptPublicValue\"] = async (parameters) => {\n    await this.#base.init();\n    return this.#base.decryptPublicValue({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * Batch form of {@link decryptPublicValue}: decrypts many publicly-decryptable\n   * values in one relayer round-trip, returning their typed clear values in\n   * order.\n   *\n   * @example\n   * ```ts\n   * const values = await relayer.decryptPublicValues({\n   *   encryptedValues: [handleA, handleB],\n   * });\n   * ```\n   */\n  decryptPublicValues: FhevmClient[\"decryptPublicValues\"] = async (parameters) => {\n    await this.#base.init();\n    return this.#base.decryptPublicValues({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * Like {@link decryptPublicValues}, but also returns the KMS signature bundle —\n   * the handles list, ABI-encoded cleartexts, and decryption proof — needed to\n   * verify or replay the result on-chain.\n   *\n   * @example\n   * ```ts\n   * const { clearValues, checkSignaturesArgs } =\n   *   await relayer.decryptPublicValuesWithSignatures({ encryptedValues: [handle] });\n   * // checkSignaturesArgs: { handlesList, abiEncodedCleartexts, decryptionProof }\n   * ```\n   */\n  decryptPublicValuesWithSignatures: FhevmClient[\"decryptPublicValuesWithSignatures\"] = async (\n    parameters,\n  ) => {\n    await this.#base.init();\n    return this.#base.decryptPublicValuesWithSignatures({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * Encrypts one typed input under the chain's FHE key, bound to the contract it\n   * targets and the user submitting it, and returns the ciphertext handle plus\n   * the input proof the contract verifies on-chain. `type` is the FHE type\n   * with the `e` prefix (`\"euint64\"`, `\"ebool\"`, `\"eaddress\"`).\n   *\n   * @example\n   * ```ts\n   * const { encryptedValue, inputProof } = await relayer.encryptValue({\n   *   value: { type: \"euint64\", value: 1000n },\n   *   contractAddress: \"0xToken…\",\n   *   userAddress: \"0xUser…\",\n   * });\n   * ```\n   */\n  encryptValue: FhevmClient[\"encryptValue\"] = async (parameters) => {\n    await this.#initEncrypt();\n    return this.#encrypt.encryptValue({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * Batch form of {@link encryptValue}: encrypts several inputs for the same\n   * contract and user in one call, returning all ciphertext handles under a\n   * single shared input proof.\n   *\n   * @example\n   * ```ts\n   * const { encryptedValues, inputProof } = await relayer.encryptValues({\n   *   values: [\n   *     { type: \"euint64\", value: 1000n },\n   *     { type: \"ebool\", value: true },\n   *   ],\n   *   contractAddress: \"0xToken…\",\n   *   userAddress: \"0xUser…\",\n   * });\n   * ```\n   */\n  encryptValues: FhevmClient[\"encryptValues\"] = async (parameters) => {\n    await this.#initEncrypt();\n    return this.#encrypt.encryptValues({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * User-decrypts a single access-controlled value: the relayer re-encrypts it\n   * to the ephemeral transport key pair, gated by the signed permit, and this\n   * returns the typed clear value. Build the key pair with\n   * {@link generateTransportKeyPair} and the permit with\n   * {@link signDecryptionPermit}.\n   *\n   * @example\n   * ```ts\n   * const { type, value } = await relayer.decryptValue({\n   *   encryptedValue: handle,\n   *   contractAddress: \"0xToken…\",\n   *   transportKeyPair,\n   *   signedPermit,\n   * });\n   * ```\n   */\n  decryptValue: FhevmClient[\"decryptValue\"] = async (parameters) => {\n    await this.#decrypt.init();\n    return this.#decrypt.decryptValue({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * Batch form of {@link decryptValue} for values that all belong to the same\n   * contract; returns the typed clear values positionally. For values spanning\n   * multiple contracts, use {@link decryptValuesFromPairs}.\n   *\n   * @example\n   * ```ts\n   * const values = await relayer.decryptValues({\n   *   encryptedValues: [handleA, handleB],\n   *   contractAddress: \"0xToken…\",\n   *   transportKeyPair,\n   *   signedPermit,\n   * });\n   * ```\n   */\n  decryptValues: FhevmClient[\"decryptValues\"] = async (parameters) => {\n    await this.#decrypt.init();\n    return this.#decrypt.decryptValues({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * User-decrypts values that span multiple contracts: each pair carries its own\n   * `contractAddress`, so one permit covering those contracts decrypts them all\n   * in a single round-trip. Returns the typed clear values positionally.\n   *\n   * @example\n   * ```ts\n   * const values = await relayer.decryptValuesFromPairs({\n   *   pairs: [\n   *     { encryptedValue: handleA, contractAddress: \"0xTokenA…\" },\n   *     { encryptedValue: handleB, contractAddress: \"0xTokenB…\" },\n   *   ],\n   *   transportKeyPair,\n   *   signedPermit,\n   * });\n   * ```\n   */\n  decryptValuesFromPairs: FhevmClient[\"decryptValuesFromPairs\"] = async (parameters) => {\n    await this.#decrypt.init();\n    return this.#decrypt.decryptValuesFromPairs({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * Fetches the chain's raw FHE public-key bytes — the key encryption uses —\n   * served from cache unless `ignoreCache` forces a refetch. Rarely called\n   * directly: {@link encryptValue}/{@link encryptValues} fetch the key for you.\n   *\n   * @example\n   * ```ts\n   * const keyBytes = await relayer.fetchFheEncryptionKeyBytes();\n   * const fresh = await relayer.fetchFheEncryptionKeyBytes({ ignoreCache: true });\n   * ```\n   */\n  fetchFheEncryptionKeyBytes: FhevmClient[\"fetchFheEncryptionKeyBytes\"] = async (parameters) => {\n    await this.#initEncrypt();\n    return this.#encrypt.fetchFheEncryptionKeyBytes({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters?.options },\n    });\n  };\n\n  /**\n   * Builds the EIP-712 user-decrypt permit and signs it with the given signer,\n   * authorizing the transport key pair to decrypt the listed contracts' values\n   * for `durationSeconds` starting at `startTimestamp`. Pass `delegatorAddress`\n   * to sign a delegated permit — decrypting values owned by that account instead\n   * of the signer's own. Persist the result via\n   * {@link serializeSignedDecryptionPermit}.\n   *\n   * @example\n   * ```ts\n   * const signedPermit = await relayer.signDecryptionPermit({\n   *   transportKeyPair,\n   *   contractAddresses: [\"0xToken…\"],\n   *   startTimestamp: Math.floor(Date.now() / 1000),\n   *   durationSeconds: 60 * 60 * 24,\n   *   signerAddress: \"0xUser…\",\n   *   signer,\n   *   // delegatorAddress: \"0xOwner…\", // omit for a self permit\n   * });\n   * ```\n   */\n  signDecryptionPermit: FhevmClient[\"signDecryptionPermit\"] = async (parameters) => {\n    await this.#base.init();\n    return this.#base.signDecryptionPermit(parameters);\n  };\n\n  // Permit/key-pair helpers carry no request options. Parsing initializes the\n  // capability needed to validate the restored value; serialization stays local.\n\n  /**\n   * Serializes a transport key pair to a hex `{ publicKey, privateKey }` pair for\n   * storage or transport, so a decryption session can resume without regenerating\n   * keys. Reverse of {@link parseTransportKeyPair}. Purely local — no round-trip.\n   *\n   * @example\n   * ```ts\n   * const stored = relayer.serializeTransportKeyPair({ transportKeyPair });\n   * // { publicKey: \"0x…\", privateKey: \"0x…\" }\n   * ```\n   */\n  serializeTransportKeyPair: FhevmClient[\"serializeTransportKeyPair\"] = (parameters) =>\n    this.#decrypt.serializeTransportKeyPair(parameters);\n\n  /**\n   * Serializes a signed permit to a plain, JSON-stringifiable object (version,\n   * EIP-712 payload, signature, signer) for caching or transport. Reverse of\n   * {@link parseSignedDecryptionPermit}. Purely local — no round-trip.\n   *\n   * @example\n   * ```ts\n   * const serialized = relayer.serializeSignedDecryptionPermit({ signedPermit });\n   * localStorage.setItem(\"permit\", JSON.stringify(serialized));\n   * ```\n   */\n  serializeSignedDecryptionPermit: FhevmClient[\"serializeSignedDecryptionPermit\"] = (parameters) =>\n    this.#base.serializeSignedDecryptionPermit(parameters);\n\n  /**\n   * Rebuilds a transport key pair from its serialized hex\n   * `{ publicKey, privateKey }` form. Reverse of {@link serializeTransportKeyPair}.\n   *\n   * @example\n   * ```ts\n   * const transportKeyPair = await relayer.parseTransportKeyPair({\n   *   publicKey: stored.publicKey,\n   *   privateKey: stored.privateKey,\n   * });\n   * ```\n   */\n  parseTransportKeyPair: FhevmClient[\"parseTransportKeyPair\"] = async (parameters) => {\n    await this.#decrypt.init();\n    return this.#decrypt.parseTransportKeyPair(parameters);\n  };\n\n  /**\n   * Rebuilds a signed permit from its serialized form and validates it: checks\n   * the EIP-712 structure, verifies the signature against the on-chain verifier,\n   * and confirms the permit's public key matches `transportKeyPair`. Reverse of\n   * {@link serializeSignedDecryptionPermit}.\n   *\n   * @throws if the permit is malformed, expired, or its signature is invalid.\n   *\n   * @example\n   * ```ts\n   * const signedPermit = await relayer.parseSignedDecryptionPermit({\n   *   serializedPermit,\n   *   transportKeyPair,\n   * });\n   * ```\n   */\n  parseSignedDecryptionPermit: FhevmClient[\"parseSignedDecryptionPermit\"] = async (parameters) => {\n    await this.#base.init();\n    return this.#base.parseSignedDecryptionPermit(parameters);\n  };\n\n  /**\n   * Generates a fresh ephemeral transport key pair for a user-decrypt session.\n   * The relayer re-encrypts decrypted values to this pair's public key, so only\n   * the holder of the private key can read them; bind it to a permit via\n   * {@link signDecryptionPermit}.\n   *\n   * @example\n   * ```ts\n   * const transportKeyPair = await relayer.generateTransportKeyPair();\n   * ```\n   */\n  generateTransportKeyPair: FhevmClient[\"generateTransportKeyPair\"] = async () => {\n    await this.#decrypt.init();\n    return this.#decrypt.generateTransportKeyPair();\n  };\n}\n\nfunction toFhevmAuth(\n  auth: NonNullable<FheChain[\"auth\"]>,\n): NonNullable<FhevmRelayerOptions[\"auth\"]> {\n  const type = auth[\"__type\"];\n  switch (type) {\n    case \"ApiKeyHeader\":\n      return { type, value: auth.value, header: auth.header };\n    case \"ApiKeyCookie\":\n      return { type, value: auth.value, cookie: auth.cookie };\n    case \"BearerToken\":\n      return { type, token: auth.token };\n    default:\n      throw new ConfigurationError(`Unknown auth type: ${String(type)}`);\n  }\n}\n"],"mappings":"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"}

package/dist/esm/index-BnIp_-Ak.d.ts

@@ -0,0 +1,328 @@
+import { u as FheChain } from "./index-D66eC3G7.js";
+import { Ut as FhevmRelayerSDK, Vt as FhevmClient, Wt as RelayerOptions, c as GenericStorage, n as RelayerConfig } from "./types-C-WTLcHZ.js";
+//#region src/relayer/fhevm-relayer.d.ts
+/** Construction config for {@link FhevmRelayer}. */
+interface FhevmRelayerConfig {
+  /** FHE chain configuration. */
+  chain: FheChain;
+  /**
+   * Cleartext mode for local dev/test chains without FHE infrastructure — reads
+   * mock cleartexts from the on-chain executor (discovered automatically)
+   * instead of calling the relayer.
+   */
+  cleartext?: boolean;
+  /**
+   * Per-transport {@link RelayerOptions}: `@fhevm/sdk` client options plus a
+   * default request `timeout` applied to every relayer round-trip on the chain.
+   */
+  options?: RelayerOptions;
+}
+/**
+ * Single-chain FHE backend that drives `@fhevm/sdk` on the calling thread with
+ * capability-scoped lazy initialization.
+ * EIP-712 signing is done by the signer layer; this backend builds the typed
+ * data and, on decrypt, reassembles the new SDK's signed permit from the
+ * interface's params + the previously returned signature.
+ *
+ * @remarks
+ * Each method delegates to the narrowest base, decrypt, or encrypt client,
+ * adding two cross-cutting behaviors that the delegated signatures don't
+ * express:
+ *
+ * - **Lazy init.** Each operation initializes only the capability it requires.
+ *   Public decrypt avoids WASM, private decrypt loads TKMS only, and encryption
+ *   alone loads TFHE and the FHE encryption key.
+ * - **Option merging.** The chain's default options (`auth`, `timeout`, `debug`)
+ *   are spread in first, then the per-call `options`, so a per-call value always
+ *   wins over the chain default. Serialization helpers make no relayer
+ *   round-trip, so they inject no options.
+ */
+declare class FhevmRelayer implements FhevmRelayerSDK {
+  #private;
+  /**
+   * Builds capability-scoped `@fhevm/sdk` clients for the chain and captures
+   * the chain's `auth`/`timeout`/`debug` as request defaults. Construction is
+   * cheap; each client's one-time init is deferred to its first operation.
+   */
+  constructor(config: FhevmRelayerConfig);
+  /** The FHE chain this backend is bound to. */
+  get chain(): FheChain<number>;
+  /**
+   * Decrypts a single publicly-decryptable value — one whose contract granted
+   * public access, so no permit or key pair is needed — into its typed clear
+   * value.
+   *
+   * @example
+   * ```ts
+   * const { type, value } = await relayer.decryptPublicValue({
+   *   encryptedValue: handle, // a bytes32 ciphertext reference
+   * });
+   * ```
+   */
+  decryptPublicValue: FhevmClient["decryptPublicValue"];
+  /**
+   * Batch form of {@link decryptPublicValue}: decrypts many publicly-decryptable
+   * values in one relayer round-trip, returning their typed clear values in
+   * order.
+   *
+   * @example
+   * ```ts
+   * const values = await relayer.decryptPublicValues({
+   *   encryptedValues: [handleA, handleB],
+   * });
+   * ```
+   */
+  decryptPublicValues: FhevmClient["decryptPublicValues"];
+  /**
+   * Like {@link decryptPublicValues}, but also returns the KMS signature bundle —
+   * the handles list, ABI-encoded cleartexts, and decryption proof — needed to
+   * verify or replay the result on-chain.
+   *
+   * @example
+   * ```ts
+   * const { clearValues, checkSignaturesArgs } =
+   *   await relayer.decryptPublicValuesWithSignatures({ encryptedValues: [handle] });
+   * // checkSignaturesArgs: { handlesList, abiEncodedCleartexts, decryptionProof }
+   * ```
+   */
+  decryptPublicValuesWithSignatures: FhevmClient["decryptPublicValuesWithSignatures"];
+  /**
+   * Encrypts one typed input under the chain's FHE key, bound to the contract it
+   * targets and the user submitting it, and returns the ciphertext handle plus
+   * the input proof the contract verifies on-chain. `type` is the FHE type
+   * with the `e` prefix (`"euint64"`, `"ebool"`, `"eaddress"`).
+   *
+   * @example
+   * ```ts
+   * const { encryptedValue, inputProof } = await relayer.encryptValue({
+   *   value: { type: "euint64", value: 1000n },
+   *   contractAddress: "0xToken…",
+   *   userAddress: "0xUser…",
+   * });
+   * ```
+   */
+  encryptValue: FhevmClient["encryptValue"];
+  /**
+   * Batch form of {@link encryptValue}: encrypts several inputs for the same
+   * contract and user in one call, returning all ciphertext handles under a
+   * single shared input proof.
+   *
+   * @example
+   * ```ts
+   * const { encryptedValues, inputProof } = await relayer.encryptValues({
+   *   values: [
+   *     { type: "euint64", value: 1000n },
+   *     { type: "ebool", value: true },
+   *   ],
+   *   contractAddress: "0xToken…",
+   *   userAddress: "0xUser…",
+   * });
+   * ```
+   */
+  encryptValues: FhevmClient["encryptValues"];
+  /**
+   * User-decrypts a single access-controlled value: the relayer re-encrypts it
+   * to the ephemeral transport key pair, gated by the signed permit, and this
+   * returns the typed clear value. Build the key pair with
+   * {@link generateTransportKeyPair} and the permit with
+   * {@link signDecryptionPermit}.
+   *
+   * @example
+   * ```ts
+   * const { type, value } = await relayer.decryptValue({
+   *   encryptedValue: handle,
+   *   contractAddress: "0xToken…",
+   *   transportKeyPair,
+   *   signedPermit,
+   * });
+   * ```
+   */
+  decryptValue: FhevmClient["decryptValue"];
+  /**
+   * Batch form of {@link decryptValue} for values that all belong to the same
+   * contract; returns the typed clear values positionally. For values spanning
+   * multiple contracts, use {@link decryptValuesFromPairs}.
+   *
+   * @example
+   * ```ts
+   * const values = await relayer.decryptValues({
+   *   encryptedValues: [handleA, handleB],
+   *   contractAddress: "0xToken…",
+   *   transportKeyPair,
+   *   signedPermit,
+   * });
+   * ```
+   */
+  decryptValues: FhevmClient["decryptValues"];
+  /**
+   * User-decrypts values that span multiple contracts: each pair carries its own
+   * `contractAddress`, so one permit covering those contracts decrypts them all
+   * in a single round-trip. Returns the typed clear values positionally.
+   *
+   * @example
+   * ```ts
+   * const values = await relayer.decryptValuesFromPairs({
+   *   pairs: [
+   *     { encryptedValue: handleA, contractAddress: "0xTokenA…" },
+   *     { encryptedValue: handleB, contractAddress: "0xTokenB…" },
+   *   ],
+   *   transportKeyPair,
+   *   signedPermit,
+   * });
+   * ```
+   */
+  decryptValuesFromPairs: FhevmClient["decryptValuesFromPairs"];
+  /**
+   * Fetches the chain's raw FHE public-key bytes — the key encryption uses —
+   * served from cache unless `ignoreCache` forces a refetch. Rarely called
+   * directly: {@link encryptValue}/{@link encryptValues} fetch the key for you.
+   *
+   * @example
+   * ```ts
+   * const keyBytes = await relayer.fetchFheEncryptionKeyBytes();
+   * const fresh = await relayer.fetchFheEncryptionKeyBytes({ ignoreCache: true });
+   * ```
+   */
+  fetchFheEncryptionKeyBytes: FhevmClient["fetchFheEncryptionKeyBytes"];
+  /**
+   * Builds the EIP-712 user-decrypt permit and signs it with the given signer,
+   * authorizing the transport key pair to decrypt the listed contracts' values
+   * for `durationSeconds` starting at `startTimestamp`. Pass `delegatorAddress`
+   * to sign a delegated permit — decrypting values owned by that account instead
+   * of the signer's own. Persist the result via
+   * {@link serializeSignedDecryptionPermit}.
+   *
+   * @example
+   * ```ts
+   * const signedPermit = await relayer.signDecryptionPermit({
+   *   transportKeyPair,
+   *   contractAddresses: ["0xToken…"],
+   *   startTimestamp: Math.floor(Date.now() / 1000),
+   *   durationSeconds: 60 * 60 * 24,
+   *   signerAddress: "0xUser…",
+   *   signer,
+   *   // delegatorAddress: "0xOwner…", // omit for a self permit
+   * });
+   * ```
+   */
+  signDecryptionPermit: FhevmClient["signDecryptionPermit"];
+  /**
+   * Serializes a transport key pair to a hex `{ publicKey, privateKey }` pair for
+   * storage or transport, so a decryption session can resume without regenerating
+   * keys. Reverse of {@link parseTransportKeyPair}. Purely local — no round-trip.
+   *
+   * @example
+   * ```ts
+   * const stored = relayer.serializeTransportKeyPair({ transportKeyPair });
+   * // { publicKey: "0x…", privateKey: "0x…" }
+   * ```
+   */
+  serializeTransportKeyPair: FhevmClient["serializeTransportKeyPair"];
+  /**
+   * Serializes a signed permit to a plain, JSON-stringifiable object (version,
+   * EIP-712 payload, signature, signer) for caching or transport. Reverse of
+   * {@link parseSignedDecryptionPermit}. Purely local — no round-trip.
+   *
+   * @example
+   * ```ts
+   * const serialized = relayer.serializeSignedDecryptionPermit({ signedPermit });
+   * localStorage.setItem("permit", JSON.stringify(serialized));
+   * ```
+   */
+  serializeSignedDecryptionPermit: FhevmClient["serializeSignedDecryptionPermit"];
+  /**
+   * Rebuilds a transport key pair from its serialized hex
+   * `{ publicKey, privateKey }` form. Reverse of {@link serializeTransportKeyPair}.
+   *
+   * @example
+   * ```ts
+   * const transportKeyPair = await relayer.parseTransportKeyPair({
+   *   publicKey: stored.publicKey,
+   *   privateKey: stored.privateKey,
+   * });
+   * ```
+   */
+  parseTransportKeyPair: FhevmClient["parseTransportKeyPair"];
+  /**
+   * Rebuilds a signed permit from its serialized form and validates it: checks
+   * the EIP-712 structure, verifies the signature against the on-chain verifier,
+   * and confirms the permit's public key matches `transportKeyPair`. Reverse of
+   * {@link serializeSignedDecryptionPermit}.
+   *
+   * @throws if the permit is malformed, expired, or its signature is invalid.
+   *
+   * @example
+   * ```ts
+   * const signedPermit = await relayer.parseSignedDecryptionPermit({
+   *   serializedPermit,
+   *   transportKeyPair,
+   * });
+   * ```
+   */
+  parseSignedDecryptionPermit: FhevmClient["parseSignedDecryptionPermit"];
+  /**
+   * Generates a fresh ephemeral transport key pair for a user-decrypt session.
+   * The relayer re-encrypts decrypted values to this pair's public key, so only
+   * the holder of the private key can read them; bind it to a permit via
+   * {@link signDecryptionPermit}.
+   *
+   * @example
+   * ```ts
+   * const transportKeyPair = await relayer.generateTransportKeyPair();
+   * ```
+   */
+  generateTransportKeyPair: FhevmClient["generateTransportKeyPair"];
+}
+//#endregion
+//#region src/node/config.d.ts
+/** Node transport — drives the FHE backend directly on the calling thread. */
+interface NodeRelayerConfig extends RelayerConfig {
+  readonly type: "node";
+  readonly createRelayer: (chain: FheChain) => FhevmRelayer;
+}
+/**
+ * Node.js transport — drives `@fhevm/sdk` via {@link FhevmRelayer} on the calling thread.
+ *
+ * @example
+ * ```ts
+ * relayers: {
+ *   [sepolia.id]: node({ timeout: 5 * 60_000 }),
+ *   [mainnet.id]: node({ batchRpcCalls: true }),
+ * }
+ * ```
+ */
+declare function node(options?: RelayerOptions): NodeRelayerConfig;
+//#endregion
+//#region src/storage/async-local-storage.d.ts
+/**
+ * {@link GenericStorage} backed by Node.js {@link AsyncLocalStorage}.
+ *
+ * Each async context (e.g. HTTP request) gets its own isolated `Map`,
+ * so credentials from one request never leak into another.
+ *
+ * Call {@link run} to establish a context before using the SDK:
+ *
+ * ```ts
+ * import { asyncLocalStorage } from "@zama-fhe/sdk/node";
+ *
+ * app.post("/api/transfer", (req, res) => {
+ *   asyncLocalStorage.run(async () => {
+ *     const sdk = new ZamaSDK({ relayer, signer, storage: asyncLocalStorage });
+ *     // credentials are scoped to this request
+ *   });
+ * });
+ * ```
+ */
+declare class AsyncLocalMapStorage implements GenericStorage {
+  #private;
+  /** Execute `fn` within an isolated storage context. */
+  run<R>(fn: () => R | Promise<R>): R | Promise<R>;
+  get<T = unknown>(key: string): Promise<T | null>;
+  set<T = unknown>(key: string, value: T): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+/** Default singleton for application-wide use. */
+declare const asyncLocalStorage: AsyncLocalMapStorage;
+//#endregion
+export { node as i, asyncLocalStorage as n, NodeRelayerConfig as r, AsyncLocalMapStorage as t };
+//# sourceMappingURL=index-BnIp_-Ak.d.ts.map

package/dist/esm/{index-CYBH0nyo.d.ts → index-D66eC3G7.d.ts}

@@ -1,19 +1,66 @@
-import { n as FheChain } from "./types-BgczXqW2.js";
+import { Address, EIP1193Provider } from "viem";
 
+//#region src/chains/types.d.ts
+/** Authentication forwarded to a chain's relayer endpoint. */
+type FheChainAuth = {
+  __type: "BearerToken";
+  token: string;
+} | {
+  __type: "ApiKeyHeader";
+  header?: string;
+  value: string;
+} | {
+  __type: "ApiKeyCookie";
+  cookie?: string;
+  value: string;
+};
+/**
+ * Complete chain configuration — the single source of truth for
+ * per-chain FHE contract addresses and network settings.
+ *
+ * All built-in presets (`mainnet`, `sepolia`, `hoodi`, `ingenTestnet`,
+ * `bscTestnet`, `hardhat`) are `FheChain` objects exported from
+ * `@zama-fhe/sdk/chains`.
+ */
+interface FheChain<TId extends number = number> {
+  readonly id: TId;
+  readonly gatewayChainId: number;
+  readonly relayerUrl: string;
+  readonly network: EIP1193Provider | string;
+  readonly aclContractAddress: Address;
+  readonly kmsContractAddress: Address;
+  readonly inputVerifierContractAddress: Address;
+  readonly verifyingContractAddressDecryption: Address;
+  readonly verifyingContractAddressInputVerification: Address;
+  /**
+   * Address of the `ConfidentialTokenWrappersRegistry` contract.
+   * `undefined` for chains where no registry is deployed (e.g. Hardhat).
+   */
+  readonly registryAddress: Address | undefined;
+  /**
+   * Address of the `TFHEExecutor` contract (cleartext mode only).
+   * Required by the `cleartext()` transport to read mock plaintexts.
+   * `undefined` for chains that use real FHE infrastructure.
+   */
+  readonly executorAddress?: Address | undefined;
+  /**
+   * Authentication for the relayer endpoint.
+   * Use `{ __type: "ApiKeyHeader", value: "your-key" }` for API-key auth,
+   * or `{ __type: "BearerToken", token: "your-token" }` for bearer auth.
+   */
+  readonly auth?: FheChainAuth;
+}
+/** At least one chain is required. */
+type AtLeastOneChain = readonly [FheChain, ...FheChain[]];
+//#endregion
 //#region src/chains/configs.d.ts
 /**
  * Mainnet network configuration (chainId 1).
- *
- * Contract addresses mirror `MainnetConfigV2` from `@zama-fhe/relayer-sdk`.
- * They are duplicated here because the `/bundle` export path only exposes
- * types at build time (runtime values require `/web` or `/node` which pull
- * in WASM). `satisfies FheChain` ensures structural drift is caught at
- * compile time.
  */
 declare const mainnet: {
   readonly id: 1;
   readonly gatewayChainId: 261131;
-  readonly relayerUrl: "https://relayer.mainnet.zama.org/v2";
+  readonly relayerUrl: "https://relayer.mainnet.zama.org";
   readonly network: "https://ethereum-rpc.publicnode.com";
   readonly aclContractAddress: "0xcA2E8f1F656CD25C01F05d0b243Ab1ecd4a8ffb6";
   readonly kmsContractAddress: "0x77627828a55156b04Ac0DC0eb30467f1a552BB03";
@@ -28,7 +75,7 @@ declare const mainnet: {
 declare const sepolia: {
   readonly id: 11155111;
   readonly gatewayChainId: 10901;
-  readonly relayerUrl: "https://relayer.testnet.zama.org/v2";
+  readonly relayerUrl: "https://relayer.testnet.zama.org";
   readonly network: "https://ethereum-sepolia-rpc.publicnode.com";
   readonly aclContractAddress: "0xf0Ffdc93b7E186bC2f8CB3dAA75D86d1930A433D";
   readonly kmsContractAddress: "0xbE0E383937d564D7FF0BC3b46c51f0bF8d5C311A";
@@ -49,8 +96,8 @@ declare const hoodi: {
   readonly relayerUrl: "";
   readonly network: "https://rpc.hoodi.ethpandaops.io";
   readonly aclContractAddress: "0x6D3FAf6f86e1fF9F3B0831Dda920AbA1cBd5bd68";
-  readonly kmsContractAddress: "0x901F8942346f7AB3a01F6D7613119Bca447Bb030";
-  readonly inputVerifierContractAddress: "0x36772142b74871f255CbD7A3e89B401d3e45825f";
+  readonly kmsContractAddress: "0x822BE20679CfAfdc352F05dEdfe12a07E912212e";
+  readonly inputVerifierContractAddress: "0xf3D9A51f32D9bC23E1eECb0fAbF1f1DA4d9Bba26";
   readonly verifyingContractAddressDecryption: "0x5ffdaAB0373E62E2ea2944776209aEf29E631A64";
   readonly verifyingContractAddressInputVerification: "0x812b06e1CDCE800494b79fFE4f925A504a9A9810";
   readonly registryAddress: "0x1807aE2f693F8530DFB126D0eF98F2F2518F292f";
@@ -131,5 +178,5 @@ declare const anvil: {
  */
 declare const chains: Record<number, FheChain>;
 //#endregion
-export { hoodi as a, sepolia as c, hardhat as i, bscTestnet as n, ingenTestnet as o, chains as r, mainnet as s, anvil as t };
-//# sourceMappingURL=index-CYBH0nyo.d.ts.map
+export { hoodi as a, sepolia as c, FheChainAuth as d, hardhat as i, AtLeastOneChain as l, bscTestnet as n, ingenTestnet as o, chains as r, mainnet as s, anvil as t, FheChain as u };
+//# sourceMappingURL=index-D66eC3G7.d.ts.map

package/dist/esm/index.d.ts

@@ -1,14 +1,11 @@
-import { n as FheChain, t as AtLeastOneChain } from "./types-BgczXqW2.js";
-import { a as hoodi, c as sepolia, i as hardhat, n as bscTestnet, o as ingenTestnet, r as chains, s as mainnet, t as anvil } from "./index-CYBH0nyo.js";
-import { A as ShieldCallbacks, B as RawLog, D as ShieldPath, E as ShieldOptions, F as GenericSigner, G as ReadContractConfig, H as TransactionResult, I as WalletAccount, J as WriteContractArgs, K as ReadContractReturnType, L as WalletAccountChange, M as UnshieldCallbacks, N as GenericStorage, O as TransferOptions, P as GenericProvider, R as WalletAccountListener, T as ApprovalStrategy, U as ContractAbi, V as TransactionReceipt, W as ReadContractArgs, X as WriteFunctionName, Y as WriteContractConfig, _ as PublicParamsData, c as DelegatedUserDecryptParams, d as EncryptParams, f as EncryptResult, g as PublicDecryptResult, h as NetworkType, i as StoredTransportKeyPair, j as TransferCallbacks, k as UnshieldOptions, l as EIP712TypedData, m as FheEncryptionKey, n as RelayerSDK, o as TransportKeyPair, p as EncryptedValue, pt as GenericLogger, q as ReadFunctionName, r as Permission, s as ClearValue, u as EncryptInput, v as RelayerSDKStatus, x as UserDecryptParams, z as WalletAccountStore } from "./relayer-cleartext-CSeMlmGO.js";
-import { $ as decodeDelegatedForUserDecryption, A as UnshieldPhase2StartedEvent, B as AclTopics, C as SetOperatorSubmittedEvent, D as TransferFromSubmittedEvent, E as TransactionOperation, F as ZamaSDKEventListener, G as TOKEN_TOPICS, H as DelegatedForUserDecryptionEvent, I as ZamaSDKEventType, J as UnwrapRequestedEvent, K as Topics, L as ZamaSDKEvents, M as UnwrapSubmittedEvent, N as ZamaSDKEvent, O as TransferSubmittedEvent, P as ZamaSDKEventInput, Q as decodeConfidentialTransfer, R as ACL_TOPICS, S as RevokeDelegationSubmittedEvent, T as TransactionErrorEvent, U as OnChainEvent, V as ConfidentialTransferEvent, W as RevokedDelegationForUserDecryptionEvent, X as decodeAclEvent, Y as WrapEvent, Z as decodeAclEvents, _ as DelegationSubmittedEvent, a as ZamaConfig, at as decodeWrap, b as EncryptStartEvent, ct as findUnwrapRequested, d as WorkerLike, et as decodeOnChainEvent, f as ApproveUnderlyingSubmittedEvent, g as DecryptStartEvent, h as DecryptErrorEvent, it as decodeUnwrapRequested, j as UnshieldPhase2SubmittedEvent, k as UnshieldPhase1SubmittedEvent, lt as findWrap, m as DecryptEndEvent, n as RelayerConfig, nt as decodeRevokedDelegationForUserDecryption, o as ZamaConfigBase, ot as findDelegatedForUserDecryption, p as BaseEvent, q as UnwrapFinalizedEvent, rt as decodeUnwrapFinalized, s as ZamaConfigGeneric, st as findRevokedDelegationForUserDecryption, t as CleartextRelayerConfig, tt as decodeOnChainEvents, u as RelayerDispatcher, v as EncryptEndEvent, w as ShieldSubmittedEvent, x as FinalizeUnwrapSubmittedEvent, y as EncryptErrorEvent, z as AclEvent } from "./types-Gn5MeDsr.js";
-import { t as ZamaConfigEthers } from "./types-OHIaPwCy.js";
-import { n as MutableWalletAccountStore, r as createWalletAccountStore, t as BaseSigner } from "./base-signer-C3Wc5oi9.js";
-import { t as cleartext } from "./cleartext-DAkOTlrE.js";
-import { $ as DecryptResult, A as BalanceCheckUnavailableError, At as decimalsContract, B as DelegationDelegateEqualsContractError, Bt as rateContract, C as SignerRequiredError, Ct as ERC7984_WRAPPER_INTERFACE_ID, D as NotEntitledError, Dt as allowanceContract, E as RpcRateLimitError, Et as supportsInterfaceContract, F as DecryptionFailedError, Ft as confidentialTransferContract, G as DelegationNotPropagatedError, Gt as wrapContract, H as DelegationExpiredError, Ht as underlyingContract, I as EncryptionFailedError, It as confidentialTransferFromContract, J as NoCiphertextError, Jt as resolveStorage, K as DelegationSelfNotAllowedError, Kt as ResolvedChainRelayer, L as AclPausedError, Lt as finalizeUnwrapContract, M as ERC20ReadFailedError, Mt as symbolContract, N as InsufficientConfidentialBalanceError, Nt as confidentialBalanceOfContract, O as ConfigurationError, Ot as approveContract, P as InsufficientERC20BalanceError, Pt as confidentialTotalSupplyContract, Q as ZamaErrorCode, R as DelegationContractIsSelfError, Rt as inferredTotalSupplyContract, S as SignerNotConfiguredError, St as ERC7984_INTERFACE_ID, T as WalletNotConnectedError, Tt as isConfidentialWrapperContract, U as DelegationExpiryUnchangedError, Ut as unwrapContract, V as DelegationExpirationTooSoonError, Vt as setOperatorContract, W as DelegationNotFoundError, Wt as unwrapFromBalanceContract, X as ChainMismatchError, Y as TransportKeyPairExpiredError, Yt as createConfig, Z as ZamaError, _ as WorkerRecycledError, _t as getDelegationExpiryContract, a as WrappersRegistryConfig, b as SigningFailedError, bt as transferAndCallContract, c as BatchDecryptAsOptions, ct as TokenWrapperPairWithMetadata, d as Delegations, dt as getTokenPairContract, et as EncryptedInput, f as Decryption, ft as getTokenPairsContract, g as matchZamaError, gt as delegateForUserDecryptionContract, h as DelegatedDecryptOptions, ht as isConfidentialTokenValidContract, i as WrappersRegistry, j as BalanceErrorDetails, jt as nameContract, k as RelayerRequestFailedError, kt as balanceOfContract, l as Token, lt as getConfidentialTokenAddressContract, m as BatchDecryptResult, mt as getTokenPairsSliceContract, n as DefaultRegistryAddresses, o as WrappedToken, ot as PaginatedResult, p as BatchDecryptItem, pt as getTokenPairsLengthContract, q as InvalidTransportKeyPairError, qt as resolveChainRelayers, r as ListPairsOptions, s as BatchBalancesResult, st as TokenWrapperPair, t as ZamaSDK, u as Permits, ut as getTokenAddressContract, v as WorkerTimeoutError, vt as isHandleDelegatedContract, w as WalletAccountNotReadyError, wt as isConfidentialTokenContract, x as SigningRejectedError, xt as ERC1363_INTERFACE_ID, y as TransactionRevertedError, yt as revokeDelegationContract, z as DelegationCooldownError, zt as isOperatorContract } from "./index-C1Mtc8Rw.js";
-import { t as ZamaConfigViem } from "./types-piBsdTIP.js";
+import { a as hoodi, c as sepolia, d as FheChainAuth, i as hardhat, l as AtLeastOneChain, n as bscTestnet, o as ingenTestnet, r as chains, s as mainnet, t as anvil, u as FheChain } from "./index-D66eC3G7.js";
+import { $ as TransferOptions, A as EncryptEndEvent, At as RawLog, B as TransferSubmittedEvent, Bt as EncryptedValue, C as ChainRouter, Ct as decodeUnwrapFinalized, D as DecryptErrorEvent, Dt as findRevokedDelegationForUserDecryption, E as DecryptEndEvent, Et as findDelegatedForUserDecryption, F as SetOperatorSubmittedEvent, Ft as DecryptValuesParameters, G as ZamaSDKEvent, Gt as TypedValue, H as UnshieldPhase2StartedEvent, I as ShieldSubmittedEvent, It as EIP712TypedData, J as ZamaSDKEventType, K as ZamaSDKEventInput, L as TransactionErrorEvent, Lt as EncryptInput, M as EncryptStartEvent, Mt as TransactionResult, N as FinalizeUnwrapSubmittedEvent, Nt as ClearValue, O as DecryptStartEvent, Ot as findUnwrapRequested, P as RevokeDelegationSubmittedEvent, Pt as DecryptPublicValuesResult, Q as ShieldPath, R as TransactionOperation, Rt as EncryptParams, S as WriteFunctionName, St as decodeRevokedDelegationForUserDecryption, T as BaseEvent, Tt as decodeWrap, U as UnshieldPhase2SubmittedEvent, Ut as FhevmRelayerSDK, V as UnshieldPhase1SubmittedEvent, W as UnwrapSubmittedEvent, X as ApprovalStrategy, Y as ZamaSDKEvents, Z as ShieldOptions, _ as ReadContractConfig, _t as decodeAclEvents, a as ZamaConfigBase, at as AclEvent, b as WriteContractArgs, bt as decodeOnChainEvent, c as GenericStorage, ct as DelegatedForUserDecryptionEvent, d as WalletAccount, dt as TOKEN_TOPICS, et as UnshieldOptions, f as WalletAccountChange, ft as Topics, g as ReadContractArgs, gt as decodeAclEvent, h as ContractAbi, ht as WrapEvent, i as ZamaConfig, it as ACL_TOPICS, j as EncryptErrorEvent, jt as TransactionReceipt, k as DelegationSubmittedEvent, kt as findWrap, l as GenericProvider, lt as OnChainEvent, m as WalletAccountStore, mt as UnwrapRequestedEvent, n as RelayerConfig, nt as TransferCallbacks, o as ZamaConfigGeneric, ot as AclTopics, p as WalletAccountListener, pt as UnwrapFinalizedEvent, q as ZamaSDKEventListener, rt as UnshieldCallbacks, s as GenericLogger, st as ConfidentialTransferEvent, t as CleartextRelayerConfig, tt as ShieldCallbacks, u as GenericSigner, ut as RevokedDelegationForUserDecryptionEvent, v as ReadContractReturnType, vt as decodeConfidentialTransfer, w as ApproveUnderlyingSubmittedEvent, wt as decodeUnwrapRequested, x as WriteContractConfig, xt as decodeOnChainEvents, y as ReadFunctionName, yt as decodeDelegatedForUserDecryption, z as TransferFromSubmittedEvent, zt as EncryptResult } from "./types-C-WTLcHZ.js";
+import { t as cleartext } from "./cleartext-U6sPs_Kd.js";
+import { t as ZamaConfigEthers } from "./types-BpvL50qX.js";
+import { n as MutableWalletAccountStore, r as createWalletAccountStore, t as BaseSigner } from "./base-signer-Q2EJECrc.js";
+import { $n as getTokenAddressContract, $t as DelegationSelfNotAllowedError, Ar as setOperatorContract, At as SignerRequiredError, Bt as InsufficientConfidentialBalanceError, Cr as confidentialTotalSupplyContract, Ct as BatchDecryptAsOptions, D as DecryptResult, Dr as inferredTotalSupplyContract, Dt as SigningFailedError, Er as finalizeUnwrapContract, Et as TransactionRevertedError, Fr as ResolvedChainRelayer, Ft as ConfigurationError, Gt as DelegationContractIsSelfError, Ht as DecryptionFailedError, Ir as resolveChainRelayers, It as RelayerRequestFailedError, Jt as DelegationExpirationTooSoonError, Kt as DelegationCooldownError, Lr as resolveStorage, Lt as BalanceCheckUnavailableError, Mr as unwrapContract, Mt as WalletNotConnectedError, Nr as unwrapFromBalanceContract, Nt as RpcRateLimitError, O as EncryptedInput, Or as isOperatorContract, Ot as SigningRejectedError, Pr as wrapContract, Pt as NotEntitledError, Qn as getConfidentialTokenAddressContract, Qt as DelegationNotPropagatedError, Rr as createConfig, Rt as BalanceErrorDetails, Sr as confidentialBalanceOfContract, St as BatchBalancesResult, Tr as confidentialTransferFromContract, Tt as matchZamaError, Ut as EncryptionFailedError, Vt as InsufficientERC20BalanceError, Wt as AclPausedError, Xn as TokenWrapperPair, Xt as DelegationExpiryUnchangedError, Yn as PaginatedResult, Yt as DelegationExpiredError, Zn as TokenWrapperPairWithMetadata, Zt as DelegationNotFoundError, _n as WrappersRegistryConfig, _r as approveContract, a as BatchDecryptItem, an as ZamaErrorCode, ar as delegateForUserDecryptionContract, bn as StoredTransportKeyPair, br as nameContract, cr as revokeDelegationContract, dr as ERC7984_INTERFACE_ID, en as InvalidTransportKeyPairError, er as getTokenPairContract, fr as ERC7984_WRAPPER_INTERFACE_ID, gn as WrappersRegistry, gr as allowanceContract, hn as ListPairsOptions, hr as supportsInterfaceContract, i as Decryption, in as ZamaError, ir as isConfidentialTokenValidContract, jr as underlyingContract, jt as WalletAccountNotReadyError, kr as rateContract, kt as SignerNotConfiguredError, lr as transferAndCallContract, mn as DefaultRegistryAddresses, mr as isConfidentialWrapperContract, n as Permits, nn as TransportKeyPairExpiredError, nr as getTokenPairsLengthContract, o as BatchDecryptResult, or as getDelegationExpiryContract, pr as isConfidentialTokenContract, qt as DelegationDelegateEqualsContractError, r as Delegations, rn as ChainMismatchError, rr as getTokenPairsSliceContract, s as DelegatedDecryptOptions, sr as isHandleDelegatedContract, t as ZamaSDK, tn as NoCiphertextError, tr as getTokenPairsContract, ur as ERC1363_INTERFACE_ID, vn as Permission, vr as balanceOfContract, wr as confidentialTransferContract, wt as Token, xr as symbolContract, xt as WrappedToken, yn as SerializedTransportKeyPair, yr as decimalsContract, zt as ERC20ReadFailedError } from "./zama-sdk-q4_qt64Q.js";
+import { t as ZamaConfigViem } from "./types-Bov8XY36.js";
 import { Address, Hex } from "viem";
-import { FheTypeName, FhevmInstanceConfig, InputProofBytesType, KmsDelegatedUserDecryptEIP712Type as KmsDelegatedDecryptEIP712Type, ZKProofLike } from "@zama-fhe/relayer-sdk/bundle";
 
 //#region src/utils/handles.d.ts
 declare const ZERO_ENCRYPTED_VALUE: "0x0000000000000000000000000000000000000000000000000000000000000000";
@@ -79,5 +76,5 @@ declare class ChromeSessionStorage implements GenericStorage {
 /** Default singleton for application-wide use. */
 declare const chromeSessionStorage: ChromeSessionStorage;
 //#endregion
-export { ACL_TOPICS, type AclEvent, AclPausedError, AclTopics, type Address, type ApprovalStrategy, type ApproveUnderlyingSubmittedEvent, type AtLeastOneChain, BalanceCheckUnavailableError, type BalanceErrorDetails, type BaseEvent, BaseSigner, type BatchBalancesResult, type BatchDecryptAsOptions, type BatchDecryptItem, type BatchDecryptResult, ChainMismatchError, ChromeSessionStorage, type ClearValue, type CleartextRelayerConfig, type ConfidentialTransferEvent, ConfigurationError, type ContractAbi, type DecryptEndEvent, type DecryptErrorEvent, type EncryptedInput as DecryptInput, type PublicDecryptResult as DecryptPublicValuesResult, type DecryptResult, type DecryptStartEvent, type UserDecryptParams as DecryptValuesParams, Decryption, DecryptionFailedError, DefaultRegistryAddresses, type DelegatedDecryptOptions, type DelegatedUserDecryptParams as DelegatedDecryptValuesParams, type DelegatedForUserDecryptionEvent, DelegationContractIsSelfError, DelegationCooldownError, DelegationDelegateEqualsContractError, DelegationExpirationTooSoonError, DelegationExpiredError, DelegationExpiryUnchangedError, DelegationNotFoundError, DelegationNotPropagatedError, DelegationSelfNotAllowedError, type DelegationSubmittedEvent, Delegations, type EIP712TypedData, ERC1363_INTERFACE_ID, ERC20ReadFailedError, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, type EncryptEndEvent, type EncryptErrorEvent, type EncryptInput, type EncryptParams, type EncryptResult, type EncryptStartEvent, type EncryptedValue, EncryptionFailedError, type FheChain, type FheEncryptionKey, type FheTypeName, type FhevmInstanceConfig, type FinalizeUnwrapSubmittedEvent, type GenericLogger, type GenericProvider, type GenericSigner, type GenericStorage, type Hex, IndexedDBStorage, type InputProofBytesType, InsufficientConfidentialBalanceError, InsufficientERC20BalanceError, InvalidTransportKeyPairError, type KmsDelegatedDecryptEIP712Type, type ListPairsOptions, MemoryStorage, MutableWalletAccountStore, type NetworkType, NoCiphertextError, NotEntitledError, type OnChainEvent, type PaginatedResult, type Permission, Permits, type PublicParamsData, type RawLog, type ReadContractArgs, type ReadContractConfig, type ReadContractReturnType, type ReadFunctionName, type RelayerConfig, type RelayerDispatcher, RelayerRequestFailedError, type RelayerSDK, type RelayerSDKStatus, type ResolvedChainRelayer, type RevokeDelegationSubmittedEvent, type RevokedDelegationForUserDecryptionEvent, RpcRateLimitError, type SetOperatorSubmittedEvent, type ShieldCallbacks, type ShieldOptions, type ShieldPath, type ShieldSubmittedEvent, SignerNotConfiguredError, SignerRequiredError, SigningFailedError, SigningRejectedError, type StoredTransportKeyPair, TOKEN_TOPICS, Token, type TokenWrapperPair, type TokenWrapperPairWithMetadata, Topics, type TransactionErrorEvent, type TransactionOperation, type TransactionReceipt, type TransactionResult, TransactionRevertedError, type TransferCallbacks, type TransferFromSubmittedEvent, type TransferOptions, type TransferSubmittedEvent, type TransportKeyPair, TransportKeyPairExpiredError, type UnshieldCallbacks, type UnshieldOptions, type UnshieldPhase1SubmittedEvent, type UnshieldPhase2StartedEvent, type UnshieldPhase2SubmittedEvent, type UnwrapFinalizedEvent, type UnwrapRequestedEvent, type UnwrapSubmittedEvent, type WalletAccount, type WalletAccountChange, type WalletAccountListener, WalletAccountNotReadyError, type WalletAccountStore, WalletNotConnectedError, type WorkerLike, WorkerRecycledError, WorkerTimeoutError, type WrapEvent, WrappedToken, WrappersRegistry, type WrappersRegistryConfig, type WriteContractArgs, type WriteContractConfig, type WriteFunctionName, ZERO_ENCRYPTED_VALUE, type ZKProofLike, type ZamaConfig, type ZamaConfigBase, type ZamaConfigEthers, type ZamaConfigGeneric, type ZamaConfigViem, ZamaError, ZamaErrorCode, ZamaSDK, type ZamaSDKEvent, type ZamaSDKEventInput, type ZamaSDKEventListener, type ZamaSDKEventType, ZamaSDKEvents, allowanceContract, anvil, approveContract, balanceOfContract, bscTestnet, chains, chromeSessionStorage, cleartext, confidentialBalanceOfContract, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, createConfig, createWalletAccountStore, decimalsContract, decodeAclEvent, decodeAclEvents, decodeConfidentialTransfer, decodeDelegatedForUserDecryption, decodeOnChainEvent, decodeOnChainEvents, decodeRevokedDelegationForUserDecryption, decodeUnwrapFinalized, decodeUnwrapRequested, decodeWrap, delegateForUserDecryptionContract, finalizeUnwrapContract, findDelegatedForUserDecryption, findRevokedDelegationForUserDecryption, findUnwrapRequested, findWrap, getConfidentialTokenAddressContract, getDelegationExpiryContract, getTokenAddressContract, getTokenPairContract, getTokenPairsContract, getTokenPairsLengthContract, getTokenPairsSliceContract, hardhat, hoodi, indexedDBStorage, inferredTotalSupplyContract, ingenTestnet, isConfidentialTokenContract, isConfidentialTokenValidContract, isConfidentialWrapperContract, isEncryptedValueZero, isHandleDelegatedContract, isOperatorContract, mainnet, matchZamaError, memoryStorage, nameContract, rateContract, resolveChainRelayers, resolveStorage, revokeDelegationContract, sepolia, setOperatorContract, supportsInterfaceContract, symbolContract, transferAndCallContract, underlyingContract, unwrapContract, unwrapFromBalanceContract, wrapContract };
+export { ACL_TOPICS, type AclEvent, AclPausedError, AclTopics, type Address, type ApprovalStrategy, type ApproveUnderlyingSubmittedEvent, type AtLeastOneChain, BalanceCheckUnavailableError, type BalanceErrorDetails, type BaseEvent, BaseSigner, type BatchBalancesResult, type BatchDecryptAsOptions, type BatchDecryptItem, type BatchDecryptResult, ChainMismatchError, type ChainRouter, ChromeSessionStorage, type ClearValue, type CleartextRelayerConfig, type ConfidentialTransferEvent, ConfigurationError, type ContractAbi, type DecryptEndEvent, type DecryptErrorEvent, type EncryptedInput as DecryptInput, type DecryptPublicValuesResult, type DecryptResult, type DecryptStartEvent, type DecryptValuesParameters, Decryption, DecryptionFailedError, DefaultRegistryAddresses, type DelegatedDecryptOptions, type DelegatedForUserDecryptionEvent, DelegationContractIsSelfError, DelegationCooldownError, DelegationDelegateEqualsContractError, DelegationExpirationTooSoonError, DelegationExpiredError, DelegationExpiryUnchangedError, DelegationNotFoundError, DelegationNotPropagatedError, DelegationSelfNotAllowedError, type DelegationSubmittedEvent, Delegations, type EIP712TypedData, ERC1363_INTERFACE_ID, ERC20ReadFailedError, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, type EncryptEndEvent, type EncryptErrorEvent, type EncryptInput, type EncryptParams, type EncryptResult, type EncryptStartEvent, type EncryptedValue, EncryptionFailedError, type FheChain, type FheChainAuth, type FinalizeUnwrapSubmittedEvent, type GenericLogger, type GenericProvider, type GenericSigner, type GenericStorage, type Hex, IndexedDBStorage, InsufficientConfidentialBalanceError, InsufficientERC20BalanceError, InvalidTransportKeyPairError, type ListPairsOptions, MemoryStorage, MutableWalletAccountStore, NoCiphertextError, NotEntitledError, type OnChainEvent, type PaginatedResult, type Permission, Permits, type RawLog, type ReadContractArgs, type ReadContractConfig, type ReadContractReturnType, type ReadFunctionName, type RelayerConfig, RelayerRequestFailedError, type FhevmRelayerSDK as RelayerSDK, type ResolvedChainRelayer, type RevokeDelegationSubmittedEvent, type RevokedDelegationForUserDecryptionEvent, RpcRateLimitError, type SerializedTransportKeyPair, type SetOperatorSubmittedEvent, type ShieldCallbacks, type ShieldOptions, type ShieldPath, type ShieldSubmittedEvent, SignerNotConfiguredError, SignerRequiredError, SigningFailedError, SigningRejectedError, type StoredTransportKeyPair, TOKEN_TOPICS, Token, type TokenWrapperPair, type TokenWrapperPairWithMetadata, Topics, type TransactionErrorEvent, type TransactionOperation, type TransactionReceipt, type TransactionResult, TransactionRevertedError, type TransferCallbacks, type TransferFromSubmittedEvent, type TransferOptions, type TransferSubmittedEvent, TransportKeyPairExpiredError, type TypedValue, type UnshieldCallbacks, type UnshieldOptions, type UnshieldPhase1SubmittedEvent, type UnshieldPhase2StartedEvent, type UnshieldPhase2SubmittedEvent, type UnwrapFinalizedEvent, type UnwrapRequestedEvent, type UnwrapSubmittedEvent, type WalletAccount, type WalletAccountChange, type WalletAccountListener, WalletAccountNotReadyError, type WalletAccountStore, WalletNotConnectedError, type WrapEvent, WrappedToken, WrappersRegistry, type WrappersRegistryConfig, type WriteContractArgs, type WriteContractConfig, type WriteFunctionName, ZERO_ENCRYPTED_VALUE, type ZamaConfig, type ZamaConfigBase, type ZamaConfigEthers, type ZamaConfigGeneric, type ZamaConfigViem, ZamaError, ZamaErrorCode, ZamaSDK, type ZamaSDKEvent, type ZamaSDKEventInput, type ZamaSDKEventListener, type ZamaSDKEventType, ZamaSDKEvents, allowanceContract, anvil, approveContract, balanceOfContract, bscTestnet, chains, chromeSessionStorage, cleartext, confidentialBalanceOfContract, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, createConfig, createWalletAccountStore, decimalsContract, decodeAclEvent, decodeAclEvents, decodeConfidentialTransfer, decodeDelegatedForUserDecryption, decodeOnChainEvent, decodeOnChainEvents, decodeRevokedDelegationForUserDecryption, decodeUnwrapFinalized, decodeUnwrapRequested, decodeWrap, delegateForUserDecryptionContract, finalizeUnwrapContract, findDelegatedForUserDecryption, findRevokedDelegationForUserDecryption, findUnwrapRequested, findWrap, getConfidentialTokenAddressContract, getDelegationExpiryContract, getTokenAddressContract, getTokenPairContract, getTokenPairsContract, getTokenPairsLengthContract, getTokenPairsSliceContract, hardhat, hoodi, indexedDBStorage, inferredTotalSupplyContract, ingenTestnet, isConfidentialTokenContract, isConfidentialTokenValidContract, isConfidentialWrapperContract, isEncryptedValueZero, isHandleDelegatedContract, isOperatorContract, mainnet, matchZamaError, memoryStorage, nameContract, rateContract, resolveChainRelayers, resolveStorage, revokeDelegationContract, sepolia, setOperatorContract, supportsInterfaceContract, symbolContract, transferAndCallContract, underlyingContract, unwrapContract, unwrapFromBalanceContract, wrapContract };
 //# sourceMappingURL=index.d.ts.map