@zama-fhe/sdk 3.2.0 → 3.3.0-alpha.10

package/dist/esm/{index-DoVo9J1n.d.ts → index-C1Mtc8Rw.d.ts}

@@ -1,6 +1,6 @@
 import { n as FheChain } from "./types-BgczXqW2.js";
-import { A as TransferCallbacks, D as TransferOptions, F as WalletAccount, J as WriteContractConfig, L as WalletAccountListener, M as GenericStorage, N as GenericProvider, O as UnshieldOptions, P as GenericSigner, T as ShieldOptions, V as TransactionResult, a as StoredTransportKeyPairWithPermits, d as EncryptParams, f as EncryptResult, ft as GenericLogger, g as PublicDecryptResult, j as UnshieldCallbacks, p as EncryptedValue, s as ClearValue } from "./relayer-cleartext-DkKKjfI6.js";
-import { E as TransactionOperation, P as ZamaSDKEventInput, a as ZamaConfig, n as RelayerConfig, s as ZamaConfigGeneric, u as RelayerDispatcher } from "./types-BjDu-RZg.js";
+import { E as ShieldOptions, F as GenericSigner, H as TransactionResult, I as WalletAccount, M as UnshieldCallbacks, N as GenericStorage, O as TransferOptions, P as GenericProvider, R as WalletAccountListener, Y as WriteContractConfig, a as StoredTransportKeyPairWithPermits, d as EncryptParams, f as EncryptResult, g as PublicDecryptResult, j as TransferCallbacks, k as UnshieldOptions, p as EncryptedValue, pt as GenericLogger, s as ClearValue } from "./relayer-cleartext-CSeMlmGO.js";
+import { E as TransactionOperation, P as ZamaSDKEventInput, a as ZamaConfig, n as RelayerConfig, s as ZamaConfigGeneric, u as RelayerDispatcher } from "./types-Gn5MeDsr.js";
 import { Address, Hex } from "viem";
 import { z } from "zod/mini";
 import { UserDecryptResults } from "@zama-fhe/relayer-sdk/bundle";
@@ -18567,6 +18567,12 @@ declare const zamaQueryKeys: {
       readonly tokenAddress: `0x${string}`;
     }];
   };
+  readonly pendingUnshield: {
+    readonly all: readonly ["zama.pendingUnshield"];
+    readonly token: (tokenAddress: Address) => readonly ["zama.pendingUnshield", {
+      readonly tokenAddress: `0x${string}`;
+    }];
+  };
   readonly hasPermit: {
     readonly all: readonly ["zama.hasPermit"];
     readonly scope: (contractAddresses: Address[], walletAccount?: WalletAccount) => readonly ["zama.hasPermit", {
@@ -18791,7 +18797,11 @@ declare const ZamaErrorCode: {
   readonly TransportKeyPairExpired: "KEYPAIR_EXPIRED"; /** Relayer rejected transport key pair (stale, expired, or malformed). */
   readonly InvalidTransportKeyPair: "INVALID_KEYPAIR"; /** No FHE ciphertext exists for this account (never shielded). */
   readonly NoCiphertext: "NO_CIPHERTEXT"; /** Relayer HTTP request failed. */
-  readonly RelayerRequestFailed: "RELAYER_REQUEST_FAILED"; /** SDK configuration is invalid (e.g. forbidden chain ID, unsupported type). */
+  readonly RelayerRequestFailed: "RELAYER_REQUEST_FAILED"; /** The configured signer/account is not entitled (ACL) to decrypt this encrypted value. Don't retry — wait for a grant. */
+  readonly NotEntitled: "NOT_ENTITLED"; /** The consumer's RPC provider rate-limited an on-chain read (e.g. HTTP 429 / JSON-RPC -32005). Retryable. */
+  readonly RpcRateLimited: "RPC_RATE_LIMITED"; /** A worker operation exceeded its configured timeout; the worker is recycled by default. Retryable. */
+  readonly OperationTimeout: "OPERATION_TIMEOUT"; /** An in-flight worker operation was aborted as collateral of another operation's timeout recycle. Retryable. */
+  readonly WorkerRecycled: "WORKER_RECYCLED"; /** SDK configuration is invalid (e.g. forbidden chain ID, unsupported type). */
   readonly Configuration: "CONFIGURATION"; /** Delegation cannot target self (delegate === msg.sender). */
   readonly DelegationSelfNotAllowed: "DELEGATION_SELF_NOT_ALLOWED"; /** Only one delegate/revoke per (delegator, delegate, contract) per block. */
   readonly DelegationCooldown: "DELEGATION_COOLDOWN"; /** No active delegation found for this (delegator, delegate, contract) tuple. */
@@ -18824,75 +18834,6 @@ declare class ZamaError extends Error {
   readonly code: ZamaErrorCode;
   constructor(code: ZamaErrorCode, message: string, options?: ErrorOptions);
 }
-/**
- * Pattern-match on a {@link ZamaError} by its error code.
- * Falls through to the `_` wildcard handler if no specific handler matches.
- * Returns `undefined` if the error is not a `ZamaError` and no `_` handler is provided.
- *
- * @example
- * ```ts
- * matchZamaError(error, {
- *   SIGNING_REJECTED: () => toast("Please approve in wallet"),
- *   TRANSACTION_REVERTED: (e) => toast(`Tx failed: ${e.message}`),
- *   _: () => toast("Unknown error"),
- * });
- * ```
- */
-declare function matchZamaError<R>(error: unknown, handlers: Partial<Record<ZamaErrorCode, (error: ZamaError) => R>> & {
-  _?: (error: unknown) => R;
-}): R | undefined;
-//#endregion
-//#region src/errors/signing.d.ts
-/** User rejected the wallet signature prompt. */
-declare class SigningRejectedError extends ZamaError {
-  constructor(message: string, options?: ErrorOptions);
-}
-/** Wallet signature failed for a reason other than rejection. */
-declare class SigningFailedError extends ZamaError {
-  constructor(message: string, options?: ErrorOptions);
-}
-//#endregion
-//#region src/errors/encryption.d.ts
-/** FHE encryption failed. */
-declare class EncryptionFailedError extends ZamaError {
-  constructor(message: string, options?: ErrorOptions);
-}
-/** FHE decryption failed. */
-declare class DecryptionFailedError extends ZamaError {
-  constructor(message: string, options?: ErrorOptions);
-}
-//#endregion
-//#region src/errors/transaction.d.ts
-/** On-chain transaction reverted. */
-declare class TransactionRevertedError extends ZamaError {
-  constructor(message: string, options?: ErrorOptions);
-}
-//#endregion
-//#region src/errors/credential.d.ts
-/** Transport key pair has expired and needs regeneration. */
-declare class TransportKeyPairExpiredError extends ZamaError {
-  constructor(message: string, options?: ErrorOptions);
-}
-/** Relayer rejected the transport key pair (stale, expired, or malformed). */
-declare class InvalidTransportKeyPairError extends ZamaError {
-  constructor(message: string, options?: ErrorOptions);
-}
-/** No FHE ciphertext exists for this account (never shielded). */
-declare class NoCiphertextError extends ZamaError {
-  constructor(message: string, options?: ErrorOptions);
-}
-//#endregion
-//#region src/errors/relayer.d.ts
-/** Relayer HTTP request failed. */
-declare class RelayerRequestFailedError extends ZamaError {
-  /** HTTP status code from the relayer, if available. */
-  readonly statusCode: number | undefined;
-  constructor(message: string, statusCode?: number, options?: ErrorOptions);
-}
-/** SDK configuration is invalid (e.g. forbidden chain ID, unsupported type). */
-declare class ConfigurationError extends ZamaError {
-  constructor(message: string, options?: ErrorOptions);
-}
 //#endregion
 //#region src/errors/chain.d.ts
 /**
@@ -18931,41 +18872,18 @@ declare class ChainMismatchError extends ZamaError {
   }, options?: ErrorOptions);
 }
 //#endregion
-//#region src/errors/signer.d.ts
-/**
- * Base class for signer/account readiness failures.
- */
-declare class SignerRequiredError extends ZamaError {
-  readonly operation: string;
-  constructor(code: ZamaErrorCode, operation: string, message: string, options?: ErrorOptions);
-}
-/**
- * Thrown when an operation requires a signer but none is configured.
- *
- * The SDK can be constructed without a signer. Operations that need wallet
- * authority throw this before probing wallet state.
- *
- * @example
- * ```ts
- * try {
- *   await token.confidentialTransfer("0xTo", 100n);
- * } catch (e) {
- *   if (e instanceof SignerNotConfiguredError) {
- *     // Fix SDK/provider configuration.
- *   }
- * }
- * ```
- */
-declare class SignerNotConfiguredError extends SignerRequiredError {
-  constructor(operation: string, options?: ErrorOptions);
+//#region src/errors/credential.d.ts
+/** Transport key pair has expired and needs regeneration. */
+declare class TransportKeyPairExpiredError extends ZamaError {
+  constructor(message: string, options?: ErrorOptions);
 }
-/** Thrown when a signer exists but no wallet account is currently connected. */
-declare class WalletNotConnectedError extends SignerRequiredError {
-  constructor(operation: string, options?: ErrorOptions);
+/** Relayer rejected the transport key pair (stale, expired, or malformed). */
+declare class InvalidTransportKeyPairError extends ZamaError {
+  constructor(message: string, options?: ErrorOptions);
 }
-/** Thrown when an async adapter has not resolved its initial wallet account yet. */
-declare class WalletAccountNotReadyError extends SignerRequiredError {
-  constructor(operation: string, options?: ErrorOptions);
+/** No FHE ciphertext exists for this account (never shielded). */
+declare class NoCiphertextError extends ZamaError {
+  constructor(message: string, options?: ErrorOptions);
 }
 //#endregion
 //#region src/errors/delegation.d.ts
@@ -19010,12 +18928,19 @@ declare class DelegationExpirationTooSoonError extends ZamaError {
  *
  * After calling `delegateForUserDecryption()`, the delegation is recorded on-chain
  * immediately. However, the gateway (deployed on Arbitrum) must sync this state
- * via cross-chain event propagation, which typically takes 1–2 minutes.
+ * via cross-chain event propagation, which usually completes within ~10 blocks
+ * (a few seconds).
  *
  * Calling `decryptBalanceAs` during this window will fail because the gateway's
  * `isHandleDelegatedForUserDecryption()` check reads from its own synced copy
  * of the ACL state, which hasn't been updated yet.
  *
+ * **You rarely need to handle this directly:** the delegated-decrypt path rides
+ * out the propagation window with a bounded internal retry (~30s), so a decrypt
+ * issued right after the grant simply waits for sync. This error only surfaces
+ * if the window outlasts the retry budget, or when retries are disabled via
+ * `waitForPropagation: false`.
+ *
  * **Note:** This error is raised as a best-effort heuristic — when a delegated
  * decryption receives an HTTP 500 from the relayer, the most likely cause is a
  * propagation delay. However, the same status code can occur if the gateway or
@@ -19025,6 +18950,16 @@ declare class DelegationNotPropagatedError extends ZamaError {
   constructor(message: string, options?: ErrorOptions);
 }
 //#endregion
+//#region src/errors/encryption.d.ts
+/** FHE encryption failed. */
+declare class EncryptionFailedError extends ZamaError {
+  constructor(message: string, options?: ErrorOptions);
+}
+/** FHE decryption failed. */
+declare class DecryptionFailedError extends ZamaError {
+  constructor(message: string, options?: ErrorOptions);
+}
+//#endregion
 //#region src/errors/balance.d.ts
 /** Structured details shared by balance-related errors. */
 interface BalanceErrorDetails {
@@ -19061,6 +18996,294 @@ declare class ERC20ReadFailedError extends ZamaError {
   constructor(message: string, options?: ErrorOptions);
 }
 //#endregion
+//#region src/errors/relayer.d.ts
+/** Relayer HTTP request failed. */
+declare class RelayerRequestFailedError extends ZamaError {
+  /** HTTP status code from the relayer, if available. */
+  readonly statusCode: number | undefined;
+  /**
+   * Server-driven retry delay in **seconds** (the SDK's duration unit and the
+   * header's own unit), from the relayer's `Retry-After` header. Set only on
+   * back-pressure (HTTP 429) responses that carry the header; `undefined`
+   * otherwise. Implies {@link retryable}.
+   */
+  readonly retryAfter: number | undefined;
+  /**
+   * Whether the request may be safely retried. `true` for relayer back-pressure
+   * (HTTP 429); pair with {@link retryAfter} for the server's suggested delay.
+   */
+  readonly retryable: boolean;
+  constructor(message: string, statusCode?: number, options?: ErrorOptions & {
+    retryAfter?: number;
+  });
+}
+/** SDK configuration is invalid (e.g. forbidden chain ID, unsupported type). */
+declare class ConfigurationError extends ZamaError {
+  constructor(message: string, options?: ErrorOptions);
+}
+//#endregion
+//#region src/errors/entitlement.d.ts
+/**
+ * The signer (or delegator) lacks ACL permission to decrypt the encrypted value —
+ * `persistAllowed` returned `false`. Terminal and **non-retryable**: the fix is
+ * an on-chain grant (`FHE.allow`), or for indexers, to wait for a backfill once
+ * the grant lands. Distinct from transient failures like {@link RpcRateLimitError}.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await sdk.decryption.decryptValues([{ encryptedValue, contractAddress }]);
+ * } catch (e) {
+ *   if (e instanceof NotEntitledError) {
+ *     // don't retry — wait for an ACL grant / backfill
+ *   }
+ * }
+ * ```
+ */
+declare class NotEntitledError extends ZamaError {
+  /** The encrypted value the actor is not entitled to decrypt. */
+  readonly encryptedValue: string;
+  /** The contract the encrypted value belongs to. */
+  readonly contractAddress: string;
+  /** The actor (signer or delegator) that lacks ACL permission. */
+  readonly account: string;
+  constructor(args: {
+    encryptedValue: string;
+    contractAddress: string;
+    account: string;
+  }, options?: ErrorOptions);
+}
+//#endregion
+//#region src/errors/rpc.d.ts
+/**
+ * The consumer's RPC provider rate-limited an on-chain read the SDK performs
+ * during decryption (e.g. the ACL check) — HTTP 429 or JSON-RPC `-32005`. An
+ * RPC-endpoint problem, **not** a decryption/entitlement failure, and safe to
+ * **retry**. Kept distinct from the relayer's own back-pressure
+ * ({@link RelayerRequestFailedError}).
+ *
+ * Backoff for chain RPC is owned by the consumer's transport: viem/ethers
+ * already honor the `Retry-After` header and retry internally before this error
+ * surfaces, so it is configured on the transport you pass via `chain.network`
+ * (not re-implemented here).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await sdk.decryption.decryptValues([{ encryptedValue, contractAddress }]);
+ * } catch (e) {
+ *   if (e instanceof RpcRateLimitError) {
+ *     // back off and retry; consider a higher-throughput RPC endpoint
+ *   }
+ * }
+ * ```
+ */
+declare class RpcRateLimitError extends ZamaError {
+  /**
+   * Suggested delay before retrying, in **seconds**, when a numeric `retryAfter`
+   * is present on the error. Usually `undefined` for chain RPC: the `Retry-After`
+   * header is consumed by the consumer's viem/ethers transport (which owns the
+   * backoff), not surfaced here — see the class doc.
+   */
+  readonly retryAfter: number | undefined;
+  constructor(message: string, options?: ErrorOptions & {
+    retryAfter?: number;
+  });
+}
+//#endregion
+//#region src/errors/signer.d.ts
+/**
+ * Base class for signer/account readiness failures.
+ */
+declare class SignerRequiredError extends ZamaError {
+  readonly operation: string;
+  constructor(code: ZamaErrorCode, operation: string, message: string, options?: ErrorOptions);
+}
+/**
+ * Thrown when an operation requires a signer but none is configured.
+ *
+ * The SDK can be constructed without a signer. Operations that need wallet
+ * authority throw this before probing wallet state.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await token.confidentialTransfer("0xTo", 100n);
+ * } catch (e) {
+ *   if (e instanceof SignerNotConfiguredError) {
+ *     // Fix SDK/provider configuration.
+ *   }
+ * }
+ * ```
+ */
+declare class SignerNotConfiguredError extends SignerRequiredError {
+  constructor(operation: string, options?: ErrorOptions);
+}
+/** Thrown when a signer exists but no wallet account is currently connected. */
+declare class WalletNotConnectedError extends SignerRequiredError {
+  constructor(operation: string, options?: ErrorOptions);
+}
+/** Thrown when an async adapter has not resolved its initial wallet account yet. */
+declare class WalletAccountNotReadyError extends SignerRequiredError {
+  constructor(operation: string, options?: ErrorOptions);
+}
+//#endregion
+//#region src/errors/signing.d.ts
+/** User rejected the wallet signature prompt. */
+declare class SigningRejectedError extends ZamaError {
+  constructor(message: string, options?: ErrorOptions);
+}
+/** Wallet signature failed for a reason other than rejection. */
+declare class SigningFailedError extends ZamaError {
+  constructor(message: string, options?: ErrorOptions);
+}
+//#endregion
+//#region src/errors/transaction.d.ts
+/** On-chain transaction reverted. */
+declare class TransactionRevertedError extends ZamaError {
+  constructor(message: string, options?: ErrorOptions);
+}
+//#endregion
+//#region src/errors/timeout.d.ts
+/**
+ * A worker operation (encrypt / decrypt / EIP-712 / key fetch) did not complete
+ * within its configured timeout — typically a stuck relayer or WASM call. On the
+ * Node pool the SDK **recycles the affected worker** (terminating the hung
+ * thread) so it self-heals; the operation itself is **retryable**.
+ *
+ * Configure the bound (seconds) via `node({ operationTimeout })`. Distinct from a
+ * decryption/entitlement failure — a timeout is an infrastructure/latency
+ * condition, so it no longer collapses into {@link DecryptionFailedError}.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await sdk.decryption.decryptValues([{ encryptedValue, contractAddress }]);
+ * } catch (e) {
+ *   if (e instanceof WorkerTimeoutError) {
+ *     // retry (the worker was recycled); consider raising operationTimeout
+ *   }
+ * }
+ * ```
+ */
+declare class WorkerTimeoutError extends ZamaError {
+  /**
+   * The worker operation that timed out. This is the internal worker op code
+   * (e.g. `USER_DECRYPT`, `ENCRYPT`), not the public SDK method name.
+   */
+  readonly operation: string;
+  /** The configured timeout that was exceeded, in **seconds** (the SDK's duration unit). */
+  readonly timeout: number;
+  /** Wall-clock time the operation ran before being abandoned, in **seconds** (may be fractional). */
+  readonly elapsed: number;
+  /** Label of the worker that stalled, when known (e.g. `node-worker-2`). */
+  readonly worker: string | undefined;
+  constructor(args: {
+    operation: string;
+    timeout: number;
+    elapsed: number;
+    worker?: string;
+  }, options?: ErrorOptions);
+}
+/**
+ * An in-flight worker operation was aborted as **collateral** when its worker was
+ * recycled — the worker was torn down to recover from *another* operation's
+ * timeout (Node pool self-healing), not because this operation itself timed out.
+ *
+ * The operation never reached a verdict, so it is **retryable**: the next call
+ * lazily re-inits a fresh worker. It is intentionally distinct from
+ * {@link WorkerTimeoutError} (this op did not exceed its own bound) and from
+ * {@link DecryptionFailedError} (nothing actually failed to decrypt) — so a
+ * consumer can retry it instead of surfacing a terminal failure.
+ *
+ * @example
+ * ```ts
+ * matchZamaError(error, {
+ *   WORKER_RECYCLED: () => retry(), // transient: the worker was replaced
+ * });
+ * ```
+ */
+declare class WorkerRecycledError extends ZamaError {
+  /**
+   * The worker operation that was aborted. This is the internal worker op code
+   * (e.g. `USER_DECRYPT`, `ENCRYPT`), not the public SDK method name.
+   */
+  readonly operation: string;
+  /** Label of the recycled worker, when known (e.g. `node-worker-2`). */
+  readonly worker: string | undefined;
+  constructor(args: {
+    operation: string;
+    worker?: string;
+  }, options?: ErrorOptions);
+}
+//#endregion
+//#region src/errors/match.d.ts
+/**
+ * Identity type that fails to instantiate unless `T` maps every code to a `ZamaError`.
+ * Guards presence + value type only: a wrong-but-valid mapping (a code pointing at a
+ * structurally identical sibling class) still compiles — `errors.test-d.ts` backstops that.
+ */
+type Complete<T extends Record<ZamaErrorCode, ZamaError>> = T;
+/**
+ * Maps each {@link ZamaErrorCode} to the error class thrown with that code, so
+ * {@link matchZamaError} handlers receive the matched subtype instead of the base
+ * `ZamaError`. Hand-maintained; the `Complete` wrapper fails the build if a code is
+ * added without an entry here (or mapped to a non-`ZamaError`).
+ */
+type ErrorForCode = Complete<{
+  [ZamaErrorCode.SigningRejected]: SigningRejectedError;
+  [ZamaErrorCode.SigningFailed]: SigningFailedError;
+  [ZamaErrorCode.EncryptionFailed]: EncryptionFailedError;
+  [ZamaErrorCode.DecryptionFailed]: DecryptionFailedError;
+  [ZamaErrorCode.TransactionReverted]: TransactionRevertedError;
+  [ZamaErrorCode.TransportKeyPairExpired]: TransportKeyPairExpiredError;
+  [ZamaErrorCode.InvalidTransportKeyPair]: InvalidTransportKeyPairError;
+  [ZamaErrorCode.NoCiphertext]: NoCiphertextError;
+  [ZamaErrorCode.RelayerRequestFailed]: RelayerRequestFailedError;
+  [ZamaErrorCode.NotEntitled]: NotEntitledError;
+  [ZamaErrorCode.RpcRateLimited]: RpcRateLimitError;
+  [ZamaErrorCode.OperationTimeout]: WorkerTimeoutError;
+  [ZamaErrorCode.WorkerRecycled]: WorkerRecycledError;
+  [ZamaErrorCode.Configuration]: ConfigurationError;
+  [ZamaErrorCode.DelegationSelfNotAllowed]: DelegationSelfNotAllowedError;
+  [ZamaErrorCode.DelegationCooldown]: DelegationCooldownError;
+  [ZamaErrorCode.DelegationNotFound]: DelegationNotFoundError;
+  [ZamaErrorCode.DelegationExpired]: DelegationExpiredError;
+  [ZamaErrorCode.InsufficientConfidentialBalance]: InsufficientConfidentialBalanceError;
+  [ZamaErrorCode.InsufficientERC20Balance]: InsufficientERC20BalanceError;
+  [ZamaErrorCode.BalanceCheckUnavailable]: BalanceCheckUnavailableError;
+  [ZamaErrorCode.ERC20ReadFailed]: ERC20ReadFailedError;
+  [ZamaErrorCode.DelegationExpiryUnchanged]: DelegationExpiryUnchangedError;
+  [ZamaErrorCode.DelegationDelegateEqualsContract]: DelegationDelegateEqualsContractError;
+  [ZamaErrorCode.DelegationContractIsSelf]: DelegationContractIsSelfError;
+  [ZamaErrorCode.AclPaused]: AclPausedError;
+  [ZamaErrorCode.DelegationExpirationTooSoon]: DelegationExpirationTooSoonError;
+  [ZamaErrorCode.DelegationNotPropagated]: DelegationNotPropagatedError;
+  [ZamaErrorCode.ChainMismatch]: ChainMismatchError;
+  [ZamaErrorCode.SignerNotConfigured]: SignerNotConfiguredError;
+  [ZamaErrorCode.WalletNotConnected]: WalletNotConnectedError;
+  [ZamaErrorCode.WalletAccountNotReady]: WalletAccountNotReadyError;
+}>;
+/**
+ * Pattern-match on a {@link ZamaError} by its error code. Each handler receives the
+ * error class for its code, so subclass fields are available without a cast.
+ * Falls through to the `_` wildcard handler if no specific handler matches.
+ * Returns `undefined` if the error is not a `ZamaError` and no `_` handler is provided.
+ *
+ * @example
+ * ```ts
+ * matchZamaError(error, {
+ *   SIGNING_REJECTED: () => toast("Please approve in wallet"),
+ *   INSUFFICIENT_CONFIDENTIAL_BALANCE: (e) => toast(`Need ${e.requested}, have ${e.available}`),
+ *   RELAYER_REQUEST_FAILED: (e) => toast(`Relayer failed (${e.statusCode})`),
+ *   _: () => toast("Unknown error"),
+ * });
+ * ```
+ */
+declare function matchZamaError<R>(error: unknown, handlers: { [K in ZamaErrorCode]?: (error: ErrorForCode[K]) => R } & {
+  _?: (error: unknown) => R;
+}): R | undefined;
+//#endregion
 //#region src/services/caching-service.d.ts
 /**
  * Storage-backed cache for decrypted FHE plaintext values.
@@ -19131,6 +19354,16 @@ declare class DelegationService {
 }
 //#endregion
 //#region src/services/decryption-service.d.ts
+/** Options shared by the delegated-decrypt entry points. */
+interface DelegatedDecryptOptions {
+  /**
+   * Ride out the gateway propagation window: when a just-granted delegation
+   * has not yet synced, the delegated decrypt is retried (bounded, ~30s) until
+   * it lands instead of throwing {@link DelegationNotPropagatedError}. Defaults
+   * to `true`. Pass `false` to fail fast on the first not-propagated response.
+   */
+  waitForPropagation?: boolean;
+}
 interface BatchDecryptItem {
   encryptedValue: EncryptedValue;
   contractAddress: Address;
@@ -19156,27 +19389,35 @@ declare class DecryptionService {
     emitEvent: (input: ZamaSDKEventInput) => void;
   });
   userDecrypt(handles: EncryptedInput[], signerAddress: Address): Promise<Record<EncryptedValue, ClearValue>>;
-  delegatedUserDecrypt(encryptedValues: EncryptedInput[], delegatorAddress: Address, delegateAddress: Address, accountAddress: Address): Promise<Record<EncryptedValue, ClearValue>>;
+  delegatedUserDecrypt(encryptedValues: EncryptedInput[], delegatorAddress: Address, delegateAddress: Address, accountAddress: Address, options?: DelegatedDecryptOptions): Promise<Record<EncryptedValue, ClearValue>>;
   delegatedBatchDecryptHandlesAs({
     encryptedInputs,
     delegatorAddress,
     delegateAddress,
     accountAddress,
-    maxConcurrency
+    maxConcurrency,
+    waitForPropagation
   }: {
     encryptedInputs: EncryptedInput[];
     delegatorAddress: Address;
     delegateAddress: Address;
     accountAddress: Address;
     maxConcurrency?: number;
+    waitForPropagation?: boolean;
   }): Promise<BatchDecryptResult>;
 }
 //#endregion
 //#region src/namespaces/decryption.d.ts
 /**
- * Public namespace for FHE decryption.
+ * Public namespace for FHE decryption — the canonical way to decrypt.
+ *
+ * Exposed as `sdk.decryption`. Prefer these methods over the low-level
+ * `sdk.relayer.userDecrypt` / `delegatedUserDecrypt` / `publicDecrypt`: they
+ * assemble the credential bundle (transport key pair, EIP-712 permit) for you,
+ * cache results, and wrap relayer errors. Reach for `sdk.relayer.*` only when
+ * you must control credential assembly by hand.
  *
- * Exposed as `sdk.decryption`. Owns the SDK-level guards (signer requirement on
+ * Owns the SDK-level guards (signer requirement on
  * `decryptValues` and `delegatedDecryptValues`, empty-array
  * short-circuit on `decryptPublicValues`, relayer error wrapping) and delegates the
  * actual work to the internal {@link DecryptionService} or the relayer directly for
@@ -19231,6 +19472,9 @@ declare class Decryption {
    *   dimension. Defaults to `delegatorAddress`. Pass the actual account address
    *   when decrypting on behalf of someone whose balance is stored under a
    *   different address (e.g. `decryptBalanceAs` with an explicit `accountAddress`).
+   * @param options - Delegated-decrypt options. By default the call rides out the
+   *   gateway propagation window ({@link DelegatedDecryptOptions.waitForPropagation});
+   *   pass `{ waitForPropagation: false }` to fail fast instead.
    * @returns Map of encrypted value → clear-text value.
    *
    * @example
@@ -19241,7 +19485,7 @@ declare class Decryption {
    * console.log(values[balance]); // 1000n
    * ```
    */
-  delegatedDecryptValues(encryptedInputs: EncryptedInput[], delegatorAddress: Address, accountAddress?: Address): Promise<Record<EncryptedValue, ClearValue>>;
+  delegatedDecryptValues(encryptedInputs: EncryptedInput[], delegatorAddress: Address, accountAddress?: Address, options?: DelegatedDecryptOptions): Promise<Record<EncryptedValue, ClearValue>>;
   /**
    * Publicly decrypt one or more FHE encrypted values.
    *
@@ -19271,6 +19515,8 @@ declare class Decryption {
    * @param delegatorAddress - The address that granted delegation rights.
    * @param accountAddress - The account on whose behalf decryption is performed. Defaults to `delegatorAddress`.
    * @param maxConcurrency - Maximum parallel decrypt calls during per-entry fallback.
+   * @param waitForPropagation - Ride out the gateway propagation window on the
+   *   initial batch attempt (default `true`). See {@link DelegatedDecryptOptions.waitForPropagation}.
    * @returns Per-entry results, each with a value or an error.
    * @throws if no signer is configured. {@link SignerNotConfiguredError}
    * @throws if signer and provider are on different chains. {@link ChainMismatchError}
@@ -19295,13 +19541,14 @@ declare class Decryption {
     encryptedInputs,
     delegatorAddress,
     accountAddress,
-    maxConcurrency
+    maxConcurrency,
+    waitForPropagation
   }: {
     encryptedInputs: EncryptedInput[];
     delegatorAddress: Address;
     accountAddress?: Address;
     maxConcurrency?: number;
-  }): Promise<BatchDecryptResult>;
+  } & DelegatedDecryptOptions): Promise<BatchDecryptResult>;
 }
 //#endregion
 //#region src/namespaces/delegations.d.ts
@@ -19313,8 +19560,9 @@ declare class Decryption {
  * actual work to the internal {@link DelegationService}.
  *
  * Delegation operations write to the host chain ACL; after a delegation is mined,
- * allow **1–2 minutes** before attempting delegated decryption to let the gateway
- * sync the ACL state via cross-chain event propagation.
+ * the gateway syncs the ACL state via cross-chain event propagation — usually
+ * within ~10 blocks (a few seconds). Delegated decryption rides out that window
+ * with a bounded internal retry, so callers can decrypt right after granting.
  */
 declare class Delegations {
   #private;
@@ -19328,9 +19576,11 @@ declare class Delegations {
    * Delegate decryption rights for a confidential contract to another address.
    * Calls `ACL.delegateForUserDecryption()` on-chain.
    *
-   * **Important:** After the transaction is mined, allow **1–2 minutes** before
-   * attempting delegated decryption. The delegation is recorded on L1 immediately,
-   * but the gateway must sync the ACL state via cross-chain event propagation.
+   * The delegation is recorded on L1 immediately, but the gateway must sync the
+   * ACL state via cross-chain event propagation — usually within ~10 blocks (a
+   * few seconds). You do not need to wait: delegated decryption rides out that
+   * window with a bounded internal retry, so you can decrypt right after this
+   * resolves.
    *
    * @param contractAddress - The confidential contract address to delegate on.
    * @param delegateAddress - Address to delegate decryption rights to.
@@ -19706,6 +19956,60 @@ declare class Token {
    * ```
    */
   confidentialTransferFrom(from: Address, to: Address, amount: bigint, callbacks?: TransferCallbacks): Promise<TransactionResult>;
+  /**
+   * ERC-7984 `confidentialTransferAndCall`: encrypted transfer that also invokes
+   * the recipient's receiver hook (`onConfidentialTransferReceived`) in a single
+   * transaction. The caller crafts the opaque `data` payload — the SDK does not
+   * encode, validate, or interpret it.
+   *
+   * Balance validation follows the same rules as {@link Token.confidentialTransfer}.
+   *
+   * @param to - Recipient address. Must implement the ERC-7984 receiver hook.
+   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).
+   * @param data - Opaque bytes forwarded to the recipient's receiver hook.
+   * @param options - Optional: `skipBalanceCheck` (default `false`).
+   * @returns The transaction hash and mined receipt.
+   *
+   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
+   * @throws if the balance is less than `amount`. {@link InsufficientConfidentialBalanceError}
+   * @throws if balance validation requires decryption that is not possible. {@link BalanceCheckUnavailableError}
+   * @throws if FHE encryption fails. {@link EncryptionFailedError}
+   * @throws if the on-chain transfer reverts. {@link TransactionRevertedError}
+   *
+   * @example
+   * ```ts
+   * const txHash = await token.confidentialTransferAndCall(
+   *   "0xRecipient",
+   *   1000n,
+   *   "0xabcd", // caller-encoded payload forwarded to the receiver hook
+   * );
+   * ```
+   */
+  confidentialTransferAndCall(to: Address, amount: bigint, data: Hex, options?: TransferOptions): Promise<TransactionResult>;
+  /**
+   * ERC-7984 `confidentialTransferFromAndCall`: operator-initiated encrypted
+   * transfer that also invokes the recipient's receiver hook in a single
+   * transaction. The caller must be an approved operator for `from` and crafts
+   * the opaque `data` payload — the SDK does not encode or interpret it.
+   *
+   * @param from - The address to transfer from (caller must be an approved operator).
+   * @param to - Recipient address. Must implement the ERC-7984 receiver hook.
+   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).
+   * @param data - Opaque bytes forwarded to the recipient's receiver hook.
+   * @param callbacks - Optional progress callbacks.
+   * @returns The transaction hash and mined receipt.
+   *
+   * @example
+   * ```ts
+   * const txHash = await token.confidentialTransferFromAndCall(
+   *   "0xFrom",
+   *   "0xRecipient",
+   *   500n,
+   *   "0xabcd",
+   * );
+   * ```
+   */
+  confidentialTransferFromAndCall(from: Address, to: Address, amount: bigint, data: Hex, callbacks?: TransferCallbacks): Promise<TransactionResult>;
   /**
    * Set operator approval for the confidential token.
    * Defaults to 1 hour from now if `until` is not specified.
@@ -19898,6 +20202,25 @@ declare class WrappedToken extends Token {
    * ```
    */
   resumeUnshield(unwrapTxHash: Hex, callbacks?: UnshieldCallbacks): Promise<TransactionResult>;
+  /**
+   * Return the unwrap tx hash of an unshield that was interrupted between its
+   * two phases, or `null` if none is pending for this wrapper.
+   *
+   * The SDK persists this automatically when {@link unshield}/{@link unshieldAll}
+   * submit phase 1, and clears it once phase 2 finalizes. Use the returned hash
+   * to surface a "resume" affordance, then pass it to {@link resumeUnshield}.
+   * Resuming is intentionally caller-driven — auto-resuming on load would fire a
+   * wallet transaction unprompted.
+   *
+   * @returns The pending unwrap tx hash, or `null`.
+   *
+   * @example
+   * ```ts
+   * const unwrapTxHash = await wrappedToken.getPendingUnshield();
+   * if (unwrapTxHash) await wrappedToken.resumeUnshield(unwrapTxHash);
+   * ```
+   */
+  getPendingUnshield(): Promise<Hex | null>;
   /**
    * Request an unwrap for a specific amount. Encrypts the amount first.
    * Call {@link finalizeUnwrap} after the request is processed on-chain.
@@ -19945,6 +20268,9 @@ declare class WrappedToken extends Token {
 /**
  * Default wrappers registry addresses for known chains.
  * Only includes chains where a registry is deployed (excludes Hardhat).
+ *
+ * @deprecated Read `registryAddress` from the chain presets instead (e.g.
+ * `sepolia.registryAddress`). Will be removed in the next major version.
  */
 declare const DefaultRegistryAddresses: Record<number, Address>;
 /** Configuration for {@link WrappersRegistry}. */
@@ -20163,6 +20489,7 @@ declare class WrappersRegistry {
  */
 declare class ZamaSDK {
   #private;
+  /** @internal */
   readonly relayer: RelayerDispatcher;
   readonly provider: GenericProvider;
   readonly signer: GenericSigner | undefined;
@@ -20212,14 +20539,15 @@ declare class ZamaSDK {
   emitEvent(input: ZamaSDKEventInput, tokenAddress?: Address): void;
   /**
    * Create a {@link WrappersRegistry} instance bound to this SDK's provider.
-   * On Mainnet and Sepolia the registry address is resolved automatically.
+   * Inherits the registry addresses derived from the SDK's chain configs, so
+   * the result is consistent with {@link ZamaSDK.registry}.
    *
    * @param registryAddresses - Optional per-chain overrides for this registry instance.
    * @returns A {@link WrappersRegistry} instance.
    *
    * @example
    * ```ts
-   * // Mainnet / Sepolia — resolved automatically
+   * // Addresses resolved from the SDK's chain configs
    * const registry = sdk.createWrappersRegistry();
    *
    * // Hardhat or custom chain — override per chain for this registry instance
@@ -20304,46 +20632,5 @@ declare class ZamaSDK {
   [Symbol.dispose](): void;
 }
 //#endregion
-//#region src/token/pending-unshield.d.ts
-/**
- * Persisted state for an in-progress unshield request.
- * Used to resume an interrupted unshield after page reload.
- */
-interface PendingUnshieldRequest {
-  /** Transaction hash of the original unwrap call. */
-  readonly unwrapTxHash: Hex;
-  /**
-   * Request identifier from the `UnwrapRequested` event.
-   * Always populated for entries persisted by this SDK version; pass it as
-   * `unwrapRequestId` to `finalizeUnwrap`. Absent only when re-loading a
-   * pending unshield serialized by an older SDK version that did not
-   * record this field — in that case pass the `encryptedAmount` from the
-   * `UnwrapRequested` event to `finalizeUnwrap` instead.
-   */
-  readonly unwrapRequestId?: EncryptedValue;
-}
-/**
- * Persist the unwrap tx hash so an interrupted unshield can be resumed later
- * (e.g. after a page reload).
- */
-declare function savePendingUnshield(storage: GenericStorage, wrapperAddress: Address, unwrapTxHash: Hex, unwrapRequestId?: EncryptedValue): Promise<void>;
-/**
- * Load a previously saved unwrap tx hash, or `null` if none exists.
- */
-declare function loadPendingUnshield(storage: GenericStorage, wrapperAddress: Address): Promise<Hex | null>;
-/**
- * Load a previously saved unwrap request, including `unwrapRequestId` when available.
- *
- * `resumeUnshield()` only needs `unwrapTxHash`: it reloads the transaction receipt and
- * rediscovers the right finalize input from the emitted `UnwrapRequested` event.
- * Use `unwrapRequestId` directly only for custom flows that call `finalizeUnwrap()`
- * without reloading the original unwrap receipt.
- */
-declare function loadPendingUnshieldRequest(storage: GenericStorage, wrapperAddress: Address): Promise<PendingUnshieldRequest | null>;
-/**
- * Clear the saved unwrap tx hash after a successful finalization.
- */
-declare function clearPendingUnshield(storage: GenericStorage, wrapperAddress: Address): Promise<void>;
-//#endregion
-export { DecryptResult as $, DelegationExpiredError as A, decimalsContract as At, ConfigurationError as B, rateContract as Bt, InsufficientConfidentialBalanceError as C, ERC7984_WRAPPER_INTERFACE_ID as Ct, DelegationCooldownError as D, allowanceContract as Dt, DelegationContractIsSelfError as E, supportsInterfaceContract as Et, SignerNotConfiguredError as F, confidentialTransferContract as Ft, TransactionRevertedError as G, wrapContract as Gt, InvalidTransportKeyPairError as H, underlyingContract as Ht, SignerRequiredError as I, confidentialTransferFromContract as It, SigningFailedError as J, resolveStorage as Jt, DecryptionFailedError as K, ResolvedChainRelayer as Kt, WalletAccountNotReadyError as L, finalizeUnwrapContract as Lt, DelegationNotFoundError as M, symbolContract as Mt, DelegationNotPropagatedError as N, confidentialBalanceOfContract as Nt, DelegationDelegateEqualsContractError as O, approveContract as Ot, DelegationSelfNotAllowedError as P, confidentialTotalSupplyContract as Pt, matchZamaError as Q, WalletNotConnectedError as R, inferredTotalSupplyContract as Rt, ERC20ReadFailedError as S, ERC7984_INTERFACE_ID as St, AclPausedError as T, isConfidentialWrapperContract as Tt, NoCiphertextError as U, unwrapContract as Ut, RelayerRequestFailedError as V, setOperatorContract as Vt, TransportKeyPairExpiredError as W, unwrapFromBalanceContract as Wt, ZamaError as X, SigningRejectedError as Y, createConfig as Yt, ZamaErrorCode as Z, Decryption as _, getDelegationExpiryContract as _t, savePendingUnshield as a, QueryFactoryOptions as at, BalanceCheckUnavailableError as b, transferAndCallContract as bt, ListPairsOptions as c, TokenWrapperPairWithMetadata as ct, WrappedToken as d, getTokenPairContract as dt, EncryptedInput as et, BatchBalancesResult as f, getTokenPairsContract as ft, Delegations as g, delegateForUserDecryptionContract as gt, Permits as h, isConfidentialTokenValidContract as ht, loadPendingUnshieldRequest as i, MutationFactoryOptions as it, DelegationExpiryUnchangedError as j, nameContract as jt, DelegationExpirationTooSoonError as k, balanceOfContract as kt, WrappersRegistry as l, getConfidentialTokenAddressContract as lt, Token as m, getTokenPairsSliceContract as mt, clearPendingUnshield as n, SignerQueryContext as nt, ZamaSDK as o, PaginatedResult as ot, BatchDecryptAsOptions as p, getTokenPairsLengthContract as pt, EncryptionFailedError as q, resolveChainRelayers as qt, loadPendingUnshield as r, zamaQueryKeys as rt, DefaultRegistryAddresses as s, TokenWrapperPair as st, PendingUnshieldRequest as t, decryptValuesQueryOptions as tt, WrappersRegistryConfig as u, getTokenAddressContract as ut, BatchDecryptItem as v, isHandleDelegatedContract as vt, InsufficientERC20BalanceError as w, isConfidentialTokenContract as wt, BalanceErrorDetails as x, ERC1363_INTERFACE_ID as xt, BatchDecryptResult as y, revokeDelegationContract as yt, ChainMismatchError as z, isOperatorContract as zt };
-//# sourceMappingURL=index-DoVo9J1n.d.ts.map
+export { DecryptResult as $, BalanceCheckUnavailableError as A, decimalsContract as At, DelegationDelegateEqualsContractError as B, rateContract as Bt, SignerRequiredError as C, ERC7984_WRAPPER_INTERFACE_ID as Ct, NotEntitledError as D, allowanceContract as Dt, RpcRateLimitError as E, supportsInterfaceContract as Et, DecryptionFailedError as F, confidentialTransferContract as Ft, DelegationNotPropagatedError as G, wrapContract as Gt, DelegationExpiredError as H, underlyingContract as Ht, EncryptionFailedError as I, confidentialTransferFromContract as It, NoCiphertextError as J, resolveStorage as Jt, DelegationSelfNotAllowedError as K, ResolvedChainRelayer as Kt, AclPausedError as L, finalizeUnwrapContract as Lt, ERC20ReadFailedError as M, symbolContract as Mt, InsufficientConfidentialBalanceError as N, confidentialBalanceOfContract as Nt, ConfigurationError as O, approveContract as Ot, InsufficientERC20BalanceError as P, confidentialTotalSupplyContract as Pt, ZamaErrorCode as Q, DelegationContractIsSelfError as R, inferredTotalSupplyContract as Rt, SignerNotConfiguredError as S, ERC7984_INTERFACE_ID as St, WalletNotConnectedError as T, isConfidentialWrapperContract as Tt, DelegationExpiryUnchangedError as U, unwrapContract as Ut, DelegationExpirationTooSoonError as V, setOperatorContract as Vt, DelegationNotFoundError as W, unwrapFromBalanceContract as Wt, ChainMismatchError as X, TransportKeyPairExpiredError as Y, createConfig as Yt, ZamaError as Z, WorkerRecycledError as _, getDelegationExpiryContract as _t, WrappersRegistryConfig as a, QueryFactoryOptions as at, SigningFailedError as b, transferAndCallContract as bt, BatchDecryptAsOptions as c, TokenWrapperPairWithMetadata as ct, Delegations as d, getTokenPairContract as dt, EncryptedInput as et, Decryption as f, getTokenPairsContract as ft, matchZamaError as g, delegateForUserDecryptionContract as gt, DelegatedDecryptOptions as h, isConfidentialTokenValidContract as ht, WrappersRegistry as i, MutationFactoryOptions as it, BalanceErrorDetails as j, nameContract as jt, RelayerRequestFailedError as k, balanceOfContract as kt, Token as l, getConfidentialTokenAddressContract as lt, BatchDecryptResult as m, getTokenPairsSliceContract as mt, DefaultRegistryAddresses as n, SignerQueryContext as nt, WrappedToken as o, PaginatedResult as ot, BatchDecryptItem as p, getTokenPairsLengthContract as pt, InvalidTransportKeyPairError as q, resolveChainRelayers as qt, ListPairsOptions as r, zamaQueryKeys as rt, BatchBalancesResult as s, TokenWrapperPair as st, ZamaSDK as t, decryptValuesQueryOptions as tt, Permits as u, getTokenAddressContract as ut, WorkerTimeoutError as v, isHandleDelegatedContract as vt, WalletAccountNotReadyError as w, isConfidentialTokenContract as wt, SigningRejectedError as x, ERC1363_INTERFACE_ID as xt, TransactionRevertedError as y, revokeDelegationContract as yt, DelegationCooldownError as z, isOperatorContract as zt };
+//# sourceMappingURL=index-C1Mtc8Rw.d.ts.map