@zama-fhe/sdk 3.0.0-alpha.2 → 3.0.0-alpha.21

package/dist/esm/types-FY7ciI37.d.ts

@@ -0,0 +1,615 @@
+import { n as FheChain, t as AtLeastOneChain } from "./types-C1S426x4.js";
+import { A as GenericSigner, O as GenericStorage, P as RawLog, _ as UserDecryptParams, a as EIP712TypedData, c as EncryptResult, d as PublicDecryptResult, f as PublicKeyData, h as RelayerWebConfig, i as DelegatedUserDecryptParams, k as GenericProvider, l as Handle, n as RelayerSDK, p as PublicParamsData, r as ClearValueType, s as EncryptParams, t as RelayerCleartext, v as RelayerWorkerClient } from "./relayer-cleartext-DJkSUlZ2.js";
+import { Address, Hex } from "viem";
+import { InputProofBytesType, KeypairType, KmsDelegatedUserDecryptEIP712Type, ZKProofLike } from "@zama-fhe/relayer-sdk/bundle";
+
+//#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}`; /** `Wrapped(address indexed to, uint256 amountIn)` */
+  readonly Wrapped: `0x${string}`; /** `UnwrapRequested(address indexed receiver, bytes32 indexed unwrapRequestId, bytes32 amount)` */
+  readonly UnwrapRequested: `0x${string}`; /** `UnwrapRequested(address indexed receiver, bytes32 amount)` */
+  readonly UnwrapRequestedLegacy: `0x${string}`; /** `UnwrapFinalized(address indexed receiver, bytes32 indexed unwrapRequestId, bytes32 encryptedAmount, uint64 cleartextAmount)` */
+  readonly UnwrapFinalized: `0x${string}`; /** `UnwrapFinalized(address indexed receiver, bytes32 encryptedAmount, uint64 cleartextAmount)` */
+  readonly UnwrapFinalizedLegacy: `0x${string}`; /** @deprecated Use `Topics.UnwrapFinalized`. */
+  readonly UnwrappedFinalized: `0x${string}`; /** `UnwrappedStarted(bool returnVal, uint256 indexed requestId, ...)` */
+  readonly UnwrappedStarted: `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 ciphertext handle for the transferred amount. */
+  readonly encryptedAmountHandle: Handle;
+}
+/** Decoded `Wrapped` event — an ERC-20 shield (wrap) operation. */
+interface WrappedEvent {
+  readonly eventName: "Wrapped";
+  /** Receiver of the minted confidential tokens. */
+  readonly to: Address;
+  /** Underlying ERC-20 tokens deposited. */
+  readonly amountIn: bigint;
+}
+/** 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 ciphertext handle for the requested unshield amount. */
+  readonly encryptedAmount: Handle;
+  /** Request identifier emitted by upgraded wrapper contracts. */
+  readonly unwrapRequestId?: Handle;
+}
+/** Decoded `UnwrapFinalized` event — an unshield completed on-chain. */
+interface UnwrapFinalizedEvent {
+  readonly eventName: "UnwrapFinalized";
+  /** Address receiving the unwrapped ERC-20 tokens. */
+  readonly receiver: Address;
+  /** FHE ciphertext handle of the burnt confidential balance. */
+  readonly encryptedAmount: Handle;
+  /** Cleartext amount of underlying ERC-20 tokens returned. */
+  readonly cleartextAmount: bigint;
+  /** Request identifier emitted by upgraded wrapper contracts. */
+  readonly unwrapRequestId?: Handle;
+}
+/** @deprecated Use `UnwrapFinalizedEvent`. */
+interface UnwrappedFinalizedEvent {
+  readonly eventName: "UnwrappedFinalized";
+  readonly receiver: Address;
+  readonly encryptedAmount: Handle;
+  readonly cleartextAmount: bigint;
+  readonly unwrapRequestId?: Handle;
+}
+/** Decoded `UnwrappedStarted` event — the relayer began processing an unshield. */
+interface UnwrappedStartedEvent {
+  readonly eventName: "UnwrappedStarted";
+  /** Whether the unwrap start succeeded. */
+  readonly returnVal: boolean;
+  /** On-chain request ID. */
+  readonly requestId: bigint;
+  /** On-chain transaction ID. */
+  readonly txId: bigint;
+  /** Receiver address. */
+  readonly to: Address;
+  /** Refund address (if applicable). */
+  readonly refund: Address;
+  /** FHE handle of the requested amount. */
+  readonly requestedAmount: Handle;
+  /** FHE handle of the burn amount. */
+  readonly burnAmount: Handle;
+}
+/** Union of all decoded confidential token event types. */
+type OnChainEvent = ConfidentialTransferEvent | WrappedEvent | UnwrapRequestedEvent | UnwrapFinalizedEvent | UnwrappedFinalizedEvent | UnwrappedStartedEvent;
+/**
+ * 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;
+/**
+ * Wrapped(address indexed to, uint256 amountIn)
+ * Indexed: to (topics[1])
+ * Data: amountIn (uint256)
+ */
+declare function decodeWrapped(log: RawLog): WrappedEvent | null;
+/**
+ * UnwrapRequested(address indexed receiver, bytes32 amount)
+ * UnwrapRequested(address indexed receiver, bytes32 indexed unwrapRequestId, bytes32 amount)
+ */
+declare function decodeUnwrapRequested(log: RawLog): UnwrapRequestedEvent | null;
+/**
+ * UnwrapFinalized(address indexed receiver, bytes32 encryptedAmount, uint64 cleartextAmount)
+ * UnwrapFinalized(address indexed receiver, bytes32 indexed unwrapRequestId, bytes32 encryptedAmount, uint64 cleartextAmount)
+ */
+declare function decodeUnwrapFinalized(log: RawLog): UnwrapFinalizedEvent | null;
+/** @deprecated Use `decodeUnwrapFinalized`. */
+declare function decodeUnwrappedFinalized(log: RawLog): UnwrappedFinalizedEvent | null;
+/**
+ * UnwrappedStarted(bool returnVal, uint256 indexed requestId, uint256 indexed txId, address indexed to,
+ *                  address refund, bytes32 requestedAmount, bytes32 burnAmount)
+ * Indexed: requestId (topics[1]), txId (topics[2]), to (topics[3])
+ * Data: returnVal, refund, requestedAmount, burnAmount
+ */
+declare function decodeUnwrappedStarted(log: RawLog): UnwrappedStartedEvent | 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 WrappedEvent} in a logs array.
+ *
+ * @example
+ * ```ts
+ * const event = findWrapped(receipt.logs);
+ * if (event) console.log(event.to, event.amountIn);
+ * ```
+ */
+declare function findWrapped(logs: readonly RawLog[]): WrappedEvent | 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}`, `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/events/sdk-events.d.ts
+/**
+ * All SDK event keys, accessible as `ZamaSDKEvents.EncryptStart` etc.
+ */
+declare const ZamaSDKEvents: {
+  readonly CredentialsLoading: "credentials:loading";
+  readonly CredentialsCached: "credentials:cached";
+  readonly CredentialsExpired: "credentials:expired";
+  readonly CredentialsCreating: "credentials:creating";
+  readonly CredentialsCreated: "credentials:created";
+  readonly CredentialsRevoked: "credentials:revoked";
+  readonly CredentialsPersistFailed: "credentials:persist_failed";
+  readonly CredentialsAllowed: "credentials:allowed";
+  readonly CredentialsCorrupted: "credentials:corrupted";
+  readonly SessionExpired: "session:expired";
+  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 ApproveSubmitted: "approve: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 CredentialsLoadingEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.CredentialsLoading;
+  /** Contract addresses being requested. */
+  contractAddresses?: Address[];
+}
+interface CredentialsCachedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.CredentialsCached;
+  /** Contract addresses covered by the cached credentials. */
+  contractAddresses?: Address[];
+}
+interface CredentialsExpiredEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.CredentialsExpired;
+  /** Contract addresses that need re-authorization. */
+  contractAddresses?: Address[];
+}
+interface CredentialsCreatingEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.CredentialsCreating;
+  /** Contract addresses being authorized. */
+  contractAddresses?: Address[];
+}
+interface CredentialsCreatedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.CredentialsCreated;
+  /** Contract addresses covered by the new credentials. */
+  contractAddresses?: Address[];
+}
+interface CredentialsRevokedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.CredentialsRevoked;
+  contractAddresses?: Address[];
+}
+interface CredentialsPersistFailedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.CredentialsPersistFailed;
+  /** The error that caused the persist failure. */
+  error: Error;
+}
+interface CredentialsAllowedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.CredentialsAllowed;
+  /** Contract addresses covered by the authorized credentials. */
+  contractAddresses?: Address[];
+}
+interface CredentialsCorruptedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.CredentialsCorrupted;
+  /** The error that revealed storage corruption. */
+  error: Error;
+}
+interface SessionExpiredEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.SessionExpired;
+  /** Why the session expired. Currently always `"ttl"`, extensible for future inactivity timeout. */
+  reason: "ttl";
+}
+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;
+  /** Handles being decrypted — correlate with matching DecryptEnd/DecryptError. */
+  handles: Handle[];
+}
+interface DecryptEndEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.DecryptEnd;
+  durationMs: number;
+  /** Handles that were decrypted. */
+  handles: Handle[];
+  /** Decrypted values keyed by handle — use this to correlate events to specific handles. */
+  result: Record<Handle, ClearValueType>;
+}
+interface DecryptErrorEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.DecryptError;
+  /** The error that caused the decryption to fail. */
+  error: Error;
+  durationMs: number;
+  /** Handles that were being decrypted when the error occurred. */
+  handles: Handle[];
+}
+interface TransactionErrorEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.TransactionError;
+  /** Which write operation failed. */
+  operation: string;
+  /** The error that caused the transaction to fail. */
+  error: Error;
+}
+interface ShieldSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.ShieldSubmitted;
+  txHash: Hex;
+}
+interface TransferSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.TransferSubmitted;
+  txHash: Hex;
+}
+interface TransferFromSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.TransferFromSubmitted;
+  txHash: Hex;
+}
+interface ApproveSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.ApproveSubmitted;
+  txHash: Hex;
+}
+interface ApproveUnderlyingSubmittedEvent extends BaseEvent {
+  type: typeof ZamaSDKEvents.ApproveUnderlyingSubmitted;
+  txHash: Hex;
+}
+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 handles and decrypted clear-text values so event
+ * subscribers can correlate and bind them in UI layers. Events never carry
+ * private keys, session signatures, or ZK proofs.
+ */
+type ZamaSDKEvent = CredentialsLoadingEvent | CredentialsCachedEvent | CredentialsExpiredEvent | CredentialsCreatingEvent | CredentialsCreatedEvent | CredentialsRevokedEvent | CredentialsPersistFailedEvent | CredentialsAllowedEvent | CredentialsCorruptedEvent | SessionExpiredEvent | EncryptStartEvent | EncryptEndEvent | EncryptErrorEvent | DecryptStartEvent | DecryptEndEvent | DecryptErrorEvent | TransactionErrorEvent | ShieldSubmittedEvent | TransferSubmittedEvent | TransferFromSubmittedEvent | ApproveSubmittedEvent | 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;
+//#endregion
+//#region src/relayer/relayer-dispatcher.d.ts
+/** Anything with a synchronous `terminate()` method (workers, pools). */
+interface WorkerLike {
+  terminate(): void;
+}
+/**
+ * Owns chain management (chains / activeChain / switchChain) and delegates
+ * every {@link RelayerSDK} operation to the relayer for the currently active
+ * chain.
+ *
+ * Groups chains by relayer config reference identity, calls `createWorker`
+ * once per group with all chain configs, then calls `createRelayer`
+ * per chain with the shared worker.
+ *
+ * Workers/pools are held separately from relayers so the dispatcher can
+ * terminate them directly — relayers never own worker lifecycle.
+ */
+declare class RelayerDispatcher implements RelayerSDK, Disposable {
+  #private;
+  constructor(chains: readonly [FheChain, ...FheChain[]], configs: Readonly<Record<number, RelayerConfig>>);
+  get chains(): readonly FheChain[];
+  get chain(): FheChain;
+  switchChain(chainId: number): void;
+  generateKeypair(): Promise<KeypairType<Hex>>;
+  createEIP712(publicKey: Hex, contractAddresses: Address[], startTimestamp: number, durationDays?: number): Promise<EIP712TypedData>;
+  encrypt(params: EncryptParams): Promise<EncryptResult>;
+  userDecrypt(params: UserDecryptParams): Promise<Readonly<Record<Handle, ClearValueType>>>;
+  publicDecrypt(handles: Handle[]): Promise<PublicDecryptResult>;
+  createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise<KmsDelegatedUserDecryptEIP712Type>;
+  delegatedUserDecrypt(params: DelegatedUserDecryptParams): Promise<Readonly<Record<Handle, ClearValueType>>>;
+  requestZKProofVerification(zkProof: ZKProofLike): Promise<InputProofBytesType>;
+  getPublicKey(): Promise<PublicKeyData | null>;
+  getPublicParams(bits: number): Promise<PublicParamsData | null>;
+  getAclAddress(): Promise<Address>;
+  terminate(): void;
+  [Symbol.dispose](): void;
+}
+//#endregion
+//#region src/relayer/base-relayer.d.ts
+declare abstract class BaseRelayer {
+  #private;
+  protected abstract readonly chain: FheChain;
+  protected abstract init(): Promise<void>;
+  protected ensureInit(): Promise<void>;
+  protected resetInit(): void;
+  getAclAddress(): Promise<Address>;
+}
+//#endregion
+//#region src/relayer/relayer-web.d.ts
+/**
+ * RelayerWeb — single-chain browser encryption/decryption layer.
+ * The worker is injected at construction time; the relayer does not own its lifecycle.
+ */
+declare class RelayerWeb extends BaseRelayer implements RelayerSDK, Disposable {
+  #private;
+  constructor(config: RelayerWebConfig);
+  protected get chain(): FheChain;
+  protected init(): Promise<void>;
+  /**
+   * Terminate clears the artifact cache only.
+   * The worker is externally owned — the relayer does not terminate it.
+   */
+  terminate(): void;
+  /** Calls {@link terminate}. */
+  [Symbol.dispose](): void;
+  /**
+   * Generate a keypair for FHE operations.
+   */
+  generateKeypair(): Promise<KeypairType<Hex>>;
+  /**
+   * Create EIP712 typed data for user decryption authorization.
+   */
+  createEIP712(publicKey: Hex, contractAddresses: Address[], startTimestamp: number, durationDays?: number): Promise<EIP712TypedData>;
+  /**
+   * Encrypt values for use in smart contract calls.
+   * Each value must specify its FHE type (ebool, euint8–256, eaddress).
+   */
+  encrypt(params: EncryptParams): Promise<EncryptResult>;
+  /**
+   * Decrypt ciphertexts using user's private key.
+   * Requires a valid EIP712 signature.
+   */
+  userDecrypt(params: UserDecryptParams): Promise<Readonly<Record<Handle, ClearValueType>>>;
+  /**
+   * Public decryption - no authorization needed.
+   * Used for publicly visible encrypted values.
+   */
+  publicDecrypt(handles: Handle[]): Promise<PublicDecryptResult>;
+  /**
+   * Create EIP712 typed data for delegated user decryption authorization.
+   */
+  createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise<KmsDelegatedUserDecryptEIP712Type>;
+  /**
+   * Decrypt ciphertexts via delegation.
+   * Requires a valid EIP712 signature from the delegator.
+   */
+  delegatedUserDecrypt(params: DelegatedUserDecryptParams): Promise<Readonly<Record<Handle, ClearValueType>>>;
+  /**
+   * Submit a ZK proof to the relayer for verification.
+   */
+  requestZKProofVerification(zkProof: ZKProofLike): Promise<InputProofBytesType>;
+  /**
+   * Get the TFHE compact public key.
+   * When storage is configured, the result is cached persistently.
+   */
+  getPublicKey(): Promise<PublicKeyData | null>;
+  /**
+   * Get public parameters for encryption capacity.
+   * When storage is configured, the result is cached persistently.
+   */
+  getPublicParams(bits: number): Promise<PublicParamsData | null>;
+}
+//#endregion
+//#region src/config/types.d.ts
+/** Options for web() relayer (threads, security, logger, storage). */
+type WebRelayerOptions = Partial<Pick<RelayerWebConfig, "threads" | "security" | "logger">>;
+/**
+ * Base relayer config.
+ *
+ * Groups chains by config reference identity, calls `createWorker`
+ * once per group with all chain configs, then calls `createRelayer`
+ * per chain with the shared worker.
+ */
+interface RelayerConfig {
+  readonly type: string;
+  /** Create a shared worker/pool for all chains in this relayer group. */
+  readonly createWorker?: (chains: FheChain[]) => any;
+  /** Create a single-chain relayer. `worker` is the return value of `createWorker`. */
+  readonly createRelayer: (chain: FheChain, worker: any) => RelayerSDK;
+}
+/** Web relayer config — narrows worker type to `RelayerWorkerClient`. */
+interface WebRelayerConfig extends RelayerConfig {
+  readonly type: "web";
+  readonly createWorker: (chains: FheChain[]) => RelayerWorkerClient;
+  readonly createRelayer: (chain: FheChain, worker: RelayerWorkerClient) => RelayerWeb;
+}
+/** Cleartext relayer config — no worker, returns `RelayerCleartext`. */
+interface CleartextRelayerConfig extends RelayerConfig {
+  readonly type: "cleartext";
+  readonly createRelayer: (chain: FheChain, worker: unknown) => RelayerCleartext;
+}
+/** 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;
+  /** Session storage. Default: IndexedDB in browser, memory in Node. */
+  sessionStorage?: GenericStorage;
+  /** ML-KEM keypair TTL in seconds. Default: 2592000 (30 days). */
+  keypairTTL?: number;
+  /** Session signature TTL in seconds. Default: 2592000 (30 days). */
+  sessionTTL?: number | "infinite";
+  /** Registry cache TTL in seconds. Default: 86400 (24h). */
+  registryTTL?: number;
+  /** SDK lifecycle event listener. */
+  onEvent?: ZamaSDKEventListener;
+}
+/** Generic config — pass any {@link GenericSigner} and {@link GenericProvider} directly. */
+interface ZamaConfigGeneric<TChains extends AtLeastOneChain = AtLeastOneChain> extends ZamaConfigBase<TChains> {
+  signer: GenericSigner;
+  provider: GenericProvider;
+}
+/** Resolved config object returned by `createConfig`. */
+interface ZamaConfig {
+  readonly chains: readonly FheChain[];
+  readonly relayer: RelayerDispatcher;
+  readonly provider: GenericProvider;
+  readonly signer: GenericSigner;
+  readonly storage: GenericStorage;
+  readonly sessionStorage: GenericStorage;
+  readonly keypairTTL: number | undefined;
+  readonly sessionTTL: number | "infinite" | undefined;
+  readonly registryTTL: number | undefined;
+  readonly onEvent: ZamaSDKEventListener | undefined;
+}
+//#endregion
+export { RevokedDelegationForUserDecryptionEvent as $, EncryptStartEvent as A, UnshieldPhase2SubmittedEvent as B, CredentialsRevokedEvent as C, DelegationSubmittedEvent as D, DecryptStartEvent as E, TransactionErrorEvent as F, ZamaSDKEventType as G, ZamaSDKEvent as H, TransferFromSubmittedEvent as I, AclEvent as J, ZamaSDKEvents as K, TransferSubmittedEvent as L, RevokeDelegationSubmittedEvent as M, SessionExpiredEvent as N, EncryptEndEvent as O, ShieldSubmittedEvent as P, OnChainEvent as Q, UnshieldPhase1SubmittedEvent as R, CredentialsPersistFailedEvent as S, findWrapped as St, DecryptErrorEvent as T, ZamaSDKEventInput as U, UnwrapSubmittedEvent as V, ZamaSDKEventListener as W, ConfidentialTransferEvent as X, AclTopics as Y, DelegatedForUserDecryptionEvent as Z, CredentialsCorruptedEvent as _, decodeUnwrappedStarted as _t, ZamaConfig as a, UnwrappedStartedEvent as at, CredentialsExpiredEvent as b, findRevokedDelegationForUserDecryption as bt, RelayerWeb as c, decodeAclEvents as ct, WorkerLike as d, decodeOnChainEvent as dt, TOKEN_TOPICS as et, ApproveSubmittedEvent as f, decodeOnChainEvents as ft, CredentialsCachedEvent as g, decodeUnwrappedFinalized as gt, CredentialsAllowedEvent as h, decodeUnwrapRequested as ht, WebRelayerOptions as i, UnwrappedFinalizedEvent as it, FinalizeUnwrapSubmittedEvent as j, EncryptErrorEvent as k, BaseRelayer as l, decodeConfidentialTransfer as lt, BaseEvent as m, decodeUnwrapFinalized as mt, RelayerConfig as n, UnwrapFinalizedEvent as nt, ZamaConfigBase as o, WrappedEvent as ot, ApproveUnderlyingSubmittedEvent as p, decodeRevokedDelegationForUserDecryption as pt, ACL_TOPICS as q, WebRelayerConfig as r, UnwrapRequestedEvent as rt, ZamaConfigGeneric as s, decodeAclEvent as st, CleartextRelayerConfig as t, Topics as tt, RelayerDispatcher as u, decodeDelegatedForUserDecryption as ut, CredentialsCreatedEvent as v, decodeWrapped as vt, DecryptEndEvent as w, CredentialsLoadingEvent as x, findUnwrapRequested as xt, CredentialsCreatingEvent as y, findDelegatedForUserDecryption as yt, UnshieldPhase2StartedEvent as z };
+//# sourceMappingURL=types-FY7ciI37.d.ts.map