@zama-fhe/sdk 3.6.0 → 3.7.0-alpha.1

package/dist/esm/{index-BCh3VaZo.d.ts → index-CxgmG5MO.d.ts}

@@ -1,9 +1,9 @@
-import { f as FheChain } from "./index-ijgDL4IC.js";
-import { $t as ClearValue, Ct as UnshieldCallbacks, D as GenericSigner, O as WalletAccount, Qt as TransactionResult, S as TransactionKind, St as TransferCallbacks, _ as PrepareTransactionRequest, _t as TransferOptions, an as EncryptResult, bt as WrapOptions, c as GenericStorage, en as DecryptPublicValuesResult, fn as RelayerSDK, g as PrepareOptions, ht as ShieldOptions, i as ZamaConfig, in as EncryptParams, l as GenericProvider, ln as FhevmRelayerOptions, o as ZamaConfigGeneric, on as EncryptedValue, v as PreparedFor, vt as UnshieldOptions, yt as UnwrapResult } from "./types-D3W3J65M.js";
-import "./cleartext-B2DI8fgm.js";
-import "./types-CFDG6lIJ.js";
-import "./base-signer-Iu5Lszrf.js";
-import "./types-Ce9Lhvrf.js";
+import { f as FheChain } from "./index-Gk1S0gjO.js";
+import { $t as ClearValue, Ct as UnshieldCallbacks, D as GenericSigner, O as WalletAccount, Qt as TransactionResult, S as TransactionKind, St as TransferCallbacks, _ as PrepareTransactionRequest, _t as TransferOptions, an as EncryptResult, bt as WrapOptions, c as GenericStorage, en as DecryptPublicValuesResult, fn as RelayerSDK, g as PrepareOptions, ht as ShieldOptions, i as ZamaConfig, in as EncryptParams, l as GenericProvider, ln as FhevmRelayerOptions, o as ZamaConfigGeneric, on as EncryptedValue, v as PreparedFor, vt as UnshieldOptions, yt as UnwrapResult } from "./types-xCRG0yhi.js";
+import "./cleartext-CROV-hgJ.js";
+import "./types-CeLa3fMJ.js";
+import "./base-signer-DlSb15WN.js";
+import "./types-kqUexcdj.js";
 import { Address, Address as Address$1, Hex, Hex as Hex$1 } from "viem";
 import { z } from "zod/mini";
 import { MutationFunctionContext, QueryKey, QueryObserverOptions, skipToken } from "@tanstack/query-core";
@@ -19604,6 +19604,15 @@ declare function isConfidentialTokenValidContract(registry: Address, confidentia
   readonly args: readonly [`0x${string}`];
 };
 //#endregion
+//#region src/contracts/constants.d.ts
+/** uint64 max — represents a permanent (no-expiry) delegation. */
+declare const MAX_UINT64: bigint;
+/**
+ * `contractAddress` covering every confidential contract with a single
+ * delegation.
+ */
+declare const WILDCARD_CONTRACT: "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF";
+//#endregion
 //#region src/schemas/primitives.d.ts
 declare const checksummedTag: unique symbol;
 /** An EVM address that has been put through `getAddress` (EIP-55 checksum form). */
@@ -19611,6 +19620,25 @@ type ChecksummedAddress = Address & {
   readonly [checksummedTag]: true;
 };
 //#endregion
+//#region src/credentials/utils.d.ts
+/**
+ * Sentinel requesting a V2 permissive ("wildcard") permit from
+ * {@link CredentialService.grantPermit} / {@link Permits.grantPermit} /
+ * {@link Permits.grantDelegationPermit} — one permit covering every contract,
+ * present and future, instead of an explicit list. Always an explicit opt-in:
+ * passing a contract list, however large, never signs a wildcard permit.
+ *
+ * @example
+ * ```ts
+ * import { WILDCARD_PERMIT } from "@zama-fhe/sdk";
+ *
+ * await sdk.permits.grantPermit(WILDCARD_PERMIT);
+ * ```
+ */
+declare const WILDCARD_PERMIT: "wildcard";
+/** The type of {@link WILDCARD_PERMIT}. */
+type WildcardPermit = typeof WILDCARD_PERMIT;
+//#endregion
 //#region src/credentials/types.d.ts
 /**
  * Serialized transport key pair — ML-KEM public + private key as hex, the shape
@@ -19660,27 +19688,54 @@ interface SerializedPermit {
   signature: Hex;
   /** Address that produced the signature. */
   signerAddress: ChecksummedAddress;
+  /**
+   * V2 (unified) permits only — delegation is metadata alongside the signed
+   * message, not part of it. Absent for V1 (where delegation lives inside
+   * `eip712.message`) and for a non-delegated V2 permit.
+   */
+  delegatorAddress?: ChecksummedAddress;
 }
-/**
- * A signed EIP-712 permit binding a signer (and optional delegator) to a set of
- * contract addresses for a bounded time window. Wraps the serialized `@fhevm/sdk`
- * permit ({@link SerializedPermit}) alongside the scope/coverage metadata the
- * permission store indexes on.
- *
- * Mirrors {@link PermissionSchema}; kept in sync by a `.test-d.ts` guard.
- */
-interface Permission {
+/** Fields shared by every permit version, regardless of shape. */
+interface PermissionBase {
   /** Public key of the transport key pair this permit is bound to, hex-encoded. */
   keypairPublicKey: Hex;
-  /** Contract addresses this permit grants decrypt access to. */
+  /**
+   * Contract addresses this permit grants decrypt access to. Never empty for
+   * a V1 permit; an empty list on a V2 permit is a wildcard — see {@link PermissionV2}.
+   */
   contractAddresses: ChecksummedAddress[];
   /** The signed serialized permit. */
   serializedPermit: SerializedPermit;
   /** Unix timestamp (seconds) when the permit becomes valid. */
   startTimestamp: number;
-  /** Validity window length in days from {@link Permission.startTimestamp}. */
+}
+/** A V1 ("legacy") permit — always scoped to a specific, non-empty contract list. */
+interface PermissionV1 extends PermissionBase {
+  /** Discriminant identifying this as a {@link PermissionV1}. */
+  version: 1;
+  /** Validity window length in days from {@link PermissionBase.startTimestamp}. */
   durationDays: number;
 }
+/**
+ * A V2 (unified) permit. `contractAddresses: []` is a *wildcard* (permissive)
+ * permit — it covers every contract, not zero.
+ */
+interface PermissionV2 extends PermissionBase {
+  /** Discriminant identifying this as a {@link PermissionV2}. */
+  version: 2;
+  /** Validity window length in seconds from {@link PermissionBase.startTimestamp}. */
+  durationSeconds: number;
+}
+/**
+ * A signed EIP-712 permit binding a signer (and optional delegator) to a set of
+ * contract addresses for a bounded time window. Wraps the serialized `@fhevm/sdk`
+ * permit ({@link SerializedPermit}) alongside the scope/coverage metadata the
+ * permission store indexes on.
+ *
+ * Discriminated by `version`: {@link PermissionV1} or {@link PermissionV2}.
+ * Mirrors {@link PermissionSchema}; kept in sync by a `.test-d.ts` guard.
+ */
+type Permission = PermissionV1 | PermissionV2;
 /**
  * Offline `preparePermit` request — `grantPermit`'s parameters split around
  * the wallet signature. `signer` and `delegator` are explicit addresses, not
@@ -19690,8 +19745,12 @@ interface Permission {
 interface PreparePermitRequest {
   /** Address that will sign the returned EIP-712 typed data. */
   signer: Address;
-  /** Contract addresses to authorize. Maximum {@link MAX_CONTRACTS_PER_PERMIT} — no chunking. */
-  contracts: readonly Address[];
+  /**
+   * Contract addresses to authorize, or {@link WildcardPermit} to request a
+   * V2 permit covering every contract. Maximum {@link MAX_CONTRACTS_PER_PERMIT}
+   * per call — no chunking. Ignored (and unchecked) when requesting a wildcard.
+   */
+  contracts: readonly Address[] | WildcardPermit;
   /** Delegator address, for a delegated permit. Omit for a self permit. */
   delegator?: Address;
   /** Permit validity window in days. Defaults to the SDK's configured `permitTTL`. */
@@ -19703,24 +19762,40 @@ interface PreparePermitRequest {
  * out-of-process signer returns for it.
  *
  * Deliberately minimal: `chainId`, `contracts`, `startTimestamp`,
- * `durationDays`, and the transport public key are all readable off
- * {@link eip712}'s `domain`/`message` directly (and, once registered, off the
- * signature-verified payload) — carrying separate top-level copies would only
- * create two sources of truth that could disagree. Read them from `eip712`
- * for display/logging use.
+ * `durationDays`/`durationSeconds`, and the transport public key are all
+ * readable off {@link PreparedPermitBase.eip712}'s `domain`/`message` directly
+ * (and, once registered, off the signature-verified payload) — carrying
+ * separate top-level copies would only create two sources of truth that could
+ * disagree. Read them from `eip712` for display/logging use.
  *
- * `version` pins the permit shape (`1` while the SDK targets protocol ≤0.13)
- * so a future V2 flow is additive, not breaking. JSON-safe — ships across a
- * process boundary as-is.
+ * Discriminated by `version`: {@link PreparedPermitV1} (protocol ≤0.13) or
+ * {@link PreparedPermitV2} (protocol ≥0.14, unified/wildcard). JSON-safe —
+ * ships across a process boundary as-is.
  */
-interface PreparedPermit {
-  /** Permit format version. Always `1` while the SDK targets protocol ≤0.13. */
-  version: 1;
+type PreparedPermit = PreparedPermitV1 | PreparedPermitV2;
+/** Fields shared by every prepared-permit version. */
+interface PreparedPermitBase {
   /** The EIP-712 typed data to sign with `eth_signTypedData_v4`. */
   eip712: SerializedPermitEip712;
   /** Address expected to sign {@link eip712}. */
   signerAddress: ChecksummedAddress;
 }
+/** A V1 ("legacy") prepared permit. Delegation, if any, lives inside `eip712.message`. */
+interface PreparedPermitV1 extends PreparedPermitBase {
+  /** Discriminant identifying this as a {@link PreparedPermitV1}. */
+  version: 1;
+}
+/**
+ * A V2 (unified) prepared permit. V2 delegation is post-sign metadata, not
+ * part of the signed message, so a delegated request carries it here instead
+ * of inside `eip712.message`.
+ */
+interface PreparedPermitV2 extends PreparedPermitBase {
+  /** Discriminant identifying this as a {@link PreparedPermitV2}. */
+  version: 2;
+  /** Delegator address, for a delegated permit. Absent for a self permit. */
+  delegatorAddress?: ChecksummedAddress;
+}
 //#endregion
 //#region src/errors/base.d.ts
 /**
@@ -19789,6 +19864,8 @@ declare const ZamaErrorCode: {
   readonly DelegationExpiryUnchanged: "DELEGATION_EXPIRY_UNCHANGED";
   /** Delegate address cannot be the contract address. */
   readonly DelegationDelegateEqualsContract: "DELEGATION_DELEGATE_EQUALS_CONTRACT";
+  /** Delegate address cannot be the wildcard address — it's only valid as `contractAddress`. */
+  readonly DelegationDelegateCannotBeWildcard: "DELEGATION_DELEGATE_CANNOT_BE_WILDCARD";
   /** Contract address cannot be the sender address. */
   readonly DelegationContractIsSelf: "DELEGATION_CONTRACT_IS_SELF";
   /** The ACL contract is paused. */
@@ -19813,6 +19890,10 @@ declare const ZamaErrorCode: {
   readonly PreparedPermitChainMismatch: "PREPARED_PERMIT_CHAIN_MISMATCH";
   /** A prepared permit's validity window elapsed before its signature was registered. */
   readonly PreparedPermitExpired: "PREPARED_PERMIT_EXPIRED";
+  /** V2 (unified) decryption permits — including wildcard permits — need protocol v0.14+; the connected chain hasn't upgraded yet. */
+  readonly UnifiedPermitNotSupported: "UNIFIED_PERMIT_NOT_SUPPORTED";
+  /** A stored V2/wildcard permit's scope is needed, but the connected relayer instance doesn't support unified decryption yet. */
+  readonly UnifiedDecryptionUnsupported: "UNIFIED_DECRYPTION_UNSUPPORTED";
   /** The unwrap request was already finalized on-chain; there is nothing left to resume. */
   readonly UnshieldAlreadyFinalized: "UNSHIELD_ALREADY_FINALIZED";
 };
@@ -19974,6 +20055,30 @@ declare class PreparedPermitChainMismatchError extends ZamaError {
 declare class PreparedPermitExpiredError extends ZamaError {
   constructor(message: string, options?: ErrorOptions);
 }
+/**
+ * The connected chain doesn't support V2 (unified) decryption permits yet —
+ * including {@link WILDCARD_PERMIT} — because it hasn't upgraded to protocol
+ * v0.14 or later. Thrown before any wallet prompt: the SDK detects this from
+ * the chain's on-chain KMS context, without a signature attempt. V1 permits
+ * (an explicit contract list, not `WILDCARD_PERMIT`) are unaffected — grant
+ * one of those instead, or retry once the network upgrades.
+ */
+declare class UnifiedPermitNotSupportedError extends ZamaError {
+  constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * A stored V2 (unified/wildcard) permit's scope is needed for this decrypt,
+ * but the connected relayer instance hasn't deployed the `/v3/user-decrypt`
+ * route it requires. Distinct from {@link UnifiedPermitNotSupportedError}:
+ * that one fires at *signing* time because the *chain* hasn't upgraded to
+ * protocol v0.14+; this one fires at *decrypt* time even though the chain and
+ * the stored permit are both V2-capable — only this particular relayer
+ * instance hasn't deployed the route yet. Grant a specific-contract (V1)
+ * permit instead, or retry once the relayer upgrades.
+ */
+declare class UnifiedDecryptionUnsupportedError extends ZamaError {
+  constructor(message: string, options?: ErrorOptions);
+}
 //#endregion
 //#region src/errors/delegation.d.ts
 /** Delegation cannot target self (delegate === msg.sender). */
@@ -20000,6 +20105,10 @@ declare class DelegationExpiryUnchangedError extends ZamaError {
 declare class DelegationDelegateEqualsContractError extends ZamaError {
   constructor(message: string, options?: ErrorOptions);
 }
+/** Delegate address cannot be the wildcard address — it's only valid as `contractAddress`. */
+declare class DelegationDelegateCannotBeWildcardError extends ZamaError {
+  constructor(message: string, options?: ErrorOptions);
+}
 /** Contract address cannot be the sender address. */
 declare class DelegationContractIsSelfError extends ZamaError {
   constructor(message: string, options?: ErrorOptions);
@@ -20358,6 +20467,8 @@ interface ErrorForCode {
   [ZamaErrorCode.DelegationExpiryUnchanged]: DelegationExpiryUnchangedError;
   /** Thrown for {@link ZamaErrorCode.DelegationDelegateEqualsContract}. */
   [ZamaErrorCode.DelegationDelegateEqualsContract]: DelegationDelegateEqualsContractError;
+  /** Thrown for {@link ZamaErrorCode.DelegationDelegateCannotBeWildcard}. */
+  [ZamaErrorCode.DelegationDelegateCannotBeWildcard]: DelegationDelegateCannotBeWildcardError;
   /** Thrown for {@link ZamaErrorCode.DelegationContractIsSelf}. */
   [ZamaErrorCode.DelegationContractIsSelf]: DelegationContractIsSelfError;
   /** Thrown for {@link ZamaErrorCode.AclPaused}. */
@@ -20382,6 +20493,10 @@ interface ErrorForCode {
   [ZamaErrorCode.PreparedPermitChainMismatch]: PreparedPermitChainMismatchError;
   /** Thrown for {@link ZamaErrorCode.PreparedPermitExpired}. */
   [ZamaErrorCode.PreparedPermitExpired]: PreparedPermitExpiredError;
+  /** Thrown for {@link ZamaErrorCode.UnifiedPermitNotSupported}. */
+  [ZamaErrorCode.UnifiedPermitNotSupported]: UnifiedPermitNotSupportedError;
+  /** Thrown for {@link ZamaErrorCode.UnifiedDecryptionUnsupported}. */
+  [ZamaErrorCode.UnifiedDecryptionUnsupported]: UnifiedDecryptionUnsupportedError;
   /** Thrown for {@link ZamaErrorCode.UnshieldAlreadyFinalized}. */
   [ZamaErrorCode.UnshieldAlreadyFinalized]: UnshieldAlreadyFinalizedError;
 }
@@ -20436,21 +20551,29 @@ declare class Permits {
    * rejection is preserved (already-signed chunks are persisted before the
    * next prompt).
    *
-   * @param contracts - Contract addresses to authorize.
+   * Pass {@link WILDCARD_PERMIT} instead of an address list to request a V2
+   * permissive permit covering every contract, present and future — an
+   * explicit opt-in, not something a large address list implies. A stolen
+   * wildcard permit decrypts anything the signer owns until it expires, so
+   * prefer a specific contract list unless the caller genuinely needs
+   * unbounded coverage.
+   *
+   * @param contracts - Contract addresses to authorize, or {@link WILDCARD_PERMIT}.
    * @throws if `transportKeyPairDerivationSecret` is configured and the keypair fails to wrap or
    *   unwrap. {@link KeyWrappingError}
    */
-  grantPermit(contracts: Address[]): Promise<void>;
+  grantPermit(contracts: Address[] | WildcardPermit): Promise<void>;
   /**
    * Sign and store an EIP-712 delegation permit authorizing decryption on
-   * behalf of `delegator`. Same idempotence/chunking semantics as {@link grantPermit}.
+   * behalf of `delegator`. Same idempotence/chunking/wildcard semantics as
+   * {@link grantPermit}.
    *
    * @param delegator - The address that delegated decryption rights to the connected signer.
-   * @param contracts - Contract addresses to authorize.
+   * @param contracts - Contract addresses to authorize, or {@link WILDCARD_PERMIT}.
    * @throws if `transportKeyPairDerivationSecret` is configured and the keypair fails to wrap or
    *   unwrap. {@link KeyWrappingError}
    */
-  grantDelegationPermit(delegator: Address, contracts: Address[]): Promise<void>;
+  grantDelegationPermit(delegator: Address, contracts: Address[] | WildcardPermit): Promise<void>;
   /**
    * Pure store lookup: is there a permit covering `contracts`?
    * No wallet prompt, no transport key pair generation. Returns `false` when no signer
@@ -20569,7 +20692,7 @@ declare class Permits {
 }
 //#endregion
 //#region src/services/delegation-service.d.ts
-/** Delegation activity and expiry, resolved from a single expiry read. */
+/** Delegation activity and expiry, resolved from the active contract or wildcard grant. */
 interface DelegationStatus {
   /** Whether the delegation is currently active (exists and not expired). */
   isActive: boolean;
@@ -20602,7 +20725,8 @@ declare class Delegations {
    * window with a bounded internal retry, so you can decrypt right after this
    * resolves.
    *
-   * @param contractAddress - The confidential contract address to delegate on.
+   * @param contractAddress - The confidential contract address to delegate on, or
+   *   {@link WILDCARD_CONTRACT} to cover every contract with a single delegation.
    * @param delegateAddress - Address to delegate decryption rights to.
    * @param expirationDate - Optional expiration date (defaults to permanent delegation via `uint64.max`).
    * @returns The transaction hash and mined receipt.
@@ -20610,6 +20734,7 @@ declare class Delegations {
    * @throws if signer and provider are on different chains. {@link ChainMismatchError}
    * @throws if `expirationDate` is less than 1 hour in the future. {@link DelegationExpirationTooSoonError}
    * @throws if the delegate equals the connected wallet. {@link DelegationSelfNotAllowedError}
+   * @throws if the delegate is the wildcard address. {@link DelegationDelegateCannotBeWildcardError}
    * @throws if the delegate equals the contract address. {@link DelegationDelegateEqualsContractError}
    * @throws if the new expiry equals the current one. {@link DelegationExpiryUnchangedError}
    * @throws if the delegation transaction reverts. {@link TransactionRevertedError}
@@ -22127,5 +22252,5 @@ declare const ZERO_ENCRYPTED_VALUE: "0x00000000000000000000000000000000000000000
  */
 declare function isEncryptedValueZero(encryptedValue: string): boolean;
 //#endregion
-export { BalanceErrorDetails as $, ERC7984_INTERFACE_ID as $t, BatchDecryptAsOptions as A, Permission as At, TransactionRevertedError as B, getConfidentialTokenAddressContract as Bt, ZamaSDKOptions as C, wrapContract as Cn, TransportKeyPairChangedError as Ct, WrappersRegistryConfig as D, ZamaErrorCode as Dt, WrappersRegistry as E, ZamaError as Et, Permits as F, SerializedTransportKeyPair as Ft, SignerRequiredError as G, getTokenPairsSliceContract as Gt, SigningFailedError as H, getTokenPairContract as Ht, ErrorForCode as I, ChecksummedAddress as It, RpcRateLimitError as J, getDelegationExpiryContract as Jt, WalletAccountNotReadyError as K, isConfidentialTokenValidContract as Kt, matchZamaError as L, PaginatedResult as Lt, Offline as M, PreparedPermit as Mt, Delegations as N, SerializedPermit as Nt, WrappedToken as O, isRetryable as Ot, DelegationStatus as P, SerializedPermitEip712 as Pt, BalanceCheckUnavailableError as Q, ERC1363_INTERFACE_ID as Qt, UnshieldAlreadyFinalizedDetails as R, TokenWrapperPair as Rt, ZamaSDK as S, unwrapRequesterContract as Sn, RevokedKmsContextError as St, ListPairsOptions as T, ChainMismatchError as Tt, SigningRejectedError as U, getTokenPairsContract as Ut, SigningErrorMetadata as V, getTokenAddressContract as Vt, SignerNotConfiguredError as W, getTokenPairsLengthContract as Wt, ConfigurationError as X, revokeDelegationContract as Xt, NotEntitledError as Y, isHandleDelegatedContract as Yt, RelayerRequestFailedError as Z, transferAndCallContract as Zt, decryptValuesQueryOptions as _, rateContract as _n, InvalidTransportKeyPairError as _t, ChromeSessionStorage as a, approveContract as an, EncryptOffloadUnavailableError as at, MutationFactoryOptions as b, unwrapContract as bn, PreparedPermitChainMismatchError as bt, indexedDBStorage as c, nameContract as cn, DelegationContractIsSelfError as ct, Decryption as d, confidentialTotalSupplyContract as dn, DelegationExpirationTooSoonError as dt, ERC7984_WRAPPER_INTERFACE_ID as en, ERC20ReadFailedError as et, BatchDecryptItem as f, confidentialTransferContract as fn, DelegationExpiredError as ft, EncryptedInput as g, isOperatorContract as gn, DelegationSelfNotAllowedError as gt, DecryptResult as h, inferredTotalSupplyContract as hn, DelegationNotPropagatedError as ht, isEncryptedValueZero as i, allowanceContract as in, DecryptionFailedError as it, Token as j, PreparePermitRequest as jt, BatchBalancesResult as k, retryAfterSeconds as kt, MemoryStorage as l, symbolContract as ln, DelegationCooldownError as lt, DelegatedDecryptOptions as m, finalizeUnwrapContract as mn, DelegationNotFoundError as mt, Hex$1 as n, isConfidentialWrapperContract as nn, InsufficientConfidentialBalanceError as nt, chromeSessionStorage as o, balanceOfContract as on, EncryptionFailedError as ot, BatchDecryptResult as p, confidentialTransferFromContract as pn, DelegationExpiryUnchangedError as pt, WalletNotConnectedError as q, delegateForUserDecryptionContract as qt, ZERO_ENCRYPTED_VALUE as r, supportsInterfaceContract as rn, InsufficientERC20BalanceError as rt, IndexedDBStorage as s, decimalsContract as sn, AclPausedError as st, Address$1 as t, isConfidentialTokenContract as tn, InsufficientAllowanceError as tt, memoryStorage as u, confidentialBalanceOfContract as un, DelegationDelegateEqualsContractError as ut, SignerQueryContext as v, setOperatorContract as vn, KeyWrappingError as vt, DefaultRegistryAddresses as w, createConfig as wn, TransportKeyPairExpiredError as wt, QueryFactoryOptions as x, unwrapFromBalanceContract as xn, PreparedPermitExpiredError as xt, zamaQueryKeys as y, underlyingContract as yn, NoCiphertextError as yt, UnshieldAlreadyFinalizedError as z, TokenWrapperPairWithMetadata as zt };
-//# sourceMappingURL=index-BCh3VaZo.d.ts.map
+export { BalanceErrorDetails as $, getConfidentialTokenAddressContract as $t, BatchDecryptAsOptions as A, rateContract as An, ZamaErrorCode as At, TransactionRevertedError as B, PreparedPermitV1 as Bt, ZamaSDKOptions as C, confidentialBalanceOfContract as Cn, RevokedKmsContextError as Ct, WrappersRegistryConfig as D, finalizeUnwrapContract as Dn, UnifiedPermitNotSupportedError as Dt, WrappersRegistry as E, confidentialTransferFromContract as En, UnifiedDecryptionUnsupportedError as Et, Permits as F, unwrapRequesterContract as Fn, PermissionV1 as Ft, SignerRequiredError as G, WILDCARD_PERMIT as Gt, SigningFailedError as H, SerializedPermit as Ht, ErrorForCode as I, wrapContract as In, PermissionV2 as It, RpcRateLimitError as J, MAX_UINT64 as Jt, WalletAccountNotReadyError as K, WildcardPermit as Kt, matchZamaError as L, createConfig as Ln, PreparePermitRequest as Lt, Offline as M, underlyingContract as Mn, retryAfterSeconds as Mt, Delegations as N, unwrapContract as Nn, Permission as Nt, WrappedToken as O, inferredTotalSupplyContract as On, ChainMismatchError as Ot, DelegationStatus as P, unwrapFromBalanceContract as Pn, PermissionBase as Pt, BalanceCheckUnavailableError as Q, TokenWrapperPairWithMetadata as Qt, UnshieldAlreadyFinalizedDetails as R, PreparedPermit as Rt, ZamaSDK as S, symbolContract as Sn, PreparedPermitExpiredError as St, ListPairsOptions as T, confidentialTransferContract as Tn, TransportKeyPairExpiredError as Tt, SigningRejectedError as U, SerializedPermitEip712 as Ut, SigningErrorMetadata as V, PreparedPermitV2 as Vt, SignerNotConfiguredError as W, SerializedTransportKeyPair as Wt, ConfigurationError as X, PaginatedResult as Xt, NotEntitledError as Y, WILDCARD_CONTRACT as Yt, RelayerRequestFailedError as Z, TokenWrapperPair as Zt, decryptValuesQueryOptions as _, allowanceContract as _n, DelegationSelfNotAllowedError as _t, ChromeSessionStorage as a, isConfidentialTokenValidContract as an, EncryptOffloadUnavailableError as at, MutationFactoryOptions as b, decimalsContract as bn, NoCiphertextError as bt, indexedDBStorage as c, isHandleDelegatedContract as cn, DelegationContractIsSelfError as ct, Decryption as d, ERC1363_INTERFACE_ID as dn, DelegationDelegateEqualsContractError as dt, getTokenAddressContract as en, ERC20ReadFailedError as et, BatchDecryptItem as f, ERC7984_INTERFACE_ID as fn, DelegationExpirationTooSoonError as ft, EncryptedInput as g, supportsInterfaceContract as gn, DelegationNotPropagatedError as gt, DecryptResult as h, isConfidentialWrapperContract as hn, DelegationNotFoundError as ht, isEncryptedValueZero as i, getTokenPairsSliceContract as in, DecryptionFailedError as it, Token as j, setOperatorContract as jn, isRetryable as jt, BatchBalancesResult as k, isOperatorContract as kn, ZamaError as kt, MemoryStorage as l, revokeDelegationContract as ln, DelegationCooldownError as lt, DelegatedDecryptOptions as m, isConfidentialTokenContract as mn, DelegationExpiryUnchangedError as mt, Hex$1 as n, getTokenPairsContract as nn, InsufficientConfidentialBalanceError as nt, chromeSessionStorage as o, delegateForUserDecryptionContract as on, EncryptionFailedError as ot, BatchDecryptResult as p, ERC7984_WRAPPER_INTERFACE_ID as pn, DelegationExpiredError as pt, WalletNotConnectedError as q, ChecksummedAddress as qt, ZERO_ENCRYPTED_VALUE as r, getTokenPairsLengthContract as rn, InsufficientERC20BalanceError as rt, IndexedDBStorage as s, getDelegationExpiryContract as sn, AclPausedError as st, Address$1 as t, getTokenPairContract as tn, InsufficientAllowanceError as tt, memoryStorage as u, transferAndCallContract as un, DelegationDelegateCannotBeWildcardError as ut, SignerQueryContext as v, approveContract as vn, InvalidTransportKeyPairError as vt, DefaultRegistryAddresses as w, confidentialTotalSupplyContract as wn, TransportKeyPairChangedError as wt, QueryFactoryOptions as x, nameContract as xn, PreparedPermitChainMismatchError as xt, zamaQueryKeys as y, balanceOfContract as yn, KeyWrappingError as yt, UnshieldAlreadyFinalizedError as z, PreparedPermitBase as zt };
+//# sourceMappingURL=index-CxgmG5MO.d.ts.map

package/dist/esm/{index-S6QjPkZE.d.ts → index-DnWijpGT.d.ts}

@@ -1,6 +1,6 @@
-import "./index-ijgDL4IC.js";
-import { c as GenericStorage, dn as RelayerOptions, n as RelayerConfig } from "./types-D3W3J65M.js";
-import "./cleartext-B2DI8fgm.js";
+import "./index-Gk1S0gjO.js";
+import { c as GenericStorage, dn as RelayerOptions, n as RelayerConfig } from "./types-xCRG0yhi.js";
+import "./cleartext-CROV-hgJ.js";
 //#region src/node/config.d.ts
 /** Node transport — drives the FHE backend directly on the calling thread. */
 interface NodeRelayerConfig extends RelayerConfig {
@@ -58,4 +58,4 @@ declare class AsyncLocalMapStorage implements GenericStorage {
 declare const asyncLocalStorage: AsyncLocalMapStorage;
 //#endregion
 export { node as i, asyncLocalStorage as n, NodeRelayerConfig as r, AsyncLocalMapStorage as t };
-//# sourceMappingURL=index-S6QjPkZE.d.ts.map
+//# sourceMappingURL=index-DnWijpGT.d.ts.map

package/dist/esm/{index-ijgDL4IC.d.ts → index-Gk1S0gjO.d.ts}

@@ -36,6 +36,15 @@ interface FheChain<TId extends number = number> {
   readonly kmsContractAddress: Address;
   /** Address of the input verifier contract. */
   readonly inputVerifierContractAddress: Address;
+  /**
+   * Address of the `ProtocolConfig` contract. Required to sign or use V2
+   * (unified) decryption permits — including {@link WILDCARD_PERMIT} — which
+   * need protocol v0.14+. Leave `undefined` for a chain still on protocol
+   * ≤0.13, or one whose `ProtocolConfig` address isn't known yet: V2 permit
+   * signing then fails with a clear {@link UnifiedPermitNotSupportedError}
+   * instead of a wallet prompt. V1 permits are unaffected either way.
+   */
+  readonly protocolConfigContractAddress?: Address | undefined;
   /** EIP-712 verifying contract address for decryption requests. */
   readonly verifyingContractAddressDecryption: Address;
   /** EIP-712 verifying contract address for input verification. */
@@ -76,6 +85,7 @@ declare const mainnet: {
   readonly verifyingContractAddressDecryption: "0x0f6024a97684f7d90ddb0fAAD79cB15F2C888D24";
   readonly verifyingContractAddressInputVerification: "0xcB1bB072f38bdAF0F328CdEf1Fc6eDa1DF029287";
   readonly registryAddress: "0xeb5015fF021DB115aCe010f23F55C2591059bBA0";
+  readonly protocolConfigContractAddress: "0xD8236B57394f90726b26aB25D38CeAC776E1a7C4";
 };
 /**
  * Polygon mainnet network configuration (chainId 137).
@@ -91,6 +101,7 @@ declare const polygon: {
   readonly verifyingContractAddressDecryption: "0x0f6024a97684f7d90ddb0fAAD79cB15F2C888D24";
   readonly verifyingContractAddressInputVerification: "0xcB1bB072f38bdAF0F328CdEf1Fc6eDa1DF029287";
   readonly registryAddress: "0xc8908569868758dAF814B5a8b96bBc44D1653d54";
+  readonly protocolConfigContractAddress: "0x17f62Ab3A1Ea519703cD597410147A30Fa1a7f1e";
 };
 /**
  * Sepolia testnet network configuration (chainId 11155111).
@@ -106,6 +117,7 @@ declare const sepolia: {
   readonly verifyingContractAddressDecryption: "0x5D8BD78e2ea6bbE41f26dFe9fdaEAa349e077478";
   readonly verifyingContractAddressInputVerification: "0x483b9dE06E4E4C7D35CCf5837A1668487406D955";
   readonly registryAddress: "0x2f0750Bbb0A246059d80e94c454586a7F27a128e";
+  readonly protocolConfigContractAddress: "0x51f9AFBc89Ea792e1a21a12AB802ab58D4dbee83";
 };
 /**
  * Polygon Amoy testnet network configuration (chainId 80002).
@@ -121,6 +133,7 @@ declare const polygonAmoy: {
   readonly verifyingContractAddressDecryption: "0x5D8BD78e2ea6bbE41f26dFe9fdaEAa349e077478";
   readonly verifyingContractAddressInputVerification: "0x483b9dE06E4E4C7D35CCf5837A1668487406D955";
   readonly registryAddress: "0xF486c3D4F4562760A43883e72E8D6f6Cf2EFdA94";
+  readonly protocolConfigContractAddress: "0x4CcF009Aba90D04f52b31fc7aDdE240578aFe10F";
 };
 /**
  * Hoodi testnet configuration (chainId 560048).
@@ -217,4 +230,4 @@ declare const anvil: {
 declare const chains: Record<number, FheChain>;
 //#endregion
 export { hoodi as a, polygon as c, AtLeastOneChain as d, FheChain as f, hardhat as i, polygonAmoy as l, bscTestnet as n, ingenTestnet as o, FheChainAuth as p, chains as r, mainnet as s, anvil as t, sepolia as u };
-//# sourceMappingURL=index-ijgDL4IC.d.ts.map
+//# sourceMappingURL=index-Gk1S0gjO.d.ts.map

package/dist/esm/index.d.ts

@@ -1,8 +1,8 @@
-import { a as hoodi, c as polygon, d as AtLeastOneChain, f as FheChain, i as hardhat, l as polygonAmoy, n as bscTestnet, o as ingenTestnet, p as FheChainAuth, r as chains, s as mainnet, t as anvil, u as sepolia } from "./index-ijgDL4IC.js";
-import { $ as SetOperatorSubmittedEvent, $t as ClearValue, A as WalletAccountListener, At as RevokedDelegationForUserDecryptionEvent, B as ApproveUnderlyingSubmittedEvent, Bt as decodeOnChainEvent, C as TransferAndCallRequest, Ct as UnshieldCallbacks, D as GenericSigner, Dt as ConfidentialTransferEvent, E as WrapRequest, Et as AclTopics, F as ReadContractReturnType, Ft as WrapEvent, G as DelegationSubmittedEvent, Gt as decodeWrap, H as DecryptEndEvent, Ht as decodeRevokedDelegationForUserDecryption, I as ReadFunctionName, It as decodeAclEvent, J as EncryptStartEvent, Jt as findUnwrapRequested, K as EncryptEndEvent, Kt as findDelegatedForUserDecryption, L as WriteContractArgs, Lt as decodeAclEvents, M as ContractAbi, Mt as Topics, N as ReadContractArgs, Nt as UnwrapFinalizedEvent, O as WalletAccount, Ot as DelegatedForUserDecryptionEvent, P as ReadContractConfig, Pt as UnwrapRequestedEvent, Q as RevokeDelegationSubmittedEvent, Qt as TransactionResult, R as WriteContractConfig, Rt as decodeConfidentialTransfer, S as TransactionKind, St as TransferCallbacks, T as UnwrapRequest, Tt as AclEvent, U as DecryptErrorEvent, Ut as decodeUnwrapFinalized, V as BaseEvent, Vt as decodeOnChainEvents, W as DecryptStartEvent, Wt as decodeUnwrapRequested, X as PermitErrorEvent, Xt as RawLog, Y as FinalizeUnwrapSubmittedEvent, Yt as findWrap, Z as PermitOperation, Zt as TransactionReceipt, _ as PrepareTransactionRequest, _t as TransferOptions, a as ZamaConfigBase, an as EncryptResult, at as UnshieldPhase1SubmittedEvent, b as RevokeDelegationRequest, bt as WrapOptions, c as GenericStorage, cn as FhevmClientOptions, ct as UnwrapSubmittedEvent, d as ConfidentialTransferFromRequest, dn as RelayerOptions, dt as ZamaSDKEventListener, en as DecryptPublicValuesResult, et as ShieldSubmittedEvent, f as ConfidentialTransferRequest, fn as RelayerSDK, ft as ZamaSDKEventType, g as PrepareOptions, gt as ShieldPath, h as PrepareFees, ht as ShieldOptions, i as ZamaConfig, in as EncryptParams, it as TransferSubmittedEvent, j as WalletAccountStore, jt as TOKEN_TOPICS, k as WalletAccountChange, kt as OnChainEvent, l as GenericProvider, ln as FhevmRelayerOptions, lt as WrapSubmittedEvent, m as FinalizeUnwrapRequest, mt as ApprovalStrategy, n as RelayerConfig, nn as EIP712TypedData, nt as TransactionOperation, o as ZamaConfigGeneric, on as EncryptedValue, ot as UnshieldPhase2StartedEvent, p as DelegateDecryptionRequest, pn as TypedValue, pt as ZamaSDKEvents, q as EncryptErrorEvent, qt as findRevokedDelegationForUserDecryption, rn as EncryptInput, rt as TransferFromSubmittedEvent, s as GenericLogger, sn as FhevmClient, st as UnshieldPhase2SubmittedEvent, t as CleartextRelayerConfig, tn as DecryptValuesParameters, tt as TransactionErrorEvent, u as ApproveUnderlyingRequest, un as FhevmRuntimeConfig, ut as ZamaSDKEvent, v as PreparedFor, vt as UnshieldOptions, w as UnwrapAllRequest, wt as ACL_TOPICS, x as SetOperatorRequest, xt as ShieldCallbacks, y as PreparedTransaction, yt as UnwrapResult, z as WriteFunctionName, zt as decodeDelegatedForUserDecryption } from "./types-D3W3J65M.js";
-import { t as cleartext } from "./cleartext-B2DI8fgm.js";
-import { t as ZamaConfigEthers } from "./types-CFDG6lIJ.js";
-import { n as MutableWalletAccountStore, r as createWalletAccountStore, t as BaseSigner } from "./base-signer-Iu5Lszrf.js";
-import { $ as BalanceErrorDetails, $t as ERC7984_INTERFACE_ID, A as BatchDecryptAsOptions, At as Permission, B as TransactionRevertedError, Bt as getConfidentialTokenAddressContract, C as ZamaSDKOptions, Cn as wrapContract, Ct as TransportKeyPairChangedError, D as WrappersRegistryConfig, Dt as ZamaErrorCode, E as WrappersRegistry, Et as ZamaError, F as Permits, Ft as SerializedTransportKeyPair, G as SignerRequiredError, Gt as getTokenPairsSliceContract, H as SigningFailedError, Ht as getTokenPairContract, I as ErrorForCode, It as ChecksummedAddress, J as RpcRateLimitError, Jt as getDelegationExpiryContract, K as WalletAccountNotReadyError, Kt as isConfidentialTokenValidContract, L as matchZamaError, Lt as PaginatedResult, M as Offline, Mt as PreparedPermit, N as Delegations, Nt as SerializedPermit, O as WrappedToken, Ot as isRetryable, P as DelegationStatus, Pt as SerializedPermitEip712, Q as BalanceCheckUnavailableError, Qt as ERC1363_INTERFACE_ID, R as UnshieldAlreadyFinalizedDetails, Rt as TokenWrapperPair, S as ZamaSDK, Sn as unwrapRequesterContract, St as RevokedKmsContextError, T as ListPairsOptions, Tt as ChainMismatchError, U as SigningRejectedError, Ut as getTokenPairsContract, V as SigningErrorMetadata, Vt as getTokenAddressContract, W as SignerNotConfiguredError, Wt as getTokenPairsLengthContract, X as ConfigurationError, Xt as revokeDelegationContract, Y as NotEntitledError, Yt as isHandleDelegatedContract, Z as RelayerRequestFailedError, Zt as transferAndCallContract, _n as rateContract, _t as InvalidTransportKeyPairError, a as ChromeSessionStorage, an as approveContract, at as EncryptOffloadUnavailableError, bn as unwrapContract, bt as PreparedPermitChainMismatchError, c as indexedDBStorage, cn as nameContract, ct as DelegationContractIsSelfError, d as Decryption, dn as confidentialTotalSupplyContract, dt as DelegationExpirationTooSoonError, en as ERC7984_WRAPPER_INTERFACE_ID, et as ERC20ReadFailedError, f as BatchDecryptItem, fn as confidentialTransferContract, ft as DelegationExpiredError, g as EncryptedInput, gn as isOperatorContract, gt as DelegationSelfNotAllowedError, h as DecryptResult, hn as inferredTotalSupplyContract, ht as DelegationNotPropagatedError, i as isEncryptedValueZero, in as allowanceContract, it as DecryptionFailedError, j as Token, jt as PreparePermitRequest, k as BatchBalancesResult, kt as retryAfterSeconds, l as MemoryStorage, ln as symbolContract, lt as DelegationCooldownError, m as DelegatedDecryptOptions, mn as finalizeUnwrapContract, mt as DelegationNotFoundError, n as Hex, nn as isConfidentialWrapperContract, nt as InsufficientConfidentialBalanceError, o as chromeSessionStorage, on as balanceOfContract, ot as EncryptionFailedError, p as BatchDecryptResult, pn as confidentialTransferFromContract, pt as DelegationExpiryUnchangedError, q as WalletNotConnectedError, qt as delegateForUserDecryptionContract, r as ZERO_ENCRYPTED_VALUE, rn as supportsInterfaceContract, rt as InsufficientERC20BalanceError, s as IndexedDBStorage, sn as decimalsContract, st as AclPausedError, t as Address, tn as isConfidentialTokenContract, tt as InsufficientAllowanceError, u as memoryStorage, un as confidentialBalanceOfContract, ut as DelegationDelegateEqualsContractError, vn as setOperatorContract, vt as KeyWrappingError, w as DefaultRegistryAddresses, wn as createConfig, wt as TransportKeyPairExpiredError, xn as unwrapFromBalanceContract, xt as PreparedPermitExpiredError, yn as underlyingContract, yt as NoCiphertextError, z as UnshieldAlreadyFinalizedError, zt as TokenWrapperPairWithMetadata } from "./index-BCh3VaZo.js";
-import { t as ZamaConfigViem } from "./types-Ce9Lhvrf.js";
-export { ACL_TOPICS, type AclEvent, AclPausedError, AclTopics, type Address, type ApprovalStrategy, type ApproveUnderlyingRequest, type ApproveUnderlyingSubmittedEvent, type AtLeastOneChain, BalanceCheckUnavailableError, type BalanceErrorDetails, type BaseEvent, BaseSigner, type BatchBalancesResult, type BatchDecryptAsOptions, type BatchDecryptItem, type BatchDecryptResult, ChainMismatchError, type ChecksummedAddress, ChromeSessionStorage, type ClearValue, type CleartextRelayerConfig, type ConfidentialTransferEvent, type ConfidentialTransferFromRequest, type ConfidentialTransferRequest, ConfigurationError, type ContractAbi, type DecryptEndEvent, type DecryptErrorEvent, type EncryptedInput as DecryptInput, type DecryptPublicValuesResult, type DecryptResult, type DecryptStartEvent, type DecryptValuesParameters, Decryption, DecryptionFailedError, DefaultRegistryAddresses, type DelegateDecryptionRequest, type DelegatedDecryptOptions, type DelegatedForUserDecryptionEvent, DelegationContractIsSelfError, DelegationCooldownError, DelegationDelegateEqualsContractError, DelegationExpirationTooSoonError, DelegationExpiredError, DelegationExpiryUnchangedError, DelegationNotFoundError, DelegationNotPropagatedError, DelegationSelfNotAllowedError, type DelegationStatus, type DelegationSubmittedEvent, Delegations, type EIP712TypedData, ERC1363_INTERFACE_ID, ERC20ReadFailedError, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, type EncryptEndEvent, type EncryptErrorEvent, type EncryptInput, EncryptOffloadUnavailableError, type EncryptParams, type EncryptResult, type EncryptStartEvent, type EncryptedValue, EncryptionFailedError, type ErrorForCode, type FheChain, type FheChainAuth, type FhevmClient, type FhevmClientOptions, type FhevmRelayerOptions, type FhevmRuntimeConfig, type FinalizeUnwrapRequest, type FinalizeUnwrapSubmittedEvent, type GenericLogger, type GenericProvider, type GenericSigner, type GenericStorage, type Hex, IndexedDBStorage, InsufficientAllowanceError, InsufficientConfidentialBalanceError, InsufficientERC20BalanceError, InvalidTransportKeyPairError, KeyWrappingError, type ListPairsOptions, MemoryStorage, MutableWalletAccountStore, NoCiphertextError, NotEntitledError, Offline, type OnChainEvent, type PaginatedResult, type Permission, type PermitErrorEvent, type PermitOperation, Permits, type PrepareFees, type PrepareOptions, type PreparePermitRequest, type PrepareTransactionRequest, type PreparedFor, type PreparedPermit, PreparedPermitChainMismatchError, PreparedPermitExpiredError, type PreparedTransaction, type RawLog, type ReadContractArgs, type ReadContractConfig, type ReadContractReturnType, type ReadFunctionName, type RelayerConfig, type RelayerOptions, RelayerRequestFailedError, type RelayerSDK, type RevokeDelegationRequest, type RevokeDelegationSubmittedEvent, type RevokedDelegationForUserDecryptionEvent, RevokedKmsContextError, RpcRateLimitError, type SerializedPermit, type SerializedPermitEip712, type SerializedTransportKeyPair, type SetOperatorRequest, type SetOperatorSubmittedEvent, type ShieldCallbacks, type ShieldOptions, type ShieldPath, type ShieldSubmittedEvent, SignerNotConfiguredError, SignerRequiredError, type SigningErrorMetadata, SigningFailedError, SigningRejectedError, TOKEN_TOPICS, Token, type TokenWrapperPair, type TokenWrapperPairWithMetadata, Topics, type TransactionErrorEvent, type TransactionKind, type TransactionOperation, type TransactionReceipt, type TransactionResult, TransactionRevertedError, type TransferAndCallRequest, type TransferCallbacks, type TransferFromSubmittedEvent, type TransferOptions, type TransferSubmittedEvent, TransportKeyPairChangedError, TransportKeyPairExpiredError, type TypedValue, type UnshieldAlreadyFinalizedDetails, UnshieldAlreadyFinalizedError, type UnshieldCallbacks, type UnshieldOptions, type UnshieldPhase1SubmittedEvent, type UnshieldPhase2StartedEvent, type UnshieldPhase2SubmittedEvent, type UnwrapAllRequest, type UnwrapFinalizedEvent, type UnwrapRequest, type UnwrapRequestedEvent, type UnwrapResult, type UnwrapSubmittedEvent, type WalletAccount, type WalletAccountChange, type WalletAccountListener, WalletAccountNotReadyError, type WalletAccountStore, WalletNotConnectedError, type WrapEvent, type WrapOptions, type WrapRequest, type WrapSubmittedEvent, 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 ZamaSDKEventListener, type ZamaSDKEventType, ZamaSDKEvents, type ZamaSDKOptions, 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, isRetryable, mainnet, matchZamaError, memoryStorage, nameContract, polygon, polygonAmoy, rateContract, retryAfterSeconds, revokeDelegationContract, sepolia, setOperatorContract, supportsInterfaceContract, symbolContract, transferAndCallContract, underlyingContract, unwrapContract, unwrapFromBalanceContract, unwrapRequesterContract, wrapContract };
+import { a as hoodi, c as polygon, d as AtLeastOneChain, f as FheChain, i as hardhat, l as polygonAmoy, n as bscTestnet, o as ingenTestnet, p as FheChainAuth, r as chains, s as mainnet, t as anvil, u as sepolia } from "./index-Gk1S0gjO.js";
+import { $ as SetOperatorSubmittedEvent, $t as ClearValue, A as WalletAccountListener, At as RevokedDelegationForUserDecryptionEvent, B as ApproveUnderlyingSubmittedEvent, Bt as decodeOnChainEvent, C as TransferAndCallRequest, Ct as UnshieldCallbacks, D as GenericSigner, Dt as ConfidentialTransferEvent, E as WrapRequest, Et as AclTopics, F as ReadContractReturnType, Ft as WrapEvent, G as DelegationSubmittedEvent, Gt as decodeWrap, H as DecryptEndEvent, Ht as decodeRevokedDelegationForUserDecryption, I as ReadFunctionName, It as decodeAclEvent, J as EncryptStartEvent, Jt as findUnwrapRequested, K as EncryptEndEvent, Kt as findDelegatedForUserDecryption, L as WriteContractArgs, Lt as decodeAclEvents, M as ContractAbi, Mt as Topics, N as ReadContractArgs, Nt as UnwrapFinalizedEvent, O as WalletAccount, Ot as DelegatedForUserDecryptionEvent, P as ReadContractConfig, Pt as UnwrapRequestedEvent, Q as RevokeDelegationSubmittedEvent, Qt as TransactionResult, R as WriteContractConfig, Rt as decodeConfidentialTransfer, S as TransactionKind, St as TransferCallbacks, T as UnwrapRequest, Tt as AclEvent, U as DecryptErrorEvent, Ut as decodeUnwrapFinalized, V as BaseEvent, Vt as decodeOnChainEvents, W as DecryptStartEvent, Wt as decodeUnwrapRequested, X as PermitErrorEvent, Xt as RawLog, Y as FinalizeUnwrapSubmittedEvent, Yt as findWrap, Z as PermitOperation, Zt as TransactionReceipt, _ as PrepareTransactionRequest, _t as TransferOptions, a as ZamaConfigBase, an as EncryptResult, at as UnshieldPhase1SubmittedEvent, b as RevokeDelegationRequest, bt as WrapOptions, c as GenericStorage, cn as FhevmClientOptions, ct as UnwrapSubmittedEvent, d as ConfidentialTransferFromRequest, dn as RelayerOptions, dt as ZamaSDKEventListener, en as DecryptPublicValuesResult, et as ShieldSubmittedEvent, f as ConfidentialTransferRequest, fn as RelayerSDK, ft as ZamaSDKEventType, g as PrepareOptions, gt as ShieldPath, h as PrepareFees, ht as ShieldOptions, i as ZamaConfig, in as EncryptParams, it as TransferSubmittedEvent, j as WalletAccountStore, jt as TOKEN_TOPICS, k as WalletAccountChange, kt as OnChainEvent, l as GenericProvider, ln as FhevmRelayerOptions, lt as WrapSubmittedEvent, m as FinalizeUnwrapRequest, mt as ApprovalStrategy, n as RelayerConfig, nn as EIP712TypedData, nt as TransactionOperation, o as ZamaConfigGeneric, on as EncryptedValue, ot as UnshieldPhase2StartedEvent, p as DelegateDecryptionRequest, pn as TypedValue, pt as ZamaSDKEvents, q as EncryptErrorEvent, qt as findRevokedDelegationForUserDecryption, rn as EncryptInput, rt as TransferFromSubmittedEvent, s as GenericLogger, sn as FhevmClient, st as UnshieldPhase2SubmittedEvent, t as CleartextRelayerConfig, tn as DecryptValuesParameters, tt as TransactionErrorEvent, u as ApproveUnderlyingRequest, un as FhevmRuntimeConfig, ut as ZamaSDKEvent, v as PreparedFor, vt as UnshieldOptions, w as UnwrapAllRequest, wt as ACL_TOPICS, x as SetOperatorRequest, xt as ShieldCallbacks, y as PreparedTransaction, yt as UnwrapResult, z as WriteFunctionName, zt as decodeDelegatedForUserDecryption } from "./types-xCRG0yhi.js";
+import { t as cleartext } from "./cleartext-CROV-hgJ.js";
+import { t as ZamaConfigEthers } from "./types-CeLa3fMJ.js";
+import { n as MutableWalletAccountStore, r as createWalletAccountStore, t as BaseSigner } from "./base-signer-DlSb15WN.js";
+import { $ as BalanceErrorDetails, $t as getConfidentialTokenAddressContract, A as BatchDecryptAsOptions, An as rateContract, At as ZamaErrorCode, B as TransactionRevertedError, Bt as PreparedPermitV1, C as ZamaSDKOptions, Cn as confidentialBalanceOfContract, Ct as RevokedKmsContextError, D as WrappersRegistryConfig, Dn as finalizeUnwrapContract, Dt as UnifiedPermitNotSupportedError, E as WrappersRegistry, En as confidentialTransferFromContract, Et as UnifiedDecryptionUnsupportedError, F as Permits, Fn as unwrapRequesterContract, Ft as PermissionV1, G as SignerRequiredError, Gt as WILDCARD_PERMIT, H as SigningFailedError, Ht as SerializedPermit, I as ErrorForCode, In as wrapContract, It as PermissionV2, J as RpcRateLimitError, Jt as MAX_UINT64, K as WalletAccountNotReadyError, Kt as WildcardPermit, L as matchZamaError, Ln as createConfig, Lt as PreparePermitRequest, M as Offline, Mn as underlyingContract, Mt as retryAfterSeconds, N as Delegations, Nn as unwrapContract, Nt as Permission, O as WrappedToken, On as inferredTotalSupplyContract, Ot as ChainMismatchError, P as DelegationStatus, Pn as unwrapFromBalanceContract, Pt as PermissionBase, Q as BalanceCheckUnavailableError, Qt as TokenWrapperPairWithMetadata, R as UnshieldAlreadyFinalizedDetails, Rt as PreparedPermit, S as ZamaSDK, Sn as symbolContract, St as PreparedPermitExpiredError, T as ListPairsOptions, Tn as confidentialTransferContract, Tt as TransportKeyPairExpiredError, U as SigningRejectedError, Ut as SerializedPermitEip712, V as SigningErrorMetadata, Vt as PreparedPermitV2, W as SignerNotConfiguredError, Wt as SerializedTransportKeyPair, X as ConfigurationError, Xt as PaginatedResult, Y as NotEntitledError, Yt as WILDCARD_CONTRACT, Z as RelayerRequestFailedError, Zt as TokenWrapperPair, _n as allowanceContract, _t as DelegationSelfNotAllowedError, a as ChromeSessionStorage, an as isConfidentialTokenValidContract, at as EncryptOffloadUnavailableError, bn as decimalsContract, bt as NoCiphertextError, c as indexedDBStorage, cn as isHandleDelegatedContract, ct as DelegationContractIsSelfError, d as Decryption, dn as ERC1363_INTERFACE_ID, dt as DelegationDelegateEqualsContractError, en as getTokenAddressContract, et as ERC20ReadFailedError, f as BatchDecryptItem, fn as ERC7984_INTERFACE_ID, ft as DelegationExpirationTooSoonError, g as EncryptedInput, gn as supportsInterfaceContract, gt as DelegationNotPropagatedError, h as DecryptResult, hn as isConfidentialWrapperContract, ht as DelegationNotFoundError, i as isEncryptedValueZero, in as getTokenPairsSliceContract, it as DecryptionFailedError, j as Token, jn as setOperatorContract, jt as isRetryable, k as BatchBalancesResult, kn as isOperatorContract, kt as ZamaError, l as MemoryStorage, ln as revokeDelegationContract, lt as DelegationCooldownError, m as DelegatedDecryptOptions, mn as isConfidentialTokenContract, mt as DelegationExpiryUnchangedError, n as Hex, nn as getTokenPairsContract, nt as InsufficientConfidentialBalanceError, o as chromeSessionStorage, on as delegateForUserDecryptionContract, ot as EncryptionFailedError, p as BatchDecryptResult, pn as ERC7984_WRAPPER_INTERFACE_ID, pt as DelegationExpiredError, q as WalletNotConnectedError, qt as ChecksummedAddress, r as ZERO_ENCRYPTED_VALUE, rn as getTokenPairsLengthContract, rt as InsufficientERC20BalanceError, s as IndexedDBStorage, sn as getDelegationExpiryContract, st as AclPausedError, t as Address, tn as getTokenPairContract, tt as InsufficientAllowanceError, u as memoryStorage, un as transferAndCallContract, ut as DelegationDelegateCannotBeWildcardError, vn as approveContract, vt as InvalidTransportKeyPairError, w as DefaultRegistryAddresses, wn as confidentialTotalSupplyContract, wt as TransportKeyPairChangedError, xn as nameContract, xt as PreparedPermitChainMismatchError, yn as balanceOfContract, yt as KeyWrappingError, z as UnshieldAlreadyFinalizedError, zt as PreparedPermitBase } from "./index-CxgmG5MO.js";
+import { t as ZamaConfigViem } from "./types-kqUexcdj.js";
+export { ACL_TOPICS, type AclEvent, AclPausedError, AclTopics, type Address, type ApprovalStrategy, type ApproveUnderlyingRequest, type ApproveUnderlyingSubmittedEvent, type AtLeastOneChain, BalanceCheckUnavailableError, type BalanceErrorDetails, type BaseEvent, BaseSigner, type BatchBalancesResult, type BatchDecryptAsOptions, type BatchDecryptItem, type BatchDecryptResult, ChainMismatchError, type ChecksummedAddress, ChromeSessionStorage, type ClearValue, type CleartextRelayerConfig, type ConfidentialTransferEvent, type ConfidentialTransferFromRequest, type ConfidentialTransferRequest, ConfigurationError, type ContractAbi, type DecryptEndEvent, type DecryptErrorEvent, type EncryptedInput as DecryptInput, type DecryptPublicValuesResult, type DecryptResult, type DecryptStartEvent, type DecryptValuesParameters, Decryption, DecryptionFailedError, DefaultRegistryAddresses, type DelegateDecryptionRequest, type DelegatedDecryptOptions, type DelegatedForUserDecryptionEvent, DelegationContractIsSelfError, DelegationCooldownError, DelegationDelegateCannotBeWildcardError, DelegationDelegateEqualsContractError, DelegationExpirationTooSoonError, DelegationExpiredError, DelegationExpiryUnchangedError, DelegationNotFoundError, DelegationNotPropagatedError, DelegationSelfNotAllowedError, type DelegationStatus, type DelegationSubmittedEvent, Delegations, type EIP712TypedData, ERC1363_INTERFACE_ID, ERC20ReadFailedError, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, type EncryptEndEvent, type EncryptErrorEvent, type EncryptInput, EncryptOffloadUnavailableError, type EncryptParams, type EncryptResult, type EncryptStartEvent, type EncryptedValue, EncryptionFailedError, type ErrorForCode, type FheChain, type FheChainAuth, type FhevmClient, type FhevmClientOptions, type FhevmRelayerOptions, type FhevmRuntimeConfig, type FinalizeUnwrapRequest, type FinalizeUnwrapSubmittedEvent, type GenericLogger, type GenericProvider, type GenericSigner, type GenericStorage, type Hex, IndexedDBStorage, InsufficientAllowanceError, InsufficientConfidentialBalanceError, InsufficientERC20BalanceError, InvalidTransportKeyPairError, KeyWrappingError, type ListPairsOptions, MAX_UINT64, MemoryStorage, MutableWalletAccountStore, NoCiphertextError, NotEntitledError, Offline, type OnChainEvent, type PaginatedResult, type Permission, type PermissionBase, type PermissionV1, type PermissionV2, type PermitErrorEvent, type PermitOperation, Permits, type PrepareFees, type PrepareOptions, type PreparePermitRequest, type PrepareTransactionRequest, type PreparedFor, type PreparedPermit, type PreparedPermitBase, PreparedPermitChainMismatchError, PreparedPermitExpiredError, type PreparedPermitV1, type PreparedPermitV2, type PreparedTransaction, type RawLog, type ReadContractArgs, type ReadContractConfig, type ReadContractReturnType, type ReadFunctionName, type RelayerConfig, type RelayerOptions, RelayerRequestFailedError, type RelayerSDK, type RevokeDelegationRequest, type RevokeDelegationSubmittedEvent, type RevokedDelegationForUserDecryptionEvent, RevokedKmsContextError, RpcRateLimitError, type SerializedPermit, type SerializedPermitEip712, type SerializedTransportKeyPair, type SetOperatorRequest, type SetOperatorSubmittedEvent, type ShieldCallbacks, type ShieldOptions, type ShieldPath, type ShieldSubmittedEvent, SignerNotConfiguredError, SignerRequiredError, type SigningErrorMetadata, SigningFailedError, SigningRejectedError, TOKEN_TOPICS, Token, type TokenWrapperPair, type TokenWrapperPairWithMetadata, Topics, type TransactionErrorEvent, type TransactionKind, type TransactionOperation, type TransactionReceipt, type TransactionResult, TransactionRevertedError, type TransferAndCallRequest, type TransferCallbacks, type TransferFromSubmittedEvent, type TransferOptions, type TransferSubmittedEvent, TransportKeyPairChangedError, TransportKeyPairExpiredError, type TypedValue, UnifiedDecryptionUnsupportedError, UnifiedPermitNotSupportedError, type UnshieldAlreadyFinalizedDetails, UnshieldAlreadyFinalizedError, type UnshieldCallbacks, type UnshieldOptions, type UnshieldPhase1SubmittedEvent, type UnshieldPhase2StartedEvent, type UnshieldPhase2SubmittedEvent, type UnwrapAllRequest, type UnwrapFinalizedEvent, type UnwrapRequest, type UnwrapRequestedEvent, type UnwrapResult, type UnwrapSubmittedEvent, WILDCARD_CONTRACT, WILDCARD_PERMIT, type WalletAccount, type WalletAccountChange, type WalletAccountListener, WalletAccountNotReadyError, type WalletAccountStore, WalletNotConnectedError, type WildcardPermit, type WrapEvent, type WrapOptions, type WrapRequest, type WrapSubmittedEvent, 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 ZamaSDKEventListener, type ZamaSDKEventType, ZamaSDKEvents, type ZamaSDKOptions, 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, isRetryable, mainnet, matchZamaError, memoryStorage, nameContract, polygon, polygonAmoy, rateContract, retryAfterSeconds, revokeDelegationContract, sepolia, setOperatorContract, supportsInterfaceContract, symbolContract, transferAndCallContract, underlyingContract, unwrapContract, unwrapFromBalanceContract, unwrapRequesterContract, wrapContract };