@zama-fhe/sdk 3.7.0-alpha.2 → 3.7.0-beta.2

package/dist/esm/token-CRJ8eCr7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-CRJ8eCr7.js","names":["#requireSigner","submitSdkTransaction"],"sources":["../../src/errors/rpc.ts","../../src/errors/chain.ts","../../src/errors/balance.ts","../../src/errors/fatal-batch.ts","../../src/utils/fhe-type.ts","../../src/utils/handles.ts","../../src/utils/alignment.ts","../../src/utils/assert-balance.ts","../../src/utils/concurrency.ts","../../src/utils/submit-transaction.ts","../../src/token/token.ts"],"sourcesContent":["import { ZamaError, ZamaErrorCode } from \"./base\";\n\n/**\n * The consumer's RPC provider rate-limited an on-chain read the SDK performs\n * during decryption (e.g. the ACL check) — HTTP 429 or JSON-RPC `-32005`. An\n * RPC-endpoint problem, **not** a decryption/entitlement failure, and safe to\n * **retry**. Kept distinct from the relayer's own back-pressure\n * ({@link RelayerRequestFailedError}).\n *\n * Backoff for chain RPC is owned by the consumer's transport: viem/ethers\n * already honor the `Retry-After` header and retry internally before this error\n * surfaces, so it is configured on the transport you pass via `chain.network`\n * (not re-implemented here).\n *\n * @example\n * ```ts\n * try {\n *   await sdk.decryption.decryptValues([{ encryptedValue, contractAddress }]);\n * } catch (e) {\n *   if (e instanceof RpcRateLimitError) {\n *     // back off and retry; consider a higher-throughput RPC endpoint\n *   }\n * }\n * ```\n */\nexport class RpcRateLimitError extends ZamaError {\n  /**\n   * Suggested delay before retrying, in **seconds**, when a numeric `retryAfter`\n   * is present on the error. Usually `undefined` for chain RPC: the `Retry-After`\n   * header is consumed by the consumer's viem/ethers transport (which owns the\n   * backoff), not surfaced here — see the class doc.\n   */\n  readonly retryAfter: number | undefined;\n\n  constructor(message: string, options?: ErrorOptions & { retryAfter?: number }) {\n    const { retryAfter, ...errorOptions } = options ?? {};\n    super(ZamaErrorCode.RpcRateLimited, message, errorOptions);\n    this.name = \"RpcRateLimitError\";\n    this.retryAfter = retryAfter;\n  }\n}\n","import { ZamaError, ZamaErrorCode } from \"./base\";\n\n/**\n * Thrown when the signer and provider are connected to different chains at the\n * start of a write operation.\n *\n * Every write method runs a chain-alignment pre-flight check. If\n * `signer.getChainId()` and `provider.getChainId()` return different values,\n * this error is thrown before any RPC mutation is attempted.\n *\n * @example\n * ```ts\n * try {\n *   await token.shield(1000n);\n * } catch (e) {\n *   if (e instanceof ChainMismatchError) {\n *     console.error(\n *       `Signer is on chain ${e.signerChainId} but provider is on chain ${e.providerChainId}`,\n *     );\n *   }\n * }\n * ```\n */\nexport class ChainMismatchError extends ZamaError {\n  /** Name of the operation that triggered the check. */\n  readonly operation: string;\n  /** Chain ID the signer is connected to. */\n  readonly signerChainId: number;\n  /** Chain ID the provider is connected to. */\n  readonly providerChainId: number;\n\n  constructor(\n    {\n      operation,\n      signerChainId,\n      providerChainId,\n    }: { operation: string; signerChainId: number; providerChainId: number },\n    options?: ErrorOptions,\n  ) {\n    super(\n      ZamaErrorCode.ChainMismatch,\n      `Operation \"${operation}\" requires signer and provider to be on the same chain, ` +\n        `but signer is on chain ${signerChainId} and provider is on chain ${providerChainId}.`,\n      options,\n    );\n    this.name = \"ChainMismatchError\";\n    this.operation = operation;\n    this.signerChainId = signerChainId;\n    this.providerChainId = providerChainId;\n  }\n}\n","import type { Address } from \"viem\";\nimport { ZamaError, ZamaErrorCode } from \"./base\";\n\n/** Structured details shared by balance-related errors. */\nexport interface BalanceErrorDetails {\n  /** Amount the caller requested, in the token's base units. */\n  readonly requested: bigint;\n  /** Amount available at the time of the check, in the token's base units. */\n  readonly available: bigint;\n  /** Address of the token contract involved. */\n  readonly token: Address;\n}\n\n/** Confidential (cToken) balance is insufficient for the requested operation. */\nexport class InsufficientConfidentialBalanceError extends ZamaError {\n  /** The amount the caller requested. */\n  readonly requested: bigint;\n  /** The available balance at the time of the check. */\n  readonly available: bigint;\n  /** The token contract address. */\n  readonly token: Address;\n\n  constructor(message: string, details: BalanceErrorDetails, options?: ErrorOptions) {\n    super(ZamaErrorCode.InsufficientConfidentialBalance, message, options);\n    this.name = \"InsufficientConfidentialBalanceError\";\n    this.requested = details.requested;\n    this.available = details.available;\n    this.token = details.token;\n  }\n}\n\n/** ERC-20 balance is insufficient for the requested shield amount. */\nexport class InsufficientERC20BalanceError extends ZamaError {\n  /** The amount the caller requested. */\n  readonly requested: bigint;\n  /** The available balance at the time of the check. */\n  readonly available: bigint;\n  /** The ERC-20 token contract address. */\n  readonly token: Address;\n\n  constructor(message: string, details: BalanceErrorDetails, options?: ErrorOptions) {\n    super(ZamaErrorCode.InsufficientERC20Balance, message, options);\n    this.name = \"InsufficientERC20BalanceError\";\n    this.requested = details.requested;\n    this.available = details.available;\n    this.token = details.token;\n  }\n}\n\n/** ERC-20 allowance granted to the wrapper is insufficient for the requested wrap amount. */\nexport class InsufficientAllowanceError extends ZamaError {\n  /** The amount the caller requested. */\n  readonly requested: bigint;\n  /** The allowance available at the time of the check. */\n  readonly available: bigint;\n  /** The underlying ERC-20 token contract address. */\n  readonly token: Address;\n\n  constructor(message: string, details: BalanceErrorDetails, options?: ErrorOptions) {\n    super(ZamaErrorCode.InsufficientAllowance, message, options);\n    this.name = \"InsufficientAllowanceError\";\n    this.requested = details.requested;\n    this.available = details.available;\n    this.token = details.token;\n  }\n}\n\n/** Balance validation could not be performed (no cached credentials and decryption not possible). */\nexport class BalanceCheckUnavailableError extends ZamaError {\n  constructor(message: string, options?: ErrorOptions) {\n    super(ZamaErrorCode.BalanceCheckUnavailable, message, options);\n    this.name = \"BalanceCheckUnavailableError\";\n  }\n}\n\n/** A public ERC-20 read (e.g. balanceOf) failed due to a network or contract error. */\nexport class ERC20ReadFailedError extends ZamaError {\n  constructor(message: string, options?: ErrorOptions) {\n    super(ZamaErrorCode.ERC20ReadFailed, message, options);\n    this.name = \"ERC20ReadFailedError\";\n  }\n}\n","import { KeyWrappingError, RevokedKmsContextError } from \"./credential\";\nimport { ConfigurationError } from \"./relayer\";\nimport { RpcRateLimitError } from \"./rpc\";\nimport { SigningRejectedError, SigningFailedError } from \"./signing\";\n\n/**\n * Returns `true` for errors that should abort an entire batch operation\n * rather than be recorded per-item — wallet signature rejected, signing\n * infrastructure broken, SDK misconfigured, the RPC provider throttling, or\n * transport key pair wrapping unusable for the whole session (wrong or missing\n * `transportKeyPairDerivationSecret`, `crypto.subtle` unavailable).\n * These are systemic failures that won't recover within the same call; for a\n * rate-limit in particular, the per-item retry loop would only amplify the\n * throttle by re-hitting the already-rate-limited endpoint. A revoked KMS\n * context is likewise batch-wide: every item's permit shares the dead context,\n * and the per-item loop would trigger one evict-and-regrant wallet prompt per\n * item instead of the one the batch attempt already spent.\n *\n * Callers iterating over a batch (e.g. per-token decrypt) should rethrow when\n * this predicate is true so the whole batch aborts, and record the error\n * per-item otherwise.\n */\nexport function isFatalBatchError(error: unknown): boolean {\n  return (\n    error instanceof SigningRejectedError ||\n    error instanceof SigningFailedError ||\n    error instanceof ConfigurationError ||\n    error instanceof RpcRateLimitError ||\n    error instanceof KeyWrappingError ||\n    error instanceof RevokedKmsContextError\n  );\n}\n","// Copied from @zama-fhe/relayer-sdk/src/sdk/FheType.ts\n// Pure utility functions with zero WASM dependency.\n// Adapted to use simple errors instead of RelayerErrorBase hierarchy.\n\n////////////////////////////////////////////////////////////////////////////////\n// Types (from types/primitives.d.ts)\n////////////////////////////////////////////////////////////////////////////////\n\nexport interface FheTypeNameToIdMap {\n  ebool: 0;\n  //euint4: 1; deprecated\n  euint8: 2;\n  euint16: 3;\n  euint32: 4;\n  euint64: 5;\n  euint128: 6;\n  eaddress: 7;\n  euint256: 8;\n}\n\nexport interface FheTypeIdToNameMap {\n  0: \"ebool\";\n  //1: 'euint4'; deprecated\n  2: \"euint8\";\n  3: \"euint16\";\n  4: \"euint32\";\n  5: \"euint64\";\n  6: \"euint128\";\n  7: \"eaddress\";\n  8: \"euint256\";\n}\n\nexport interface FheTypeEncryptionBitwidthToIdMap {\n  2: FheTypeNameToIdMap[\"ebool\"];\n  8: FheTypeNameToIdMap[\"euint8\"];\n  16: FheTypeNameToIdMap[\"euint16\"];\n  32: FheTypeNameToIdMap[\"euint32\"];\n  64: FheTypeNameToIdMap[\"euint64\"];\n  128: FheTypeNameToIdMap[\"euint128\"];\n  160: FheTypeNameToIdMap[\"eaddress\"];\n  256: FheTypeNameToIdMap[\"euint256\"];\n}\n\nexport type FheTypeIdToEncryptionBitwidthMap = {\n  [K in keyof FheTypeEncryptionBitwidthToIdMap as FheTypeEncryptionBitwidthToIdMap[K]]: K;\n};\n\ntype Prettify<T> = { [K in keyof T]: T[K] } & {};\n\nexport type FheTypeName = Prettify<keyof FheTypeNameToIdMap>;\nexport type FheTypeId = Prettify<keyof FheTypeIdToNameMap>;\nexport type EncryptionBits = Prettify<keyof FheTypeEncryptionBitwidthToIdMap>;\n\n////////////////////////////////////////////////////////////////////////////////\n// Lookup Maps\n////////////////////////////////////////////////////////////////////////////////\n\nconst MINIMUM_ENCRYPTION_BIT_WIDTH = 2;\n\nconst FheTypeNameToId: FheTypeNameToIdMap = {\n  ebool: 0,\n  //euint4: 1, deprecated\n  euint8: 2,\n  euint16: 3,\n  euint32: 4,\n  euint64: 5,\n  euint128: 6,\n  eaddress: 7,\n  euint256: 8,\n} as const;\n\nconst FheTypeIdToName: FheTypeIdToNameMap = {\n  0: \"ebool\",\n  //1: 'euint4', deprecated\n  2: \"euint8\",\n  3: \"euint16\",\n  4: \"euint32\",\n  5: \"euint64\",\n  6: \"euint128\",\n  7: \"eaddress\",\n  8: \"euint256\",\n} as const;\n\nconst FheTypeIdToEncryptionBitwidth: FheTypeIdToEncryptionBitwidthMap = {\n  0: 2,\n  //1:?, euint4 deprecated\n  2: 8,\n  3: 16,\n  4: 32,\n  5: 64,\n  6: 128,\n  7: 160,\n  8: 256,\n} as const;\n\nconst EncryptionBitwidthToFheTypeId: FheTypeEncryptionBitwidthToIdMap = {\n  2: 0,\n  8: 2,\n  16: 3,\n  32: 4,\n  64: 5,\n  128: 6,\n  160: 7,\n  256: 8,\n} as const;\n\nObject.freeze(FheTypeNameToId);\nObject.freeze(FheTypeIdToName);\nObject.freeze(FheTypeIdToEncryptionBitwidth);\nObject.freeze(EncryptionBitwidthToFheTypeId);\n\n////////////////////////////////////////////////////////////////////////////////\n// Type Guards\n////////////////////////////////////////////////////////////////////////////////\n\nexport function isFheTypeId(value: unknown): value is FheTypeId {\n  switch (value as FheTypeId) {\n    case 0:\n    case 2:\n    case 3:\n    case 4:\n    case 5:\n    case 6:\n    case 7:\n    case 8:\n      return true;\n    default:\n      return false;\n  }\n}\n\nexport function isFheTypeName(value: unknown): value is FheTypeName {\n  if (typeof value !== \"string\") {\n    return false;\n  }\n  return value in FheTypeNameToId;\n}\n\nexport function isEncryptionBits(value: unknown): value is EncryptionBits {\n  if (typeof value !== \"number\") {\n    return false;\n  }\n  return value in EncryptionBitwidthToFheTypeId;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Converters\n////////////////////////////////////////////////////////////////////////////////\n\nexport function fheTypeIdFromEncryptionBits(bitwidth: number): FheTypeId {\n  if (!isEncryptionBits(bitwidth)) {\n    throw new Error(`Invalid encryption bits ${bitwidth}`);\n  }\n  return EncryptionBitwidthToFheTypeId[bitwidth];\n}\n\nexport function fheTypeIdFromName(name: string): FheTypeId {\n  if (!isFheTypeName(name)) {\n    throw new Error(`Invalid FheType name '${name}'`);\n  }\n  return FheTypeNameToId[name];\n}\n\nexport function fheTypeNameFromId(id: number): FheTypeName {\n  if (!isFheTypeId(id)) {\n    throw new Error(`Invalid FheType id '${id}'`);\n  }\n  return FheTypeIdToName[id];\n}\n\nexport function encryptionBitsFromFheTypeId(typeId: number): EncryptionBits {\n  if (!isFheTypeId(typeId)) {\n    throw new Error(`Invalid FheType id '${typeId}'`);\n  }\n  const bw = FheTypeIdToEncryptionBitwidth[typeId];\n  if (bw < MINIMUM_ENCRYPTION_BIT_WIDTH) {\n    throw new Error(\n      `Invalid FheType encryption bit width: ${bw}. Minimum is ${MINIMUM_ENCRYPTION_BIT_WIDTH} bits.`,\n    );\n  }\n  return bw;\n}\n\nexport function encryptionBitsFromFheTypeName(name: string): EncryptionBits {\n  if (!isFheTypeName(name)) {\n    throw new Error(`Invalid FheType name '${name}'`);\n  }\n  const bw = FheTypeIdToEncryptionBitwidth[FheTypeNameToId[name]];\n  if (bw < MINIMUM_ENCRYPTION_BIT_WIDTH) {\n    throw new Error(\n      `Invalid FheType encryption bit width: ${bw}. Minimum is ${MINIMUM_ENCRYPTION_BIT_WIDTH} bits.`,\n    );\n  }\n  return bw;\n}\n","import type { EncryptedValue } from \"../relayer/types\";\nimport { encryptionBitsFromFheTypeId, isFheTypeId } from \"./fhe-type\";\n\n/** All-zero encrypted-value sentinel — a 32-byte zero handle representing the cleartext value `0`. */\nexport const ZERO_ENCRYPTED_VALUE =\n  \"0x0000000000000000000000000000000000000000000000000000000000000000\" as const;\n\n/**\n * Check whether an encrypted value represents the zero value.\n */\nexport function isEncryptedValueZero(encryptedValue: string): boolean {\n  return encryptedValue === ZERO_ENCRYPTED_VALUE || encryptedValue === \"0x\";\n}\n\n/**\n * Per-request cleartext-bit budget enforced by the KMS gateway, mirrored from\n * `@fhevm/sdk`'s `MAX_KMS_DECRYPT_DECRYPTION_BIT_LIMIT` (protocol-level constant,\n * not imported — see {@link MAX_CONTRACTS_PER_PERMIT} for why). Internal: decrypt\n * requests are chunked to respect it automatically, so callers never need this value.\n */\nexport const MAX_DECRYPTION_REQUEST_BITS = 2048;\n\n/** Max encryption bit width among all currently-known FHE types (euint256). */\nconst MAX_KNOWN_ENCRYPTION_BITS = 256;\n\n/**\n * Cleartext bit cost of decrypting a single handle, derived from its FHE\n * type (encoded at bits 8-15 of the handle — the same layout `@fhevm/sdk`'s\n * `FhevmHandle` decodes, byte 30 of the 32-byte handle).\n *\n * Falls back to {@link MAX_KNOWN_ENCRYPTION_BITS} for an unrecognized type\n * byte, or for a value that isn't parseable hex at all, instead of throwing.\n * A real on-chain handle is always well-formed with a valid type byte, so\n * this fallback only ever fires for synthetic test/placeholder handles —\n * deliberately more permissive than the relayer's own strict validation so\n * chunking stays safe without requiring every test fixture to encode a real\n * FHE handle. Do not tighten this to match relayer semantics.\n */\nexport function encryptionBitsForHandle(encryptedValue: EncryptedValue): number {\n  let handleValue: bigint;\n  try {\n    handleValue = BigInt(encryptedValue);\n  } catch {\n    return MAX_KNOWN_ENCRYPTION_BITS;\n  }\n  const typeByte = Number((handleValue >> 8n) & 0xffn);\n  return isFheTypeId(typeByte) ? encryptionBitsFromFheTypeId(typeByte) : MAX_KNOWN_ENCRYPTION_BITS;\n}\n\n/**\n * Split `handles` into groups whose cumulative cleartext-bit cost never\n * exceeds `maxBits`, preserving input order. Unlike {@link chunkContracts}\n * (fixed-size slices), a greedy accumulate-until-exceeded walk is required\n * since per-handle cost varies by FHE type. A handle whose own cost exceeds\n * `maxBits` still gets a solo chunk — always makes forward progress.\n */\nexport function chunkHandlesByBitBudget(\n  handles: readonly EncryptedValue[],\n  maxBits: number = MAX_DECRYPTION_REQUEST_BITS,\n): EncryptedValue[][] {\n  const chunks: EncryptedValue[][] = [];\n  let current: EncryptedValue[] = [];\n  let currentBits = 0;\n\n  for (const handle of handles) {\n    const bits = encryptionBitsForHandle(handle);\n    if (current.length > 0 && currentBits + bits > maxBits) {\n      chunks.push(current);\n      current = [];\n      currentBits = 0;\n    }\n    current.push(handle);\n    currentBits += bits;\n  }\n  if (current.length > 0) {\n    chunks.push(current);\n  }\n  return chunks;\n}\n","import {\n  ChainMismatchError,\n  SignerNotConfiguredError,\n  WalletAccountNotReadyError,\n} from \"../errors\";\nimport type { GenericProvider, GenericSigner, WalletAccount } from \"../types\";\n\n/**\n * Pre-flight guard for signer-required operations. Resolves the connected\n * wallet account (refreshing once if the signer reports it isn't ready) and\n * verifies the signer's chain matches the provider's.\n *\n * @internal\n */\nexport async function requireAlignedWalletAccount(\n  operation: string,\n  signer: GenericSigner | undefined,\n  provider: GenericProvider,\n): Promise<WalletAccount> {\n  if (!signer) {\n    throw new SignerNotConfiguredError(operation);\n  }\n  let account: WalletAccount;\n  try {\n    account = signer.requireWalletAccount(operation);\n  } catch (error) {\n    if (!(error instanceof WalletAccountNotReadyError) || !signer.refreshWalletAccount) {\n      throw error;\n    }\n    await signer.refreshWalletAccount();\n    account = signer.requireWalletAccount(operation);\n  }\n  const providerChainId = await provider.getChainId();\n  if (account.chainId !== providerChainId) {\n    throw new ChainMismatchError({ operation, signerChainId: account.chainId, providerChainId });\n  }\n  return account;\n}\n\n/**\n * Variant of {@link requireAlignedWalletAccount} that returns only the aligned\n * chain ID. Useful when a write path only needs to ensure signer/provider\n * coherence and doesn't otherwise consume the account.\n *\n * @internal\n */\nexport async function requireChainAlignment(\n  operation: string,\n  signer: GenericSigner | undefined,\n  provider: GenericProvider,\n): Promise<number> {\n  return (await requireAlignedWalletAccount(operation, signer, provider)).chainId;\n}\n","import type { Address } from \"viem\";\nimport { getAddress } from \"viem\";\nimport {\n  BalanceCheckUnavailableError,\n  InsufficientConfidentialBalanceError,\n  ZamaError,\n} from \"../errors\";\nimport type { GenericProvider, GenericSigner } from \"../types\";\nimport { requireAlignedWalletAccount } from \"./alignment\";\n\n/**\n * Pre-flight for a write that would silently move zero on a short balance:\n * decrypt the connected account's balance on `tokenAddress` and throw if it\n * is below `amount`. Decrypting can prompt for a permit signature when none\n * is cached. A failure that is not already a typed SDK error surfaces as\n * {@link BalanceCheckUnavailableError}.\n *\n * @internal\n */\nexport async function assertConfidentialBalance(params: {\n  operation: string;\n  tokenAddress: Address;\n  amount: bigint;\n  signer: GenericSigner | undefined;\n  provider: GenericProvider;\n  readBalance: (owner: Address) => Promise<bigint>;\n}): Promise<void> {\n  const { operation, tokenAddress, amount, signer, provider, readBalance } = params;\n  if (amount === 0n) {\n    return;\n  }\n\n  let balance: bigint;\n  try {\n    const account = await requireAlignedWalletAccount(operation, signer, provider);\n    balance = await readBalance(getAddress(account.address));\n  } catch (error) {\n    if (error instanceof ZamaError) {\n      throw error;\n    }\n    throw new BalanceCheckUnavailableError(`Balance validation failed (token: ${tokenAddress})`, {\n      cause: error,\n    });\n  }\n\n  if (balance < amount) {\n    throw new InsufficientConfidentialBalanceError(\n      `Insufficient confidential balance: requested ${amount}, available ${balance} (token: ${tokenAddress})`,\n      { requested: amount, available: balance, token: tokenAddress },\n    );\n  }\n}\n","/**\n * Execute an array of async thunks with bounded concurrency.\n * Defaults to `Infinity` (equivalent to `Promise.all`).\n */\nexport async function pLimit<T>(\n  fns: (() => Promise<T>)[],\n  maxConcurrency = Infinity,\n): Promise<T[]> {\n  if (Number.isFinite(maxConcurrency) && maxConcurrency <= 0) {\n    throw new Error(\"maxConcurrency must be a positive number\");\n  }\n  if (!Number.isFinite(maxConcurrency) || maxConcurrency >= fns.length) {\n    return Promise.all(fns.map((f) => f()));\n  }\n\n  const results: T[] = Array.from({ length: fns.length });\n  let index = 0;\n\n  async function worker() {\n    while (index < fns.length) {\n      const i = index++;\n      if (fns[i]) {\n        results[i] = await fns[i]();\n      }\n    }\n  }\n\n  await Promise.all(Array.from({ length: maxConcurrency }, worker));\n  return results;\n}\n","import type { Hex } from \"viem\";\nimport { TransactionRevertedError, ZamaError } from \"../errors\";\nimport type { TransactionOperation, ZamaSDKEventInput } from \"../events/sdk-events\";\nimport { transactionOperationMetadata, ZamaSDKEvents } from \"../events/sdk-events\";\nimport type {\n  GenericLogger,\n  GenericProvider,\n  GenericSigner,\n  TransactionResult,\n  WriteContractConfig,\n} from \"../types\";\nimport { swallow } from \"./swallow\";\n\n/**\n * Shared write-transaction pipeline for SDK calls that submit a transaction.\n *\n * On success: writes the tx, emits the per-operation submitted event from\n * {@link transactionOperationMetadata}, fires `onSubmitted`, waits for the\n * receipt, and returns `{ txHash, receipt }`.\n *\n * On failure: emits a {@link ZamaSDKEvents.TransactionError} event with the\n * transaction-level error it will throw, then throws it. Existing `ZamaError`\n * instances are rethrown as-is; all other failures are wrapped in\n * `TransactionRevertedError` with the original error as `cause`.\n */\nexport async function submitTransaction(params: {\n  operation: TransactionOperation;\n  signer: GenericSigner;\n  provider: GenericProvider;\n  config: WriteContractConfig;\n  emit: (input: ZamaSDKEventInput) => void;\n  onSubmitted?: (txHash: Hex) => void;\n  logger: GenericLogger;\n}): Promise<TransactionResult> {\n  const { operation, signer, provider, config, emit, onSubmitted, logger } = params;\n  const metadata = transactionOperationMetadata[operation];\n\n  try {\n    const txHash = await signer.writeContract(config);\n    emit(metadata.submittedEvent(txHash));\n    void swallow(`${operation}: onSubmitted`, () => onSubmitted?.(txHash), logger);\n    const receipt = await provider.waitForTransactionReceipt(txHash);\n    return { txHash, receipt };\n  } catch (error) {\n    const failure =\n      error instanceof ZamaError\n        ? error\n        : new TransactionRevertedError(`Transaction failed during ${operation}`, { cause: error });\n\n    emit({ type: ZamaSDKEvents.TransactionError, operation, error: failure });\n    throw failure;\n  }\n}\n","import { type Address, getAddress, type Hex } from \"viem\";\nimport {\n  confidentialBalanceOfContract,\n  confidentialTransferAndCallContract,\n  confidentialTransferContract,\n  confidentialTransferFromAndCallContract,\n  confidentialTransferFromContract,\n  decimalsContract,\n  ERC7984_INTERFACE_ID,\n  ERC7984_WRAPPER_INTERFACE_ID,\n  isOperatorContract,\n  nameContract,\n  setOperatorContract,\n  supportsInterfaceContract,\n  symbolContract,\n} from \"../contracts\";\nimport {\n  ConfigurationError,\n  DecryptionFailedError,\n  EncryptionFailedError,\n  isFatalBatchError,\n  requireConfigured,\n  ZamaError,\n} from \"../errors\";\nimport type { TransactionOperation, ZamaSDKEventInput } from \"../events/sdk-events\";\nimport type { EncryptedValue } from \"../relayer/types\";\nimport { toError } from \"../utils\";\nimport { requireAlignedWalletAccount, requireChainAlignment } from \"../utils/alignment\";\nimport { assertConfidentialBalance } from \"../utils/assert-balance\";\nimport { assertBigint } from \"../utils/assertions\";\nimport { pLimit } from \"../utils/concurrency\";\nimport { isEncryptedValueZero } from \"../utils/handles\";\nimport { submitTransaction as submitSdkTransaction } from \"../utils/submit-transaction\";\nimport { swallow } from \"../utils/swallow\";\nimport type {\n  GenericSigner,\n  TransactionResult,\n  TransferCallbacks,\n  TransferOptions,\n  WriteContractConfig,\n} from \"../types\";\nimport type { ZamaSDK } from \"../zama-sdk\";\n\n/** Options for {@link Token.batchDecryptBalancesAs}. */\nexport interface BatchDecryptAsOptions {\n  /** The address of the account that delegated decryption rights. */\n  delegatorAddress: Address;\n  /** Pre-fetched encrypted values. When omitted, they are fetched from the chain. */\n  encryptedValues?: EncryptedValue[];\n  /**\n   * The account whose on-chain balance to read. Defaults to the delegator\n   * address, which is the common case (the delegator grants permission to\n   * decrypt their own balance). Only set this when the account differs\n   * from the delegator.\n   *\n   * Matches the `account` parameter of `confidentialBalanceOf(account)` on-chain.\n   */\n  accountAddress?: Address;\n  /** Maximum number of concurrent decrypt calls. Default: 10. */\n  maxConcurrency?: number;\n  /** Called when decryption fails for a single token. Return a fallback bigint. */\n  onError?: (error: Error, address: Address) => bigint;\n}\n\n/** Result of {@link Token.batchBalancesOf}. */\nexport interface BatchBalancesResult {\n  /** Successfully decrypted balances, keyed by token address. */\n  results: Map<Address, bigint>;\n  /** Per-token errors for tokens that failed to decrypt. */\n  errors: Map<Address, ZamaError>;\n}\n\n/**\n * High-level interface for an ERC-7984 confidential token.\n * Hides FHE complexity (encryption, decryption, EIP-712 signing) behind\n * familiar ERC-20-like methods.\n *\n * For ERC-7984 wrappers (shield/unshield), use {@link WrappedToken} instead —\n * it extends `Token` with wrapper-specific operations.\n *\n * Decryption, credentials, caching, and event emission are handled by the\n * owning {@link ZamaSDK} — this class only exposes token-scoped helpers\n * that delegate to `sdk.decryption.decryptValues` and `sdk.permits.grantPermit`.\n */\nexport class Token {\n  /** The SDK instance this token operates through. */\n  readonly sdk: ZamaSDK;\n  /** Checksummed address of the confidential token contract. */\n  readonly address: Address;\n\n  constructor(sdk: ZamaSDK, address: Address) {\n    this.sdk = sdk;\n    this.address = getAddress(address);\n  }\n\n  /** Resolve `sdk.signer` or throw {@link SignerNotConfiguredError} tagged with `operation`. */\n  #requireSigner(operation: string): GenericSigner {\n    return requireConfigured(this.sdk.signer, operation);\n  }\n\n  // METADATA\n\n  /** Read the token name from the contract. */\n  async name(): Promise<string> {\n    return this.sdk.provider.readContract(nameContract(this.address));\n  }\n\n  /** Read the token symbol from the contract. */\n  async symbol(): Promise<string> {\n    return this.sdk.provider.readContract(symbolContract(this.address));\n  }\n\n  /** Read the token decimals from the contract. */\n  async decimals(): Promise<number> {\n    return this.sdk.provider.readContract(decimalsContract(this.address));\n  }\n\n  // ERC-165 DISCOVERY\n\n  /**\n   * ERC-165 check for {@link ERC7984_INTERFACE_ID} support.\n   *\n   * @returns `true` if the contract implements the ERC-7984 confidential token interface.\n   */\n  async isConfidential(): Promise<boolean> {\n    return this.sdk.provider.readContract(\n      supportsInterfaceContract(this.address, ERC7984_INTERFACE_ID),\n    );\n  }\n\n  /**\n   * ERC-165 check for IERC7984ERC20Wrapper support.\n   *\n   * @returns `true` if the contract implements the ERC-7984 wrapper interface\n   *   ({@link ERC7984_WRAPPER_INTERFACE_ID}, `0x1f1c62b2`).\n   */\n  async isWrapper(): Promise<boolean> {\n    return this.sdk.provider.readContract(\n      supportsInterfaceContract(this.address, ERC7984_WRAPPER_INTERFACE_ID),\n    );\n  }\n\n  // BALANCES\n\n  /**\n   * Decrypt and return the plaintext balance for the given owner.\n   * Acquires FHE credentials via a wallet signature if none are cached.\n   *\n   * @param owner - Balance owner address.\n   * @returns The decrypted plaintext balance as a bigint.\n   * @throws if FHE decryption fails. {@link DecryptionFailedError}\n   *\n   * @example\n   * ```ts\n   * const balance = await token.balanceOf(\"0xOwner\");\n   * ```\n   */\n  async balanceOf(owner: Address): Promise<bigint> {\n    const ownerAddress = getAddress(owner);\n    const encryptedValue = await this.readConfidentialBalanceOf(ownerAddress);\n    const result = await this.sdk.decryption.decryptValues([\n      { encryptedValue, contractAddress: this.address },\n    ]);\n    const value = result[encryptedValue];\n    if (value === undefined) {\n      throw new DecryptionFailedError(`Decryption returned no value for ${encryptedValue}`);\n    }\n    assertBigint(value, \"balanceOf: result[encryptedValue]\");\n    return value;\n  }\n\n  /**\n   * Return the raw encrypted balance without decrypting.\n   *\n   * @param owner - Balance owner address.\n   * @returns The encrypted balance as a hex string.\n   *\n   * @example\n   * ```ts\n   * const encryptedValue = await token.confidentialBalanceOf(\"0xOwner\");\n   * ```\n   */\n  async confidentialBalanceOf(owner: Address): Promise<EncryptedValue> {\n    return this.readConfidentialBalanceOf(getAddress(owner));\n  }\n\n  /**\n   * Decrypt the balance of a delegator using delegated decryption credentials.\n   * The connected signer acts as the delegatee who has been granted permission\n   * by the delegator to decrypt their balance.\n   *\n   * Clear values are cached in storage keyed by `(account, token, encryptedValue)`.\n   * Because every on-chain balance change produces a new encrypted value,\n   * stale cache entries are never served. Cache write failures are silently\n   * ignored — they do not affect the returned value.\n   *\n   * @param delegatorAddress - The address of the account that delegated decryption rights.\n   * @param accountAddress - The account whose on-chain balance to read. Defaults\n   *   to the delegator address.\n   * @returns The decrypted plaintext balance as a bigint.\n   * @throws if no active delegation exists. {@link DelegationNotFoundError}\n   * @throws if the delegation has expired. {@link DelegationExpiredError}\n   * @throws if delegated decryption fails. {@link DecryptionFailedError}\n   *\n   * @example\n   * ```ts\n   * const balance = await token.decryptBalanceAs({\n   *   delegatorAddress: \"0xDelegator\",\n   * });\n   * ```\n   */\n  async decryptBalanceAs({\n    delegatorAddress,\n    accountAddress,\n  }: {\n    delegatorAddress: Address;\n    accountAddress?: Address;\n  }): Promise<bigint> {\n    await requireChainAlignment(\"decryptBalanceAs\", this.sdk.signer, this.sdk.provider);\n    const normalizedDelegator = getAddress(delegatorAddress);\n    const normalizedAccount = accountAddress ? getAddress(accountAddress) : normalizedDelegator;\n\n    const encryptedValue = await this.readConfidentialBalanceOf(normalizedAccount);\n    if (isEncryptedValueZero(encryptedValue)) {\n      return 0n;\n    }\n\n    const result = await this.sdk.decryption.delegatedDecryptValues(\n      [{ encryptedValue, contractAddress: this.address }],\n      normalizedDelegator,\n      normalizedAccount,\n    );\n\n    const value = result[encryptedValue];\n    if (value === undefined) {\n      throw new DecryptionFailedError(\n        `Delegated decryption returned no value for ${encryptedValue}`,\n      );\n    }\n    assertBigint(value, \"decryptBalanceAs: result[encryptedValue]\");\n    return value;\n  }\n\n  // BATCH STATICS\n\n  /**\n   * Decrypt confidential balances for multiple tokens in parallel, returning\n   * successes and per-token errors separately. Pre-authorizes all token\n   * addresses in a single wallet signature, then delegates each decrypt to\n   * `sdk.decryption.decryptValues`.\n   *\n   * Tokens that fail to decrypt land in `errors`; the batch keeps going.\n   *\n   * @param tokens - Array of {@link Token} instances bound to the same SDK.\n   * @param owner - Balance owner address.\n   * @returns `{ results, errors }` partitioning the per-token outcomes.\n   * @throws A failure that affects the whole session (rejected signature,\n   * misconfiguration, RPC rate limit, key unwrapping failure, revoked KMS\n   * context) rejects the call instead of landing in `errors`.\n   *\n   * @example\n   * ```ts\n   * const { results, errors } = await Token.batchBalancesOf(tokens, owner);\n   * ```\n   */\n  static async batchBalancesOf(tokens: Token[], owner: Address): Promise<BatchBalancesResult> {\n    const results = new Map<Address, bigint>();\n    const errors = new Map<Address, ZamaError>();\n    if (tokens.length === 0) {\n      return { results, errors };\n    }\n\n    const sdk = Token.assertSameSdk(tokens);\n    // Fail fast on chain mismatch before prompting the wallet for a signature.\n    await requireChainAlignment(\"batchBalancesOf\", sdk.signer, sdk.provider);\n    // Pre-authorize the full token set in one wallet signature so subsequent\n    // per-token decryptValues calls reuse the cached credentials.\n    await sdk.permits.grantPermit(tokens.map((t) => t.address));\n\n    // `pLimit` cannot cancel calls that already started. The shared flag stops\n    // the queued tokens from starting once a fatal error is seen, so they do\n    // not each trigger their own recovery wallet prompt.\n    let aborted = false;\n    let fatal: unknown;\n\n    const outcomes = await pLimit(\n      tokens.map((t) => async () => {\n        if (aborted) {\n          return { status: \"aborted\" as const };\n        }\n        try {\n          return { status: \"fulfilled\" as const, value: await t.balanceOf(owner) };\n        } catch (reason) {\n          // A fatal error (rejected signature, revoked KMS context, rate\n          // limit) would fail every token: stop the batch.\n          if (isFatalBatchError(reason)) {\n            aborted = true;\n            fatal ??= reason;\n            return { status: \"aborted\" as const };\n          }\n          return { status: \"rejected\" as const, reason };\n        }\n      }),\n      5,\n    );\n\n    // Some tokens were never attempted after the abort, so a partial result\n    // would be wrong: reject the whole call.\n    if (fatal !== undefined) {\n      throw fatal;\n    }\n\n    for (let i = 0; i < tokens.length; i++) {\n      const tokenAddress = tokens[i]!.address;\n      const outcome = outcomes[i]!;\n      if (outcome.status === \"aborted\") {\n        continue;\n      }\n      if (outcome.status === \"fulfilled\") {\n        results.set(tokenAddress, outcome.value);\n      } else {\n        const reason = outcome.reason;\n        const error =\n          reason instanceof ZamaError\n            ? reason\n            : new DecryptionFailedError(toError(reason).message, { cause: reason });\n        errors.set(tokenAddress, error);\n      }\n    }\n\n    // Total failure: surface the first error so callers know nothing decrypted.\n    if (errors.size === tokens.length) {\n      const firstError = errors.values().next().value;\n      throw firstError ?? new DecryptionFailedError(\"All token balance decryptions failed\");\n    }\n\n    return { results, errors };\n  }\n\n  /**\n   * Batch decrypt confidential balances as a delegate across multiple tokens.\n   * Mirrors {@link batchBalancesOf} but uses delegated credentials.\n   *\n   * **Error handling:** If a per-token decryption fails and no `onError` callback\n   * is provided, errors are collected and thrown as an aggregated\n   * `DecryptionFailedError`. When the relayer returns no value for an encrypted value,\n   * a `DecryptionFailedError` is thrown for that token (never silently returns `0n`).\n   * Pass `onError: () => 0n` to opt into the silent zero behavior.\n   *\n   * @param tokens - Array of Token instances to decrypt balances for.\n   * @param options - Delegated decryption configuration.\n   * @returns A Map from token address to decrypted balance.\n   * @throws if no active delegation exists. {@link DelegationNotFoundError}\n   * @throws if the delegation has expired. {@link DelegationExpiredError}\n   * @throws if any decryption fails and no `onError` is provided. {@link DecryptionFailedError}\n   * @throws A failure that affects the whole session (rejected signature, RPC\n   * rate limit, revoked KMS context) rejects the call even when `onError` is\n   * provided.\n   *\n   * @example\n   * ```ts\n   * const balances = await Token.batchDecryptBalancesAs(tokens, {\n   *   delegatorAddress: \"0xDelegator\",\n   *   onError: (err, addr) => { console.error(addr, err); return 0n; },\n   * });\n   * ```\n   */\n  static async batchDecryptBalancesAs(\n    tokens: Token[],\n    options: BatchDecryptAsOptions,\n  ): Promise<Map<Address, bigint>> {\n    if (tokens.length === 0) {\n      return new Map();\n    }\n\n    const sdk = Token.assertSameSdk(tokens);\n    const results = new Map<Address, bigint>();\n    const errors = new Map<Address, ZamaError>();\n    const normalizedAccount = options.accountAddress\n      ? getAddress(options.accountAddress)\n      : getAddress(options.delegatorAddress);\n    const maxConcurrency = options.maxConcurrency ?? 10;\n    if (options.encryptedValues && tokens.length !== options.encryptedValues.length) {\n      throw new DecryptionFailedError(\n        `tokens.length (${tokens.length}) must equal encryptedValues.length (${options.encryptedValues.length})`,\n      );\n    }\n    const resolvedEncryptedValues =\n      options.encryptedValues ??\n      (await Token.readBalanceHandlesBatch(tokens, normalizedAccount, errors, maxConcurrency));\n\n    const decryptRequests: Array<{ token: Token; encryptedValue: EncryptedValue }> = [];\n    for (const [index, token] of tokens.entries()) {\n      const encryptedValue = resolvedEncryptedValues[index];\n      if (!encryptedValue || errors.has(token.address)) {\n        continue;\n      }\n      if (isEncryptedValueZero(encryptedValue)) {\n        // Zero balance → skip the relayer; no decryption needed.\n        results.set(token.address, 0n);\n      } else {\n        decryptRequests.push({ token, encryptedValue });\n      }\n    }\n\n    if (decryptRequests.length > 0) {\n      const decrypted = await sdk.decryption.delegatedBatchDecryptValues({\n        encryptedInputs: decryptRequests.map(({ token, encryptedValue }) => ({\n          encryptedValue,\n          contractAddress: token.address,\n        })),\n        delegatorAddress: options.delegatorAddress,\n        accountAddress: options.accountAddress,\n        maxConcurrency,\n      });\n\n      for (const [index, item] of decrypted.items.entries()) {\n        const request = decryptRequests[index];\n        if (!request) {\n          continue;\n        }\n        if (item.error) {\n          errors.set(request.token.address, item.error);\n          continue;\n        }\n        const value = item.value;\n        if (value === undefined) {\n          errors.set(\n            request.token.address,\n            new DecryptionFailedError(\n              `Batch delegated decryption returned no value for ${item.encryptedValue} on token ${request.token.address}`,\n            ),\n          );\n          continue;\n        }\n        assertBigint(value, \"batchDecryptBalancesAs: result[encryptedValue]\");\n        results.set(request.token.address, value);\n      }\n    }\n\n    if (errors.size === 0) {\n      return results;\n    }\n\n    if (options.onError) {\n      const callbackErrors: Array<{ address: Address; error: Error }> = [];\n      for (const [address, error] of errors) {\n        try {\n          results.set(address, options.onError(error, address));\n        } catch (callbackError) {\n          callbackErrors.push({ address, error: toError(callbackError) });\n        }\n      }\n      if (callbackErrors.length > 0) {\n        const message = callbackErrors\n          .map(({ address, error }) => `${address}: ${error.message}`)\n          .join(\"; \");\n        throw new DecryptionFailedError(\n          `Batch delegated decryption onError callback failed for ${callbackErrors.length} token(s): ${message}`,\n          { cause: callbackErrors[0]?.error },\n        );\n      }\n      return results;\n    }\n\n    const errorEntries = Array.from(errors.entries());\n    const message = errorEntries.map(([addr, e]) => `${addr}: ${e.message}`).join(\"; \");\n    throw new DecryptionFailedError(\n      `Batch delegated decryption failed for ${errors.size} token(s): ${message}`,\n      { cause: errorEntries[0]?.[1] },\n    );\n  }\n\n  private static async readBalanceHandlesBatch(\n    tokens: Token[],\n    accountAddress: Address,\n    errors: Map<Address, ZamaError>,\n    maxConcurrency: number,\n  ): Promise<Array<EncryptedValue | undefined>> {\n    // `pLimit` cannot cancel calls that already started. The shared flag stops\n    // the queued tokens from re-hitting an endpoint that already failed for\n    // the whole batch.\n    let aborted = false;\n    let fatal: unknown;\n\n    const outcomes = await pLimit(\n      tokens.map((token) => async () => {\n        if (aborted) {\n          return { status: \"aborted\" as const };\n        }\n        try {\n          return {\n            status: \"fulfilled\" as const,\n            value: await token.readConfidentialBalanceOf(accountAddress),\n          };\n        } catch (reason) {\n          if (isFatalBatchError(reason)) {\n            aborted = true;\n            fatal ??= reason;\n            return { status: \"aborted\" as const };\n          }\n          return { status: \"rejected\" as const, reason };\n        }\n      }),\n      maxConcurrency,\n    );\n\n    if (fatal !== undefined) {\n      throw fatal;\n    }\n\n    const encryptedValues: Array<EncryptedValue | undefined> = [];\n    for (const [index, token] of tokens.entries()) {\n      const outcome = outcomes[index];\n      if (!outcome || outcome.status === \"aborted\") {\n        continue;\n      }\n      if (outcome.status === \"fulfilled\") {\n        encryptedValues[index] = outcome.value;\n        continue;\n      }\n      errors.set(\n        token.address,\n        outcome.reason instanceof ZamaError\n          ? outcome.reason\n          : new DecryptionFailedError(toError(outcome.reason).message, { cause: outcome.reason }),\n      );\n    }\n    return encryptedValues;\n  }\n\n  // WRITE OPERATIONS\n\n  /**\n   * Confidential transfer. Encrypts the amount via FHE, then calls the contract.\n   *\n   * By default, the SDK validates the confidential balance before submitting.\n   * If a cached plaintext balance exists it is used; otherwise, if credentials\n   * are cached, it decrypts on the fly. Set `skipBalanceCheck: true` to bypass\n   * this validation (e.g. for smart wallets).\n   *\n   * @param to - Recipient address.\n   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).\n   * @param options - Optional: `skipBalanceCheck` (default `false`).\n   * @returns The transaction hash and mined receipt.\n   * @throws if signer and provider are on different chains. {@link ChainMismatchError}\n   * @throws if the balance is less than `amount`. {@link InsufficientConfidentialBalanceError}\n   * @throws if balance validation requires decryption that is not possible. {@link BalanceCheckUnavailableError}\n   * @throws if FHE encryption fails. {@link EncryptionFailedError}\n   * @throws if the on-chain transfer reverts. {@link TransactionRevertedError}\n   *\n   * @example\n   * ```ts\n   * const txHash = await token.confidentialTransfer(\"0xRecipient\", 1000n);\n   * ```\n   */\n  async confidentialTransfer(\n    to: Address,\n    amount: bigint,\n    options?: TransferOptions,\n  ): Promise<TransactionResult> {\n    this.#requireSigner(\"confidentialTransfer\");\n    const account = await requireAlignedWalletAccount(\n      \"confidentialTransfer\",\n      this.sdk.signer,\n      this.sdk.provider,\n    );\n    const { skipBalanceCheck = false, onEncryptComplete, onTransferSubmitted } = options ?? {};\n\n    const normalizedTo = getAddress(to);\n\n    if (!skipBalanceCheck) {\n      await this.assertConfidentialBalance(amount);\n    }\n\n    const { encryptedValues, inputProof } = await this.sdk.encrypt({\n      values: [{ value: amount, type: \"euint64\" }],\n      contractAddress: this.address,\n      userAddress: getAddress(account.address),\n    });\n    void swallow(\"transfer: onEncryptComplete\", () => onEncryptComplete?.(), this.sdk.logger);\n\n    if (encryptedValues.length === 0) {\n      throw new EncryptionFailedError(\"Encryption returned no encrypted values\");\n    }\n\n    return this.submitTransaction({\n      operation: \"transfer\",\n      config: confidentialTransferContract(\n        this.address,\n        normalizedTo,\n        encryptedValues[0]!,\n        inputProof,\n      ),\n      onSubmitted: onTransferSubmitted,\n    });\n  }\n\n  /**\n   * Operator encrypted transfer on behalf of another address.\n   * The caller must be an approved operator for `from`.\n   *\n   * @param from - The address to transfer from (caller must be an approved operator).\n   * @param to - Recipient address.\n   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).\n   * @returns The transaction hash and mined receipt.\n   *\n   * @example\n   * ```ts\n   * const txHash = await token.confidentialTransferFrom(\"0xFrom\", \"0xTo\", 500n);\n   * ```\n   */\n  async confidentialTransferFrom(\n    from: Address,\n    to: Address,\n    amount: bigint,\n    callbacks?: TransferCallbacks,\n  ): Promise<TransactionResult> {\n    this.#requireSigner(\"confidentialTransferFrom\");\n    const account = await requireAlignedWalletAccount(\n      \"confidentialTransferFrom\",\n      this.sdk.signer,\n      this.sdk.provider,\n    );\n    const normalizedFrom = getAddress(from);\n    const normalizedTo = getAddress(to);\n\n    // The input proof is verified against msg.sender, so it binds to the caller, not `from`.\n    const { encryptedValues, inputProof } = await this.sdk.encrypt({\n      values: [{ value: amount, type: \"euint64\" }],\n      contractAddress: this.address,\n      userAddress: getAddress(account.address),\n    });\n    void swallow(\n      \"transferFrom: onEncryptComplete\",\n      () => callbacks?.onEncryptComplete?.(),\n      this.sdk.logger,\n    );\n\n    if (encryptedValues.length === 0) {\n      throw new EncryptionFailedError(\"Encryption returned no encrypted values\");\n    }\n\n    return this.submitTransaction({\n      operation: \"transferFrom\",\n      config: confidentialTransferFromContract(\n        this.address,\n        normalizedFrom,\n        normalizedTo,\n        encryptedValues[0]!,\n        inputProof,\n      ),\n      onSubmitted: callbacks?.onTransferSubmitted,\n    });\n  }\n\n  /**\n   * ERC-7984 `confidentialTransferAndCall`: encrypted transfer that also invokes\n   * the recipient's receiver hook (`onConfidentialTransferReceived`) in a single\n   * transaction. The caller crafts the opaque `data` payload — the SDK does not\n   * encode, validate, or interpret it.\n   *\n   * Balance validation follows the same rules as {@link Token.confidentialTransfer}.\n   *\n   * @param to - Recipient address. Must implement the ERC-7984 receiver hook.\n   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).\n   * @param data - Opaque bytes forwarded to the recipient's receiver hook.\n   * @param options - Optional: `skipBalanceCheck` (default `false`).\n   * @returns The transaction hash and mined receipt.\n   *\n   * @throws if signer and provider are on different chains. {@link ChainMismatchError}\n   * @throws if the balance is less than `amount`. {@link InsufficientConfidentialBalanceError}\n   * @throws if balance validation requires decryption that is not possible. {@link BalanceCheckUnavailableError}\n   * @throws if FHE encryption fails. {@link EncryptionFailedError}\n   * @throws if the on-chain transfer reverts. {@link TransactionRevertedError}\n   *\n   * @example\n   * ```ts\n   * const txHash = await token.confidentialTransferAndCall(\n   *   \"0xRecipient\",\n   *   1000n,\n   *   \"0xabcd\", // caller-encoded payload forwarded to the receiver hook\n   * );\n   * ```\n   */\n  async confidentialTransferAndCall(\n    to: Address,\n    amount: bigint,\n    data: Hex,\n    options?: TransferOptions,\n  ): Promise<TransactionResult> {\n    this.#requireSigner(\"confidentialTransferAndCall\");\n    const account = await requireAlignedWalletAccount(\n      \"confidentialTransferAndCall\",\n      this.sdk.signer,\n      this.sdk.provider,\n    );\n    const { skipBalanceCheck = false, onEncryptComplete, onTransferSubmitted } = options ?? {};\n\n    const normalizedTo = getAddress(to);\n\n    if (!skipBalanceCheck) {\n      await this.assertConfidentialBalance(amount);\n    }\n\n    const { encryptedValues, inputProof } = await this.sdk.encrypt({\n      values: [{ value: amount, type: \"euint64\" }],\n      contractAddress: this.address,\n      userAddress: getAddress(account.address),\n    });\n    void swallow(\n      \"transferAndCall: onEncryptComplete\",\n      () => onEncryptComplete?.(),\n      this.sdk.logger,\n    );\n\n    if (encryptedValues.length === 0) {\n      throw new EncryptionFailedError(\"Encryption returned no encrypted values\");\n    }\n\n    return this.submitTransaction({\n      operation: \"transferAndCall\",\n      config: confidentialTransferAndCallContract(\n        this.address,\n        normalizedTo,\n        encryptedValues[0]!,\n        inputProof,\n        data,\n      ),\n      onSubmitted: onTransferSubmitted,\n    });\n  }\n\n  /**\n   * ERC-7984 `confidentialTransferFromAndCall`: operator-initiated encrypted\n   * transfer that also invokes the recipient's receiver hook in a single\n   * transaction. The caller must be an approved operator for `from` and crafts\n   * the opaque `data` payload — the SDK does not encode or interpret it.\n   *\n   * @param from - The address to transfer from (caller must be an approved operator).\n   * @param to - Recipient address. Must implement the ERC-7984 receiver hook.\n   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).\n   * @param data - Opaque bytes forwarded to the recipient's receiver hook.\n   * @param callbacks - Optional progress callbacks.\n   * @returns The transaction hash and mined receipt.\n   *\n   * @example\n   * ```ts\n   * const txHash = await token.confidentialTransferFromAndCall(\n   *   \"0xFrom\",\n   *   \"0xRecipient\",\n   *   500n,\n   *   \"0xabcd\",\n   * );\n   * ```\n   */\n  async confidentialTransferFromAndCall(\n    from: Address,\n    to: Address,\n    amount: bigint,\n    data: Hex,\n    callbacks?: TransferCallbacks,\n  ): Promise<TransactionResult> {\n    this.#requireSigner(\"confidentialTransferFromAndCall\");\n    const account = await requireAlignedWalletAccount(\n      \"confidentialTransferFromAndCall\",\n      this.sdk.signer,\n      this.sdk.provider,\n    );\n    const normalizedFrom = getAddress(from);\n    const normalizedTo = getAddress(to);\n\n    // The input proof is verified against msg.sender, so it binds to the caller, not `from`.\n    const { encryptedValues, inputProof } = await this.sdk.encrypt({\n      values: [{ value: amount, type: \"euint64\" }],\n      contractAddress: this.address,\n      userAddress: getAddress(account.address),\n    });\n    void swallow(\n      \"transferFromAndCall: onEncryptComplete\",\n      () => callbacks?.onEncryptComplete?.(),\n      this.sdk.logger,\n    );\n\n    if (encryptedValues.length === 0) {\n      throw new EncryptionFailedError(\"Encryption returned no encrypted values\");\n    }\n\n    return this.submitTransaction({\n      operation: \"transferFromAndCall\",\n      config: confidentialTransferFromAndCallContract(\n        this.address,\n        normalizedFrom,\n        normalizedTo,\n        encryptedValues[0]!,\n        inputProof,\n        data,\n      ),\n      onSubmitted: callbacks?.onTransferSubmitted,\n    });\n  }\n\n  // OPERATOR APPROVAL\n\n  /**\n   * Set operator approval for the confidential token.\n   * Defaults to 1 hour from now if `until` is not specified.\n   *\n   * @param operator - The address to set as an operator.\n   * @param until - Optional Unix timestamp for approval expiry. Defaults to now + 1 hour.\n   * @returns The transaction hash and mined receipt.\n   *\n   * @example\n   * ```ts\n   * const txHash = await token.setOperator(\"0xOperator\");\n   * ```\n   */\n  async setOperator(operator: Address, until?: number): Promise<TransactionResult> {\n    this.#requireSigner(\"setOperator\");\n    await requireChainAlignment(\"setOperator\", this.sdk.signer, this.sdk.provider);\n    const normalizedOperator = getAddress(operator);\n    return this.submitTransaction({\n      operation: \"setOperator\",\n      config: setOperatorContract(this.address, normalizedOperator, until),\n    });\n  }\n\n  /**\n   * Check if a spender is an approved operator for a given holder.\n   *\n   * @param holder - The token holder address.\n   * @param spender - The address to check operator approval for.\n   * @returns `true` if the spender is an approved operator for the holder.\n   *\n   * @example\n   * ```ts\n   * if (await token.isOperator(\"0xHolder\", \"0xSpender\")) {\n   *   // spender can call transferFrom on behalf of holder\n   * }\n   * ```\n   */\n  async isOperator(holder: Address, spender: Address): Promise<boolean> {\n    return this.sdk.provider.readContract(\n      isOperatorContract(this.address, getAddress(holder), getAddress(spender)),\n    );\n  }\n\n  // PROTECTED HELPERS\n\n  /**\n   * Read the on-chain encrypted balance for a given owner.\n   *\n   * @internal\n   */\n  protected async readConfidentialBalanceOf(owner: Address): Promise<EncryptedValue> {\n    return await this.sdk.provider.readContract(confidentialBalanceOfContract(this.address, owner));\n  }\n\n  /**\n   * Pre-flight the connected account's balance on this token before a write\n   * that would otherwise move zero on a short balance.\n   *\n   * @internal\n   */\n  protected async assertConfidentialBalance(amount: bigint): Promise<void> {\n    return assertConfidentialBalance({\n      operation: \"assertConfidentialBalance\",\n      tokenAddress: this.address,\n      amount,\n      signer: this.sdk.signer,\n      provider: this.sdk.provider,\n      readBalance: (owner) => this.balanceOf(owner),\n    });\n  }\n\n  /**\n   * Emit a token-scoped event through the owning {@link ZamaSDK} so that\n   * subscribers see a unified stream.\n   *\n   * @internal\n   */\n  protected emit(input: ZamaSDKEventInput): void {\n    this.sdk.emitEvent(input, this.address);\n  }\n\n  /**\n   * Submit a token-scoped write transaction through the shared SDK transaction\n   * pipeline. Callers keep pre-flight and operation-specific work local.\n   *\n   * @internal\n   */\n  protected async submitTransaction(params: {\n    operation: TransactionOperation;\n    config: WriteContractConfig;\n    onSubmitted?: (txHash: Hex) => void;\n  }): Promise<TransactionResult> {\n    const { operation, config, onSubmitted } = params;\n    return submitSdkTransaction({\n      operation,\n      signer: this.#requireSigner(operation),\n      provider: this.sdk.provider,\n      config,\n      emit: (input) => this.emit(input),\n      onSubmitted,\n      logger: this.sdk.logger,\n    });\n  }\n\n  /** Verify all tokens share the same SDK instance and return it. */\n  private static assertSameSdk(tokens: Token[]): ZamaSDK {\n    const sdk = tokens[0]!.sdk;\n    for (let i = 1; i < tokens.length; i++) {\n      if (tokens[i]!.sdk !== sdk) {\n        throw new ConfigurationError(\n          \"All tokens in a batch operation must share the same ZamaSDK instance\",\n        );\n      }\n    }\n    return sdk;\n  }\n}\n"],"mappings":"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"}

package/dist/esm/{types-BOyFfG7D.d.ts → types-Bz5-wHPv.d.ts}

@@ -1,6 +1,6 @@
-import { d as AtLeastOneChain, f as FheChain } from "./index-Gk1S0gjO.js";
+import { d as AtLeastOneChain, f as FheChain } from "./index-ijgDL4IC.js";
 import { Abi, Address, ContractFunctionArgs, ContractFunctionName, ContractFunctionReturnType, Hex } from "viem";
-import { CanUseUnifiedDecryptionPermitParameters, CanUseUnifiedDecryptionPermitReturnType, CreateUnsignedLegacyDecryptionPermitEip712Parameters, CreateUnsignedLegacyDecryptionPermitEip712ReturnType, CreateUnsignedUnifiedDecryptionPermitEip712Parameters, CreateUnsignedUnifiedDecryptionPermitEip712ReturnType } from "@fhevm/sdk/actions/base";
+import { CreateUnsignedLegacyDecryptionPermitEip712Parameters, CreateUnsignedLegacyDecryptionPermitEip712ReturnType } from "@fhevm/sdk/actions/base";
 import { createFhevmClient, setFhevmRuntimeConfig } from "@fhevm/sdk/viem";
 import { Eip712Like, TypedValue, TypedValue as TypedValue$1 } from "@fhevm/sdk/types";
 import { DecryptValuesParameters } from "@fhevm/sdk/actions/decrypt";
@@ -176,7 +176,7 @@ interface FhevmRelayerOptions {
  * Single-chain FHE backend contract. Implemented by `FhevmRelayer` (drives
  * `@fhevm/sdk`); translates between the domain shapes above and the engine's API.
  */
-interface RelayerSDK extends Pick<FhevmClient, "encryptValue" | "encryptValues" | "decryptPublicValue" | "decryptPublicValues" | "decryptPublicValuesWithSignatures" | "decryptValue" | "decryptValues" | "decryptValuesFromPairs" | "fetchFheEncryptionKeyBytes" | "generateTransportKeyPair" | "serializeTransportKeyPair" | "serializeSignedDecryptionPermit" | "signDecryptionPermit" | "signUnifiedDecryptionPermit" | "parseTransportKeyPair" | "parseSignedDecryptionPermit"> {
+interface RelayerSDK extends Pick<FhevmClient, "encryptValue" | "encryptValues" | "decryptPublicValue" | "decryptPublicValues" | "decryptPublicValuesWithSignatures" | "decryptValue" | "decryptValues" | "decryptValuesFromPairs" | "fetchFheEncryptionKeyBytes" | "generateTransportKeyPair" | "serializeTransportKeyPair" | "serializeSignedDecryptionPermit" | "signDecryptionPermit" | "parseTransportKeyPair" | "parseSignedDecryptionPermit"> {
   /** The single FHE-enabled chain this backend instance is bound to. */
   chain: FheChain;
   /**
@@ -191,33 +191,6 @@ interface RelayerSDK extends Pick<FhevmClient, "encryptValue" | "encryptValues"
    * resolve the active protocol version — signer-offline, not network-offline.
    */
   createUnsignedLegacyDecryptionPermitEip712(parameters: CreateUnsignedLegacyDecryptionPermitEip712Parameters): Promise<CreateUnsignedLegacyDecryptionPermitEip712ReturnType>;
-  /**
-   * Builds the unsigned EIP-712 typed data for a V2 (unified) decryption
-   * permit — the signer-less counterpart to {@link FhevmClient.signUnifiedDecryptionPermit}.
-   * Not exposed on `@fhevm/sdk`'s client decorator, so it's called directly
-   * against the base client rather than through a decorated method.
-   *
-   * Unlike its V1 counterpart, this builder has no `delegatorAddress`
-   * parameter: V2 delegation is post-sign metadata, not part of the signed
-   * message, so a delegated offline request carries it separately on
-   * {@link PreparedPermit} instead of threading it through here.
-   *
-   * Backs the offline permit flow (`Offline.preparePermit`): the SDK builds
-   * the typed data here and hands it to an out-of-process signer for
-   * `eth_signTypedData_v4`. Reads the chain's KMS signers context on-chain to
-   * resolve the active protocol version — signer-offline, not network-offline.
-   */
-  createUnsignedUnifiedDecryptionPermitEip712(parameters: CreateUnsignedUnifiedDecryptionPermitEip712Parameters): Promise<CreateUnsignedUnifiedDecryptionPermitEip712ReturnType>;
-  /**
-   * Reports whether the connected relayer supports V2 (unified) decryption
-   * permits — specifically its `/v3/user-decrypt` route. Not exposed on
-   * `@fhevm/sdk`'s client decorator, so it's called directly against the base
-   * client rather than through a decorated method.
-   *
-   * The relayer's feature set is resolved once per client and pinned, so
-   * repeated calls are cheap and never drift.
-   */
-  canUseUnifiedDecryptionPermit(parameters?: CanUseUnifiedDecryptionPermitParameters): Promise<CanUseUnifiedDecryptionPermitReturnType>;
   /**
    * Releases backend resources (e.g. an encrypt worker) once in-flight work
    * finishes; a later call re-acquires them. Safe to omit and safe to call twice.
@@ -566,9 +539,9 @@ declare const ZamaSDKEvents: {
   readonly WrapSubmitted: "wrap:submitted";
   readonly UnwrapSubmitted: "unwrap:submitted";
   readonly FinalizeUnwrapSubmitted: "finalizeUnwrap:submitted";
+  readonly VaultSubmitted: "vault:submitted";
   readonly DelegationSubmitted: "delegation:submitted";
   readonly RevokeDelegationSubmitted: "revokeDelegation:submitted";
-  readonly InvalidateDecryptionSignaturesSubmitted: "invalidateDecryptionSignatures:submitted";
   readonly UnshieldPhase1Submitted: "unshield:phase1_submitted";
   readonly UnshieldPhase2Started: "unshield:phase2_started";
   readonly UnshieldPhase2Submitted: "unshield:phase2_submitted";
@@ -577,7 +550,10 @@ declare const ZamaSDKEvents: {
 type ZamaSDKEventType = (typeof ZamaSDKEvents)[keyof typeof ZamaSDKEvents];
 /** Fields present on every SDK event; each concrete event extends this. */
 interface BaseEvent {
-  /** Confidential token this event relates to, when the operation targets one. */
+  /**
+   * Contract this event relates to, when the operation targets one: the
+   * confidential token, or the vault batcher for {@link VaultSubmittedEvent}.
+   */
   tokenAddress?: Address;
   /** Unix epoch time (milliseconds) at which the event was emitted. */
   timestamp: number;
@@ -694,6 +670,17 @@ interface SetOperatorSubmittedEvent extends BaseEvent {
   /** Hash of the submitted setOperator transaction. */
   txHash: Hex;
 }
+/** Which vault batcher write a {@link VaultSubmittedEvent} describes. */
+type VaultOperation = "join" | "quit" | "claim" | "recover" | "dispatchBatch";
+/** Emitted when a vault batcher transaction has been submitted to the network. */
+interface VaultSubmittedEvent extends BaseEvent {
+  /** Event type discriminant. */
+  type: typeof ZamaSDKEvents.VaultSubmitted;
+  /** Hash of the submitted batcher transaction. */
+  txHash: Hex;
+  /** The batcher write this transaction performs. */
+  vaultOperation: VaultOperation;
+}
 /** Emitted when an underlying-ERC-20 approval transaction has been submitted to the network. */
 interface ApproveUnderlyingSubmittedEvent extends BaseEvent {
   /** Event type discriminant. */
@@ -743,13 +730,6 @@ interface RevokeDelegationSubmittedEvent extends BaseEvent {
   /** Hash of the submitted revokeDelegation transaction. */
   txHash: Hex;
 }
-/** Emitted when an invalidate-decryption-signatures transaction has been submitted to the network. */
-interface InvalidateDecryptionSignaturesSubmittedEvent extends BaseEvent {
-  /** Event type discriminant. */
-  type: typeof ZamaSDKEvents.InvalidateDecryptionSignaturesSubmitted;
-  /** Hash of the submitted invalidateDecryptionSignatures transaction. */
-  txHash: Hex;
-}
 /** Emitted when the first phase of an unshield (the unwrap request) has been submitted. */
 interface UnshieldPhase1SubmittedEvent extends BaseEvent {
   /** Event type discriminant. */
@@ -776,7 +756,7 @@ interface UnshieldPhase2SubmittedEvent extends BaseEvent {
  * 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 | PermitErrorEvent | TransactionErrorEvent | ShieldSubmittedEvent | TransferSubmittedEvent | TransferFromSubmittedEvent | SetOperatorSubmittedEvent | ApproveUnderlyingSubmittedEvent | WrapSubmittedEvent | UnwrapSubmittedEvent | FinalizeUnwrapSubmittedEvent | DelegationSubmittedEvent | RevokeDelegationSubmittedEvent | InvalidateDecryptionSignaturesSubmittedEvent | UnshieldPhase1SubmittedEvent | UnshieldPhase2StartedEvent | UnshieldPhase2SubmittedEvent;
+type ZamaSDKEvent = EncryptStartEvent | EncryptEndEvent | EncryptErrorEvent | DecryptStartEvent | DecryptEndEvent | DecryptErrorEvent | PermitErrorEvent | TransactionErrorEvent | ShieldSubmittedEvent | TransferSubmittedEvent | TransferFromSubmittedEvent | SetOperatorSubmittedEvent | VaultSubmittedEvent | ApproveUnderlyingSubmittedEvent | WrapSubmittedEvent | UnwrapSubmittedEvent | FinalizeUnwrapSubmittedEvent | DelegationSubmittedEvent | RevokeDelegationSubmittedEvent | UnshieldPhase1SubmittedEvent | UnshieldPhase2StartedEvent | UnshieldPhase2SubmittedEvent;
 /** Callback invoked with each emitted {@link ZamaSDKEvent}. */
 type ZamaSDKEventListener = (event: ZamaSDKEvent) => void;
 /**
@@ -786,7 +766,7 @@ type ZamaSDKEventListener = (event: ZamaSDKEvent) => void;
  * one (`shield:transferAndCall` vs. `shield:approveAndWrap`), routing both error
  * and success events on a single field — see {@link transactionOperationMetadata}.
  */
-type TransactionOperation = "approveUnderlying" | "approveUnderlying:reset" | "delegateDecryption" | "finalizeUnwrap" | "invalidateDecryptionSignatures" | "revokeDelegation" | "setOperator" | "shield:transferAndCall" | "shield:approveAndWrap" | "wrap" | "transfer" | "transferAndCall" | "transferFrom" | "transferFromAndCall" | "unwrap" | "unwrapAll";
+type TransactionOperation = "approveUnderlying" | "approveUnderlying:reset" | "delegateDecryption" | "finalizeUnwrap" | "revokeDelegation" | "setOperator" | "shield:transferAndCall" | "shield:approveAndWrap" | "wrap" | "transfer" | "transferAndCall" | "transferFrom" | "transferFromAndCall" | "unwrap" | "unwrapAll" | "vault:join" | "vault:quit" | "vault:claim" | "vault:recover" | "vault:dispatchBatch";
 //#endregion
 //#region src/types/contract.d.ts
 /** ABI type accepted by contract call builders. Supports both typed and untyped ABIs. */
@@ -1379,5 +1359,5 @@ type ZamaConfig = {
   readonly [zamaConfigBrand]: true;
 };
 //#endregion
-export { RevokeDelegationSubmittedEvent as $, TransactionResult as $t, WalletAccountListener as A, OnChainEvent as At, ApproveUnderlyingSubmittedEvent as B, decodeDelegatedForUserDecryption as Bt, TransferAndCallRequest as C, TransferCallbacks as Ct, GenericSigner as D, AclTopics as Dt, WrapRequest as E, AclEvent as Et, ReadContractReturnType as F, UnwrapRequestedEvent as Ft, DelegationSubmittedEvent as G, decodeUnwrapRequested as Gt, DecryptEndEvent as H, decodeOnChainEvents as Ht, ReadFunctionName as I, WrapEvent as It, EncryptStartEvent as J, findRevokedDelegationForUserDecryption as Jt, EncryptEndEvent as K, decodeWrap as Kt, WriteContractArgs as L, decodeAclEvent as Lt, ContractAbi as M, TOKEN_TOPICS as Mt, ReadContractArgs as N, Topics as Nt, WalletAccount as O, ConfidentialTransferEvent as Ot, ReadContractConfig as P, UnwrapFinalizedEvent as Pt, PermitOperation as Q, TransactionReceipt as Qt, WriteContractConfig as R, decodeAclEvents as Rt, TransactionKind as S, ShieldCallbacks as St, UnwrapRequest as T, ACL_TOPICS as Tt, DecryptErrorEvent as U, decodeRevokedDelegationForUserDecryption as Ut, BaseEvent as V, decodeOnChainEvent as Vt, DecryptStartEvent as W, decodeUnwrapFinalized as Wt, InvalidateDecryptionSignaturesSubmittedEvent as X, findWrap as Xt, FinalizeUnwrapSubmittedEvent as Y, findUnwrapRequested as Yt, PermitErrorEvent as Z, RawLog as Zt, PrepareTransactionRequest as _, ShieldPath as _t, ZamaConfigBase as a, EncryptParams as an, TransferSubmittedEvent as at, RevokeDelegationRequest as b, UnwrapResult as bt, GenericStorage as c, FhevmClient as cn, UnshieldPhase2SubmittedEvent as ct, ConfidentialTransferFromRequest as d, FhevmRuntimeConfig as dn, ZamaSDKEvent as dt, ClearValue as en, SetOperatorSubmittedEvent as et, ConfidentialTransferRequest as f, RelayerOptions as fn, ZamaSDKEventListener as ft, PrepareOptions as g, ShieldOptions as gt, PrepareFees as h, ApprovalStrategy as ht, ZamaConfig as i, EncryptInput as in, TransferFromSubmittedEvent as it, WalletAccountStore as j, RevokedDelegationForUserDecryptionEvent as jt, WalletAccountChange as k, DelegatedForUserDecryptionEvent as kt, GenericProvider as l, FhevmClientOptions as ln, UnwrapSubmittedEvent as lt, FinalizeUnwrapRequest as m, TypedValue$1 as mn, ZamaSDKEvents as mt, RelayerConfig as n, DecryptValuesParameters as nn, TransactionErrorEvent as nt, ZamaConfigGeneric as o, EncryptResult as on, UnshieldPhase1SubmittedEvent as ot, DelegateDecryptionRequest as p, RelayerSDK as pn, ZamaSDKEventType as pt, EncryptErrorEvent as q, findDelegatedForUserDecryption as qt, WebRelayerConfig as r, EIP712TypedData as rn, TransactionOperation as rt, GenericLogger as s, EncryptedValue as sn, UnshieldPhase2StartedEvent as st, CleartextRelayerConfig as t, DecryptPublicValuesResult as tn, ShieldSubmittedEvent as tt, ApproveUnderlyingRequest as u, FhevmRelayerOptions as un, WrapSubmittedEvent as ut, PreparedFor as v, TransferOptions as vt, UnwrapAllRequest as w, UnshieldCallbacks as wt, SetOperatorRequest as x, WrapOptions as xt, PreparedTransaction as y, UnshieldOptions as yt, WriteFunctionName as z, decodeConfidentialTransfer as zt };
-//# sourceMappingURL=types-BOyFfG7D.d.ts.map
+export { SetOperatorSubmittedEvent as $, TransactionReceipt as $t, WalletAccountListener as A, DelegatedForUserDecryptionEvent as At, ApproveUnderlyingSubmittedEvent as B, decodeConfidentialTransfer as Bt, TransferAndCallRequest as C, ShieldCallbacks as Ct, GenericSigner as D, AclEvent as Dt, WrapRequest as E, ACL_TOPICS as Et, ReadContractReturnType as F, UnwrapFinalizedEvent as Ft, DelegationSubmittedEvent as G, decodeUnwrapFinalized as Gt, DecryptEndEvent as H, decodeOnChainEvent as Ht, ReadFunctionName as I, UnwrapRequestedEvent as It, EncryptStartEvent as J, findDelegatedForUserDecryption as Jt, EncryptEndEvent as K, decodeUnwrapRequested as Kt, WriteContractArgs as L, WrapEvent as Lt, ContractAbi as M, RevokedDelegationForUserDecryptionEvent as Mt, ReadContractArgs as N, TOKEN_TOPICS as Nt, WalletAccount as O, AclTopics as Ot, ReadContractConfig as P, Topics as Pt, RevokeDelegationSubmittedEvent as Q, RawLog as Qt, WriteContractConfig as R, decodeAclEvent as Rt, TransactionKind as S, WrapOptions as St, UnwrapRequest as T, UnshieldCallbacks as Tt, DecryptErrorEvent as U, decodeOnChainEvents as Ut, BaseEvent as V, decodeDelegatedForUserDecryption as Vt, DecryptStartEvent as W, decodeRevokedDelegationForUserDecryption as Wt, PermitErrorEvent as X, findUnwrapRequested as Xt, FinalizeUnwrapSubmittedEvent as Y, findRevokedDelegationForUserDecryption as Yt, PermitOperation as Z, findWrap as Zt, PrepareTransactionRequest as _, ShieldOptions as _t, ZamaConfigBase as a, EncryptInput as an, UnshieldPhase1SubmittedEvent as at, RevokeDelegationRequest as b, UnshieldOptions as bt, GenericStorage as c, EncryptedValue as cn, UnwrapSubmittedEvent as ct, ConfidentialTransferFromRequest as d, FhevmRelayerOptions as dn, WrapSubmittedEvent as dt, TransactionResult as en, ShieldSubmittedEvent as et, ConfidentialTransferRequest as f, FhevmRuntimeConfig as fn, ZamaSDKEvent as ft, PrepareOptions as g, ApprovalStrategy as gt, PrepareFees as h, TypedValue$1 as hn, ZamaSDKEvents as ht, ZamaConfig as i, EIP712TypedData as in, TransferSubmittedEvent as it, WalletAccountStore as j, OnChainEvent as jt, WalletAccountChange as k, ConfidentialTransferEvent as kt, GenericProvider as l, FhevmClient as ln, VaultOperation as lt, FinalizeUnwrapRequest as m, RelayerSDK as mn, ZamaSDKEventType as mt, RelayerConfig as n, DecryptPublicValuesResult as nn, TransactionOperation as nt, ZamaConfigGeneric as o, EncryptParams as on, UnshieldPhase2StartedEvent as ot, DelegateDecryptionRequest as p, RelayerOptions as pn, ZamaSDKEventListener as pt, EncryptErrorEvent as q, decodeWrap as qt, WebRelayerConfig as r, DecryptValuesParameters as rn, TransferFromSubmittedEvent as rt, GenericLogger as s, EncryptResult as sn, UnshieldPhase2SubmittedEvent as st, CleartextRelayerConfig as t, ClearValue as tn, TransactionErrorEvent as tt, ApproveUnderlyingRequest as u, FhevmClientOptions as un, VaultSubmittedEvent as ut, PreparedFor as v, ShieldPath as vt, UnwrapAllRequest as w, TransferCallbacks as wt, SetOperatorRequest as x, UnwrapResult as xt, PreparedTransaction as y, TransferOptions as yt, WriteFunctionName as z, decodeAclEvents as zt };
+//# sourceMappingURL=types-Bz5-wHPv.d.ts.map

package/dist/esm/{types-BRIpBy9n.d.ts → types-CI6BtpB7.d.ts}

@@ -1,5 +1,5 @@
-import { d as AtLeastOneChain } from "./index-Gk1S0gjO.js";
-import { a as ZamaConfigBase } from "./types-BOyFfG7D.js";
+import { d as AtLeastOneChain } from "./index-ijgDL4IC.js";
+import { a as ZamaConfigBase } from "./types-Bz5-wHPv.js";
 import { EIP1193Provider, PublicClient, WalletClient } from "viem";
 //#region src/viem/types.d.ts
 /** Viem config — pass native viem clients directly. */
@@ -13,4 +13,4 @@ interface ZamaConfigViem<TChains extends AtLeastOneChain = AtLeastOneChain> exte
 }
 //#endregion
 export { ZamaConfigViem as t };
-//# sourceMappingURL=types-BRIpBy9n.d.ts.map
+//# sourceMappingURL=types-CI6BtpB7.d.ts.map

package/dist/esm/{types-OXQqX_kH.d.ts → types-v0_sfkli.d.ts}

@@ -1,5 +1,5 @@
-import { d as AtLeastOneChain } from "./index-Gk1S0gjO.js";
-import { a as ZamaConfigBase } from "./types-BOyFfG7D.js";
+import { d as AtLeastOneChain } from "./index-ijgDL4IC.js";
+import { a as ZamaConfigBase } from "./types-Bz5-wHPv.js";
 import { EIP1193Provider } from "viem";
 import { Provider, Signer } from "ethers";
 //#region src/ethers/types.d.ts
@@ -26,4 +26,4 @@ type ZamaConfigEthers<TChains extends AtLeastOneChain = AtLeastOneChain> = ZamaC
 });
 //#endregion
 export { ZamaConfigEthers as t };
-//# sourceMappingURL=types-OXQqX_kH.d.ts.map
+//# sourceMappingURL=types-v0_sfkli.d.ts.map

package/dist/esm/{validation-DWe2k89s.js → validation-BRu06AM_.js}

@@ -1,2 +1,2 @@
-import{t as e}from"./relayer-B6Zo6EkX.js";import{z as t}from"zod/mini";function n(n,r){let i=t.safeParse(n,r);if(i.success)return i.data;throw new e(t.prettifyError(i.error),{cause:i.error})}export{n as t};
-//# sourceMappingURL=validation-DWe2k89s.js.map
+import{t as e}from"./relayer-CVKO9GmQ.js";import{z as t}from"zod/mini";function n(n,r){let i=t.safeParse(n,r);if(i.success)return i.data;throw new e(t.prettifyError(i.error),{cause:i.error})}export{n as t};
+//# sourceMappingURL=validation-BRu06AM_.js.map

package/dist/esm/{validation-DWe2k89s.js.map → validation-BRu06AM_.js.map}

@@ -1 +1 @@
-{"version":3,"file":"validation-DWe2k89s.js","names":[],"sources":["../../src/validation.ts"],"sourcesContent":["import { z } from \"zod/mini\";\nimport { ConfigurationError } from \"./errors\";\n\nexport function parseSchema<T>(schema: z.core.$ZodType<T>, value: unknown): T {\n  const parsed = z.safeParse(schema, value);\n  if (parsed.success) {\n    return parsed.data;\n  }\n  throw new ConfigurationError(z.prettifyError(parsed.error), { cause: parsed.error });\n}\n"],"mappings":"uEAGA,SAAgB,EAAe,EAA4B,EAAmB,CAC5E,IAAM,EAAS,EAAE,UAAU,EAAQ,CAAK,EACxC,GAAI,EAAO,QACT,OAAO,EAAO,KAEhB,MAAM,IAAI,EAAmB,EAAE,cAAc,EAAO,KAAK,EAAG,CAAE,MAAO,EAAO,KAAM,CAAC,CACrF"}
+{"version":3,"file":"validation-BRu06AM_.js","names":[],"sources":["../../src/validation.ts"],"sourcesContent":["import { z } from \"zod/mini\";\nimport { ConfigurationError } from \"./errors\";\n\nexport function parseSchema<T>(schema: z.core.$ZodType<T>, value: unknown): T {\n  const parsed = z.safeParse(schema, value);\n  if (parsed.success) {\n    return parsed.data;\n  }\n  throw new ConfigurationError(z.prettifyError(parsed.error), { cause: parsed.error });\n}\n"],"mappings":"uEAGA,SAAgB,EAAe,EAA4B,EAAmB,CAC5E,IAAM,EAAS,EAAE,UAAU,EAAQ,CAAK,EACxC,GAAI,EAAO,QACT,OAAO,EAAO,KAEhB,MAAM,IAAI,EAAmB,EAAE,cAAc,EAAO,KAAK,EAAG,CAAE,MAAO,EAAO,KAAM,CAAC,CACrF"}