@zama-fhe/sdk 3.4.0-alpha.9 → 3.4.0

package/dist/esm/{types-Tk8PiPCk.d.ts → types-BEz-VgR_.d.ts}

@@ -1,13 +1,16 @@
-import { l as AtLeastOneChain } from "./index-doNE2KoX.js";
-import { a as ZamaConfigBase } from "./types-CELdIAFG.js";
+import { l as AtLeastOneChain } from "./index-S6_V7aAH.js";
+import { a as ZamaConfigBase } from "./types-CWPSTRF6.js";
 import { EIP1193Provider, PublicClient, WalletClient } from "viem";
 //#region src/viem/types.d.ts
 /** Viem config — pass native viem clients directly. */
 interface ZamaConfigViem<TChains extends AtLeastOneChain = AtLeastOneChain> extends ZamaConfigBase<TChains> {
+  /** Viem public client for host-chain reads. */
   publicClient: PublicClient;
+  /** Viem wallet client for signing and write transactions. */
   walletClient: WalletClient;
+  /** Optional EIP-1193 provider used to observe wallet account/chain changes; omit to disable account-change tracking. */
   ethereum?: EIP1193Provider;
 }
 //#endregion
 export { ZamaConfigViem as t };
-//# sourceMappingURL=types-Tk8PiPCk.d.ts.map
+//# sourceMappingURL=types-BEz-VgR_.d.ts.map

package/dist/esm/{types-CELdIAFG.d.ts → types-CWPSTRF6.d.ts}

@@ -1,5 +1,5 @@
-import { l as AtLeastOneChain, u as FheChain } from "./index-doNE2KoX.js";
-import { createFhevmBaseClient, createFhevmClient, createFhevmDecryptClient, createFhevmEncryptClient, setFhevmRuntimeConfig } from "@fhevm/sdk/viem";
+import { l as AtLeastOneChain, u as FheChain } from "./index-S6_V7aAH.js";
+import { createFhevmClient, setFhevmRuntimeConfig } from "@fhevm/sdk/viem";
 import { Abi, Address, ContractFunctionArgs, ContractFunctionName, ContractFunctionReturnType, Hex } from "viem";
 import { Eip712Like, TypedValue, TypedValue as TypedValue$1 } from "@fhevm/sdk/types";
 import { DecryptValuesParameters } from "@fhevm/sdk/actions/decrypt";
@@ -23,18 +23,25 @@ type EncryptInput = {
 interface EncryptParams {
   /** Typed inputs for encryption. Each value must specify its FHE type. */
   readonly values: readonly EncryptInput[];
+  /** Contract the encrypted inputs will be sent to (bound into the input proof). */
   contractAddress: Address;
+  /** Address of the user producing the encrypted inputs (bound into the input proof). */
   userAddress: Address;
 }
 /** Result from encryption — contract-ready hex encrypted values and input proof. */
 interface EncryptResult {
+  /** Encrypted values, in the same order as the inputs, ready to pass to the contract. */
   readonly encryptedValues: readonly EncryptedValue[];
+  /** Zero-knowledge proof authorizing the encrypted values as valid contract inputs. */
   inputProof: Hex;
 }
 /** Result from public decryption. */
 interface DecryptPublicValuesResult {
+  /** Decrypted clear-text values keyed by their encrypted value. */
   readonly clearValues: Record<EncryptedValue, ClearValue>;
+  /** The clear values ABI-encoded, as passed to on-chain verification. */
   abiEncodedClearValues: Hex;
+  /** KMS signature proving the decryption is authentic. */
   decryptionProof: Hex;
 }
 /**
@@ -45,7 +52,9 @@ interface DecryptPublicValuesResult {
  * produces (which is versioned and evolves).
  */
 type EIP712TypedData = Eip712Like;
-/** The underlying client returned by `@fhevm/sdk`'s `createFhevmClient`. */
+/**
+ * The underlying client returned by `@fhevm/sdk`'s `createFhevmClient`.
+ */
 type FhevmClient = ReturnType<typeof createFhevmClient>;
 /** Per-client `@fhevm/sdk` options (`batchRpcCalls`, `fheEncryptionKey`). */
 type FhevmClientOptions = NonNullable<Parameters<typeof createFhevmClient>[0]["options"]>;
@@ -96,7 +105,6 @@ type FhevmRuntimeConfig = Parameters<typeof setFhevmRuntimeConfig>[0];
  * round-trip (mirrors its `RelayerCommonOptions`). Distinct from
  * {@link RelayerOptions}, which configures a transport once at construction —
  * these are applied per call.
- *
  */
 interface FhevmRelayerOptions {
   /** Relayer authentication for the chain. Defaulted from the chain's config. */
@@ -167,7 +175,8 @@ interface FhevmRelayerOptions {
  * Single-chain FHE backend contract. Implemented by `FhevmRelayer` (drives
  * `@fhevm/sdk`); translates between the domain shapes above and the engine's API.
  */
-interface FhevmRelayerSDK extends Pick<FhevmClient, "encryptValue" | "encryptValues" | "decryptPublicValue" | "decryptPublicValues" | "decryptPublicValuesWithSignatures" | "decryptValue" | "decryptValues" | "decryptValuesFromPairs" | "fetchFheEncryptionKeyBytes" | "generateTransportKeyPair" | "serializeTransportKeyPair" | "serializeSignedDecryptionPermit" | "signDecryptionPermit" | "parseTransportKeyPair" | "parseSignedDecryptionPermit"> {
+interface RelayerSDK extends Pick<FhevmClient, "encryptValue" | "encryptValues" | "decryptPublicValue" | "decryptPublicValues" | "decryptPublicValuesWithSignatures" | "decryptValue" | "decryptValues" | "decryptValuesFromPairs" | "fetchFheEncryptionKeyBytes" | "generateTransportKeyPair" | "serializeTransportKeyPair" | "serializeSignedDecryptionPermit" | "signDecryptionPermit" | "parseTransportKeyPair" | "parseSignedDecryptionPermit"> {
+  /** The single FHE-enabled chain this backend instance is bound to. */
   chain: FheChain;
 }
 //#endregion
@@ -209,6 +218,7 @@ declare const Topics: {
 };
 /** Decoded `ConfidentialTransfer` event — an encrypted token transfer. */
 interface ConfidentialTransferEvent {
+  /** Event name discriminant. */
   readonly eventName: "ConfidentialTransfer";
   /** Sender address. */
   readonly from: Address;
@@ -223,6 +233,7 @@ interface ConfidentialTransferEvent {
  * handle that lands in `ConfidentialTransfer.encryptedAmount`.
  */
 interface WrapEvent {
+  /** Event name discriminant. */
   readonly eventName: "Wrap";
   /** Receiver of the minted confidential tokens. */
   readonly to: Address;
@@ -233,6 +244,7 @@ interface WrapEvent {
 }
 /** Decoded `UnwrapRequested` event — an unshield request submitted. */
 interface UnwrapRequestedEvent {
+  /** Event name discriminant. */
   readonly eventName: "UnwrapRequested";
   /** Address that will receive the unwrapped ERC-20 tokens. */
   readonly receiver: Address;
@@ -243,6 +255,7 @@ interface UnwrapRequestedEvent {
 }
 /** Decoded `UnwrapFinalized` event — an unshield completed on-chain. */
 interface UnwrapFinalizedEvent {
+  /** Event name discriminant. */
   readonly eventName: "UnwrapFinalized";
   /** Address receiving the unwrapped ERC-20 tokens. */
   readonly receiver: Address;
@@ -333,6 +346,7 @@ declare const AclTopics: {
 };
 /** Decoded `DelegatedForUserDecryption` event — a delegation was created or renewed. */
 interface DelegatedForUserDecryptionEvent {
+  /** Event name discriminant. */
   readonly eventName: "DelegatedForUserDecryption";
   /** Address of the delegator (the account granting access). */
   readonly delegator: Address;
@@ -349,6 +363,7 @@ interface DelegatedForUserDecryptionEvent {
 }
 /** Decoded `RevokedDelegationForUserDecryption` event — a delegation was revoked. */
 interface RevokedDelegationForUserDecryptionEvent {
+  /** Event name discriminant. */
   readonly eventName: "RevokedDelegationForUserDecryption";
   /** Address of the delegator. */
   readonly delegator: Address;
@@ -511,73 +526,109 @@ declare const ZamaSDKEvents: {
 };
 /** Union of all SDK event type strings. */
 type ZamaSDKEventType = (typeof ZamaSDKEvents)[keyof typeof ZamaSDKEvents];
+/** Fields present on every SDK event; each concrete event extends this. */
 interface BaseEvent {
+  /** Confidential token this event relates to, when the operation targets one. */
   tokenAddress?: Address;
+  /** Unix epoch time (milliseconds) at which the event was emitted. */
   timestamp: number;
   /** Shared identifier linking related events in multi-phase operations (e.g. unshield). */
   operationId?: string;
 }
+/** Emitted when an FHE encryption starts. */
 interface EncryptStartEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.EncryptStart;
 }
+/** Emitted when an FHE encryption completes successfully. */
 interface EncryptEndEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.EncryptEnd;
+  /** Time the encryption took, in milliseconds. */
   durationMs: number;
 }
+/** Emitted when an FHE encryption fails. */
 interface EncryptErrorEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.EncryptError;
   /** The error that caused the encryption to fail. */
   error: Error;
+  /** Time elapsed before the encryption failed, in milliseconds. */
   durationMs: number;
 }
+/** Emitted when an FHE decryption starts. */
 interface DecryptStartEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.DecryptStart;
   /** Encrypted values being decrypted — correlate with matching DecryptEnd/DecryptError. */
   encryptedValues: EncryptedValue[];
 }
+/** Emitted when an FHE decryption completes successfully. */
 interface DecryptEndEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.DecryptEnd;
+  /** Time the decryption took, in milliseconds. */
   durationMs: number;
   /** Encrypted values that were decrypted. */
   encryptedValues: EncryptedValue[];
   /** Decrypted values keyed by encrypted value — use this to correlate events to specific entries. */
   result: Record<EncryptedValue, ClearValue>;
 }
+/** Emitted when an FHE decryption fails. */
 interface DecryptErrorEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.DecryptError;
   /** The error that caused the decryption to fail. */
   error: Error;
+  /** Time elapsed before the decryption failed, in milliseconds. */
   durationMs: number;
   /** Encrypted values that were being decrypted when the error occurred. */
   encryptedValues: EncryptedValue[];
 }
+/** Emitted when a write operation's transaction fails (before or after submission). */
 interface TransactionErrorEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.TransactionError;
   /** Which SDK operation failed. */
   operation: TransactionOperation;
   /** The error that caused the transaction to fail. */
   error: Error;
 }
+/** Emitted when a shield transaction has been submitted to the network. */
 interface ShieldSubmittedEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.ShieldSubmitted;
+  /** Hash of the submitted shield transaction. */
   txHash: Hex;
   /** Which execution path was used: single-tx `transferAndCall` or two-tx `approveAndWrap`. */
   shieldPath: ShieldPath;
 }
+/** Emitted when a confidential transfer transaction has been submitted to the network. */
 interface TransferSubmittedEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.TransferSubmitted;
+  /** Hash of the submitted transfer transaction. */
   txHash: Hex;
 }
+/** Emitted when a confidential `transferFrom` transaction has been submitted to the network. */
 interface TransferFromSubmittedEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.TransferFromSubmitted;
+  /** Hash of the submitted transferFrom transaction. */
   txHash: Hex;
 }
+/** Emitted when a set-operator transaction has been submitted to the network. */
 interface SetOperatorSubmittedEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.SetOperatorSubmitted;
+  /** Hash of the submitted setOperator transaction. */
   txHash: Hex;
 }
+/** Emitted when an underlying-ERC-20 approval transaction has been submitted to the network. */
 interface ApproveUnderlyingSubmittedEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.ApproveUnderlyingSubmitted;
+  /** Hash of the submitted approval transaction. */
   txHash: Hex;
   /** Which approval transaction was submitted. */
   step: "reset" | "approve";
@@ -589,34 +640,56 @@ interface ApproveUnderlyingSubmittedEvent extends BaseEvent {
  * how `unwrap` emits its own event rather than reusing the unshield phases.
  */
 interface WrapSubmittedEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.WrapSubmitted;
+  /** Hash of the submitted wrap transaction. */
   txHash: Hex;
 }
+/** Emitted when an unwrap transaction has been submitted to the network. */
 interface UnwrapSubmittedEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.UnwrapSubmitted;
+  /** Hash of the submitted unwrap transaction. */
   txHash: Hex;
 }
+/** Emitted when a finalize-unwrap transaction has been submitted to the network. */
 interface FinalizeUnwrapSubmittedEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.FinalizeUnwrapSubmitted;
+  /** Hash of the submitted finalizeUnwrap transaction. */
   txHash: Hex;
 }
+/** Emitted when a decryption-delegation transaction has been submitted to the network. */
 interface DelegationSubmittedEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.DelegationSubmitted;
+  /** Hash of the submitted delegation transaction. */
   txHash: Hex;
 }
+/** Emitted when a revoke-delegation transaction has been submitted to the network. */
 interface RevokeDelegationSubmittedEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.RevokeDelegationSubmitted;
+  /** Hash of the submitted revokeDelegation transaction. */
   txHash: Hex;
 }
+/** Emitted when the first phase of an unshield (the unwrap request) has been submitted. */
 interface UnshieldPhase1SubmittedEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.UnshieldPhase1Submitted;
+  /** Hash of the submitted phase-1 transaction. */
   txHash: Hex;
 }
+/** Emitted when the second phase of an unshield (finalization) starts. */
 interface UnshieldPhase2StartedEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.UnshieldPhase2Started;
 }
+/** Emitted when the second phase of an unshield (finalization) has been submitted. */
 interface UnshieldPhase2SubmittedEvent extends BaseEvent {
+  /** Event type discriminant. */
   type: typeof ZamaSDKEvents.UnshieldPhase2Submitted;
+  /** Hash of the submitted phase-2 transaction. */
   txHash: Hex;
 }
 /**
@@ -627,115 +700,8 @@ interface UnshieldPhase2SubmittedEvent extends BaseEvent {
  * private keys, permit signatures, or ZK proofs.
  */
 type ZamaSDKEvent = EncryptStartEvent | EncryptEndEvent | EncryptErrorEvent | DecryptStartEvent | DecryptEndEvent | DecryptErrorEvent | TransactionErrorEvent | ShieldSubmittedEvent | TransferSubmittedEvent | TransferFromSubmittedEvent | SetOperatorSubmittedEvent | ApproveUnderlyingSubmittedEvent | WrapSubmittedEvent | UnwrapSubmittedEvent | FinalizeUnwrapSubmittedEvent | DelegationSubmittedEvent | RevokeDelegationSubmittedEvent | UnshieldPhase1SubmittedEvent | UnshieldPhase2StartedEvent | UnshieldPhase2SubmittedEvent;
+/** Callback invoked with each emitted {@link ZamaSDKEvent}. */
 type ZamaSDKEventListener = (event: ZamaSDKEvent) => void;
-/** Distributive Omit that preserves the discriminated union. */
-type ZamaSDKEventInput = ZamaSDKEvent extends (infer E) ? E extends ZamaSDKEvent ? Omit<E, "timestamp" | "tokenAddress"> : never : never;
-/**
- * Single source of truth for each transaction operation's submitted-event payload.
- *
- * Adding a write op = adding one entry here. `TransactionOperation` is then
- * `keyof typeof transactionOperationMetadata`, so the dispatch table and the
- * operation union cannot drift.
- *
- * The `satisfies` check enforces that every entry produces a valid
- * {@link ZamaSDKEventInput}.
- */
-declare const transactionOperationMetadata: {
-  approveUnderlying: {
-    submittedEvent: (txHash: Hex) => {
-      type: "approveUnderlying:submitted";
-      txHash: `0x${string}`;
-      step: "approve";
-    };
-  };
-  "approveUnderlying:reset": {
-    submittedEvent: (txHash: Hex) => {
-      type: "approveUnderlying:submitted";
-      txHash: `0x${string}`;
-      step: "reset";
-    };
-  };
-  delegateDecryption: {
-    submittedEvent: (txHash: Hex) => {
-      type: "delegation:submitted";
-      txHash: `0x${string}`;
-    };
-  };
-  finalizeUnwrap: {
-    submittedEvent: (txHash: Hex) => {
-      type: "finalizeUnwrap:submitted";
-      txHash: `0x${string}`;
-    };
-  };
-  revokeDelegation: {
-    submittedEvent: (txHash: Hex) => {
-      type: "revokeDelegation:submitted";
-      txHash: `0x${string}`;
-    };
-  };
-  setOperator: {
-    submittedEvent: (txHash: Hex) => {
-      type: "setOperator:submitted";
-      txHash: `0x${string}`;
-    };
-  };
-  "shield:transferAndCall": {
-    submittedEvent: (txHash: Hex) => {
-      type: "shield:submitted";
-      txHash: `0x${string}`;
-      shieldPath: "transferAndCall";
-    };
-  };
-  "shield:approveAndWrap": {
-    submittedEvent: (txHash: Hex) => {
-      type: "shield:submitted";
-      txHash: `0x${string}`;
-      shieldPath: "approveAndWrap";
-    };
-  };
-  wrap: {
-    submittedEvent: (txHash: Hex) => {
-      type: "wrap:submitted";
-      txHash: `0x${string}`;
-    };
-  };
-  transfer: {
-    submittedEvent: (txHash: Hex) => {
-      type: "transfer:submitted";
-      txHash: `0x${string}`;
-    };
-  };
-  transferAndCall: {
-    submittedEvent: (txHash: Hex) => {
-      type: "transfer:submitted";
-      txHash: `0x${string}`;
-    };
-  };
-  transferFrom: {
-    submittedEvent: (txHash: Hex) => {
-      type: "transferFrom:submitted";
-      txHash: `0x${string}`;
-    };
-  };
-  transferFromAndCall: {
-    submittedEvent: (txHash: Hex) => {
-      type: "transferFrom:submitted";
-      txHash: `0x${string}`;
-    };
-  };
-  unwrap: {
-    submittedEvent: (txHash: Hex) => {
-      type: "unwrap:submitted";
-      txHash: `0x${string}`;
-    };
-  };
-  unwrapAll: {
-    submittedEvent: (txHash: Hex) => {
-      type: "unwrap:submitted";
-      txHash: `0x${string}`;
-    };
-  };
-};
 /**
  * SDK transaction operations that emit submitted/error lifecycle events.
  *
@@ -743,33 +709,7 @@ declare const transactionOperationMetadata: {
  * one (`shield:transferAndCall` vs. `shield:approveAndWrap`), routing both error
  * and success events on a single field — see {@link transactionOperationMetadata}.
  */
-type TransactionOperation = keyof typeof transactionOperationMetadata;
-//#endregion
-//#region src/chains/router.d.ts
-/**
- * Multichain router. Owns chain management (chains / chain / switchChain) and
- * hands out the single-chain {@link FhevmRelayerSDK} backend for the currently active
- * chain via {@link ChainRouter.relayer}. Builds one backend per chain from its
- * {@link RelayerConfig}.
- */
-declare class ChainRouter {
-  #private;
-  constructor(chains: readonly [FheChain, ...FheChain[]], configs: Readonly<Record<number, RelayerConfig>>);
-  get chains(): readonly FheChain[];
-  get chain(): FheChain;
-  /**
-   * Point the router at `chainId`. The active chain follows the wallet even when
-   * that chain has no configured backend: the {@link chain} / {@link relayer}
-   * getters throw a {@link ConfigurationError} for an unconfigured chain, so an
-   * unsupported chain fails loudly at the next operation rather than silently
-   * routing to the previously active chain (which would encrypt against, and
-   * sign an EIP-712 decryption permit for, the wrong chain's domain and ACL).
-   * Switching back to a configured chain restores service.
-   */
-  switchChain(chainId: number): void;
-  /** The single-chain backend for the currently active chain. */
-  get relayer(): FhevmRelayerSDK;
-}
+type TransactionOperation = "approveUnderlying" | "approveUnderlying:reset" | "delegateDecryption" | "finalizeUnwrap" | "revokeDelegation" | "setOperator" | "shield:transferAndCall" | "shield:approveAndWrap" | "wrap" | "transfer" | "transferAndCall" | "transferFrom" | "transferFromAndCall" | "unwrap" | "unwrapAll";
 //#endregion
 //#region src/types/contract.d.ts
 /** ABI type accepted by contract call builders. Supports both typed and untyped ABIs. */
@@ -820,12 +760,16 @@ interface WriteContractConfig<TAbi extends ContractAbi = ContractAbi, TFunctionN
 //#region src/types/signer.d.ts
 /** Snapshot of the connected wallet account at a point in time. */
 interface WalletAccount {
+  /** Address of the connected wallet account. */
   address: Address;
+  /** Chain ID the wallet is currently connected to. */
   chainId: number;
 }
 /** A wallet account transition emitted by signer adapters. */
 interface WalletAccountChange {
+  /** Account before the transition; `undefined` if none was connected. */
   previous?: WalletAccount;
+  /** Account after the transition; `undefined` on disconnect. */
   next?: WalletAccount;
 }
 /** Listener for wallet account transitions. */
@@ -920,7 +864,10 @@ interface GenericProvider {
  * structured clone, `MemoryStorage` stores values as-is.
  */
 interface GenericStorage {
-  /** Retrieve a value by key. Returns `null` if the key does not exist. */
+  /**
+   * Retrieve a value by key.
+   * @returns The stored value, or `null` if the key does not exist.
+   */
   get<T = unknown>(key: string): Promise<T | null>;
   /** Store a value under the given key, overwriting any existing entry. */
   set<T = unknown>(key: string, value: T): Promise<void>;
@@ -934,9 +881,13 @@ interface GenericStorage {
  * Pass via config to observe operation lifecycle (start, success, error, timeout).
  */
 interface GenericLogger {
+  /** Log at info level. */
   info: (message: string, data?: Record<string, unknown>) => void;
+  /** Log at debug level. */
   debug: (message: string, data?: Record<string, unknown>) => void;
+  /** Log at warn level. */
   warn: (message: string, data?: Record<string, unknown>) => void;
+  /** Log at error level. */
   error: (message: string, data?: Record<string, unknown>) => void;
 }
 //#endregion
@@ -946,16 +897,17 @@ interface GenericLogger {
  * dispatcher calls it once per chain.
  */
 interface RelayerConfig {
+  /** Discriminant identifying the relayer transport (e.g. `"web"`, `"node"`, `"cleartext"`). */
   readonly type: string;
-  /** Create a single-chain relayer. */
-  readonly createRelayer: (chain: FheChain) => FhevmRelayerSDK;
 }
 /** Web relayer config — drives the FHE backend directly. */
 interface WebRelayerConfig extends RelayerConfig {
+  /** Discriminant for the web transport. */
   readonly type: "web";
 }
 /** Cleartext relayer config — drives the FHE backend in cleartext mode. */
 interface CleartextRelayerConfig extends RelayerConfig {
+  /** Discriminant for the cleartext transport. */
   readonly type: "cleartext";
 }
 /** Shared options across all adapter paths. */
@@ -1008,6 +960,7 @@ interface ZamaConfigGeneric<TChains extends AtLeastOneChain = AtLeastOneChain> e
    * `SignerNotConfiguredError` when invoked without a signer.
    */
   signer?: GenericSigner;
+  /** Provider for public host-chain reads. */
   provider: GenericProvider;
 }
 declare const zamaConfigBrand: unique symbol;
@@ -1017,7 +970,6 @@ declare const zamaConfigBrand: unique symbol;
  */
 type ZamaConfig = {
   readonly chains: readonly FheChain[];
-  readonly router: ChainRouter;
   readonly provider: GenericProvider;
   readonly signer: GenericSigner | undefined;
   readonly storage: GenericStorage;
@@ -1036,5 +988,5 @@ type ZamaConfig = {
   readonly [zamaConfigBrand]: true;
 };
 //#endregion
-export { ShieldPath as $, EncryptEndEvent as A, findRevokedDelegationForUserDecryption as At, TransferSubmittedEvent as B, EncryptInput as Bt, ChainRouter as C, decodeOnChainEvent as Ct, DecryptErrorEvent as D, decodeUnwrapRequested as Dt, DecryptEndEvent as E, decodeUnwrapFinalized as Et, SetOperatorSubmittedEvent as F, TransactionResult as Ft, WrapSubmittedEvent as G, FhevmRelayerOptions as Gt, UnshieldPhase2StartedEvent as H, EncryptResult as Ht, ShieldSubmittedEvent as I, ClearValue as It, ZamaSDKEventListener as J, TypedValue$1 as Jt, ZamaSDKEvent as K, FhevmRelayerSDK as Kt, TransactionErrorEvent as L, DecryptPublicValuesResult as Lt, EncryptStartEvent as M, findWrap as Mt, FinalizeUnwrapSubmittedEvent as N, RawLog as Nt, DecryptStartEvent as O, decodeWrap as Ot, RevokeDelegationSubmittedEvent as P, TransactionReceipt as Pt, ShieldOptions as Q, TransactionOperation as R, DecryptValuesParameters as Rt, WriteFunctionName as S, decodeDelegatedForUserDecryption as St, BaseEvent as T, decodeRevokedDelegationForUserDecryption as Tt, UnshieldPhase2SubmittedEvent as U, EncryptedValue as Ut, UnshieldPhase1SubmittedEvent as V, EncryptParams as Vt, UnwrapSubmittedEvent as W, FhevmClient as Wt, ZamaSDKEvents as X, ZamaSDKEventType as Y, ApprovalStrategy as Z, ReadContractConfig as _, UnwrapRequestedEvent as _t, ZamaConfigBase as a, TransferCallbacks as at, WriteContractArgs as b, decodeAclEvents as bt, GenericStorage as c, AclEvent as ct, WalletAccount as d, DelegatedForUserDecryptionEvent as dt, TransferOptions as et, WalletAccountChange as f, OnChainEvent as ft, ReadContractArgs as g, UnwrapFinalizedEvent as gt, ContractAbi as h, Topics as ht, ZamaConfig as i, ShieldCallbacks as it, EncryptErrorEvent as j, findUnwrapRequested as jt, DelegationSubmittedEvent as k, findDelegatedForUserDecryption as kt, GenericProvider as l, AclTopics as lt, WalletAccountStore as m, TOKEN_TOPICS as mt, RelayerConfig as n, UnwrapResult as nt, ZamaConfigGeneric as o, UnshieldCallbacks as ot, WalletAccountListener as p, RevokedDelegationForUserDecryptionEvent as pt, ZamaSDKEventInput as q, RelayerOptions as qt, WebRelayerConfig as r, WrapOptions as rt, GenericLogger as s, ACL_TOPICS as st, CleartextRelayerConfig as t, UnshieldOptions as tt, GenericSigner as u, ConfidentialTransferEvent as ut, ReadContractReturnType as v, WrapEvent as vt, ApproveUnderlyingSubmittedEvent as w, decodeOnChainEvents as wt, WriteContractConfig as x, decodeConfidentialTransfer as xt, ReadFunctionName as y, decodeAclEvent as yt, TransferFromSubmittedEvent as z, EIP712TypedData as zt };
-//# sourceMappingURL=types-CELdIAFG.d.ts.map
+export { UnshieldOptions as $, EncryptErrorEvent as A, findWrap as At, UnshieldPhase1SubmittedEvent as B, EncryptResult as Bt, ApproveUnderlyingSubmittedEvent as C, decodeRevokedDelegationForUserDecryption as Ct, DecryptStartEvent as D, findDelegatedForUserDecryption as Dt, DecryptErrorEvent as E, decodeWrap as Et, ShieldSubmittedEvent as F, DecryptPublicValuesResult as Ft, ZamaSDKEvent as G, FhevmRuntimeConfig as Gt, UnshieldPhase2SubmittedEvent as H, FhevmClient as Ht, TransactionErrorEvent as I, DecryptValuesParameters as It, ZamaSDKEvents as J, TypedValue$1 as Jt, ZamaSDKEventListener as K, RelayerOptions as Kt, TransactionOperation as L, EIP712TypedData as Lt, FinalizeUnwrapSubmittedEvent as M, TransactionReceipt as Mt, RevokeDelegationSubmittedEvent as N, TransactionResult as Nt, DelegationSubmittedEvent as O, findRevokedDelegationForUserDecryption as Ot, SetOperatorSubmittedEvent as P, ClearValue as Pt, TransferOptions as Q, TransferFromSubmittedEvent as R, EncryptInput as Rt, WriteFunctionName as S, decodeOnChainEvents as St, DecryptEndEvent as T, decodeUnwrapRequested as Tt, UnwrapSubmittedEvent as U, FhevmClientOptions as Ut, UnshieldPhase2StartedEvent as V, EncryptedValue as Vt, WrapSubmittedEvent as W, FhevmRelayerOptions as Wt, ShieldOptions as X, ApprovalStrategy as Y, ShieldPath as Z, ReadContractConfig as _, decodeAclEvent as _t, ZamaConfigBase as a, ACL_TOPICS as at, WriteContractArgs as b, decodeDelegatedForUserDecryption as bt, GenericStorage as c, ConfidentialTransferEvent as ct, WalletAccount as d, RevokedDelegationForUserDecryptionEvent as dt, UnwrapResult as et, WalletAccountChange as f, TOKEN_TOPICS as ft, ReadContractArgs as g, WrapEvent as gt, ContractAbi as h, UnwrapRequestedEvent as ht, ZamaConfig as i, UnshieldCallbacks as it, EncryptStartEvent as j, RawLog as jt, EncryptEndEvent as k, findUnwrapRequested as kt, GenericProvider as l, DelegatedForUserDecryptionEvent as lt, WalletAccountStore as m, UnwrapFinalizedEvent as mt, RelayerConfig as n, ShieldCallbacks as nt, ZamaConfigGeneric as o, AclEvent as ot, WalletAccountListener as p, Topics as pt, ZamaSDKEventType as q, RelayerSDK as qt, WebRelayerConfig as r, TransferCallbacks as rt, GenericLogger as s, AclTopics as st, CleartextRelayerConfig as t, WrapOptions as tt, GenericSigner as u, OnChainEvent as ut, ReadContractReturnType as v, decodeAclEvents as vt, BaseEvent as w, decodeUnwrapFinalized as wt, WriteContractConfig as x, decodeOnChainEvent as xt, ReadFunctionName as y, decodeConfidentialTransfer as yt, TransferSubmittedEvent as z, EncryptParams as zt };
+//# sourceMappingURL=types-CWPSTRF6.d.ts.map

package/dist/esm/{types-DlSUyFe2.d.ts → types-Dr7AmEs1.d.ts}

@@ -1,5 +1,5 @@
-import { l as AtLeastOneChain } from "./index-doNE2KoX.js";
-import { a as ZamaConfigBase } from "./types-CELdIAFG.js";
+import { l as AtLeastOneChain } from "./index-S6_V7aAH.js";
+import { a as ZamaConfigBase } from "./types-CWPSTRF6.js";
 import { EIP1193Provider } from "viem";
 import { Provider, Signer } from "ethers";
 //#region src/ethers/types.d.ts
@@ -26,4 +26,4 @@ type ZamaConfigEthers<TChains extends AtLeastOneChain = AtLeastOneChain> = ZamaC
 });
 //#endregion
 export { ZamaConfigEthers as t };
-//# sourceMappingURL=types-DlSUyFe2.d.ts.map
+//# sourceMappingURL=types-Dr7AmEs1.d.ts.map

package/dist/esm/viem/index.d.ts

@@ -1,7 +1,7 @@
-import { u as FheChain } from "../index-doNE2KoX.js";
-import { Pt as TransactionReceipt, Ut as EncryptedValue, _ as ReadContractConfig, i as ZamaConfig, l as GenericProvider, x as WriteContractConfig, zt as EIP712TypedData } from "../types-CELdIAFG.js";
-import { t as BaseSigner } from "../base-signer-Ds8CoYy0.js";
-import { t as ZamaConfigViem } from "../types-Tk8PiPCk.js";
+import { d as FheChainAuth, l as AtLeastOneChain, u as FheChain } from "../index-S6_V7aAH.js";
+import { A as EncryptErrorEvent, B as UnshieldPhase1SubmittedEvent, C as ApproveUnderlyingSubmittedEvent, D as DecryptStartEvent, E as DecryptErrorEvent, F as ShieldSubmittedEvent, G as ZamaSDKEvent, Gt as FhevmRuntimeConfig, H as UnshieldPhase2SubmittedEvent, I as TransactionErrorEvent, J as ZamaSDKEvents, K as ZamaSDKEventListener, L as TransactionOperation, Lt as EIP712TypedData, M as FinalizeUnwrapSubmittedEvent, Mt as TransactionReceipt, N as RevokeDelegationSubmittedEvent, O as DelegationSubmittedEvent, P as SetOperatorSubmittedEvent, Pt as ClearValue, R as TransferFromSubmittedEvent, S as WriteFunctionName, T as DecryptEndEvent, U as UnwrapSubmittedEvent, V as UnshieldPhase2StartedEvent, Vt as EncryptedValue, W as WrapSubmittedEvent, Z as ShieldPath, _ as ReadContractConfig, a as ZamaConfigBase, b as WriteContractArgs, c as GenericStorage, d as WalletAccount, f as WalletAccountChange, g as ReadContractArgs, h as ContractAbi, i as ZamaConfig, j as EncryptStartEvent, jt as RawLog, k as EncryptEndEvent, l as GenericProvider, m as WalletAccountStore, n as RelayerConfig, p as WalletAccountListener, q as ZamaSDKEventType, s as GenericLogger, u as GenericSigner, v as ReadContractReturnType, w as BaseEvent, x as WriteContractConfig, y as ReadFunctionName, z as TransferSubmittedEvent } from "../types-CWPSTRF6.js";
+import { n as MutableWalletAccountStore, t as BaseSigner } from "../base-signer-BvL-jMNO.js";
+import { t as ZamaConfigViem } from "../types-BEz-VgR_.js";
 import { Abi, Address, ContractFunctionArgs, ContractFunctionName, ContractFunctionReturnType, EIP1193Provider, Hex, Hex as Hex$1, PublicClient, WalletClient } from "viem";
 //#region src/viem/config.d.ts
 /** Create a {@link ZamaConfig} from viem clients. */
@@ -23,13 +23,22 @@ declare function createConfig<const TChains extends readonly [FheChain, ...FheCh
 interface ViemSignerConfig {
   /** Wallet client for signing and write operations. */
   walletClient: WalletClient;
+  /** Raw EIP-1193 provider enabling wallet lifecycle events; omit for a no-op `subscribe()`. */
   ethereum?: EIP1193Provider;
 }
+/**
+ * {@link GenericSigner} backed by a viem `WalletClient` for EIP-712 signing and
+ * write transactions. Pass `ethereum` in {@link ViemSignerConfig} to track
+ * wallet lifecycle events.
+ */
 declare class ViemSigner extends BaseSigner {
   #private;
   constructor(config: ViemSignerConfig);
+  /** Sign EIP-712 typed data (used for decrypt authorization). */
   signTypedData(typedData: EIP712TypedData): Promise<Hex$1>;
+  /** Send a write transaction and return the tx hash. */
   writeContract<const TAbi extends Abi | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, "nonpayable" | "payable">, const TArgs extends ContractFunctionArgs<TAbi, "nonpayable" | "payable", TFunctionName>>(config: WriteContractConfig<TAbi, TFunctionName, TArgs>): Promise<Hex$1>;
+  /** Unsubscribe from the EIP-1193 provider's wallet lifecycle events. */
   protected onDispose(): void;
 }
 //#endregion
@@ -55,41 +64,61 @@ interface ViemProviderConfig {
 declare class ViemProvider implements GenericProvider {
   #private;
   constructor(config: ViemProviderConfig);
+  /** Return the chain ID of the connected network. */
   getChainId(): Promise<number>;
+  /** Execute a read-only call and return the decoded result. */
   readContract<const TAbi extends Abi | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, "pure" | "view">, const TArgs extends ContractFunctionArgs<TAbi, "pure" | "view", TFunctionName>>(config: ReadContractConfig<TAbi, TFunctionName, TArgs>): Promise<ContractFunctionReturnType<TAbi, "pure" | "view", TFunctionName, TArgs>>;
+  /** Wait for a transaction to be mined and return its receipt. */
   waitForTransactionReceipt(hash: Hex$1): Promise<TransactionReceipt>;
+  /** Return the latest block timestamp in seconds. */
   getBlockTimestamp(): Promise<bigint>;
 }
 //#endregion
 //#region src/viem/contracts.d.ts
+/** Reads a token's confidential (encrypted) balance handle for `userAddress` via a viem client. */
 declare function readConfidentialBalanceOfContract(client: PublicClient, tokenAddress: Address, userAddress: Address): Promise<`0x${string}`>;
+/** Reads the underlying ERC-20 address wrapped by a confidential wrapper via a viem client. */
 declare function readUnderlyingTokenContract(client: PublicClient, wrapperAddress: Address): Promise<`0x${string}`>;
+/** Reads whether a token implements the given ERC-165 interface id via a viem client. */
 declare function readSupportsInterfaceContract(client: PublicClient, tokenAddress: Address, interfaceId: Address): Promise<boolean>;
+/** Submits a confidential transfer of an encrypted amount to `to` via a viem wallet client. */
 declare function writeConfidentialTransferContract(client: WalletClient, tokenAddress: Address, to: Address, encryptedAmount: EncryptedValue, inputProof: Hex$1): Promise<`0x${string}`>;
+/** Submits an unwrap of an encrypted amount from `from` to `to` on a confidential ERC-20 via a viem wallet client. */
 declare function writeUnwrapContract(client: WalletClient, encryptedErc20: Address, from: Address, to: Address, encryptedAmount: EncryptedValue, inputProof: Hex$1): Promise<`0x${string}`>;
+/** Submits an unwrap of the full encrypted balance from `from` to `to` via a viem wallet client. */
 declare function writeUnwrapFromBalanceContract(client: WalletClient, encryptedErc20: Address, from: Address, to: Address, encryptedBalance: EncryptedValue): Promise<`0x${string}`>;
+/** Finalizes a pending unwrap request with the decrypted amount and decryption proof via a viem wallet client. */
 declare function writeFinalizeUnwrapContract(client: WalletClient, wrapper: Address, unwrapRequestId: EncryptedValue, unwrapAmountCleartext: bigint, decryptionProof: Hex$1): Promise<`0x${string}`>;
+/** Authorizes `operator` on a token, until an optional expiry timestamp, via a viem wallet client. */
 declare function writeSetOperatorContract(client: WalletClient, tokenAddress: Address, operator: Address, until?: number): Promise<`0x${string}`>;
+/** Wraps `amount` of the underlying ERC-20 into confidential tokens credited to `to` via a viem wallet client. */
 declare function writeWrapContract(client: WalletClient, wrapperAddress: Address, to: Address, amount: bigint): Promise<`0x${string}`>;
+/** Reads all underlying/confidential token pairs from a wrappers registry via a viem client. */
 declare function readTokenPairsContract(client: PublicClient, registry: Address): Promise<readonly {
   tokenAddress: `0x${string}`;
   confidentialTokenAddress: `0x${string}`;
   isValid: boolean;
 }[]>;
+/** Reads the number of token pairs in a wrappers registry via a viem client. */
 declare function readTokenPairsLengthContract(client: PublicClient, registry: Address): Promise<bigint>;
+/** Reads a slice of token pairs (`fromIndex` to `toIndex`) from a wrappers registry via a viem client. */
 declare function readTokenPairsSliceContract(client: PublicClient, registry: Address, fromIndex: bigint, toIndex: bigint): Promise<readonly {
   tokenAddress: `0x${string}`;
   confidentialTokenAddress: `0x${string}`;
   isValid: boolean;
 }[]>;
+/** Reads the token pair at `index` from a wrappers registry via a viem client. */
 declare function readTokenPairContract(client: PublicClient, registry: Address, index: bigint): Promise<{
   tokenAddress: `0x${string}`;
   confidentialTokenAddress: `0x${string}`;
   isValid: boolean;
 }>;
+/** Reads the confidential token registered for a given underlying token in a wrappers registry via a viem client. */
 declare function readConfidentialTokenAddressContract(client: PublicClient, registry: Address, tokenAddress: Address): Promise<readonly [boolean, `0x${string}`]>;
+/** Reads the underlying token registered for a given confidential token in a wrappers registry via a viem client. */
 declare function readTokenAddressContract(client: PublicClient, registry: Address, confidentialTokenAddress: Address): Promise<readonly [boolean, `0x${string}`]>;
+/** Reads whether a confidential token is registered and valid in a wrappers registry via a viem client. */
 declare function readIsConfidentialTokenValidContract(client: PublicClient, registry: Address, confidentialTokenAddress: Address): Promise<boolean>;
 //#endregion
-export { type EncryptedValue, type Hex, ViemProvider, type ViemProviderConfig, ViemSigner, type ViemSignerConfig, type ZamaConfigViem, createConfig, readConfidentialBalanceOfContract, readConfidentialTokenAddressContract, readIsConfidentialTokenValidContract, readSupportsInterfaceContract, readTokenAddressContract, readTokenPairContract, readTokenPairsContract, readTokenPairsLengthContract, readTokenPairsSliceContract, readUnderlyingTokenContract, writeConfidentialTransferContract, writeFinalizeUnwrapContract, writeSetOperatorContract, writeUnwrapContract, writeUnwrapFromBalanceContract, writeWrapContract };
+export { type ApproveUnderlyingSubmittedEvent, type AtLeastOneChain, type BaseEvent, BaseSigner, type ClearValue, type ContractAbi, type DecryptEndEvent, type DecryptErrorEvent, type DecryptStartEvent, type DelegationSubmittedEvent, type EIP712TypedData, type EncryptEndEvent, type EncryptErrorEvent, type EncryptStartEvent, type EncryptedValue, type FheChain, type FheChainAuth, type FhevmRuntimeConfig, type FinalizeUnwrapSubmittedEvent, type GenericLogger, type GenericProvider, type GenericSigner, type GenericStorage, type Hex, type MutableWalletAccountStore, type RawLog, type ReadContractArgs, type ReadContractConfig, type ReadContractReturnType, type ReadFunctionName, type RelayerConfig, type RevokeDelegationSubmittedEvent, type SetOperatorSubmittedEvent, type ShieldPath, type ShieldSubmittedEvent, type TransactionErrorEvent, type TransactionOperation, type TransactionReceipt, type TransferFromSubmittedEvent, type TransferSubmittedEvent, type UnshieldPhase1SubmittedEvent, type UnshieldPhase2StartedEvent, type UnshieldPhase2SubmittedEvent, type UnwrapSubmittedEvent, ViemProvider, type ViemProviderConfig, ViemSigner, type ViemSignerConfig, type WalletAccount, type WalletAccountChange, type WalletAccountListener, type WalletAccountStore, type WrapSubmittedEvent, type WriteContractArgs, type WriteContractConfig, type WriteFunctionName, type ZamaConfig, type ZamaConfigBase, type ZamaConfigViem, type ZamaSDKEvent, type ZamaSDKEventListener, type ZamaSDKEventType, ZamaSDKEvents, createConfig, readConfidentialBalanceOfContract, readConfidentialTokenAddressContract, readIsConfidentialTokenValidContract, readSupportsInterfaceContract, readTokenAddressContract, readTokenPairContract, readTokenPairsContract, readTokenPairsLengthContract, readTokenPairsSliceContract, readUnderlyingTokenContract, writeConfidentialTransferContract, writeFinalizeUnwrapContract, writeSetOperatorContract, writeUnwrapContract, writeUnwrapFromBalanceContract, writeWrapContract };
 //# sourceMappingURL=index.d.ts.map