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

package/dist/esm/types-C-WTLcHZ.d.ts

@@ -0,0 +1,988 @@
+import { l as AtLeastOneChain, u as FheChain } from "./index-D66eC3G7.js";
+import { createFhevmBaseClient, createFhevmClient, createFhevmDecryptClient, createFhevmEncryptClient, 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";
+
+//#region src/relayer/types.d.ts
+/** Canonical SDK type for an encrypted value — a `bytes32` ciphertext reference. */
+type EncryptedValue = Hex;
+/** Canonical SDK type for a decrypted clear-text value. */
+type ClearValue = TypedValue["value"] | bigint | string | undefined;
+/** A single value to encrypt with its FHE type. */
+type EncryptInput = {
+  readonly type: `e${Exclude<TypedValue["type"], "bool" | "address">}`;
+  readonly value: bigint;
+} | {
+  readonly type: `e${Extract<TypedValue["type"], "bool">}`;
+  readonly value: boolean | 1n | 0n;
+} | {
+  readonly type: `e${Extract<TypedValue["type"], "address">}`;
+  readonly value: Address;
+};
+/** Parameters for encryption */
+interface EncryptParams {
+  /** Typed inputs for encryption. Each value must specify its FHE type. */
+  readonly values: readonly EncryptInput[];
+  contractAddress: Address;
+  userAddress: Address;
+}
+/** Result from encryption — contract-ready hex encrypted values and input proof. */
+interface EncryptResult {
+  readonly encryptedValues: readonly EncryptedValue[];
+  inputProof: Hex;
+}
+/** Result from public decryption. */
+interface DecryptPublicValuesResult {
+  readonly clearValues: Record<EncryptedValue, ClearValue>;
+  abiEncodedClearValues: Hex;
+  decryptionProof: Hex;
+}
+/**
+ * EIP-712 typed data for a (delegated) user-decrypt permit. Built by the FHE
+ * backend and handed to the signer layer (`GenericSigner.signTypedData`), which
+ * forwards it to the wallet. A structural shape — the SDK's contract is "sign
+ * this typed data", independent of the specific KMS permit variant `@fhevm/sdk`
+ * produces (which is versioned and evolves).
+ */
+type EIP712TypedData = Eip712Like;
+/** 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"]>;
+/**
+ * Options for a relayer transport (`web` / `node` / `cleartext`): the per-client
+ * `@fhevm/sdk` options that shape the underlying client, plus the request
+ * defaults `timeout` and `debug` applied to every relayer round-trip on the
+ * chain. A per-call `timeout`/`debug` overrides these defaults.
+ *
+ * @remarks
+ * The three client options mirror {@link FhevmClientOptions} but are listed
+ * explicitly so each carries its own documentation; `timeout` and `debug` are
+ * picked from {@link FhevmRelayerOptions}, the per-request option set.
+ */
+interface RelayerOptions extends Pick<FhevmRelayerOptions, "timeout" | "debug"> {
+  /**
+   * Batch the client's JSON-RPC reads (the on-chain calls it makes to resolve
+   * the protocol and key versions) into a single request instead of issuing
+   * them one by one.
+   *
+   * @defaultValue `false`
+   */
+  readonly batchRpcCalls?: boolean;
+  /**
+   * A pre-fetched FHE public encryption key. Supply it to skip the ~50 MB key
+   * fetch `@fhevm/sdk` otherwise performs during init — e.g. to reuse a key
+   * cached across clients or sessions.
+   *
+   * @defaultValue none — the key is fetched from the relayer's `keyurl`.
+   */
+  readonly fheEncryptionKey?: FhevmClientOptions["fheEncryptionKey"];
+  /**
+   * Pins the TFHE/KMS WASM module versions instead of auto-resolving them from
+   * the chain's on-chain protocol version.
+   *
+   * @defaultValue `'auto'`
+   */
+  readonly moduleVersions?: FhevmClientOptions["moduleVersions"];
+}
+/**
+ * Global `@fhevm/sdk` runtime config — WASM load mode, threads, logger, auth,
+ * module versions. Applied once per process (the underlying `setFhevmRuntimeConfig`
+ * is one-shot and idempotent; conflicting configs across chains will throw).
+ */
+type FhevmRuntimeConfig = Parameters<typeof setFhevmRuntimeConfig>[0];
+/**
+ * The full set of per-request options `@fhevm/sdk`'s relayer accepts on every
+ * 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. */
+  readonly auth?: FhevmRuntimeConfig["auth"];
+  /** Extra HTTP headers attached to each relayer request. */
+  readonly headers?: Record<string, string>;
+  /**
+   * When `true`, `@fhevm/sdk`'s relayer emits verbose per-request trace logs to
+   * `console.log` (`[RelayerAsyncRequest]:…`), following each round-trip through
+   * its polling/retry loop. Off by default. A per-call `debug` overrides this.
+   *
+   * @remarks
+   * This is a raw diagnostic switch on the FHE backend, separate from the SDK's
+   * own configurable logger ({@link GenericLogger} via `createConfig`): it always
+   * writes to `console`, regardless of any logger you pass. Use it for one-off
+   * troubleshooting of relayer round-trips, not as a production logging channel.
+   *
+   * @defaultValue `false` `@fhevm/sdk` treats a missing flag as off.
+   */
+  readonly debug?: boolean;
+  /**
+   * Times a failed HTTP fetch is retried on transient errors before the request
+   * gives up. This is the low-level fetch retry, separate from the async-job
+   * polling loop that waits on a queued relayer request.
+   *
+   * @defaultValue `3` `@fhevm/sdk`'s `FETCH_RETRY`.
+   */
+  readonly fetchRetries?: number;
+  /**
+   * Delay between those fetch retries, in milliseconds.
+   *
+   * @defaultValue `1_000` `@fhevm/sdk`'s `FETCH_RETRY_AFTER_MS`;
+   */
+  readonly fetchRetryDelayInMilliseconds?: number;
+  /**
+   * Cancels the request (and its retry/backoff loop) when aborted.
+   *
+   * @defaultValue none — the SDK injects no signal, so a request is uncancellable
+   * unless a per-call `signal` is passed.
+   */
+  readonly signal?: AbortSignal;
+  /**
+   * Maximum duration, in milliseconds, to wait for a relayer **request** — an
+   * input-proof generation or a decryption, including its retry/backoff polling
+   * loop, not a single HTTP call. Defaults to the `@fhevm/sdk` ceiling of one
+   * hour; set a shorter bound only if you would rather fail than keep waiting. A
+   * per-call `timeout` overrides this default.
+   *
+   * @remarks
+   * Bounds only the relayer request, not `@fhevm/sdk`'s one-time (per client)
+   * init phase — on-chain protocol-version resolution, the ~50 MB FHE key fetch,
+   * and the WASM module load — which runs before the first request and can hang
+   * independently of this value. A failed init does not self-recover; discard
+   * the client and build a new one to retry.
+   *
+   * @defaultValue `3_600_000` (1 hour) — `@fhevm/sdk`'s
+   * `DEFAULT_GLOBAL_REQUEST_TIMEOUT_MS`, applied when no `timeout` is set at
+   * construction or per call.
+   *
+   * @privateRemarks
+   * `@fhevm/sdk`'s `init()` accepts no options, so no timeout/signal reaches
+   * that phase, and it memoizes a rejected ready-promise (`??=`). Bounding init
+   * is tracked upstream in `@fhevm/sdk`.
+   */
+  readonly timeout?: number;
+}
+/**
+ * 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"> {
+  chain: FheChain;
+}
+//#endregion
+//#region src/types/transaction.d.ts
+/** Framework-agnostic log shape compatible with any Ethereum provider. */
+interface RawLog {
+  /** Indexed event topics (topic[0] is the event signature hash). */
+  readonly topics: readonly Hex[];
+  /** ABI-encoded non-indexed event data. */
+  readonly data: Hex;
+}
+/** Framework-agnostic transaction receipt (only the fields the SDK needs). */
+interface TransactionReceipt {
+  /** Event logs emitted during the transaction. */
+  readonly logs: readonly RawLog[];
+}
+/** Result of a write operation: the tx hash and its mined receipt. */
+interface TransactionResult {
+  /** The transaction hash. */
+  txHash: Hex;
+  /** The mined transaction receipt. */
+  receipt: TransactionReceipt;
+}
+//#endregion
+//#region src/events/onchain-events.d.ts
+/**
+ * Event topic0 constants (keccak256 of the canonical Solidity signature).
+ * Pass to `getLogs({ topics: [Object.values(Topics)] })` to fetch all events.
+ */
+declare const Topics: {
+  /** `ConfidentialTransfer(address indexed from, address indexed to, bytes32 indexed amount)` */readonly ConfidentialTransfer: `0x${string}`; /** `Wrap(address indexed to, uint256 roundedAmount, euint64 encryptedWrappedAmount)` */
+  readonly Wrap: `0x${string}`; /** `UnwrapRequested(address indexed receiver, bytes32 indexed unwrapRequestId, bytes32 amount)` */
+  readonly UnwrapRequested: `0x${string}`; /** `UnwrapFinalized(address indexed receiver, bytes32 indexed unwrapRequestId, bytes32 encryptedAmount, uint64 cleartextAmount)` */
+  readonly UnwrapFinalized: `0x${string}`;
+};
+/** Decoded `ConfidentialTransfer` event — an encrypted token transfer. */
+interface ConfidentialTransferEvent {
+  readonly eventName: "ConfidentialTransfer";
+  /** Sender address. */
+  readonly from: Address;
+  /** Receiver address. */
+  readonly to: Address;
+  /** FHE encrypted value for the transferred amount. */
+  readonly encryptedAmount: EncryptedValue;
+}
+/**
+ * Decoded `Wrap` event — an ERC-20 shield (wrap) operation. Emitted alongside a
+ * `ConfidentialTransfer(from=zeroAddress, ...)`; `encryptedWrappedAmount` is the same FHE
+ * handle that lands in `ConfidentialTransfer.encryptedAmount`.
+ */
+interface WrapEvent {
+  readonly eventName: "Wrap";
+  /** Receiver of the minted confidential tokens. */
+  readonly to: Address;
+  /** Cleartext underlying ERC-20 tokens deposited, rounded down to a multiple of the rate. */
+  readonly roundedAmount: bigint;
+  /** FHE encrypted value for the wrapped (minted) amount. */
+  readonly encryptedWrappedAmount: EncryptedValue;
+}
+/** Decoded `UnwrapRequested` event — an unshield request submitted. */
+interface UnwrapRequestedEvent {
+  readonly eventName: "UnwrapRequested";
+  /** Address that will receive the unwrapped ERC-20 tokens. */
+  readonly receiver: Address;
+  /** FHE encrypted value for the requested unshield amount. */
+  readonly encryptedAmount: EncryptedValue;
+  /** Request identifier from the `UnwrapRequested` event topic. */
+  readonly unwrapRequestId?: EncryptedValue;
+}
+/** Decoded `UnwrapFinalized` event — an unshield completed on-chain. */
+interface UnwrapFinalizedEvent {
+  readonly eventName: "UnwrapFinalized";
+  /** Address receiving the unwrapped ERC-20 tokens. */
+  readonly receiver: Address;
+  /** FHE encrypted value of the burnt confidential balance. */
+  readonly encryptedAmount: EncryptedValue;
+  /** Cleartext amount of underlying ERC-20 tokens returned. */
+  readonly cleartextAmount: bigint;
+  /** Request identifier from the `UnwrapFinalized` event topic. */
+  readonly unwrapRequestId?: EncryptedValue;
+}
+/** Union of all decoded confidential token event types. */
+type OnChainEvent = ConfidentialTransferEvent | WrapEvent | UnwrapRequestedEvent | UnwrapFinalizedEvent;
+/**
+ * ConfidentialTransfer(address indexed from, address indexed to, bytes32 indexed amount)
+ * All 3 params indexed → topics[1..3], no data.
+ */
+declare function decodeConfidentialTransfer(log: RawLog): ConfidentialTransferEvent | null;
+/**
+ * Wrap(address indexed to, uint256 roundedAmount, euint64 encryptedWrappedAmount)
+ * Indexed: to (topics[1])
+ * Data: roundedAmount (uint256), encryptedWrappedAmount (bytes32)
+ */
+declare function decodeWrap(log: RawLog): WrapEvent | null;
+/**
+ * UnwrapRequested(address indexed receiver, bytes32 indexed unwrapRequestId, bytes32 amount)
+ */
+declare function decodeUnwrapRequested(log: RawLog): UnwrapRequestedEvent | null;
+/**
+ * UnwrapFinalized(address indexed receiver, bytes32 indexed unwrapRequestId, bytes32 encryptedAmount, uint64 cleartextAmount)
+ */
+declare function decodeUnwrapFinalized(log: RawLog): UnwrapFinalizedEvent | null;
+/**
+ * Try all decoders on a single log and return the first match, or `null`.
+ *
+ * @example
+ * ```ts
+ * const event = decodeOnChainEvent(log);
+ * if (event?.eventName === "ConfidentialTransfer") {
+ *   console.log(event.from, event.to);
+ * }
+ * ```
+ */
+declare function decodeOnChainEvent(log: RawLog): OnChainEvent | null;
+/**
+ * Batch-decode an array of logs, skipping unrecognized entries.
+ *
+ * @example
+ * ```ts
+ * const events = decodeOnChainEvents(receipt.logs);
+ * ```
+ */
+declare function decodeOnChainEvents(logs: readonly RawLog[]): OnChainEvent[];
+/**
+ * Find the first {@link UnwrapRequestedEvent} in a logs array.
+ *
+ * @example
+ * ```ts
+ * const event = findUnwrapRequested(receipt.logs);
+ * if (event) console.log(event.receiver, event.encryptedAmount);
+ * ```
+ */
+declare function findUnwrapRequested(logs: readonly RawLog[]): UnwrapRequestedEvent | null;
+/**
+ * Find the first {@link WrapEvent} in a logs array.
+ *
+ * @example
+ * ```ts
+ * const event = findWrap(receipt.logs);
+ * if (event) console.log(event.to, event.roundedAmount);
+ * ```
+ */
+declare function findWrap(logs: readonly RawLog[]): WrapEvent | null;
+/**
+ * All confidential token event topic0 hashes.
+ * Pass to `getLogs({ topics: [TOKEN_TOPICS] })` to fetch
+ * all confidential token events in a single RPC call.
+ */
+declare const TOKEN_TOPICS: readonly [`0x${string}`, `0x${string}`, `0x${string}`, `0x${string}`];
+/**
+ * ACL delegation event topic0 constants (keccak256 of the canonical Solidity signature).
+ * These are ACL events, NOT token events — they are emitted by the ACL contract.
+ */
+declare const AclTopics: {
+  /** `DelegatedForUserDecryption(address indexed delegator, address indexed delegate, address contractAddress, uint64 delegationCounter, uint64 oldExpirationDate, uint64 newExpirationDate)` */readonly DelegatedForUserDecryption: `0x${string}`; /** `RevokedDelegationForUserDecryption(address indexed delegator, address indexed delegate, address contractAddress, uint64 delegationCounter, uint64 oldExpirationDate)` */
+  readonly RevokedDelegationForUserDecryption: `0x${string}`;
+};
+/** Decoded `DelegatedForUserDecryption` event — a delegation was created or renewed. */
+interface DelegatedForUserDecryptionEvent {
+  readonly eventName: "DelegatedForUserDecryption";
+  /** Address of the delegator (the account granting access). */
+  readonly delegator: Address;
+  /** Address of the delegate (the account receiving access). */
+  readonly delegate: Address;
+  /** Contract address the delegation applies to. */
+  readonly contractAddress: Address;
+  /** Monotonic delegation counter. */
+  readonly delegationCounter: bigint;
+  /** Previous expiration timestamp (0 if first delegation). */
+  readonly oldExpirationDate: bigint;
+  /** New expiration timestamp. */
+  readonly newExpirationDate: bigint;
+}
+/** Decoded `RevokedDelegationForUserDecryption` event — a delegation was revoked. */
+interface RevokedDelegationForUserDecryptionEvent {
+  readonly eventName: "RevokedDelegationForUserDecryption";
+  /** Address of the delegator. */
+  readonly delegator: Address;
+  /** Address of the delegate. */
+  readonly delegate: Address;
+  /** Contract address the revocation applies to. */
+  readonly contractAddress: Address;
+  /** Monotonic delegation counter. */
+  readonly delegationCounter: bigint;
+  /** Expiration date that was active before revocation. */
+  readonly oldExpirationDate: bigint;
+}
+/** Union of all decoded ACL delegation event types. */
+type AclEvent = DelegatedForUserDecryptionEvent | RevokedDelegationForUserDecryptionEvent;
+/**
+ * DelegatedForUserDecryption(address indexed delegator, address indexed delegate,
+ *   address contractAddress, uint64 delegationCounter, uint64 oldExpirationDate, uint64 newExpirationDate)
+ * Indexed: delegator (topics[1]), delegate (topics[2])
+ * Data: contractAddress, delegationCounter, oldExpirationDate, newExpirationDate
+ */
+declare function decodeDelegatedForUserDecryption(log: RawLog): DelegatedForUserDecryptionEvent | null;
+/**
+ * RevokedDelegationForUserDecryption(address indexed delegator, address indexed delegate,
+ *   address contractAddress, uint64 delegationCounter, uint64 oldExpirationDate)
+ * Indexed: delegator (topics[1]), delegate (topics[2])
+ * Data: contractAddress, delegationCounter, oldExpirationDate
+ */
+declare function decodeRevokedDelegationForUserDecryption(log: RawLog): RevokedDelegationForUserDecryptionEvent | null;
+/**
+ * Try all ACL delegation decoders on a single log and return the first match, or `null`.
+ */
+declare function decodeAclEvent(log: RawLog): AclEvent | null;
+/**
+ * Batch-decode an array of logs for ACL delegation events, skipping unrecognized entries.
+ */
+declare function decodeAclEvents(logs: readonly RawLog[]): AclEvent[];
+/**
+ * Find the first {@link DelegatedForUserDecryptionEvent} in a logs array.
+ */
+declare function findDelegatedForUserDecryption(logs: readonly RawLog[]): DelegatedForUserDecryptionEvent | null;
+/**
+ * Find the first {@link RevokedDelegationForUserDecryptionEvent} in a logs array.
+ */
+declare function findRevokedDelegationForUserDecryption(logs: readonly RawLog[]): RevokedDelegationForUserDecryptionEvent | null;
+/**
+ * Both ACL delegation event topic0 hashes.
+ * Pass to `getLogs({ topics: [ACL_TOPICS] })` to fetch
+ * all delegation events in a single RPC call.
+ */
+declare const ACL_TOPICS: readonly [`0x${string}`, `0x${string}`];
+//#endregion
+//#region src/types/callbacks.d.ts
+/** Progress callbacks for multi-step unshield operations. */
+interface UnshieldCallbacks {
+  /** Fired after the unwrap transaction is submitted. */
+  onUnwrapSubmitted?: (txHash: Hex) => void;
+  /** Fired when the finalization step begins (receipt parsed, about to finalize). */
+  onFinalizing?: () => void;
+  /** Fired after the finalize transaction is submitted. */
+  onFinalizeSubmitted?: (txHash: Hex) => void;
+}
+/** Progress callbacks for multi-step shield operations. */
+interface ShieldCallbacks {
+  /** Fired after the ERC-20 approval transaction is submitted (skipped when `approvalStrategy: "skip"`). */
+  onApprovalSubmitted?: (txHash: Hex) => void;
+  /** Fired after the shield (wrap) transaction is submitted. */
+  onShieldSubmitted?: (txHash: Hex) => void;
+}
+/** Progress callbacks for multi-step confidential transfer operations. */
+interface TransferCallbacks {
+  /** Fired after FHE encryption of the transfer amount completes. */
+  onEncryptComplete?: () => void;
+  /** Fired after the transfer transaction is submitted. */
+  onTransferSubmitted?: (txHash: Hex) => void;
+}
+//#endregion
+//#region src/types/token.d.ts
+/** Options for {@link ConfidentialToken.confidentialTransfer}. */
+interface TransferOptions extends TransferCallbacks {
+  /** Skip confidential balance validation (e.g. for smart wallets). Default: `false`. */
+  skipBalanceCheck?: boolean;
+}
+/**
+ * User-facing approval strategy.
+ *
+ * - `"exact"` (default): approve exactly `amount`.
+ * - `"max"`: approve unlimited.
+ * - `"skip"`: assume a pre-existing approval; skip the approve step.
+ */
+type ApprovalStrategy = "max" | "exact" | "skip";
+/**
+ * The resolved shielding execution path — what actually ran on-chain.
+ * Reported on {@link ShieldSubmittedEvent}; on a failure, the path is
+ * encoded in {@link TransactionErrorEvent.operation} as
+ * `"shield:transferAndCall"` or `"shield:approveAndWrap"`. Decided
+ * automatically by ERC-165 introspection on the underlying ERC-20.
+ *
+ * - `"transferAndCall"`: single tx via ERC-1363 (no approval).
+ * - `"approveAndWrap"`: legacy two-tx path (`approve` then `wrap`).
+ */
+type ShieldPath = "transferAndCall" | "approveAndWrap";
+/** Options for {@link WrappedToken.shield}. */
+interface ShieldOptions extends ShieldCallbacks {
+  /** See {@link ApprovalStrategy}. Default: `"exact"`. Ignored when the underlying supports ERC-1363 (single-tx path requires no approval). */
+  approvalStrategy?: ApprovalStrategy;
+  /** Recipient address for the shielded tokens. Defaults to the connected wallet. */
+  to?: Address;
+}
+/** Options for {@link WrappedToken.unshield}. */
+interface UnshieldOptions extends UnshieldCallbacks {
+  /** Skip confidential balance validation (e.g. for smart wallets). Default: `false`. */
+  skipBalanceCheck?: boolean;
+}
+//#endregion
+//#region src/events/sdk-events.d.ts
+/**
+ * All SDK event keys, accessible as `ZamaSDKEvents.EncryptStart` etc.
+ */
+declare const ZamaSDKEvents: {
+  readonly EncryptStart: "encrypt:start";
+  readonly EncryptEnd: "encrypt:end";
+  readonly EncryptError: "encrypt:error";
+  readonly DecryptStart: "decrypt:start";
+  readonly DecryptEnd: "decrypt:end";
+  readonly DecryptError: "decrypt:error";
+  readonly TransactionError: "transaction:error";
+  readonly ShieldSubmitted: "shield:submitted";
+  readonly TransferSubmitted: "transfer:submitted";
+  readonly TransferFromSubmitted: "transferFrom:submitted";
+  readonly SetOperatorSubmitted: "setOperator:submitted";
+  readonly ApproveUnderlyingSubmitted: "approveUnderlying:submitted";
+  readonly UnwrapSubmitted: "unwrap:submitted";
+  readonly FinalizeUnwrapSubmitted: "finalizeUnwrap:submitted";
+  readonly DelegationSubmitted: "delegation:submitted";
+  readonly RevokeDelegationSubmitted: "revokeDelegation:submitted";
+  readonly UnshieldPhase1Submitted: "unshield:phase1_submitted";
+  readonly UnshieldPhase2Started: "unshield:phase2_started";
+  readonly UnshieldPhase2Submitted: "unshield:phase2_submitted";
+};
+/** Union of all SDK event type strings. */
+type ZamaSDKEventType = (typeof ZamaSDKEvents)[keyof typeof ZamaSDKEvents];
+interface BaseEvent {
+  tokenAddress?: Address;
+  timestamp: number;
+  /** Shared identifier linking related events in multi-phase operations (e.g. unshield). */
+  operationId?: string;
+}
+interface EncryptStartEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.EncryptStart;
+}
+interface EncryptEndEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.EncryptEnd;
+  durationMs: number;
+}
+interface EncryptErrorEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.EncryptError;
+  /** The error that caused the encryption to fail. */
+  error: Error;
+  durationMs: number;
+}
+interface DecryptStartEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.DecryptStart;
+  /** Encrypted values being decrypted — correlate with matching DecryptEnd/DecryptError. */
+  encryptedValues: EncryptedValue[];
+}
+interface DecryptEndEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.DecryptEnd;
+  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>;
+}
+interface DecryptErrorEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.DecryptError;
+  /** The error that caused the decryption to fail. */
+  error: Error;
+  durationMs: number;
+  /** Encrypted values that were being decrypted when the error occurred. */
+  encryptedValues: EncryptedValue[];
+}
+interface TransactionErrorEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.TransactionError;
+  /** Which SDK operation failed. */
+  operation: TransactionOperation;
+  /** The error that caused the transaction to fail. */
+  error: Error;
+}
+interface ShieldSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.ShieldSubmitted;
+  txHash: Hex;
+  /** Which execution path was used: single-tx `transferAndCall` or two-tx `approveAndWrap`. */
+  shieldPath: ShieldPath;
+}
+interface TransferSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.TransferSubmitted;
+  txHash: Hex;
+}
+interface TransferFromSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.TransferFromSubmitted;
+  txHash: Hex;
+}
+interface SetOperatorSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.SetOperatorSubmitted;
+  txHash: Hex;
+}
+interface ApproveUnderlyingSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.ApproveUnderlyingSubmitted;
+  txHash: Hex;
+  /** Which approval transaction was submitted. */
+  step: "reset" | "approve";
+}
+interface UnwrapSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.UnwrapSubmitted;
+  txHash: Hex;
+}
+interface FinalizeUnwrapSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.FinalizeUnwrapSubmitted;
+  txHash: Hex;
+}
+interface DelegationSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.DelegationSubmitted;
+  txHash: Hex;
+}
+interface RevokeDelegationSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.RevokeDelegationSubmitted;
+  txHash: Hex;
+}
+interface UnshieldPhase1SubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.UnshieldPhase1Submitted;
+  txHash: Hex;
+}
+interface UnshieldPhase2StartedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.UnshieldPhase2Started;
+}
+interface UnshieldPhase2SubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.UnshieldPhase2Submitted;
+  txHash: Hex;
+}
+/**
+ * Discriminated union of all SDK events.
+ *
+ * Decrypt events carry encrypted values and decrypted clear-text values so event
+ * subscribers can correlate and bind them in UI layers. Events never carry
+ * private keys, permit signatures, or ZK proofs.
+ */
+type ZamaSDKEvent = EncryptStartEvent | EncryptEndEvent | EncryptErrorEvent | DecryptStartEvent | DecryptEndEvent | DecryptErrorEvent | TransactionErrorEvent | ShieldSubmittedEvent | TransferSubmittedEvent | TransferFromSubmittedEvent | SetOperatorSubmittedEvent | ApproveUnderlyingSubmittedEvent | UnwrapSubmittedEvent | FinalizeUnwrapSubmittedEvent | DelegationSubmittedEvent | RevokeDelegationSubmittedEvent | UnshieldPhase1SubmittedEvent | UnshieldPhase2StartedEvent | UnshieldPhase2SubmittedEvent;
+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";
+    };
+  };
+  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.
+ *
+ * Operation strings encode the execution-path discriminator for flows that have
+ * 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;
+}
+//#endregion
+//#region src/types/contract.d.ts
+/** ABI type accepted by contract call builders. Supports both typed and untyped ABIs. */
+type ContractAbi = Abi | readonly unknown[];
+/** Extract read-only function names (`pure` | `view`) from a contract ABI. */
+type ReadFunctionName<TAbi extends ContractAbi = ContractAbi> = ContractFunctionName<TAbi, "pure" | "view">;
+/** Extract write function names (`nonpayable` | `payable`) from a contract ABI. */
+type WriteFunctionName<TAbi extends ContractAbi = ContractAbi> = ContractFunctionName<TAbi, "nonpayable" | "payable">;
+/** Infer the argument tuple for a read-only contract function. */
+type ReadContractArgs<TAbi extends ContractAbi = ContractAbi, TFunctionName extends ReadFunctionName<TAbi> = ReadFunctionName<TAbi>> = ContractFunctionArgs<TAbi, "pure" | "view", TFunctionName>;
+/** Infer the argument tuple for a write contract function. */
+type WriteContractArgs<TAbi extends ContractAbi = ContractAbi, TFunctionName extends WriteFunctionName<TAbi> = WriteFunctionName<TAbi>> = ContractFunctionArgs<TAbi, "nonpayable" | "payable", TFunctionName>;
+/** Infer the return type for a read-only contract function. */
+type ReadContractReturnType<TAbi extends ContractAbi = ContractAbi, TFunctionName extends ReadFunctionName<TAbi> = ReadFunctionName<TAbi>, TArgs extends ReadContractArgs<TAbi, TFunctionName> = ReadContractArgs<TAbi, TFunctionName>> = ContractFunctionReturnType<TAbi, "pure" | "view", TFunctionName, TArgs>;
+/**
+ * Typed read-contract configuration.
+ * Matches the shape returned by read contract builders in `src/contracts/`.
+ */
+interface ReadContractConfig<TAbi extends ContractAbi = ContractAbi, TFunctionName extends ReadFunctionName<TAbi> = ReadFunctionName<TAbi>, TArgs extends ReadContractArgs<TAbi, TFunctionName> = ReadContractArgs<TAbi, TFunctionName>> {
+  /** Target contract address. */
+  readonly address: Address;
+  /** ABI fragment for the function being called. */
+  readonly abi: TAbi;
+  /** Solidity function name. */
+  readonly functionName: TFunctionName;
+  /** Contract call arguments inferred from the ABI and function name. */
+  readonly args: TArgs;
+}
+/**
+ * Typed write-contract configuration.
+ * Matches the shape returned by write contract builders in `src/contracts/`.
+ */
+interface WriteContractConfig<TAbi extends ContractAbi = ContractAbi, TFunctionName extends WriteFunctionName<TAbi> = WriteFunctionName<TAbi>, TArgs extends WriteContractArgs<TAbi, TFunctionName> = WriteContractArgs<TAbi, TFunctionName>> {
+  /** Target contract address. */
+  readonly address: Address;
+  /** ABI fragment for the function being called. */
+  readonly abi: TAbi;
+  /** Solidity function name. */
+  readonly functionName: TFunctionName;
+  /** Contract call arguments inferred from the ABI and function name. */
+  readonly args: TArgs;
+  /** Native value to send with the transaction (for payable functions). */
+  readonly value?: bigint;
+  /** Gas limit override. */
+  readonly gas?: bigint;
+}
+//#endregion
+//#region src/types/signer.d.ts
+/** Snapshot of the connected wallet account at a point in time. */
+interface WalletAccount {
+  address: Address;
+  chainId: number;
+}
+/** A wallet account transition emitted by signer adapters. */
+interface WalletAccountChange {
+  previous?: WalletAccount;
+  next?: WalletAccount;
+}
+/** Listener for wallet account transitions. */
+type WalletAccountListener = (change: WalletAccountChange) => void;
+/**
+ * Synchronous observable store for wallet account readiness.
+ *
+ * Direct subscriptions observe raw signer adapter transitions. For SDK-
+ * coordinated cleanup and React query invalidation, subscribe through
+ * `ZamaSDK.onWalletAccountChange` so credential/cache cleanup runs first.
+ */
+interface WalletAccountStore {
+  /** Synchronous, non-prompting snapshot of the currently connected wallet account. */
+  getSnapshot(): WalletAccount | undefined;
+  /**
+   * Whether the store has received at least one snapshot. Adapters whose
+   * initial account is only available asynchronously start unready; callers
+   * can distinguish "still loading" from "wallet not connected".
+   */
+  isReady(): boolean;
+  /**
+   * Subscribe to wallet account transitions (connect, disconnect, account
+   * change, chain change). Returns an unsubscribe function.
+   *
+   * If a wallet account is already known when `subscribe` is called, the
+   * listener MUST be invoked synchronously with
+   * `{ previous: undefined, next: <current> }`. The SDK relies on this to
+   * warm credentials for already-connected signers; custom stores that skip
+   * this initial emit will silently break credential pre-warming.
+   */
+  subscribe(onWalletAccountChange: WalletAccountListener): () => void;
+}
+/**
+ * Framework-agnostic signer interface — wallet authority only.
+ *
+ * Public chain reads have moved to {@link GenericProvider}. A signer is only
+ * required for operations that involve a user-controlled wallet
+ * (`requireWalletAccount`, `signTypedData`, `writeContract`).
+ */
+interface GenericSigner {
+  /** Observable wallet account readiness state. */
+  readonly walletAccount: WalletAccountStore;
+  /**
+   * Return the currently connected wallet account or throw
+   * {@link WalletNotConnectedError}. Must not initiate wallet connection.
+   */
+  requireWalletAccount(operation: string): WalletAccount;
+  /**
+   * Optional non-prompting account discovery hook for adapters whose initial
+   * account snapshot is only available asynchronously.
+   */
+  refreshWalletAccount?(): Promise<WalletAccount | undefined>;
+  /** Sign EIP-712 typed data (used for decrypt authorization). */
+  signTypedData(typedData: EIP712TypedData): Promise<Hex>;
+  /** Send a write transaction and return the tx hash. */
+  writeContract<const TAbi extends ContractAbi, TFunctionName extends WriteFunctionName<TAbi>, const TArgs extends WriteContractArgs<TAbi, TFunctionName>>(config: WriteContractConfig<TAbi, TFunctionName, TArgs>): Promise<Hex>;
+  /** Release adapter-owned wallet watchers or provider event listeners. */
+  dispose?(): void;
+}
+//#endregion
+//#region src/types/provider.d.ts
+/**
+ * Framework-agnostic read-only provider interface.
+ *
+ * Represents the minimal set of capabilities needed to perform public chain
+ * reads: querying state via `eth_call`, checking chain identity, awaiting
+ * transaction receipts, and fetching block timestamps.
+ *
+ * Any caller with only an RPC endpoint (server indexer, SSR, dApp pre-connect)
+ * can drive the SDK via a {@link GenericProvider} implementation, without
+ * instantiating a wallet-shaped object. Use {@link ViemProvider},
+ * {@link EthersProvider}, or {@link WagmiProvider}; or implement the
+ * interface directly.
+ */
+interface GenericProvider {
+  /** 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 ContractAbi, TFunctionName extends ReadFunctionName<TAbi>, const TArgs extends ReadContractArgs<TAbi, TFunctionName>>(config: ReadContractConfig<TAbi, TFunctionName, TArgs>): Promise<ReadContractReturnType<TAbi, TFunctionName, TArgs>>;
+  /** Wait for a transaction to be mined and return its receipt. */
+  waitForTransactionReceipt(hash: Hex): Promise<TransactionReceipt>;
+  /** Return the latest block timestamp in seconds. */
+  getBlockTimestamp(): Promise<bigint>;
+}
+//#endregion
+//#region src/types/storage.d.ts
+/**
+ * Pluggable key-value store for persisting FHE credentials.
+ *
+ * The SDK stores objects directly (not JSON strings). Implementations must
+ * preserve value types through round-trips — e.g. `IndexedDBStorage` uses
+ * structured clone, `MemoryStorage` stores values as-is.
+ */
+interface GenericStorage {
+  /** Retrieve a value by key. Returns `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>;
+  /** Remove the entry for the given key (no-op if absent). */
+  delete(key: string): Promise<void>;
+}
+//#endregion
+//#region src/types/logger.d.ts
+/**
+ * Optional logger for SDK observability.
+ * Pass via config to observe operation lifecycle (start, success, error, timeout).
+ */
+interface GenericLogger {
+  info: (message: string, data?: Record<string, unknown>) => void;
+  debug: (message: string, data?: Record<string, unknown>) => void;
+  warn: (message: string, data?: Record<string, unknown>) => void;
+  error: (message: string, data?: Record<string, unknown>) => void;
+}
+//#endregion
+//#region src/config/types.d.ts
+/**
+ * Base relayer config. `createRelayer` builds one single-chain relayer; the
+ * dispatcher calls it once per chain.
+ */
+interface RelayerConfig {
+  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 {
+  readonly type: "web";
+}
+/** Cleartext relayer config — drives the FHE backend in cleartext mode. */
+interface CleartextRelayerConfig extends RelayerConfig {
+  readonly type: "cleartext";
+}
+/** Shared options across all adapter paths. */
+interface ZamaConfigBase<TChains extends AtLeastOneChain = AtLeastOneChain> {
+  /** FHE chain configurations. Defines which chains support FHE operations. */
+  chains: TChains;
+  /** Per-chain relayer configuration. Every chain must have a relayer entry. */
+  relayers: { [K in TChains[number]["id"]]: RelayerConfig };
+  /** Credential storage. Default: IndexedDB in browser, memory in Node. */
+  storage?: GenericStorage;
+  /** Optional dedicated storage for permits. Defaults to `storage`. */
+  permitStorage?: GenericStorage;
+  /** ML-KEM transport key pair TTL in seconds. Default: 2592000 (30 days). */
+  transportKeyPairTTL?: number;
+  /** Permit lifetime in days. Default: 30. Clamped to `transportKeyPairTTL / 86400`. */
+  permitTTL?: number;
+  /** Registry cache TTL in seconds. Default: 86400 (24h). */
+  registryTTL?: number;
+  /** SDK lifecycle event listener. */
+  onEvent?: ZamaSDKEventListener;
+  /**
+   * Global `@fhevm/sdk` runtime config — WASM load mode, threads, logger, auth,
+   * module versions. `runtime.auth` is the process-wide fallback; each chain's
+   * `auth` is forwarded on that chain's relayer requests and takes precedence.
+   */
+  runtime?: FhevmRuntimeConfig;
+  /**
+   * Optional logger for SDK diagnostics. Conforms to the four-level
+   * {@link GenericLogger} interface (`error`/`warn`/`info`/`debug`), which
+   * common loggers (console, pino, winston, OpenTelemetry's `DiagLogger`)
+   * satisfy directly. When omitted, the SDK emits no log output of its own.
+   * The SDK never bundles a logging library or imposes a format.
+   */
+  logger?: GenericLogger;
+}
+/** Generic config — pass any {@link GenericSigner} and {@link GenericProvider} directly. */
+interface ZamaConfigGeneric<TChains extends AtLeastOneChain = AtLeastOneChain> extends ZamaConfigBase<TChains> {
+  /**
+   * Optional wallet signer. Omit for read-only usage (indexers, SSR,
+   * pre-wallet-connect states). Signer-required SDK operations throw
+   * `SignerNotConfiguredError` when invoked without a signer.
+   */
+  signer?: GenericSigner;
+  provider: GenericProvider;
+}
+declare const zamaConfigBrand: unique symbol;
+/**
+ * Resolved, validated config object. Obtain via `createConfig()` or an
+ * adapter-specific factory — never construct by hand.
+ */
+type ZamaConfig = {
+  readonly chains: readonly FheChain[];
+  readonly router: ChainRouter;
+  readonly provider: GenericProvider;
+  readonly signer: GenericSigner | undefined;
+  readonly storage: GenericStorage;
+  readonly permitStorage: GenericStorage;
+  readonly transportKeyPairTTL: number;
+  readonly permitTTL: number;
+  readonly registryTTL: number;
+  readonly onEvent: ZamaSDKEventListener | undefined;
+  /**
+   * The SDK-wide logger, always present. Wraps the optional consumer-supplied
+   * {@link GenericLogger}; silent when none was configured.
+   */
+  readonly logger: GenericLogger;
+} & {
+  readonly [zamaConfigBrand]: true;
+};
+//#endregion
+export { TransferOptions as $, EncryptEndEvent as A, RawLog as At, TransferSubmittedEvent as B, EncryptedValue as Bt, ChainRouter as C, decodeUnwrapFinalized as Ct, DecryptErrorEvent as D, findRevokedDelegationForUserDecryption as Dt, DecryptEndEvent as E, findDelegatedForUserDecryption as Et, SetOperatorSubmittedEvent as F, DecryptValuesParameters as Ft, ZamaSDKEvent as G, TypedValue$1 as Gt, UnshieldPhase2StartedEvent as H, FhevmRelayerOptions as Ht, ShieldSubmittedEvent as I, EIP712TypedData as It, ZamaSDKEventType as J, ZamaSDKEventInput as K, TransactionErrorEvent as L, EncryptInput as Lt, EncryptStartEvent as M, TransactionResult as Mt, FinalizeUnwrapSubmittedEvent as N, ClearValue as Nt, DecryptStartEvent as O, findUnwrapRequested as Ot, RevokeDelegationSubmittedEvent as P, DecryptPublicValuesResult as Pt, ShieldPath as Q, TransactionOperation as R, EncryptParams as Rt, WriteFunctionName as S, decodeRevokedDelegationForUserDecryption as St, BaseEvent as T, decodeWrap as Tt, UnshieldPhase2SubmittedEvent as U, FhevmRelayerSDK as Ut, UnshieldPhase1SubmittedEvent as V, FhevmClient as Vt, UnwrapSubmittedEvent as W, RelayerOptions as Wt, ApprovalStrategy as X, ZamaSDKEvents as Y, ShieldOptions as Z, ReadContractConfig as _, decodeAclEvents as _t, ZamaConfigBase as a, AclEvent as at, WriteContractArgs as b, decodeOnChainEvent as bt, GenericStorage as c, DelegatedForUserDecryptionEvent as ct, WalletAccount as d, TOKEN_TOPICS as dt, UnshieldOptions as et, WalletAccountChange as f, Topics as ft, ReadContractArgs as g, decodeAclEvent as gt, ContractAbi as h, WrapEvent as ht, ZamaConfig as i, ACL_TOPICS as it, EncryptErrorEvent as j, TransactionReceipt as jt, DelegationSubmittedEvent as k, findWrap as kt, GenericProvider as l, OnChainEvent as lt, WalletAccountStore as m, UnwrapRequestedEvent as mt, RelayerConfig as n, TransferCallbacks as nt, ZamaConfigGeneric as o, AclTopics as ot, WalletAccountListener as p, UnwrapFinalizedEvent as pt, ZamaSDKEventListener as q, WebRelayerConfig as r, UnshieldCallbacks as rt, GenericLogger as s, ConfidentialTransferEvent as st, CleartextRelayerConfig as t, ShieldCallbacks as tt, GenericSigner as u, RevokedDelegationForUserDecryptionEvent as ut, ReadContractReturnType as v, decodeConfidentialTransfer as vt, ApproveUnderlyingSubmittedEvent as w, decodeUnwrapRequested as wt, WriteContractConfig as x, decodeOnChainEvents as xt, ReadFunctionName as y, decodeDelegatedForUserDecryption as yt, TransferFromSubmittedEvent as z, EncryptResult as zt };
+//# sourceMappingURL=types-C-WTLcHZ.d.ts.map