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

package/dist/esm/fhevm-relayer-Cm-ZR1vP.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fhevm-relayer-Cm-ZR1vP.js","names":["#config","#progressListeners","#generation","#withActive","#initOnce","#dispatch","#releaseRequested","#releaseIfIdle","#degradePromise","#pinnedInline","#degrade","#crashes","#sequence","#overBoundary","#spawn","#warnCallbackThrew","#teardown","#active","#createWorker","#raceReady","#armCrashHandler","#classifyDegrade","#warnDegraded","#chain","#base","#decrypt","#encrypt","#defaultOptions","#buildEncryptBackend","#encryptInitPromise","#initEncrypt","createUnsignedLegacyDecryptionPermitEip712Action"],"sources":["../../src/chains/to-fhevm-chain.ts","../../../../node_modules/.pnpm/comlink@4.4.2/node_modules/comlink/dist/esm/comlink.mjs","../../src/worker/protocol.ts","../../src/worker/spawn.ts","../../src/worker/encrypt-worker-client.ts","../../src/relayer/fhevm-relayer.ts"],"sourcesContent":["import type { FhevmChain } from \"@fhevm/sdk/chains\";\nimport type { FheChain } from \"./types\";\n\n/**\n * Derive an `@fhevm/sdk` {@link FhevmChain} from zama-sdk's richer\n * {@link FheChain}.\n *\n * `FheChain` carries fields `@fhevm/sdk` does not model (RPC `network`,\n * `registryAddress`, `executorAddress`, cleartext signer keys); those stay on\n * `FheChain` for the token layer. This adapter projects only the subset the\n * FHE runtime needs: contract addresses, relayer URL, and gateway.\n */\nexport function toFhevmChain(chain: FheChain): FhevmChain {\n  return {\n    id: chain.id,\n    fhevm: {\n      contracts: {\n        acl: { address: chain.aclContractAddress },\n        inputVerifier: { address: chain.inputVerifierContractAddress },\n        kmsVerifier: { address: chain.kmsContractAddress },\n        protocolConfig: undefined,\n      },\n      relayerUrl: chain.relayerUrl,\n      gateway: {\n        id: chain.gatewayChainId,\n        contracts: {\n          decryption: { address: chain.verifyingContractAddressDecryption },\n          inputVerification: { address: chain.verifyingContractAddressInputVerification },\n        },\n      },\n    },\n  } satisfies FhevmChain;\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n * SPDX-License-Identifier: Apache-2.0\n */\nconst proxyMarker = Symbol(\"Comlink.proxy\");\nconst createEndpoint = Symbol(\"Comlink.endpoint\");\nconst releaseProxy = Symbol(\"Comlink.releaseProxy\");\nconst finalizer = Symbol(\"Comlink.finalizer\");\nconst throwMarker = Symbol(\"Comlink.thrown\");\nconst isObject = (val) => (typeof val === \"object\" && val !== null) || typeof val === \"function\";\n/**\n * Internal transfer handle to handle objects marked to proxy.\n */\nconst proxyTransferHandler = {\n    canHandle: (val) => isObject(val) && val[proxyMarker],\n    serialize(obj) {\n        const { port1, port2 } = new MessageChannel();\n        expose(obj, port1);\n        return [port2, [port2]];\n    },\n    deserialize(port) {\n        port.start();\n        return wrap(port);\n    },\n};\n/**\n * Internal transfer handler to handle thrown exceptions.\n */\nconst throwTransferHandler = {\n    canHandle: (value) => isObject(value) && throwMarker in value,\n    serialize({ value }) {\n        let serialized;\n        if (value instanceof Error) {\n            serialized = {\n                isError: true,\n                value: {\n                    message: value.message,\n                    name: value.name,\n                    stack: value.stack,\n                },\n            };\n        }\n        else {\n            serialized = { isError: false, value };\n        }\n        return [serialized, []];\n    },\n    deserialize(serialized) {\n        if (serialized.isError) {\n            throw Object.assign(new Error(serialized.value.message), serialized.value);\n        }\n        throw serialized.value;\n    },\n};\n/**\n * Allows customizing the serialization of certain values.\n */\nconst transferHandlers = new Map([\n    [\"proxy\", proxyTransferHandler],\n    [\"throw\", throwTransferHandler],\n]);\nfunction isAllowedOrigin(allowedOrigins, origin) {\n    for (const allowedOrigin of allowedOrigins) {\n        if (origin === allowedOrigin || allowedOrigin === \"*\") {\n            return true;\n        }\n        if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction expose(obj, ep = globalThis, allowedOrigins = [\"*\"]) {\n    ep.addEventListener(\"message\", function callback(ev) {\n        if (!ev || !ev.data) {\n            return;\n        }\n        if (!isAllowedOrigin(allowedOrigins, ev.origin)) {\n            console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);\n            return;\n        }\n        const { id, type, path } = Object.assign({ path: [] }, ev.data);\n        const argumentList = (ev.data.argumentList || []).map(fromWireValue);\n        let returnValue;\n        try {\n            const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);\n            const rawValue = path.reduce((obj, prop) => obj[prop], obj);\n            switch (type) {\n                case \"GET\" /* MessageType.GET */:\n                    {\n                        returnValue = rawValue;\n                    }\n                    break;\n                case \"SET\" /* MessageType.SET */:\n                    {\n                        parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);\n                        returnValue = true;\n                    }\n                    break;\n                case \"APPLY\" /* MessageType.APPLY */:\n                    {\n                        returnValue = rawValue.apply(parent, argumentList);\n                    }\n                    break;\n                case \"CONSTRUCT\" /* MessageType.CONSTRUCT */:\n                    {\n                        const value = new rawValue(...argumentList);\n                        returnValue = proxy(value);\n                    }\n                    break;\n                case \"ENDPOINT\" /* MessageType.ENDPOINT */:\n                    {\n                        const { port1, port2 } = new MessageChannel();\n                        expose(obj, port2);\n                        returnValue = transfer(port1, [port1]);\n                    }\n                    break;\n                case \"RELEASE\" /* MessageType.RELEASE */:\n                    {\n                        returnValue = undefined;\n                    }\n                    break;\n                default:\n                    return;\n            }\n        }\n        catch (value) {\n            returnValue = { value, [throwMarker]: 0 };\n        }\n        Promise.resolve(returnValue)\n            .catch((value) => {\n            return { value, [throwMarker]: 0 };\n        })\n            .then((returnValue) => {\n            const [wireValue, transferables] = toWireValue(returnValue);\n            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);\n            if (type === \"RELEASE\" /* MessageType.RELEASE */) {\n                // detach and deactive after sending release response above.\n                ep.removeEventListener(\"message\", callback);\n                closeEndPoint(ep);\n                if (finalizer in obj && typeof obj[finalizer] === \"function\") {\n                    obj[finalizer]();\n                }\n            }\n        })\n            .catch((error) => {\n            // Send Serialization Error To Caller\n            const [wireValue, transferables] = toWireValue({\n                value: new TypeError(\"Unserializable return value\"),\n                [throwMarker]: 0,\n            });\n            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);\n        });\n    });\n    if (ep.start) {\n        ep.start();\n    }\n}\nfunction isMessagePort(endpoint) {\n    return endpoint.constructor.name === \"MessagePort\";\n}\nfunction closeEndPoint(endpoint) {\n    if (isMessagePort(endpoint))\n        endpoint.close();\n}\nfunction wrap(ep, target) {\n    const pendingListeners = new Map();\n    ep.addEventListener(\"message\", function handleMessage(ev) {\n        const { data } = ev;\n        if (!data || !data.id) {\n            return;\n        }\n        const resolver = pendingListeners.get(data.id);\n        if (!resolver) {\n            return;\n        }\n        try {\n            resolver(data);\n        }\n        finally {\n            pendingListeners.delete(data.id);\n        }\n    });\n    return createProxy(ep, pendingListeners, [], target);\n}\nfunction throwIfProxyReleased(isReleased) {\n    if (isReleased) {\n        throw new Error(\"Proxy has been released and is not useable\");\n    }\n}\nfunction releaseEndpoint(ep) {\n    return requestResponseMessage(ep, new Map(), {\n        type: \"RELEASE\" /* MessageType.RELEASE */,\n    }).then(() => {\n        closeEndPoint(ep);\n    });\n}\nconst proxyCounter = new WeakMap();\nconst proxyFinalizers = \"FinalizationRegistry\" in globalThis &&\n    new FinalizationRegistry((ep) => {\n        const newCount = (proxyCounter.get(ep) || 0) - 1;\n        proxyCounter.set(ep, newCount);\n        if (newCount === 0) {\n            releaseEndpoint(ep);\n        }\n    });\nfunction registerProxy(proxy, ep) {\n    const newCount = (proxyCounter.get(ep) || 0) + 1;\n    proxyCounter.set(ep, newCount);\n    if (proxyFinalizers) {\n        proxyFinalizers.register(proxy, ep, proxy);\n    }\n}\nfunction unregisterProxy(proxy) {\n    if (proxyFinalizers) {\n        proxyFinalizers.unregister(proxy);\n    }\n}\nfunction createProxy(ep, pendingListeners, path = [], target = function () { }) {\n    let isProxyReleased = false;\n    const proxy = new Proxy(target, {\n        get(_target, prop) {\n            throwIfProxyReleased(isProxyReleased);\n            if (prop === releaseProxy) {\n                return () => {\n                    unregisterProxy(proxy);\n                    releaseEndpoint(ep);\n                    pendingListeners.clear();\n                    isProxyReleased = true;\n                };\n            }\n            if (prop === \"then\") {\n                if (path.length === 0) {\n                    return { then: () => proxy };\n                }\n                const r = requestResponseMessage(ep, pendingListeners, {\n                    type: \"GET\" /* MessageType.GET */,\n                    path: path.map((p) => p.toString()),\n                }).then(fromWireValue);\n                return r.then.bind(r);\n            }\n            return createProxy(ep, pendingListeners, [...path, prop]);\n        },\n        set(_target, prop, rawValue) {\n            throwIfProxyReleased(isProxyReleased);\n            // FIXME: ES6 Proxy Handler `set` methods are supposed to return a\n            // boolean. To show good will, we return true asynchronously ¯\\_(ツ)_/¯\n            const [value, transferables] = toWireValue(rawValue);\n            return requestResponseMessage(ep, pendingListeners, {\n                type: \"SET\" /* MessageType.SET */,\n                path: [...path, prop].map((p) => p.toString()),\n                value,\n            }, transferables).then(fromWireValue);\n        },\n        apply(_target, _thisArg, rawArgumentList) {\n            throwIfProxyReleased(isProxyReleased);\n            const last = path[path.length - 1];\n            if (last === createEndpoint) {\n                return requestResponseMessage(ep, pendingListeners, {\n                    type: \"ENDPOINT\" /* MessageType.ENDPOINT */,\n                }).then(fromWireValue);\n            }\n            // We just pretend that `bind()` didn’t happen.\n            if (last === \"bind\") {\n                return createProxy(ep, pendingListeners, path.slice(0, -1));\n            }\n            const [argumentList, transferables] = processArguments(rawArgumentList);\n            return requestResponseMessage(ep, pendingListeners, {\n                type: \"APPLY\" /* MessageType.APPLY */,\n                path: path.map((p) => p.toString()),\n                argumentList,\n            }, transferables).then(fromWireValue);\n        },\n        construct(_target, rawArgumentList) {\n            throwIfProxyReleased(isProxyReleased);\n            const [argumentList, transferables] = processArguments(rawArgumentList);\n            return requestResponseMessage(ep, pendingListeners, {\n                type: \"CONSTRUCT\" /* MessageType.CONSTRUCT */,\n                path: path.map((p) => p.toString()),\n                argumentList,\n            }, transferables).then(fromWireValue);\n        },\n    });\n    registerProxy(proxy, ep);\n    return proxy;\n}\nfunction myFlat(arr) {\n    return Array.prototype.concat.apply([], arr);\n}\nfunction processArguments(argumentList) {\n    const processed = argumentList.map(toWireValue);\n    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];\n}\nconst transferCache = new WeakMap();\nfunction transfer(obj, transfers) {\n    transferCache.set(obj, transfers);\n    return obj;\n}\nfunction proxy(obj) {\n    return Object.assign(obj, { [proxyMarker]: true });\n}\nfunction windowEndpoint(w, context = globalThis, targetOrigin = \"*\") {\n    return {\n        postMessage: (msg, transferables) => w.postMessage(msg, targetOrigin, transferables),\n        addEventListener: context.addEventListener.bind(context),\n        removeEventListener: context.removeEventListener.bind(context),\n    };\n}\nfunction toWireValue(value) {\n    for (const [name, handler] of transferHandlers) {\n        if (handler.canHandle(value)) {\n            const [serializedValue, transferables] = handler.serialize(value);\n            return [\n                {\n                    type: \"HANDLER\" /* WireValueType.HANDLER */,\n                    name,\n                    value: serializedValue,\n                },\n                transferables,\n            ];\n        }\n    }\n    return [\n        {\n            type: \"RAW\" /* WireValueType.RAW */,\n            value,\n        },\n        transferCache.get(value) || [],\n    ];\n}\nfunction fromWireValue(value) {\n    switch (value.type) {\n        case \"HANDLER\" /* WireValueType.HANDLER */:\n            return transferHandlers.get(value.name).deserialize(value.value);\n        case \"RAW\" /* WireValueType.RAW */:\n            return value.value;\n    }\n}\nfunction requestResponseMessage(ep, pendingListeners, msg, transfers) {\n    return new Promise((resolve) => {\n        const id = generateUUID();\n        pendingListeners.set(id, resolve);\n        if (ep.start) {\n            ep.start();\n        }\n        ep.postMessage(Object.assign({ id }, msg), transfers);\n    });\n}\nfunction generateUUID() {\n    return new Array(4)\n        .fill(0)\n        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))\n        .join(\"-\");\n}\n\nexport { createEndpoint, expose, finalizer, proxy, proxyMarker, releaseProxy, transfer, transferHandlers, windowEndpoint, wrap };\n//# sourceMappingURL=comlink.mjs.map\n","/**\n * Shared contract between the main-thread encrypt client and the encrypt\n * worker, spoken over Comlink. Every payload must survive `structuredClone`:\n * no `AbortSignal`, no class instances; callbacks cross as Comlink proxies.\n */\n\nimport type { FhevmChain } from \"@fhevm/sdk/chains\";\nimport type {\n  FhevmClientOptions,\n  FhevmEncryptBackend,\n  FhevmRelayerOptions,\n  WireRuntimeConfig,\n} from \"../relayer/types\";\nimport { isValidRetryAfterSeconds, readRetryAfterHeader } from \"../utils/error\";\n\ntype EncryptParameters = Parameters<FhevmEncryptBackend[\"encryptValue\"]>[0];\ntype EncryptsParameters = Parameters<FhevmEncryptBackend[\"encryptValues\"]>[0];\n\n/**\n * What the worker offloads, and all the encrypt client's surface the worker\n * client implements. Key fetches stay on the calling thread, where the chain's\n * auth applies and the key never crosses back out.\n */\nexport type EncryptOffloadBackend = Pick<\n  FhevmEncryptBackend,\n  \"init\" | \"encryptValue\" | \"encryptValues\"\n>;\n\n/** Per-request options minus `signal`, the one non-cloneable member of the set. */\nexport type WireRequestOptions = Omit<FhevmRelayerOptions, \"signal\">;\n\nexport type WireProgressEvent = Parameters<\n  NonNullable<NonNullable<EncryptParameters[\"options\"]>[\"onProgress\"]>\n>[0];\n\nexport type WireInitPayload = {\n  readonly chain: FhevmChain;\n  /** RPC URL for host-chain reads; absent when reads proxy through `rpcRequest`. */\n  readonly rpcUrl: string | undefined;\n  /** Carries `fheEncryptionKey`, prefetched on the main thread so the worker skips the download. */\n  readonly clientOptions: FhevmClientOptions;\n  readonly runtime: WireRuntimeConfig;\n};\n\n/** Main-thread callback the worker uses for host-chain reads when the chain's network is an injected provider. */\nexport type WireRpcRequest = (args: { method: string; params?: unknown }) => Promise<unknown>;\n\n/**\n * Main-thread callback receiving every operation's progress events, routed on\n * `id`. One channel per worker avoids minting a `MessageChannel` per call, whose\n * local port and listener would linger until garbage collection after terminate.\n * Returns `unknown`: a Comlink proxy call answers with a promise.\n */\nexport type WireProgressCallback = (id: number, event: WireProgressEvent) => unknown;\n\nexport type WireLogCallback = (level: \"debug\" | \"warn\" | \"error\", message: string) => unknown;\n\n/**\n * The API the worker exposes over Comlink. `id` correlates an in-flight\n * operation with `abort` and with its progress events, since neither an\n * `AbortSignal` nor a per-call callback can cross the boundary cheaply. The\n * `init` callback parameters must be passed as Comlink proxies (or `null`).\n */\nexport type EncryptWorkerApi = {\n  init(\n    payload: WireInitPayload,\n    rpcRequest: WireRpcRequest | null,\n    log: WireLogCallback,\n    onProgress: WireProgressCallback,\n  ): Promise<void>;\n  encryptValue(\n    id: number,\n    parameters: {\n      readonly value: EncryptParameters[\"value\"];\n      readonly contractAddress: string;\n      readonly userAddress: string;\n      readonly options: WireRequestOptions | undefined;\n    },\n  ): ReturnType<FhevmEncryptBackend[\"encryptValue\"]>;\n  encryptValues(\n    id: number,\n    parameters: {\n      readonly values: EncryptsParameters[\"values\"];\n      readonly contractAddress: string;\n      readonly userAddress: string;\n      readonly options: WireRequestOptions | undefined;\n    },\n  ): ReturnType<FhevmEncryptBackend[\"encryptValues\"]>;\n  abort(id: number): void;\n};\n\n/** Raw message the worker posts once its module graph has loaded, before Comlink traffic. */\nexport const WORKER_READY_MESSAGE = \"zama-encrypt-worker-ready\";\n\n/**\n * An `Error` flattened for the boundary crossing, thrown by the worker as a\n * plain object so it survives structured clone intact. `props` carries the\n * fields the SDK's duck-typed classifiers read (`statusCode`, `retryAfter`,\n * `code`, …); a cloned `Error` instance would drop them with the prototype.\n * Reading them through the prototype chain is deliberate: upstream's `status`\n * and `relayerApiError` are prototype getters, not own fields.\n */\nexport type WireError = {\n  readonly wireError: true;\n  readonly name: string;\n  readonly message: string;\n  readonly stack: string | undefined;\n  readonly props: Record<string, unknown>;\n  readonly cause: WireError | undefined;\n};\n\nexport function isWireError(value: unknown): value is WireError {\n  // Exact `true`, not presence: an `Error` subclass carrying the key must not be\n  // rehydrated as a flattened one.\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    (value as { wireError?: unknown }).wireError === true\n  );\n}\n\n/**\n * Fields preserved across the boundary: what the error classifiers read off\n * `@fhevm/sdk`, relayer, and JSON-RPC errors, plus the `error`/`info` nesting\n * keys those classifiers walk alongside `cause`.\n */\nconst WIRE_ERROR_PROPS = [\n  \"statusCode\",\n  \"status\",\n  \"retryAfter\",\n  \"timeoutMs\",\n  \"relayerApiError\",\n  \"code\",\n  \"data\",\n  \"shortMessage\",\n  \"details\",\n  \"error\",\n  \"info\",\n] as const;\n\nconst MAX_CAUSE_DEPTH = 6;\n\n/** A probe is exact where a structural walk only approximates. */\nfunction isCloneSafe(value: unknown): boolean {\n  try {\n    structuredClone(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * The `Retry-After` header survives as a plain number of seconds; the\n * `Response` object it lives on cannot cross the boundary.\n */\nfunction retryAfterFromResponse(error: object): number | undefined {\n  const response = (error as { response?: { headers?: unknown } }).response;\n  return readRetryAfterHeader(response?.headers);\n}\n\n/**\n * `JSON.stringify` throws instead of returning `undefined` on a bigint or a\n * circular value; a non-Error thrown value must never fail error handling itself.\n */\nfunction stringifyNonError(error: unknown): string {\n  try {\n    return JSON.stringify(error) ?? String(error);\n  } catch {\n    return String(error);\n  }\n}\n\n/** The classifier fields readable off one thrown value, `Error` or plain object alike. */\nfunction extractWireProps(source: object): Record<string, unknown> {\n  const props: Record<string, unknown> = {};\n  for (const key of WIRE_ERROR_PROPS) {\n    const value = (source as Record<string, unknown>)[key];\n    if (value !== undefined && isCloneSafe(value)) {\n      props[key] = value;\n    }\n  }\n  // The header wins over a malformed own delay (`0`, negative, `NaN`), as the\n  // inline extractor in `utils/error.ts` decides it.\n  if (!isValidRetryAfterSeconds(props[\"retryAfter\"])) {\n    const fromHeader = retryAfterFromResponse(source);\n    if (fromHeader !== undefined) {\n      props[\"retryAfter\"] = fromHeader;\n    }\n  }\n  return props;\n}\n\nexport function toWireError(error: unknown, depth: number = MAX_CAUSE_DEPTH): WireError {\n  if (isWireError(error)) {\n    return error;\n  }\n  const nest = (cause: unknown): WireError | undefined =>\n    depth > 0 && cause !== undefined ? toWireError(cause, depth - 1) : undefined;\n  if (error instanceof Error) {\n    return {\n      wireError: true,\n      name: error.name,\n      message: error.message,\n      stack: error.stack,\n      props: extractWireProps(error),\n      cause: nest(error.cause),\n    };\n  }\n  if (typeof error === \"object\" && error !== null) {\n    // Wallets reject with a plain `{ code, message, data }`; dropping `code`\n    // would break viem's classification inside the worker.\n    const { message, cause } = error as { message?: unknown; cause?: unknown };\n    return {\n      wireError: true,\n      name: \"Error\",\n      message: typeof message === \"string\" ? message : stringifyNonError(error),\n      stack: undefined,\n      props: extractWireProps(error),\n      cause: nest(cause),\n    };\n  }\n  return {\n    wireError: true,\n    name: \"Error\",\n    message: typeof error === \"string\" ? error : stringifyNonError(error),\n    stack: undefined,\n    props: {},\n    cause: undefined,\n  };\n}\n\n/**\n * Rebuilds a plain `Error` carrying the original `name`, own fields, and cause\n * chain, so name-based classification and status/retry-after extraction behave\n * as if the error had been thrown on this thread.\n */\nexport function fromWireError(wire: WireError): Error {\n  const error = new Error(wire.message, wire.cause ? { cause: fromWireError(wire.cause) } : {});\n  error.name = wire.name;\n  if (wire.stack !== undefined) {\n    error.stack = wire.stack;\n  }\n  Object.assign(error, wire.props);\n  return error;\n}\n","/** Isolated so the CJS build can replace worker construction with an inert stub. */\n\n/** False in the CJS stub, which ships no worker chunk; a caller-supplied `offloadWorker` source works in either build. */\nexport const BUNDLED_ENCRYPT_WORKER = true;\n\nexport function createEncryptWorker(): Worker {\n  // Keep the `new Worker(new URL(...))` expression exactly in this inline\n  // form: bundlers detect it statically to emit and rewrite the worker chunk,\n  // and lose it if the URL is hoisted into a variable.\n  return new Worker(new URL(\"./encrypt.worker.js\", import.meta.url), {\n    type: \"module\",\n    name: \"zama-fhe-encrypt\",\n  });\n}\n","import { proxy, transfer, wrap, type Remote } from \"comlink\";\nimport type { EIP1193Provider } from \"viem\";\nimport { EncryptOffloadUnavailableError } from \"../errors/encryption\";\nimport type { FhevmClientOptions } from \"../relayer/types\";\nimport type { LoggerService } from \"../services/logger-service\";\nimport type {\n  EncryptOffloadBackend,\n  EncryptWorkerApi,\n  WireInitPayload,\n  WireProgressEvent,\n  WireRequestOptions,\n} from \"./protocol\";\nimport { WORKER_READY_MESSAGE, fromWireError, isWireError, toWireError } from \"./protocol\";\nimport { createEncryptWorker } from \"./spawn\";\n\n/**\n * Watchdog deadlines, in milliseconds, for worker lifecycle steps: each is a\n * ceiling on \"the worker never answered\", not on legitimate slow work. Encrypt\n * operations themselves are not watched: nothing bounds local WASM compute, so\n * a proof may run for as long as it needs.\n */\nexport type EncryptWorkerTimeouts = {\n  /** Worker startup + module-graph load; a bundler that mishandled the worker URL fails here. */\n  readonly spawn: number;\n  /** Client init inside the worker realm: chain reads and WASM compilation. */\n  readonly init: number;\n};\n\nexport const DEFAULT_ENCRYPT_WORKER_TIMEOUTS: EncryptWorkerTimeouts = {\n  spawn: 10_000,\n  init: 300_000,\n};\n\n/** Second crash pins the client to the calling thread. */\nconst CRASH_PIN_THRESHOLD = 2;\n\n/** Stable prefix of every degrade warning. */\nexport const ENCRYPT_OFFLOAD_WARN_PREFIX = \"Encrypt offload unavailable\";\n\n/** Workers already returned by an `offloadWorker` factory, to catch a factory that hands out one worker forever. */\nconst handedOutWorkers = new WeakSet<Worker>();\n\n/** Internal signal: the worker infrastructure failed; the operation itself was not rejected. */\nclass WorkerUnavailableError extends Error {\n  /** True when a worker that had already signalled ready died under us, so a respawn is worth trying. */\n  readonly crashed: boolean;\n\n  constructor(message: string, options?: ErrorOptions & { readonly crashed?: boolean }) {\n    super(message, options);\n    this.name = \"WorkerUnavailableError\";\n    this.crashed = options?.crashed ?? false;\n  }\n}\n\n/**\n * A payload Comlink could not clone into the worker (`DataCloneError`) or could\n * not return out of it (its own `TypeError`): a boundary failure, so it degrades\n * rather than reaching the caller as an application error.\n */\nfunction isCloneFailure(error: unknown): boolean {\n  if (typeof error !== \"object\" || error === null) {\n    return false;\n  }\n  const { name, message } = error as { name?: unknown; message?: unknown };\n  return (\n    name === \"DataCloneError\" ||\n    (name === \"TypeError\" &&\n      typeof message === \"string\" &&\n      message.includes(\"Unserializable return value\"))\n  );\n}\n\nfunction throwIfAborted(signal: AbortSignal | undefined): void {\n  if (signal?.aborted) {\n    throw signal.reason ?? new DOMException(\"The operation was aborted.\", \"AbortError\");\n  }\n}\n\n/** What the client remembers about worker crashes, dropped whole by a worker answer and by a release. */\ntype CrashHistory = {\n  readonly count: number;\n  /** The crash that killed the current worker, so a call landing after it degrades as a crash too. */\n  readonly last: WorkerUnavailableError | undefined;\n  /** Crash count the degrade warning was last emitted for, so one failure warns once. */\n  readonly warnedFor: number;\n};\n\nconst NO_CRASHES: CrashHistory = { count: 0, last: undefined, warnedFor: -1 };\n\n/**\n * The key copied for the crossing plus the buffers to transfer, so the wire copy\n * is moved instead of cloned. Anything but the known binary shape crosses\n * unchanged.\n */\nfunction keyForTransfer(key: FhevmClientOptions[\"fheEncryptionKey\"]): {\n  readonly key: FhevmClientOptions[\"fheEncryptionKey\"];\n  readonly transfers: Transferable[];\n} {\n  if (key === undefined) {\n    return { key, transfers: [] };\n  }\n  const publicKeyBytes = key.publicKeyBytes.bytes;\n  const crsBytes = key.crsBytes.bytes;\n  if (!(publicKeyBytes instanceof Uint8Array) || !(crsBytes instanceof Uint8Array)) {\n    return { key, transfers: [] };\n  }\n  // `slice` yields a fresh exactly-sized buffer, so transferring it leaves this\n  // thread's cached key intact.\n  const publicKeyCopy = publicKeyBytes.slice();\n  const crsCopy = crsBytes.slice();\n  return {\n    key: {\n      ...key,\n      publicKeyBytes: { ...key.publicKeyBytes, bytes: publicKeyCopy },\n      crsBytes: { ...key.crsBytes, bytes: crsCopy },\n    },\n    transfers: [publicKeyCopy.buffer as ArrayBuffer, crsCopy.buffer as ArrayBuffer],\n  };\n}\n\n/**\n * Per-call options: `signal` is forwarded as an `abort` call, `onProgress` is\n * served from the worker's shared progress channel, and `never` keeps the\n * callback contravariantly compatible with each operation's own event type.\n */\ntype CallOptions = WireRequestOptions & {\n  readonly signal?: AbortSignal;\n  readonly onProgress?: (args: never) => void;\n};\n\n/**\n * Everything scoped to one spawned worker, created by the init that spawns it\n * and dropped whole by a teardown. A late event carrying its own generation can\n * therefore only settle that generation, never the worker running in its place.\n */\ntype WorkerGeneration = {\n  /** Memoized bring-up for this worker; it dies with the generation, so the next call re-runs it. */\n  initPromise: Promise<void> | undefined;\n  worker: Worker | undefined;\n  api: Remote<EncryptWorkerApi> | undefined;\n  /** Never resolves; teardown rejects it, and every boundary crossing races it so all of them settle together. */\n  readonly doomed: Promise<never>;\n  /** Rejects `doomed` with the teardown's `WorkerUnavailableError`. */\n  readonly doom: (error: WorkerUnavailableError) => void;\n};\n\nfunction createWorkerGeneration(): WorkerGeneration {\n  let doom!: (error: WorkerUnavailableError) => void;\n  const doomed = new Promise<never>((_resolve, reject) => {\n    doom = reject;\n  });\n  // An idle teardown dooms a generation with no crossing racing it; this\n  // handler keeps that from surfacing as an unhandled rejection.\n  doomed.catch(() => {});\n  return { initPromise: undefined, worker: undefined, api: undefined, doomed, doom };\n}\n\nexport type EncryptWorkerClientConfig = {\n  readonly initPayload: Omit<WireInitPayload, \"rpcUrl\">;\n  /** The chain's RPC endpoint: a URL crosses into the worker; a provider is proxied per request. */\n  readonly network: EIP1193Provider | string;\n  /** Fetches the FHE key on the calling thread, where the chain's auth applies; the worker realm never downloads it itself. */\n  readonly prefetchKey: () => Promise<FhevmClientOptions[\"fheEncryptionKey\"]>;\n  readonly createInlineClient: () => EncryptOffloadBackend;\n  readonly logger: LoggerService;\n  readonly timeouts: EncryptWorkerTimeouts;\n  /** A string or `URL` is spawned with the SDK's worker options; a factory is called for the worker itself. */\n  readonly workerSource?: string | URL | (() => Worker);\n  /**\n   * A pre-known reason offload cannot work in this session: init degrades with\n   * it immediately, so strict rejects at call time rather than at config time.\n   */\n  readonly blockedReason?: string;\n  /**\n   * Strict offload (`offloadEncrypt: true`): never run encryption on the\n   * calling thread. Every path that would degrade rejects with\n   * {@link EncryptOffloadUnavailableError} instead.\n   */\n  readonly strict: boolean;\n};\n\n/**\n * Encrypt backend that runs `@fhevm/sdk` in a dedicated module worker so proof\n * generation never blocks the main thread. Only infrastructure failure degrades\n * to inline (or rejects under `strict`); worker-reported errors are rethrown,\n * since inline would fail the same way.\n */\nexport class EncryptWorkerClient implements EncryptOffloadBackend {\n  readonly #config: EncryptWorkerClientConfig;\n  /** Resources of the worker currently being brought up or served; undefined while none runs. */\n  #generation: WorkerGeneration | undefined;\n  /** True once the client runs inline for the rest of its life, with no further spawn attempts. */\n  #pinnedInline = false;\n  #crashes: CrashHistory = NO_CRASHES;\n  /** Wire ids, allocated across generations so a late reply can never be read as a live operation. */\n  #sequence = 0;\n  /** Per-operation `onProgress`, keyed by wire id and routed over one channel registered at init: one channel per worker avoids minting a `MessageChannel` per call, whose local port and listener would linger until garbage collection after terminate. */\n  readonly #progressListeners = new Map<number, (event: WireProgressEvent) => void>();\n  /** Memoized inline backend. Kept, with its key copy, across a worker recovery so a later degrade skips the refetch. */\n  #degradePromise: Promise<EncryptOffloadBackend> | undefined;\n  /** Operations that must drain before a requested release terminates the worker. */\n  #active = 0;\n  #releaseRequested = false;\n\n  constructor(config: EncryptWorkerClientConfig) {\n    this.#config = config;\n  }\n\n  init = (): Promise<void> => {\n    // A call landing mid-drain rides the worker being released rather than\n    // canceling the release: the drain still completes, and the call after it\n    // spawns a fresh worker.\n    const generation = (this.#generation ??= createWorkerGeneration());\n    if (generation.initPromise === undefined) {\n      // Only a successful cycle is memoized: a failure a retry could clear must\n      // not be replayed to every later call.\n      const attempt: Promise<void> = this.#withActive(() => this.#initOnce(generation)).catch(\n        (error: unknown) => {\n          if (generation.initPromise === attempt) {\n            generation.initPromise = undefined;\n          }\n          throw error;\n        },\n      );\n      generation.initPromise = attempt;\n    }\n    return generation.initPromise;\n  };\n\n  encryptValue: EncryptOffloadBackend[\"encryptValue\"] = (parameters) =>\n    this.#withActive(() =>\n      this.#dispatch(\n        (backend) => backend.encryptValue(parameters),\n        // Spread, so a field upstream adds to the parameters still crosses; the\n        // stripped `options` replaces the caller's, which carries `signal`.\n        (api, id, options) => api.encryptValue(id, { ...parameters, options }),\n        parameters.options,\n      ),\n    );\n\n  encryptValues: EncryptOffloadBackend[\"encryptValues\"] = (parameters) =>\n    this.#withActive(() =>\n      this.#dispatch(\n        (backend) => backend.encryptValues(parameters),\n        (api, id, options) => api.encryptValues(id, { ...parameters, options }),\n        parameters.options,\n      ),\n    );\n\n  /**\n   * Releases the worker without changing what callers observe: in-flight\n   * operations (an init included) run to completion over the worker, and the\n   * worker is terminated as soon as the last one settles, immediately if the\n   * client is idle. The client is not spent: the release resets it whole, so a\n   * later call re-fetches the key and spawns a fresh worker exactly like the\n   * first one, even if the client had degraded to the calling thread. The drain\n   * is not bounded: a worker wedged inside an operation is only terminated once\n   * that operation settles.\n   */\n  dispose(): void {\n    this.#releaseRequested = true;\n    this.#releaseIfIdle();\n  }\n\n  /**\n   * The one place that decides between the worker and the calling thread:\n   * inline once pinned or while no worker is running; otherwise the worker,\n   * falling back to inline on infrastructure failure while application errors\n   * pass through.\n   */\n  async #dispatch<T>(\n    invoke: (backend: EncryptOffloadBackend) => Promise<T>,\n    overWorker: (\n      api: Remote<EncryptWorkerApi>,\n      id: number,\n      options: WireRequestOptions,\n    ) => Promise<T>,\n    callOptions: CallOptions | undefined,\n  ): Promise<T> {\n    const { signal, onProgress, ...options } = callOptions ?? {};\n    // The worker dequeues an abort only after the proof, so a dispatched call always runs whole.\n    throwIfAborted(signal);\n    await this.init();\n    // A listener added after the abort never fires, so an abort during init needs this recheck.\n    throwIfAborted(signal);\n    const generation = this.#generation;\n    const api = generation?.api;\n    // An existing degrade attempt already carries the decision that created it,\n    // and its inline backend caches the key, so reuse it rather than degrading again.\n    if (this.#degradePromise !== undefined && (this.#pinnedInline || api === undefined)) {\n      return invoke(await this.#degradePromise);\n    }\n    if (generation === undefined || api === undefined) {\n      return invoke(\n        await this.#degrade(\n          generation,\n          this.#crashes.last ?? new WorkerUnavailableError(\"Encrypt worker not running.\"),\n        ),\n      );\n    }\n    const id = this.#sequence++;\n    const onAbort = () => void api.abort(id).catch(() => {});\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\n    if (onProgress) {\n      this.#progressListeners.set(id, onProgress as (event: WireProgressEvent) => void);\n    }\n    try {\n      const result = await this.#overBoundary(generation, overWorker(api, id, options));\n      // A worker operation that answered clears the crash history: two unrelated\n      // crashes far apart must not add up to a permanent degrade.\n      this.#crashes = NO_CRASHES;\n      return result;\n    } catch (error) {\n      if (error instanceof WorkerUnavailableError) {\n        return invoke(await this.#degrade(generation, error));\n      }\n      throw error;\n    } finally {\n      this.#progressListeners.delete(id);\n      signal?.removeEventListener(\"abort\", onAbort);\n    }\n  }\n\n  async #initOnce(generation: WorkerGeneration): Promise<void> {\n    if (this.#pinnedInline) {\n      // The degrade that pinned the client already initialized the backend every call now runs on.\n      return;\n    }\n    const blockedReason = this.#config.blockedReason;\n    if (blockedReason !== undefined) {\n      // Handled before any resource is spent: non-strict callers never get here\n      // (the relayer inlines directly), and strict throws out of the degrade.\n      await this.#degrade(generation, new WorkerUnavailableError(blockedReason));\n      return;\n    }\n    // Outside the degrade guard: a failed key fetch is an application/network\n    // error, and the inline backend would refetch the same key from the same\n    // relayer. It rejects out of init exactly as the inline arm's would.\n    const fheEncryptionKey = await this.#config.prefetchKey();\n    try {\n      const api = await this.#spawn(generation);\n      const network = this.#config.network;\n      const rpcRequest =\n        typeof network === \"string\"\n          ? null\n          : proxy(async (args: { method: string; params?: unknown }) => {\n              try {\n                return await network.request(args as Parameters<EIP1193Provider[\"request\"]>[0]);\n              } catch (error) {\n                // Comlink keeps only name/message/stack on a thrown error, which\n                // would strip the provider's `code` (4001, -32005) the worker's\n                // classifiers read; flatten it so those fields cross.\n                throw toWireError(error);\n              }\n            });\n      // A callback that throws would reject the Comlink proxy call back in the\n      // worker realm, where nothing can report it, so it is contained here.\n      const log = proxy((level: \"debug\" | \"warn\" | \"error\", message: string) => {\n        try {\n          this.#config.logger[level](message);\n        } catch (error) {\n          this.#warnCallbackThrew(\"logger\", error);\n        }\n      });\n      const onProgress = proxy((id: number, event: WireProgressEvent) => {\n        try {\n          this.#progressListeners.get(id)?.(event);\n        } catch (error) {\n          this.#warnCallbackThrew(\"onProgress\", error);\n        }\n      });\n      // The copy stays on this thread so a later degrade to inline reuses the\n      // key instead of refetching; transferring the wire copy avoids a third\n      // in-transit copy of it.\n      const wireKey = keyForTransfer(fheEncryptionKey);\n      await this.#overBoundary(\n        generation,\n        api.init(\n          transfer(\n            {\n              ...this.#config.initPayload,\n              clientOptions: {\n                ...this.#config.initPayload.clientOptions,\n                fheEncryptionKey: wireKey.key,\n              },\n              rpcUrl: typeof network === \"string\" ? network : undefined,\n            },\n            wireKey.transfers,\n          ),\n          rpcRequest,\n          log,\n          onProgress,\n        ),\n        { ms: this.#config.timeouts.init, operation: \"init\" },\n      );\n      generation.api = api;\n      this.#crashes = { ...this.#crashes, last: undefined };\n    } catch (error) {\n      // Only \"the worker never answered or crashed\" is infrastructure. An error\n      // the worker itself reported (a chain read, bad key material) would fail\n      // the same way inline, so it reaches the caller unchanged.\n      if (!(error instanceof WorkerUnavailableError)) {\n        this.#teardown(generation, new WorkerUnavailableError(\"Encrypt worker init failed.\"));\n        throw error;\n      }\n      await this.#degrade(generation, error);\n    }\n  }\n\n  /** Reports a caller callback that threw; the reporting itself must not throw back into the worker. */\n  #warnCallbackThrew(callback: string, error: unknown): void {\n    const reason = error instanceof Error ? error.message : String(error);\n    try {\n      this.#config.logger.warn(`Encrypt offload ${callback} callback threw: ${reason}`);\n    } catch {\n      // A logger that throws on its own warning leaves nowhere left to report.\n    }\n  }\n\n  /**\n   * The count spans a whole public entry, its init included, so a release\n   * requested mid-call cannot terminate the worker between the init and the\n   * operation.\n   */\n  async #withActive<T>(work: () => Promise<T>): Promise<T> {\n    this.#active++;\n    try {\n      return await work();\n    } finally {\n      this.#active--;\n      this.#releaseIfIdle();\n    }\n  }\n\n  #releaseIfIdle(): void {\n    if (!this.#releaseRequested || this.#active > 0) {\n      return;\n    }\n    this.#releaseRequested = false;\n    this.#generation?.worker?.terminate();\n    // A full reset, so a release is the recovery lever for a degraded client:\n    // the next call re-fetches the key and spawns a fresh worker either way.\n    this.#generation = undefined;\n    this.#degradePromise = undefined;\n    this.#pinnedInline = false;\n    this.#crashes = NO_CRASHES;\n  }\n\n  #createWorker(): Worker {\n    const source = this.#config.workerSource;\n    if (source === undefined) {\n      return createEncryptWorker();\n    }\n    if (typeof source === \"function\") {\n      const worker = source();\n      // A memoized factory would hand the client a worker it already terminated,\n      // so the contract is one fresh Worker per call.\n      if (handedOutWorkers.has(worker)) {\n        this.#config.logger.warnAlways(\n          \"The offloadWorker factory returned a worker it already handed out; each call must construct a fresh Worker.\",\n        );\n      }\n      handedOutWorkers.add(worker);\n      return worker;\n    }\n    return new Worker(source, { type: \"module\", name: \"zama-fhe-encrypt\" });\n  }\n\n  /** Resolves once the worker's module graph has loaded. */\n  async #spawn(generation: WorkerGeneration): Promise<Remote<EncryptWorkerApi>> {\n    let worker: Worker;\n    try {\n      worker = this.#createWorker();\n    } catch (error) {\n      // A blocked construction is infrastructure, so it must reach the\n      // degrade path as such rather than as the raw thrown error.\n      throw new WorkerUnavailableError(error instanceof Error ? error.message : String(error), {\n        cause: error,\n      });\n    }\n    generation.worker = worker;\n    const api = await this.#raceReady(generation, worker);\n    this.#armCrashHandler(generation, worker);\n    return api;\n  }\n\n  /** Resolves with the Comlink API on the worker's ready message; rejects on the spawn deadline or a pre-ready error. */\n  #raceReady(generation: WorkerGeneration, worker: Worker): Promise<Remote<EncryptWorkerApi>> {\n    return new Promise<Remote<EncryptWorkerApi>>((resolve, reject) => {\n      const settle = () => {\n        clearTimeout(timer);\n        worker.removeEventListener(\"message\", onReady);\n        worker.removeEventListener(\"error\", onError);\n      };\n      const timer = setTimeout(() => {\n        settle();\n        reject(\n          new WorkerUnavailableError(\n            `Encrypt worker did not start within ${this.#config.timeouts.spawn}ms.`,\n          ),\n        );\n      }, this.#config.timeouts.spawn);\n      const onReady = (event: MessageEvent) => {\n        if (event.data === WORKER_READY_MESSAGE) {\n          settle();\n          resolve(wrap<EncryptWorkerApi>(worker));\n        }\n      };\n      const onError = (event: ErrorEvent) => {\n        settle();\n        const message = event.message || \"Encrypt worker error.\";\n        // A worker that never came up is not worth respawning per call, so\n        // this failure is not flagged as a crash.\n        reject(new WorkerUnavailableError(message));\n        this.#teardown(generation, new WorkerUnavailableError(message));\n      };\n      worker.addEventListener(\"message\", onReady);\n      worker.addEventListener(\"error\", onError);\n    });\n  }\n\n  /** Permanent crash detector, armed only after ready so a pre-ready failure never counts as a crash. */\n  #armCrashHandler(generation: WorkerGeneration, worker: Worker): void {\n    worker.addEventListener(\"error\", (event: ErrorEvent) => {\n      // A generation already torn down cannot crash the client again: nothing\n      // is waiting on it, and the worker running in its place is unaffected.\n      if (this.#generation !== generation) {\n        return;\n      }\n      // A ready worker died under us: the teardown drops the memoized init so\n      // the next call spawns a fresh one, and the operations it took down\n      // finish inline.\n      const crash = new WorkerUnavailableError(event.message || \"Encrypt worker error.\", {\n        crashed: true,\n      });\n      this.#crashes = { ...this.#crashes, count: this.#crashes.count + 1, last: crash };\n      this.#teardown(generation, crash);\n    });\n  }\n\n  /**\n   * Awaits one promise crossing the worker boundary, racing the generation's\n   * `doomed` promise so a teardown settles it with the teardown's\n   * `WorkerUnavailableError`, which degrades it inline. Without a `deadline` it\n   * settles whenever the worker answers; a `deadline` bounds a lifecycle step,\n   * and missing it means the worker is presumed stuck, so the generation is\n   * torn down whole.\n   */\n  async #overBoundary<T>(\n    generation: WorkerGeneration,\n    work: Promise<T>,\n    deadline?: { readonly ms: number; readonly operation: string },\n  ): Promise<T> {\n    const timer =\n      deadline === undefined\n        ? undefined\n        : setTimeout(() => {\n            this.#teardown(\n              generation,\n              new WorkerUnavailableError(\n                `Encrypt worker ${deadline.operation} timed out after ${deadline.ms}ms.`,\n              ),\n            );\n          }, deadline.ms);\n    try {\n      return await Promise.race([\n        work.catch((error: unknown) => {\n          const failure = isWireError(error) ? fromWireError(error) : (error as Error);\n          // A payload Comlink could not carry is infrastructure, so it degrades\n          // instead of reaching the caller as the operation's own failure.\n          throw isCloneFailure(failure)\n            ? new WorkerUnavailableError(failure.message, { cause: failure })\n            : failure;\n        }),\n        generation.doomed,\n      ]);\n    } finally {\n      if (timer !== undefined) {\n        clearTimeout(timer);\n      }\n    }\n  }\n\n  /**\n   * Rejects and drops one generation whole: its worker, its memoized init, and\n   * every crossing racing its `doomed` promise. The next call therefore re-runs\n   * the cycle on a fresh generation, so a spurious teardown costs a respawn\n   * rather than a permanent degrade.\n   */\n  #teardown(generation: WorkerGeneration | undefined, error: WorkerUnavailableError): void {\n    if (generation === undefined) {\n      return;\n    }\n    if (this.#generation === generation) {\n      this.#generation = undefined;\n    }\n    generation.worker?.terminate();\n    generation.worker = undefined;\n    generation.api = undefined;\n    generation.initPromise = undefined;\n    generation.doom(error);\n  }\n\n  async #degrade(\n    generation: WorkerGeneration | undefined,\n    cause: unknown,\n  ): Promise<EncryptOffloadBackend> {\n    const reason = cause instanceof Error ? cause.message : String(cause);\n    if (this.#config.strict) {\n      this.#teardown(generation, new WorkerUnavailableError(\"Encrypt worker unavailable.\"));\n      throw new EncryptOffloadUnavailableError(\n        `Encrypt offload required (offloadEncrypt: true) but unavailable: ${reason}`,\n        { cause },\n      );\n    }\n    const { transient, pinning } = this.#classifyDegrade(cause);\n    this.#pinnedInline ||= !transient;\n    this.#teardown(generation, new WorkerUnavailableError(\"Encrypt worker degraded to inline.\"));\n    this.#warnDegraded(reason, transient, pinning);\n    if (this.#degradePromise === undefined) {\n      // Only a live backend is memoized: an inline init is a key refetch, and a\n      // transient failure there must not close the degrade path for the session.\n      const attempt: Promise<EncryptOffloadBackend> = (async () => {\n        const inline = this.#config.createInlineClient();\n        await inline.init();\n        return inline;\n      })().catch((error: unknown) => {\n        if (this.#degradePromise === attempt) {\n          this.#degradePromise = undefined;\n        }\n        this.#config.logger.warnAlways(\n          `Encrypt inline fallback failed to initialize: ${error instanceof Error ? error.message : String(error)}`,\n        );\n        throw error;\n      });\n      this.#degradePromise = attempt;\n    }\n    return this.#degradePromise;\n  }\n\n  /**\n   * How one failure degrades, read off the state before the degrade mutates it:\n   * `transient` diverts only this call, `pinning` settles the client inline now.\n   * One crash is treated as transient; a repeat crash, or a worker that never\n   * came up, settles the client inline rather than spawning a replacement per call.\n   */\n  #classifyDegrade(cause: unknown): { readonly transient: boolean; readonly pinning: boolean } {\n    const transient =\n      cause instanceof WorkerUnavailableError &&\n      cause.crashed &&\n      this.#crashes.count < CRASH_PIN_THRESHOLD;\n    return { transient, pinning: !transient && !this.#pinnedInline };\n  }\n\n  /** One warning per failure, whether it pins the client inline or only diverts this call. */\n  #warnDegraded(reason: string, transient: boolean, pinning: boolean): void {\n    if (!pinning && this.#crashes.warnedFor === this.#crashes.count) {\n      return;\n    }\n    this.#crashes = { ...this.#crashes, warnedFor: this.#crashes.count };\n    const scope = transient ? \"in-flight encryption falls back\" : \"encryption falls back\";\n    // Always on the console: a silent return to main-thread encryption is the\n    // freeze this offload prevents.\n    this.#config.logger.warnAlways(\n      `${ENCRYPT_OFFLOAD_WARN_PREFIX}, ${scope} to the calling thread: ${reason}`,\n    );\n  }\n}\n","import { createUnsignedLegacyDecryptionPermitEip712 as createUnsignedLegacyDecryptionPermitEip712Action } from \"@fhevm/sdk/actions/base\";\nimport {\n  createFhevmBaseClient,\n  createFhevmDecryptClient,\n  createFhevmEncryptClient,\n  hasFhevmRuntimeConfig,\n} from \"@fhevm/sdk/viem\";\nimport {\n  createFhevmCleartextBaseClient,\n  createFhevmCleartextDecryptClient,\n  createFhevmCleartextEncryptClient,\n} from \"@fhevm/sdk/viem/cleartext\";\nimport { createPublicClient, custom, http } from \"viem\";\nimport { toFhevmChain } from \"../chains/to-fhevm-chain\";\nimport type { FheChain } from \"../chains/types\";\nimport { ConfigurationError } from \"../errors\";\nimport { getAppliedWireRuntime, hasAppliedLocateFile } from \"./applied-runtime\";\nimport type { LoggerService } from \"../services/logger-service\";\nimport {\n  DEFAULT_ENCRYPT_WORKER_TIMEOUTS,\n  EncryptWorkerClient,\n  type EncryptWorkerClientConfig,\n  type EncryptWorkerTimeouts,\n} from \"../worker/encrypt-worker-client\";\nimport { BUNDLED_ENCRYPT_WORKER } from \"../worker/spawn\";\nimport type {\n  FhevmBaseClient,\n  FhevmClient,\n  FhevmDecryptClient,\n  FhevmEncryptBackend,\n  FhevmRelayerOptions,\n  RelayerSDK,\n  RelayerOptions,\n  WireRuntimeConfig,\n} from \"./types\";\n\n/** The `@fhevm/sdk` client inputs the worker realm rebuilds its own client from. */\ntype EncryptInitPayload = EncryptWorkerClientConfig[\"initPayload\"];\n\n/** Construction config for {@link FhevmRelayer}. */\nexport interface FhevmRelayerConfig {\n  /** FHE chain configuration. */\n  chain: FheChain;\n  /**\n   * Cleartext mode for local dev/test chains without FHE infrastructure — reads\n   * mock cleartexts from the on-chain executor (discovered automatically)\n   * instead of calling the relayer.\n   */\n  cleartext?: boolean;\n  /**\n   * Per-transport {@link RelayerOptions}: `@fhevm/sdk` client options plus a\n   * default request `timeout` applied to every relayer round-trip on the chain.\n   */\n  options?: RelayerOptions;\n  /** Encrypt-worker offload mode; see `web()`'s `offloadEncrypt` option. */\n  offloadEncrypt?: \"auto\" | boolean;\n  /** Watchdog deadlines for the encrypt worker; `web()` defaults every field before it gets here. */\n  offloadTimeouts?: EncryptWorkerTimeouts;\n  /** Custom source for the encrypt worker; see `web()`'s `offloadWorker` option. */\n  offloadWorker?: string | URL | (() => Worker);\n  /** Receives worker log lines and offload-fallback warnings. */\n  logger: LoggerService;\n}\n\n/**\n * Single-chain FHE backend that drives `@fhevm/sdk` on the calling thread with\n * capability-scoped lazy initialization.\n * EIP-712 signing is done by the signer layer; this backend builds the typed\n * data and, on decrypt, reassembles the new SDK's signed permit from the\n * interface's params + the previously returned signature.\n *\n * @remarks\n * Each method delegates to the narrowest base, decrypt, or encrypt client,\n * adding two cross-cutting behaviors that the delegated signatures don't\n * express:\n *\n * - **Lazy init.** Each operation initializes only the capability it requires.\n *   Public decrypt avoids WASM, private decrypt loads TKMS only, and encryption\n *   alone loads TFHE and the FHE encryption key.\n * - **Option merging.** The chain's default options (`auth`, `timeout`, `debug`)\n *   are spread in first, then the per-call `options`, so a per-call value always\n *   wins over the chain default. Serialization helpers make no relayer\n *   round-trip, so they inject no options.\n *\n * @internal\n */\nexport class FhevmRelayer implements RelayerSDK {\n  readonly #chain: FheChain;\n  readonly #base: FhevmBaseClient;\n  readonly #decrypt: FhevmDecryptClient;\n  readonly #encrypt: FhevmEncryptBackend;\n  readonly #defaultOptions: Partial<FhevmRelayerOptions>;\n  #encryptInitPromise: Promise<void> | undefined;\n\n  /**\n   * Builds capability-scoped `@fhevm/sdk` clients for the chain and captures\n   * the chain's `auth`/`timeout`/`debug` as request defaults. Construction is\n   * cheap; each client's one-time init is deferred to its first operation.\n   */\n  constructor(config: FhevmRelayerConfig) {\n    this.#chain = config.chain;\n    const { timeout, debug, batchRpcCalls, moduleVersions, fheEncryptionKey } =\n      config.options ?? {};\n    const auth = this.#chain.auth ? toFhevmAuth(this.#chain.auth) : undefined;\n    const transport =\n      typeof this.#chain.network === \"string\"\n        ? http(this.#chain.network)\n        : custom(this.#chain.network);\n    const params = {\n      publicClient: createPublicClient({ transport }),\n      chain: toFhevmChain(this.#chain),\n      options: { batchRpcCalls, moduleVersions, fheEncryptionKey },\n    };\n    this.#defaultOptions = {\n      ...(auth !== undefined && { auth }),\n      ...(timeout !== undefined && { timeout }),\n      ...(debug !== undefined && { debug }),\n    };\n    // The FHE key is always fetched here, on the calling thread, so the chain's\n    // default request options (auth in particular) apply; a worker realm has no\n    // access to them.\n    const prefetchKey = () =>\n      this.#base.fetchFheEncryptionKeyBytes({ options: this.#defaultOptions });\n    // Re-listed rather than spread: the upstream client exposes an enumerable\n    // `ready` getter, and a spread would call it, starting init at construction.\n    const withInlineInit = (client: FhevmEncryptBackend): FhevmEncryptBackend => ({\n      init: async () => {\n        await prefetchKey();\n        await client.init();\n      },\n      encryptValue: (parameters) => client.encryptValue(parameters),\n      encryptValues: (parameters) => client.encryptValues(parameters),\n      fetchFheEncryptionKeyBytes: (parameters) => client.fetchFheEncryptionKeyBytes(parameters),\n    });\n    if (config.cleartext) {\n      this.#base = createFhevmCleartextBaseClient(params);\n      this.#decrypt = createFhevmCleartextDecryptClient(params);\n      this.#encrypt = withInlineInit(createFhevmCleartextEncryptClient(params));\n    } else {\n      this.#base = createFhevmBaseClient(params);\n      this.#decrypt = createFhevmDecryptClient(params);\n      this.#encrypt = this.#buildEncryptBackend(config, params, {\n        prefetchKey,\n        createInlineClient: () => withInlineInit(createFhevmEncryptClient(params)),\n      });\n    }\n  }\n\n  /**\n   * Picks the encrypt backend for a non-cleartext chain: the worker client when\n   * offload is on and reachable, the inline calling-thread client otherwise.\n   */\n  #buildEncryptBackend(\n    config: FhevmRelayerConfig,\n    params: { chain: EncryptInitPayload[\"chain\"]; options: EncryptInitPayload[\"clientOptions\"] },\n    inline: {\n      prefetchKey: EncryptWorkerClientConfig[\"prefetchKey\"];\n      createInlineClient: () => FhevmEncryptBackend;\n    },\n  ): FhevmEncryptBackend {\n    const offload = config.offloadEncrypt ?? false;\n    const strict = offload === true;\n    const workerAvailable =\n      typeof Worker === \"function\" &&\n      (config.offloadWorker !== undefined || BUNDLED_ENCRYPT_WORKER);\n    // Silent both ways: offload off is what the caller asked for, and a realm\n    // with no Worker is an environment fact that would warn on every SSR\n    // render. Strict skips the capability check, since construction runs during\n    // that render and the failure must surface at call time instead.\n    if (offload === false || !(strict || workerAvailable)) {\n      return inline.createInlineClient();\n    }\n    const runtime = getAppliedWireRuntime();\n    const blocker = encryptOffloadBlocker(runtime);\n    if (blocker !== undefined && !strict) {\n      // Always on the console: the alternative is an opaque rejection at\n      // encrypt time, or WASM assets silently resolved from the default URLs.\n      config.logger.warnAlways(`Encryption runs on the calling thread: ${blocker}.`);\n      return inline.createInlineClient();\n    }\n    const workerClient = new EncryptWorkerClient({\n      initPayload: { chain: params.chain, clientOptions: params.options, runtime: runtime ?? {} },\n      network: this.#chain.network,\n      prefetchKey: inline.prefetchKey,\n      createInlineClient: inline.createInlineClient,\n      logger: config.logger,\n      timeouts: config.offloadTimeouts ?? DEFAULT_ENCRYPT_WORKER_TIMEOUTS,\n      workerSource: config.offloadWorker,\n      // Strict with a blocker: the client degrades at init, which rejects at\n      // call time rather than at config time.\n      blockedReason: blocker,\n      strict,\n    });\n    return {\n      init: () => workerClient.init(),\n      encryptValue: (parameters) => workerClient.encryptValue(parameters),\n      encryptValues: (parameters) => workerClient.encryptValues(parameters),\n      // Served from the calling thread: routing it through the worker would\n      // structured-clone the ~50 MB key back out on every call. `ignoreCache`\n      // therefore refreshes this thread's cache, not the worker's seeded key.\n      fetchFheEncryptionKeyBytes: (parameters) => this.#base.fetchFheEncryptionKeyBytes(parameters),\n      dispose: () => workerClient.dispose(),\n    };\n  }\n\n  /** The FHE chain this backend is bound to. */\n  get chain() {\n    return this.#chain;\n  }\n\n  // Only a fulfilled init is memoized: a rejection clears the memo so the next\n  // encryption retries instead of inheriting a transient key-fetch failure.\n  #initEncrypt = (): Promise<void> => {\n    this.#encryptInitPromise ??= this.#encrypt.init().catch((error: unknown) => {\n      this.#encryptInitPromise = undefined;\n      throw error;\n    });\n    return this.#encryptInitPromise;\n  };\n\n  /**\n   * Releases the encrypt worker once in-flight encryptions settle and drops the\n   * memoized init; the next encryption spawns a fresh worker and re-initializes.\n   */\n  dispose = (): void => {\n    this.#encryptInitPromise = undefined;\n    this.#encrypt.dispose?.();\n  };\n\n  /**\n   * Decrypts a single publicly-decryptable value — one whose contract granted\n   * public access, so no permit or key pair is needed — into its typed clear\n   * value.\n   *\n   * @example\n   * ```ts\n   * const { type, value } = await relayer.decryptPublicValue({\n   *   encryptedValue: handle, // a bytes32 ciphertext reference\n   * });\n   * ```\n   */\n  decryptPublicValue: FhevmClient[\"decryptPublicValue\"] = async (parameters) => {\n    await this.#base.init();\n    return this.#base.decryptPublicValue({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * Batch form of {@link decryptPublicValue}: decrypts many publicly-decryptable\n   * values in one relayer round-trip, returning their typed clear values in\n   * order.\n   *\n   * @example\n   * ```ts\n   * const values = await relayer.decryptPublicValues({\n   *   encryptedValues: [handleA, handleB],\n   * });\n   * ```\n   */\n  decryptPublicValues: FhevmClient[\"decryptPublicValues\"] = async (parameters) => {\n    await this.#base.init();\n    return this.#base.decryptPublicValues({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * Like {@link decryptPublicValues}, but also returns the KMS signature bundle —\n   * the handles list, ABI-encoded cleartexts, and decryption proof — needed to\n   * verify or replay the result on-chain.\n   *\n   * @example\n   * ```ts\n   * const { clearValues, checkSignaturesArgs } =\n   *   await relayer.decryptPublicValuesWithSignatures({ encryptedValues: [handle] });\n   * // checkSignaturesArgs: { handlesList, abiEncodedCleartexts, decryptionProof }\n   * ```\n   */\n  decryptPublicValuesWithSignatures: FhevmClient[\"decryptPublicValuesWithSignatures\"] = async (\n    parameters,\n  ) => {\n    await this.#base.init();\n    return this.#base.decryptPublicValuesWithSignatures({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * Encrypts one typed input under the chain's FHE key, bound to the contract it\n   * targets and the user submitting it, and returns the ciphertext handle plus\n   * the input proof the contract verifies on-chain. `type` is the FHE type\n   * with the `e` prefix (`\"euint64\"`, `\"ebool\"`, `\"eaddress\"`).\n   *\n   * @example\n   * ```ts\n   * const { encryptedValue, inputProof } = await relayer.encryptValue({\n   *   value: { type: \"euint64\", value: 1000n },\n   *   contractAddress: \"0xToken…\",\n   *   userAddress: \"0xUser…\",\n   * });\n   * ```\n   */\n  encryptValue: FhevmClient[\"encryptValue\"] = async (parameters) => {\n    await this.#initEncrypt();\n    return this.#encrypt.encryptValue({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * Batch form of {@link encryptValue}: encrypts several inputs for the same\n   * contract and user in one call, returning all ciphertext handles under a\n   * single shared input proof.\n   *\n   * @example\n   * ```ts\n   * const { encryptedValues, inputProof } = await relayer.encryptValues({\n   *   values: [\n   *     { type: \"euint64\", value: 1000n },\n   *     { type: \"ebool\", value: true },\n   *   ],\n   *   contractAddress: \"0xToken…\",\n   *   userAddress: \"0xUser…\",\n   * });\n   * ```\n   */\n  encryptValues: FhevmClient[\"encryptValues\"] = async (parameters) => {\n    await this.#initEncrypt();\n    return this.#encrypt.encryptValues({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * User-decrypts a single access-controlled value: the relayer re-encrypts it\n   * to the ephemeral transport key pair, gated by the signed permit, and this\n   * returns the typed clear value. Build the key pair with\n   * {@link generateTransportKeyPair} and the permit with\n   * {@link signDecryptionPermit}.\n   *\n   * @example\n   * ```ts\n   * const { type, value } = await relayer.decryptValue({\n   *   encryptedValue: handle,\n   *   contractAddress: \"0xToken…\",\n   *   transportKeyPair,\n   *   signedPermit,\n   * });\n   * ```\n   */\n  decryptValue: FhevmClient[\"decryptValue\"] = async (parameters) => {\n    await this.#decrypt.init();\n    return this.#decrypt.decryptValue({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * Batch form of {@link decryptValue} for values that all belong to the same\n   * contract; returns the typed clear values positionally. For values spanning\n   * multiple contracts, use {@link decryptValuesFromPairs}.\n   *\n   * @example\n   * ```ts\n   * const values = await relayer.decryptValues({\n   *   encryptedValues: [handleA, handleB],\n   *   contractAddress: \"0xToken…\",\n   *   transportKeyPair,\n   *   signedPermit,\n   * });\n   * ```\n   */\n  decryptValues: FhevmClient[\"decryptValues\"] = async (parameters) => {\n    await this.#decrypt.init();\n    return this.#decrypt.decryptValues({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * User-decrypts values that span multiple contracts: each pair carries its own\n   * `contractAddress`, so one permit covering those contracts decrypts them all\n   * in a single round-trip. Returns the typed clear values positionally.\n   *\n   * @example\n   * ```ts\n   * const values = await relayer.decryptValuesFromPairs({\n   *   pairs: [\n   *     { encryptedValue: handleA, contractAddress: \"0xTokenA…\" },\n   *     { encryptedValue: handleB, contractAddress: \"0xTokenB…\" },\n   *   ],\n   *   transportKeyPair,\n   *   signedPermit,\n   * });\n   * ```\n   */\n  decryptValuesFromPairs: FhevmClient[\"decryptValuesFromPairs\"] = async (parameters) => {\n    await this.#decrypt.init();\n    return this.#decrypt.decryptValuesFromPairs({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters.options },\n    });\n  };\n\n  /**\n   * Fetches the chain's raw FHE public-key bytes — the key encryption uses —\n   * served from cache unless `ignoreCache` forces a refetch. Rarely called\n   * directly: {@link encryptValue}/{@link encryptValues} fetch the key for you.\n   *\n   * @example\n   * ```ts\n   * const keyBytes = await relayer.fetchFheEncryptionKeyBytes();\n   * const fresh = await relayer.fetchFheEncryptionKeyBytes({ ignoreCache: true });\n   * ```\n   */\n  fetchFheEncryptionKeyBytes: FhevmClient[\"fetchFheEncryptionKeyBytes\"] = async (parameters) => {\n    // Served from the base client, which shares the key cache with the encrypt\n    // client: initializing encryption here would spawn the encrypt worker and\n    // wait out its bring-up for a key this thread fetches itself.\n    await this.#base.init();\n    return this.#base.fetchFheEncryptionKeyBytes({\n      ...parameters,\n      options: { ...this.#defaultOptions, ...parameters?.options },\n    });\n  };\n\n  /**\n   * Builds the EIP-712 user-decrypt permit and signs it with the given signer,\n   * authorizing the transport key pair to decrypt the listed contracts' values\n   * for `durationSeconds` starting at `startTimestamp`. Pass `delegatorAddress`\n   * to sign a delegated permit — decrypting values owned by that account instead\n   * of the signer's own. Persist the result via\n   * {@link serializeSignedDecryptionPermit}.\n   *\n   * @example\n   * ```ts\n   * const signedPermit = await relayer.signDecryptionPermit({\n   *   transportKeyPair,\n   *   contractAddresses: [\"0xToken…\"],\n   *   startTimestamp: Math.floor(Date.now() / 1000),\n   *   durationSeconds: 60 * 60 * 24,\n   *   signerAddress: \"0xUser…\",\n   *   signer,\n   *   // delegatorAddress: \"0xOwner…\", // omit for a self permit\n   * });\n   * ```\n   */\n  signDecryptionPermit: FhevmClient[\"signDecryptionPermit\"] = async (parameters) => {\n    await this.#base.init();\n    return this.#base.signDecryptionPermit(parameters);\n  };\n\n  /**\n   * Builds the unsigned EIP-712 typed data for a V1 decryption permit, without\n   * signing it — the signer-less counterpart to {@link signDecryptionPermit}.\n   * Hand the result to an out-of-process signer for `eth_signTypedData_v4`,\n   * then verify the returned signature via {@link parseSignedDecryptionPermit}.\n   *\n   * Not on `@fhevm/sdk`'s client decorator, so it's called directly against\n   * the base client rather than through a decorated method.\n   *\n   * @example\n   * ```ts\n   * const eip712 = await relayer.createUnsignedLegacyDecryptionPermitEip712({\n   *   transportKeyPair,\n   *   contractAddresses: [\"0xToken…\"],\n   *   startTimestamp: Math.floor(Date.now() / 1000),\n   *   durationSeconds: 60 * 60 * 24,\n   *   // delegatorAddress: \"0xOwner…\", // omit for a self permit\n   * });\n   * ```\n   */\n  createUnsignedLegacyDecryptionPermitEip712: RelayerSDK[\"createUnsignedLegacyDecryptionPermitEip712\"] =\n    (parameters) => createUnsignedLegacyDecryptionPermitEip712Action(this.#base, parameters);\n\n  // Permit/key-pair helpers carry no request options. Parsing explicitly\n  // initializes the capability that validates the restored value; serialization\n  // resolves the frozen context internally (via initPublicAction), which reads\n  // on-chain state.\n\n  /**\n   * Serializes a transport key pair to a hex `{ publicKey, privateKey }` pair for\n   * storage or transport, so a decryption session can resume without regenerating\n   * keys. Reverse of {@link parseTransportKeyPair}.\n   *\n   * @example\n   * ```ts\n   * const stored = await relayer.serializeTransportKeyPair({ transportKeyPair });\n   * // { publicKey: \"0x…\", privateKey: \"0x…\" }\n   * ```\n   */\n  serializeTransportKeyPair: FhevmClient[\"serializeTransportKeyPair\"] = (parameters) =>\n    this.#decrypt.serializeTransportKeyPair(parameters);\n\n  /**\n   * Serializes a signed permit to a plain, JSON-stringifiable object (version,\n   * EIP-712 payload, signature, signer) for caching or transport. Reverse of\n   * {@link parseSignedDecryptionPermit}.\n   *\n   * @example\n   * ```ts\n   * const serialized = await relayer.serializeSignedDecryptionPermit({ signedPermit });\n   * localStorage.setItem(\"permit\", JSON.stringify(serialized));\n   * ```\n   */\n  serializeSignedDecryptionPermit: FhevmClient[\"serializeSignedDecryptionPermit\"] = (parameters) =>\n    this.#base.serializeSignedDecryptionPermit(parameters);\n\n  /**\n   * Rebuilds a transport key pair from its serialized hex\n   * `{ publicKey, privateKey }` form. Reverse of {@link serializeTransportKeyPair}.\n   *\n   * @example\n   * ```ts\n   * const transportKeyPair = await relayer.parseTransportKeyPair({\n   *   publicKey: stored.publicKey,\n   *   privateKey: stored.privateKey,\n   * });\n   * ```\n   */\n  parseTransportKeyPair: FhevmClient[\"parseTransportKeyPair\"] = async (parameters) => {\n    await this.#decrypt.init();\n    return this.#decrypt.parseTransportKeyPair(parameters);\n  };\n\n  /**\n   * Rebuilds a signed permit from its serialized form and validates it: checks\n   * the EIP-712 structure, verifies the signature against the on-chain verifier,\n   * and confirms the permit's public key matches `transportKeyPair`. Reverse of\n   * {@link serializeSignedDecryptionPermit}.\n   *\n   * @throws if the permit is malformed, expired, or its signature is invalid.\n   *\n   * @example\n   * ```ts\n   * const signedPermit = await relayer.parseSignedDecryptionPermit({\n   *   serializedPermit,\n   *   transportKeyPair,\n   * });\n   * ```\n   */\n  parseSignedDecryptionPermit: FhevmClient[\"parseSignedDecryptionPermit\"] = async (parameters) => {\n    await this.#base.init();\n    return this.#base.parseSignedDecryptionPermit(parameters);\n  };\n\n  /**\n   * Generates a fresh ephemeral transport key pair for a user-decrypt session.\n   * The relayer re-encrypts decrypted values to this pair's public key, so only\n   * the holder of the private key can read them; bind it to a permit via\n   * {@link signDecryptionPermit}.\n   *\n   * @example\n   * ```ts\n   * const transportKeyPair = await relayer.generateTransportKeyPair();\n   * ```\n   */\n  generateTransportKeyPair: FhevmClient[\"generateTransportKeyPair\"] = async () => {\n    await this.#decrypt.init();\n    return this.#decrypt.generateTransportKeyPair();\n  };\n}\n\n/**\n * The one reason, if any, this thread's configuration cannot be reproduced in\n * the worker realm, so offload is worse than inline there.\n */\nfunction encryptOffloadBlocker(runtime: WireRuntimeConfig | undefined): string | undefined {\n  // A runtime `locateFile` is a function: it cannot be cloned into the worker\n  // realm, which would silently resolve WASM assets from the default URLs.\n  if (hasAppliedLocateFile()) {\n    return \"a runtime locateFile cannot cross the encrypt worker boundary\";\n  }\n  // Unreadable here, so the worker would run on fhevm defaults: an auth it\n  // carries would 401 inside the worker as an application error, which never degrades.\n  if (runtime === undefined && hasFhevmRuntimeConfig()) {\n    return \"a runtime config set outside createConfig cannot be replicated in the encrypt worker realm\";\n  }\n  return undefined;\n}\n\n/**\n * Translates the SDK's public {@link FheChain.auth} shape (discriminated by\n * `__type`) into the `type`-discriminated `auth` that `@fhevm/sdk` expects.\n *\n * @throws if the auth discriminator is not one of the supported kinds.\n */\nfunction toFhevmAuth(\n  auth: NonNullable<FheChain[\"auth\"]>,\n): NonNullable<FhevmRelayerOptions[\"auth\"]> {\n  const type = auth[\"__type\"];\n  switch (type) {\n    case \"ApiKeyHeader\":\n      return { type, value: auth.value, header: auth.header };\n    case \"ApiKeyCookie\":\n      return { type, value: auth.value, cookie: auth.cookie };\n    case \"BearerToken\":\n      return { type, token: auth.token };\n    default:\n      throw new ConfigurationError(`Unknown auth type: ${String(type)}`);\n  }\n}\n"],"x_google_ignoreList":[1],"mappings":"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"}

package/dist/esm/relayer-CVKO9GmQ.js

@@ -1,2 +0,0 @@
-function e(e){return e instanceof Error?e:typeof e==`object`&&e&&`message`in e?Error(String(e.message)):Error(String(e))}function t(e){if(!(e instanceof Error))return!1;if(e.name===`ContractFunctionExecutionError`||e.name===`ContractFunctionRevertedError`||`code`in e&&e.code===`CALL_EXCEPTION`)return!0;let t=e.message.toLowerCase();return t.includes(`execution reverted`)||t.includes(`call revert exception`)}const n=[`cause`,`error`,`info`];function r(e,t,i=6){if(i<0||typeof e!=`object`||!e)return;let a=e;if(t(a))return a;for(let e of n){let n=a[e];if(typeof n==`object`&&n){let e=r(n,t,i-1);if(e)return e}}}function i(e){if(e.code===-32005||e.status===429||e.code===429)return!0;if(e.code===`SERVER_ERROR`&&typeof e.info==`object`&&e.info!==null){let t=e.info.responseStatus;if(typeof t==`string`&&/^\s*429\b/.test(t))return!0}return!1}function a(e){if(i(e))return!0;if(typeof e.message==`string`){let t=e.message.toLowerCase();return t.includes(`too many requests`)||t.includes(`rate limit`)||t.includes(`rate-limit`)}return!1}function o(e){return r(e,e=>typeof e.name==`string`&&e.name.startsWith(`Relayer`))!==void 0}function s(e){return r(e,e=>e.name===`RelayerTimeoutError`)!==void 0}function c(e){return!o(e)&&r(e,a)!==void 0}function l(e){return!o(e)&&r(e,i)!==void 0}function u(e){return e.toLowerCase().includes(`is not authorized to decrypt handle`)}function d(e){return e.toLowerCase().includes(`invalid transportkeypair`)}const f=[`data`,`raw`,`signature`];function p(e){for(let t of f){let n=e[t];if(typeof n==`string`&&n.toLowerCase().startsWith(`0x77ddbe81`))return!0}if(typeof e.message==`string`){let t=e.message.toLowerCase();return t.includes(`0x77ddbe81`)||t.includes(`invalidkmscontext`)}return!1}function m(e){return r(e,p)!==void 0}function h(e){return/handle (0x[0-9a-fA-F]{64})/.exec(e)?.[1]}function g(e){if(e==null)return;let t=e.trim();if(t!==``){if(/^\d+$/.test(t))return Number(t);if(/[a-zA-Z]/.test(t)){let e=Date.parse(t);if(!Number.isNaN(e))return Math.max(0,Math.round((e-Date.now())/1e3))}}}function _(e){if(typeof e!=`object`||!e)return;let t=e.get;if(typeof t==`function`)return g(t.call(e,`Retry-After`))}function v(e){let t=e.response;if(typeof t==`object`&&t)return _(t.headers)}function y(e){return typeof e==`number`&&Number.isFinite(e)&&e>0}function b(e){return y(e.retryAfter)?e.retryAfter:v(e)}function x(e){let t=r(e,e=>b(e)!==void 0);return t?b(t):void 0}function S(e){let t=r(e,e=>typeof e.statusCode==`number`||typeof e.status==`number`);if(t)return typeof t.statusCode==`number`?t.statusCode:t.status}function C(e){let t=r(e,e=>typeof e.code==`number`&&e.code!==-1);return t?t.code:void 0}function w(e){return e instanceof Error&&e.name!==`Error`?e.name:void 0}const T={SigningRejected:`SIGNING_REJECTED`,SigningFailed:`SIGNING_FAILED`,EncryptionFailed:`ENCRYPTION_FAILED`,DecryptionFailed:`DECRYPTION_FAILED`,EncryptOffloadUnavailable:`ENCRYPT_OFFLOAD_UNAVAILABLE`,TransactionReverted:`TRANSACTION_REVERTED`,TransportKeyPairExpired:`KEYPAIR_EXPIRED`,InvalidTransportKeyPair:`INVALID_KEYPAIR`,RevokedKmsContext:`REVOKED_KMS_CONTEXT`,NoCiphertext:`NO_CIPHERTEXT`,RelayerRequestFailed:`RELAYER_REQUEST_FAILED`,NotEntitled:`NOT_ENTITLED`,RpcRateLimited:`RPC_RATE_LIMITED`,Configuration:`CONFIGURATION`,DelegationSelfNotAllowed:`DELEGATION_SELF_NOT_ALLOWED`,DelegationCooldown:`DELEGATION_COOLDOWN`,DelegationNotFound:`DELEGATION_NOT_FOUND`,DelegationExpired:`DELEGATION_EXPIRED`,InsufficientConfidentialBalance:`INSUFFICIENT_CONFIDENTIAL_BALANCE`,InsufficientERC20Balance:`INSUFFICIENT_ERC20_BALANCE`,InsufficientAllowance:`INSUFFICIENT_ALLOWANCE`,BalanceCheckUnavailable:`BALANCE_CHECK_UNAVAILABLE`,ERC20ReadFailed:`ERC20_READ_FAILED`,DelegationExpiryUnchanged:`DELEGATION_EXPIRY_UNCHANGED`,DelegationDelegateEqualsContract:`DELEGATION_DELEGATE_EQUALS_CONTRACT`,DelegationContractIsSelf:`DELEGATION_CONTRACT_IS_SELF`,AclPaused:`ACL_PAUSED`,DelegationExpirationTooSoon:`DELEGATION_EXPIRATION_TOO_SOON`,DelegationNotPropagated:`DELEGATION_NOT_PROPAGATED`,ChainMismatch:`CHAIN_MISMATCH`,SignerNotConfigured:`SIGNER_NOT_CONFIGURED`,WalletNotConnected:`WALLET_NOT_CONNECTED`,WalletAccountNotReady:`WALLET_ACCOUNT_NOT_READY`,KeyWrappingFailed:`KEY_WRAPPING_FAILED`,TransportKeyPairChanged:`TRANSPORT_KEY_PAIR_CHANGED`,PreparedPermitChainMismatch:`PREPARED_PERMIT_CHAIN_MISMATCH`,PreparedPermitExpired:`PREPARED_PERMIT_EXPIRED`,UnshieldAlreadyFinalized:`UNSHIELD_ALREADY_FINALIZED`},E={[T.SigningRejected]:!1,[T.SigningFailed]:!1,[T.EncryptionFailed]:!1,[T.DecryptionFailed]:!1,[T.EncryptOffloadUnavailable]:!1,[T.TransactionReverted]:!1,[T.TransportKeyPairExpired]:!1,[T.InvalidTransportKeyPair]:!1,[T.RevokedKmsContext]:!1,[T.NoCiphertext]:!1,[T.RelayerRequestFailed]:!1,[T.NotEntitled]:!1,[T.RpcRateLimited]:!0,[T.Configuration]:!1,[T.DelegationSelfNotAllowed]:!1,[T.DelegationCooldown]:!0,[T.DelegationNotFound]:!1,[T.DelegationExpired]:!1,[T.InsufficientConfidentialBalance]:!1,[T.InsufficientERC20Balance]:!1,[T.InsufficientAllowance]:!1,[T.BalanceCheckUnavailable]:!1,[T.ERC20ReadFailed]:!1,[T.DelegationExpiryUnchanged]:!1,[T.DelegationDelegateEqualsContract]:!1,[T.DelegationContractIsSelf]:!1,[T.AclPaused]:!1,[T.DelegationExpirationTooSoon]:!1,[T.DelegationNotPropagated]:!0,[T.ChainMismatch]:!1,[T.SignerNotConfigured]:!1,[T.WalletNotConnected]:!1,[T.WalletAccountNotReady]:!0,[T.KeyWrappingFailed]:!1,[T.TransportKeyPairChanged]:!1,[T.PreparedPermitChainMismatch]:!1,[T.PreparedPermitExpired]:!1,[T.UnshieldAlreadyFinalized]:!1};var D=class extends Error{code;retryable;constructor(e,t,n){super(t,n),Object.setPrototypeOf(this,new.target.prototype),this.name=`ZamaError`,this.code=e,this.retryable=n?.retryable??E[e]}};function O(e){return e instanceof D&&e.retryable}function k(e){if(!O(e)||!(`retryAfter`in e))return;let t=e.retryAfter;return y(t)?t:void 0}var A=class extends D{statusCode;retryAfter;constructor(e,t,n){let r=n?.retryable??t===429;super(T.RelayerRequestFailed,e,{...n,retryable:r}),this.name=`RelayerRequestFailedError`,this.statusCode=t,this.retryAfter=r?n?.retryAfter:void 0}},j=class extends D{constructor(e,t){super(T.Configuration,e,t),this.name=`ConfigurationError`}};export{e as S,m as _,O as a,h as b,x as c,l as d,t as f,s as g,o as h,T as i,C as l,u as m,A as n,k as o,d as p,D as r,S as s,j as t,w as u,c as v,_ as x,y};
-//# sourceMappingURL=relayer-CVKO9GmQ.js.map

package/dist/esm/relayer-CVKO9GmQ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"relayer-CVKO9GmQ.js","names":[],"sources":["../../src/utils/error.ts","../../src/errors/base.ts","../../src/errors/relayer.ts"],"sourcesContent":["/** Coerce an unknown caught value to an Error instance. */\nexport function toError(error: unknown): Error {\n  if (error instanceof Error) {\n    return error;\n  }\n  if (typeof error === \"object\" && error !== null && \"message\" in error) {\n    return new Error(String(error.message));\n  }\n  return new Error(String(error));\n}\n\n/**\n * Returns true if the error is a contract call revert (as opposed to a network/transport error).\n * Detects viem's ContractFunctionExecutionError / ContractFunctionRevertedError\n * and ethers' CALL_EXCEPTION.\n */\nexport function isContractCallError(error: unknown): boolean {\n  if (!(error instanceof Error)) {\n    return false;\n  }\n  // viem: ContractFunctionExecutionError, ContractFunctionRevertedError\n  if (\n    error.name === \"ContractFunctionExecutionError\" ||\n    error.name === \"ContractFunctionRevertedError\"\n  ) {\n    return true;\n  }\n  // ethers: error.code === \"CALL_EXCEPTION\"\n  if (\"code\" in error && error.code === \"CALL_EXCEPTION\") {\n    return true;\n  }\n  // Fallback: common revert message patterns from various providers\n  const msg = error.message.toLowerCase();\n  return msg.includes(\"execution reverted\") || msg.includes(\"call revert exception\");\n}\n\n/** JSON-RPC error code providers use for rate limiting (\"limit exceeded\"). */\nconst JSON_RPC_LIMIT_EXCEEDED = -32005;\n\n/** Properties that may nest a lower-level cause across viem / ethers / fetch. */\nconst NESTED_ERROR_KEYS = [\"cause\", \"error\", \"info\"] as const;\n\n/**\n * Walk an error and its nested causes (`cause` / `error` / `info`, as used by\n * viem, ethers, and fetch wrappers), applying `predicate` to each object node.\n * Returns the first node for which `predicate` returns true, or `undefined`.\n * Depth-bounded to avoid pathological / cyclic structures.\n */\nfunction findInErrorChain(\n  error: unknown,\n  predicate: (node: Record<string, unknown>) => boolean,\n  depth = 6,\n): Record<string, unknown> | undefined {\n  if (depth < 0 || error === null || error === undefined || typeof error !== \"object\") {\n    return undefined;\n  }\n  const node = error as Record<string, unknown>;\n  if (predicate(node)) {\n    return node;\n  }\n  for (const key of NESTED_ERROR_KEYS) {\n    const next = node[key];\n    if (next !== undefined && next !== null && typeof next === \"object\") {\n      const found = findInErrorChain(next, predicate, depth - 1);\n      if (found) {\n        return found;\n      }\n    }\n  }\n  return undefined;\n}\n\n// ============================================================================\n// Classification detectors\n// ============================================================================\n\n/**\n * Structured (unambiguous) consumer rate-limit signal across the RPC providers\n * the SDK reads through:\n * - JSON-RPC `-32005` (\"limit exceeded\");\n * - viem-style numeric `status: 429`, and viem's own `shouldRetry` shape where\n *   the JSON-RPC error `code` is `429`;\n * - ethers' 429, which surfaces as `code: \"SERVER_ERROR\"` with the status only\n *   in `info.responseStatus` (a string like `\"429 Too Many Requests\"`) and no\n *   numeric top-level status — the leading code is parsed out of it.\n *\n * Deliberately NOT `statusCode: 429` — that is the relayer / node-fetch HTTP\n * shape, which stays {@link RelayerRequestFailedError} (SDK-236), so a relayer\n * 429 is never mistaken for a consumer-RPC throttle.\n */\nfunction nodeHasStructuredRateLimit(node: Record<string, unknown>): boolean {\n  if (node.code === JSON_RPC_LIMIT_EXCEEDED || node.status === 429 || node.code === 429) {\n    return true;\n  }\n  // ethers: `code: \"SERVER_ERROR\"`, status lives in `info.responseStatus`.\n  if (node.code === \"SERVER_ERROR\" && typeof node.info === \"object\" && node.info !== null) {\n    const responseStatus = (node.info as Record<string, unknown>).responseStatus;\n    if (typeof responseStatus === \"string\" && /^\\s*429\\b/.test(responseStatus)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction nodeIsRpcRateLimit(node: Record<string, unknown>): boolean {\n  if (nodeHasStructuredRateLimit(node)) {\n    return true;\n  }\n  // Message fallback for providers without a structured code. Deliberately\n  // narrow (specific throttling phrases, no bare \"429\") to avoid false positives\n  // that would turn a terminal error into a retryable one.\n  if (typeof node.message === \"string\") {\n    const msg = node.message.toLowerCase();\n    return (\n      msg.includes(\"too many requests\") || msg.includes(\"rate limit\") || msg.includes(\"rate-limit\")\n    );\n  }\n  return false;\n}\n\n/**\n * True when a failure originates from `@fhevm/sdk`'s relayer transport. Every\n * relayer error it throws — `RelayerResponseStatusError`, `RelayerResponseApiError`,\n * `RelayerMaxRetryError`, `RelayerTimeoutError`, … — carries the `Relayer` `name`\n * prefix. Such errors stay the relayer's domain ({@link RelayerRequestFailedError}\n * / SDK-236), never {@link RpcRateLimitError}, even on a 429 (which `@fhevm/sdk`\n * retries internally, honoring `Retry-After`, before surfacing).\n */\nexport function isRelayerError(error: unknown): boolean {\n  return (\n    findInErrorChain(\n      error,\n      (node) => typeof node.name === \"string\" && node.name.startsWith(\"Relayer\"),\n    ) !== undefined\n  );\n}\n\n/**\n * True when the failure is an `@fhevm/sdk` relayer *timeout* (`RelayerTimeoutError`,\n * thrown when a request exceeds the relayer's global deadline without a verdict).\n * Unlike a terminal 4xx/5xx, the operation itself is safe to retry, so callers map\n * it to a {@link RelayerRequestFailedError} with `retryable: true` — mirroring the\n * former `WorkerTimeoutError`, which was likewise documented retryable.\n */\nexport function isRelayerTimeoutError(error: unknown): boolean {\n  return findInErrorChain(error, (node) => node.name === \"RelayerTimeoutError\") !== undefined;\n}\n\n/**\n * True if the error is the consumer's RPC provider throttling an on-chain read\n * (HTTP 429 / JSON-RPC -32005). Relayer-originated 429s are excluded.\n */\nexport function isRpcRateLimitError(error: unknown): boolean {\n  if (isRelayerError(error)) {\n    return false;\n  }\n  return findInErrorChain(error, nodeIsRpcRateLimit) !== undefined;\n}\n\n/**\n * Like {@link isRpcRateLimitError} but only matches an unambiguous **structured**\n * signal (`-32005` or a viem `status: 429`), ignoring message text. The classifier\n * promotes this ahead of any HTTP status, while a message-only throttle is only\n * trusted when no status is present — so a relayer HTTP error whose body happens\n * to say \"rate limit\" still maps to {@link RelayerRequestFailedError}.\n */\nexport function hasStructuredRpcRateLimitSignal(error: unknown): boolean {\n  if (isRelayerError(error)) {\n    return false;\n  }\n  return findInErrorChain(error, nodeHasStructuredRateLimit) !== undefined;\n}\n\n/**\n * Transport-error signatures of the consumer's own RPC client (viem / ethers).\n * The SDK's on-chain reads (the ACL `persistAllowed` pre-check) go through that\n * client, which already retries transport faults internally — so a failure\n * carrying one of these shapes must NOT be retried again by the SDK on top.\n */\nfunction nodeHasConsumerRpcSignature(node: Record<string, unknown>): boolean {\n  // ethers transient transport codes.\n  const code = node.code;\n  if (code === \"NETWORK_ERROR\" || code === \"SERVER_ERROR\" || code === \"TIMEOUT\") {\n    return true;\n  }\n  // viem transport error classes, matched by `name`.\n  const name = node.name;\n  return (\n    name === \"HttpRequestError\" ||\n    name === \"RpcRequestError\" ||\n    name === \"TimeoutError\" ||\n    name === \"WebSocketRequestError\"\n  );\n}\n\n/**\n * True when a failure originates from the **consumer's RPC provider** (viem /\n * ethers) rather than the relayer. Keeps the SDK's relayer retry from\n * double-retrying transport faults the integrator's client already retried.\n * A relayer error (`Relayer*`) is never consumer-RPC.\n */\nexport function isConsumerRpcError(error: unknown): boolean {\n  if (isRelayerError(error)) {\n    return false;\n  }\n  if (hasStructuredRpcRateLimitSignal(error)) {\n    return true;\n  }\n  return findInErrorChain(error, nodeHasConsumerRpcSignature) !== undefined;\n}\n\n/**\n * `@fhevm/sdk`'s ACL gate (`checkPersistAllowed`) throws an `AclUserDecryptionError`\n * when the requesting actor isn't allowed: `User <a> is not authorized to decrypt\n * handle <h>!`. Matching that phrase is what lets {@link wrapDecryptError} surface\n * a typed NotEntitledError with the parsed handle.\n *\n * Deliberately excludes the sibling `Dapp contract <a> is not authorized to\n * **user** decrypt handle <h>!` — a dapp ACL misconfig, intentionally left to\n * DecryptionFailedError. The differentiator is the inserted \"user\": the actor\n * message reads \"…to decrypt handle\", the dapp message \"…to user decrypt handle\",\n * so keying on \"is not authorized to decrypt handle\" matches only the former.\n *\n * The `error.test.ts` drift guard reads the installed `@fhevm/sdk` source and\n * fails loudly if the message is reworded.\n */\nexport function isNotEntitledMessage(message: string): boolean {\n  return message.toLowerCase().includes(\"is not authorized to decrypt handle\");\n}\n\n/**\n * `@fhevm/sdk`'s `verifyTkmsPublicKey` throws `invalid TransportKeyPairKeyPair`\n * when a stored transport key pair can't be re-derived under the current TKMS\n * version — the signal that the persisted key pair is stale (typically after a\n * KMS/TKMS rotation) and must be evicted and regenerated. Matching it lets the\n * signing and decrypt paths surface a typed {@link InvalidTransportKeyPairError}\n * and self-heal the vault entry.\n */\nexport function isInvalidTransportKeyPairMessage(message: string): boolean {\n  return message.toLowerCase().includes(\"invalid transportkeypair\");\n}\n\n/**\n * 4-byte selector of `InvalidKmsContext(uint256)`, the revert ProtocolConfig\n * raises when the KMS signers read resolves an unknown or revoked context.\n * The `error.test.ts` drift guard recomputes it from the Solidity signature.\n */\nexport const INVALID_KMS_CONTEXT_SELECTOR = \"0x77ddbe81\";\n\n/** Revert-data fields across clients: viem's `raw`/`signature`, ethers' `data`. */\nconst REVERT_DATA_KEYS = [\"data\", \"raw\", \"signature\"] as const;\n\nfunction nodeHasInvalidKmsContextRevert(node: Record<string, unknown>): boolean {\n  for (const key of REVERT_DATA_KEYS) {\n    const value = node[key];\n    if (typeof value === \"string\" && value.toLowerCase().startsWith(INVALID_KMS_CONTEXT_SELECTOR)) {\n      return true;\n    }\n  }\n  // Text-only fallback for wrappers that stringify the revert instead of\n  // carrying the data fields above.\n  if (typeof node.message === \"string\") {\n    const msg = node.message.toLowerCase();\n    return msg.includes(INVALID_KMS_CONTEXT_SELECTOR) || msg.includes(\"invalidkmscontext\");\n  }\n  return false;\n}\n\n/**\n * True when a failure is the on-chain KMS signers read reverting with\n * `InvalidKmsContext`: the permit's KMS context has been revoked (or never\n * existed), so every permit signed under it is permanently dead. The decrypt\n * path uses this to evict the permit and re-grant under the current context.\n *\n * The installed `@fhevm/sdk` performs that read without the error in its ABI,\n * so the revert arrives as raw data; the selector is matched anywhere in the\n * cause chain, with a message fallback for text-only providers.\n */\nexport function isRevokedKmsContextError(error: unknown): boolean {\n  return findInErrorChain(error, nodeHasInvalidKmsContextRevert) !== undefined;\n}\n\n/** Parse the on-chain handle out of the not-entitled message. */\nexport function parseHandleFromMessage(message: string): string | undefined {\n  return /handle (0x[0-9a-fA-F]{64})/.exec(message)?.[1];\n}\n\n/**\n * Parse an HTTP `Retry-After` header value into **seconds** (the SDK's duration\n * unit and the header's own unit), or `undefined` when absent/unparseable. Per\n * RFC 9110 the value is either a non-negative number of seconds (`\"120\"`) or an\n * HTTP-date; a past date floors to `0`.\n */\nexport function parseRetryAfterHeader(value: string | null | undefined): number | undefined {\n  if (value === null || value === undefined) {\n    return undefined;\n  }\n  const trimmed = value.trim();\n  if (trimmed === \"\") {\n    return undefined;\n  }\n  // delta-seconds: a non-negative integer (already the unit we want).\n  if (/^\\d+$/.test(trimmed)) {\n    return Number(trimmed);\n  }\n  // HTTP-date — an IMF-fixdate always carries alphabetic day/month names, so\n  // require a letter before deferring to the lenient Date.parse.\n  if (/[a-zA-Z]/.test(trimmed)) {\n    const dateMs = Date.parse(trimmed);\n    if (!Number.isNaN(dateMs)) {\n      return Math.max(0, Math.round((dateMs - Date.now()) / 1000));\n    }\n  }\n  return undefined;\n}\n\n/** Read a `Retry-After` header (→ seconds) off a `Headers`-like object, if present. */\nexport function readRetryAfterHeader(headers: unknown): number | undefined {\n  if (headers === null || typeof headers !== \"object\") {\n    return undefined;\n  }\n  const get = (headers as { get?: unknown }).get;\n  if (typeof get !== \"function\") {\n    return undefined;\n  }\n  return parseRetryAfterHeader(\n    (get as (name: string) => string | null).call(headers, \"Retry-After\"),\n  );\n}\n\n/**\n * A node's **relayer** `Retry-After` header (seconds), read from a wrapped fetch\n * `Response` (the relayer's `cause.response.headers`). The SDK owns the\n * relayer fetch, so parsing the header there is legitimate.\n *\n * The viem/chain side (`HttpRequestError.headers`) is deliberately **not** read:\n * for consumer RPC the integrator's viem/ethers transport already honors\n * `Retry-After` in its own retry loop (and retries) before the error ever\n * surfaces, so re-reading it here would re-implement a transport concern.\n * Chain-RPC backoff is configured on the consumer's transport (`chain.network`).\n */\nfunction retryAfterFromHeader(node: Record<string, unknown>): number | undefined {\n  const response = node.response;\n  if (response !== null && typeof response === \"object\") {\n    return readRetryAfterHeader((response as Record<string, unknown>).headers);\n  }\n  return undefined;\n}\n\n/**\n * True for a well-formed server-driven retry delay, in seconds: a finite,\n * positive number. Shared by the chain-walking extractor below and the public\n * {@link retryAfterSeconds} accessor (`errors/base.ts`), so a malformed value\n * (`0`, negative, `NaN`) is rejected the same way everywhere instead of being\n * handed unchanged to a `setTimeout` backoff.\n */\nexport function isValidRetryAfterSeconds(value: unknown): value is number {\n  return typeof value === \"number\" && Number.isFinite(value) && value > 0;\n}\n\n/**\n * A single node's server-driven retry delay (seconds): a numeric `retryAfter`\n * (a non-positive synthetic value is ignored), else a `Retry-After` header.\n */\nfunction retryAfterFromNode(node: Record<string, unknown>): number | undefined {\n  if (isValidRetryAfterSeconds(node.retryAfter)) {\n    return node.retryAfter;\n  }\n  return retryAfterFromHeader(node);\n}\n\n/**\n * Best-effort extraction of a server-driven retry delay, in **seconds**, from\n * anywhere in an error's cause chain. Reads a numeric `retryAfter` property and\n * the **relayer's** `Retry-After` header (`cause.response.headers`). The\n * consumer-RPC/chain side is intentionally not read — viem/ethers own that\n * backoff (see {@link retryAfterFromHeader}). `undefined` when absent.\n */\nexport function extractRetryAfter(error: unknown): number | undefined {\n  const node = findInErrorChain(error, (n) => retryAfterFromNode(n) !== undefined);\n  return node ? retryAfterFromNode(node) : undefined;\n}\n\n/**\n * Extract an HTTP status code from an error or anywhere in its cause chain.\n * Relayer SDK errors may carry a `status` or `statusCode` property; walking the\n * full chain (rather than just depth-1) keeps this in step with the other\n * chain-walking detectors and avoids a depth asymmetry between them.\n */\nexport function extractHttpStatus(error: unknown): number | undefined {\n  const node = findInErrorChain(\n    error,\n    (n) => typeof n.statusCode === \"number\" || typeof n.status === \"number\",\n  );\n  if (!node) {\n    return undefined;\n  }\n  return (typeof node.statusCode === \"number\" ? node.statusCode : node.status) as number;\n}\n\n/**\n * A JSON-RPC / EIP-1193 numeric error code (e.g. `4001` for user rejection, or a\n * wallet/provider code like `-32603`) found anywhere in a signing failure's cause\n * chain. Gives a signing error a structured, groupable field instead of leaving\n * the code buried in free-text `message` or an opaque nested `cause`.\n *\n * Skips `-1`: viem's own `UnknownRpcError` fallback code for errors it can't\n * classify, not an RPC-provided code. Reporting it as `rpcCode` would read as\n * a real (if odd) wallet error code, so the chain walk continues past it in\n * case a real code is nested deeper (e.g. in `cause`).\n */\nexport function extractRpcErrorCode(error: unknown): number | undefined {\n  const node = findInErrorChain(error, (n) => typeof n.code === \"number\" && n.code !== -1);\n  return node ? (node.code as number) : undefined;\n}\n\n/**\n * The `name` of the error class a signing failure was thrown as (e.g. viem's\n * `InvalidParamsRpcError`, an EIP-1193 `ProviderRpcError`) — a stable,\n * library-level classification an observability integration can group and alert\n * on. Deliberately reads only the top-level error, not the full cause chain: a\n * wallet's own internal error class name is inconsistent across wallets and\n * buried at an arbitrary depth, so it is not guessed at here — the full chain\n * remains available via the wrapped error's `cause` for manual inspection.\n */\nexport function extractWalletErrorName(error: unknown): string | undefined {\n  return error instanceof Error && error.name !== \"Error\" ? error.name : undefined;\n}\n","import { isValidRetryAfterSeconds } from \"../utils/error\";\n\n/**\n * Typed error codes thrown by the SDK.\n * Use `error.code` or `instanceof` to programmatically handle specific failure modes.\n *\n * @example\n * ```ts\n * try {\n *   await token.confidentialTransfer(\"0xTo\", 100n);\n * } catch (e) {\n *   if (e instanceof SigningRejectedError) {\n *     // User rejected the wallet signature\n *   }\n * }\n * ```\n */\nexport const ZamaErrorCode = {\n  /** User rejected the wallet signature prompt. */\n  SigningRejected: \"SIGNING_REJECTED\",\n  /** Wallet signature failed for a reason other than rejection. */\n  SigningFailed: \"SIGNING_FAILED\",\n  /** FHE encryption failed. */\n  EncryptionFailed: \"ENCRYPTION_FAILED\",\n  /** FHE decryption failed. */\n  DecryptionFailed: \"DECRYPTION_FAILED\",\n  /** Encryption offload was required (`offloadEncrypt: true`) but the worker is unavailable. */\n  EncryptOffloadUnavailable: \"ENCRYPT_OFFLOAD_UNAVAILABLE\",\n  /** On-chain transaction reverted. */\n  TransactionReverted: \"TRANSACTION_REVERTED\",\n  /** Transport key pair has expired and needs regeneration. */\n  TransportKeyPairExpired: \"KEYPAIR_EXPIRED\",\n  /** Relayer rejected transport key pair (stale, expired, or malformed). */\n  InvalidTransportKeyPair: \"INVALID_KEYPAIR\",\n  /** The permit's KMS context was revoked on-chain; the SDK's evict-and-regrant retry also failed. */\n  RevokedKmsContext: \"REVOKED_KMS_CONTEXT\",\n  /** No FHE ciphertext exists for this account (never shielded). */\n  NoCiphertext: \"NO_CIPHERTEXT\",\n  /** Relayer HTTP request failed. */\n  RelayerRequestFailed: \"RELAYER_REQUEST_FAILED\",\n  /** The configured signer/account is not entitled (ACL) to decrypt this encrypted value. Don't retry — wait for a grant. */\n  NotEntitled: \"NOT_ENTITLED\",\n  /** The consumer's RPC provider rate-limited an on-chain read (e.g. HTTP 429 / JSON-RPC -32005). Retryable. */\n  RpcRateLimited: \"RPC_RATE_LIMITED\",\n  /** SDK configuration is invalid (e.g. forbidden chain ID, unsupported type). */\n  Configuration: \"CONFIGURATION\",\n  /** Delegation cannot target self (delegate === msg.sender). */\n  DelegationSelfNotAllowed: \"DELEGATION_SELF_NOT_ALLOWED\",\n  /** Only one delegate/revoke per (delegator, delegate, contract) per block. */\n  DelegationCooldown: \"DELEGATION_COOLDOWN\",\n  /** No active delegation found for this (delegator, delegate, contract) tuple. */\n  DelegationNotFound: \"DELEGATION_NOT_FOUND\",\n  /** The delegation has expired. */\n  DelegationExpired: \"DELEGATION_EXPIRED\",\n  /** Confidential (cToken) balance is insufficient for the requested operation. */\n  InsufficientConfidentialBalance: \"INSUFFICIENT_CONFIDENTIAL_BALANCE\",\n  /** ERC-20 balance is insufficient for the requested shield amount. */\n  InsufficientERC20Balance: \"INSUFFICIENT_ERC20_BALANCE\",\n  /** ERC-20 allowance granted to the wrapper is insufficient for the requested wrap amount. */\n  InsufficientAllowance: \"INSUFFICIENT_ALLOWANCE\",\n  /** Balance validation could not be performed (no cached credentials and decryption not possible). */\n  BalanceCheckUnavailable: \"BALANCE_CHECK_UNAVAILABLE\",\n  /** Public ERC-20 read (e.g. balanceOf) failed due to a network or contract error. */\n  ERC20ReadFailed: \"ERC20_READ_FAILED\",\n  /** The new expiration date equals the current one — no on-chain change needed. */\n  DelegationExpiryUnchanged: \"DELEGATION_EXPIRY_UNCHANGED\",\n  /** Delegate address cannot be the contract address. */\n  DelegationDelegateEqualsContract: \"DELEGATION_DELEGATE_EQUALS_CONTRACT\",\n  /** Contract address cannot be the sender address. */\n  DelegationContractIsSelf: \"DELEGATION_CONTRACT_IS_SELF\",\n  /** The ACL contract is paused. */\n  AclPaused: \"ACL_PAUSED\",\n  /** Expiration date is too soon (must be at least 1 hour in the future). */\n  DelegationExpirationTooSoon: \"DELEGATION_EXPIRATION_TOO_SOON\",\n  /** Delegation exists on-chain but hasn't propagated to the gateway yet. */\n  DelegationNotPropagated: \"DELEGATION_NOT_PROPAGATED\",\n  /** Signer and provider are connected to different chains. */\n  ChainMismatch: \"CHAIN_MISMATCH\",\n  /** Operation requires a signer but none is configured. */\n  SignerNotConfigured: \"SIGNER_NOT_CONFIGURED\",\n  /** Operation requires a connected wallet account. */\n  WalletNotConnected: \"WALLET_NOT_CONNECTED\",\n  /** Wallet account discovery is still resolving. */\n  WalletAccountNotReady: \"WALLET_ACCOUNT_NOT_READY\",\n  /** Wrapping or unwrapping the transport private key with `transportKeyPairDerivationSecret` failed. */\n  KeyWrappingFailed: \"KEY_WRAPPING_FAILED\",\n  /** The transport key pair changed between `preparePermit` and `registerPermit`. */\n  TransportKeyPairChanged: \"TRANSPORT_KEY_PAIR_CHANGED\",\n  /** A prepared permit's `chainId` does not match the chain `registerPermit` is running against. */\n  PreparedPermitChainMismatch: \"PREPARED_PERMIT_CHAIN_MISMATCH\",\n  /** A prepared permit's validity window elapsed before its signature was registered. */\n  PreparedPermitExpired: \"PREPARED_PERMIT_EXPIRED\",\n  /** The unwrap request was already finalized on-chain; there is nothing left to resume. */\n  UnshieldAlreadyFinalized: \"UNSHIELD_ALREADY_FINALIZED\",\n} as const;\n\n/** Union of all {@link ZamaErrorCode} string values. */\nexport type ZamaErrorCode = (typeof ZamaErrorCode)[keyof typeof ZamaErrorCode];\n\n/** Identity type that fails to instantiate unless `T` maps every {@link ZamaErrorCode} to a `boolean`. */\ntype Complete<T extends Record<ZamaErrorCode, boolean>> = T;\n\n/**\n * Default retryability for each {@link ZamaErrorCode}. `Complete` fails the build\n * if a new code is added without an entry here — the same exhaustiveness guard\n * `matchZamaError`'s `ErrorForCode` map uses (see `match.ts`) — so a new\n * transient (or terminal) cause can't silently default to the wrong signal.\n *\n * {@link RelayerRequestFailedError} is the one exception: its retryability\n * depends on the HTTP status (only a 429 is retryable), not just the code, so\n * it overrides this default via the constructor's `retryable` option instead\n * of being read from here.\n */\nconst RETRYABLE_BY_CODE: Complete<Record<ZamaErrorCode, boolean>> = {\n  [ZamaErrorCode.SigningRejected]: false,\n  [ZamaErrorCode.SigningFailed]: false,\n  [ZamaErrorCode.EncryptionFailed]: false,\n  [ZamaErrorCode.DecryptionFailed]: false,\n  [ZamaErrorCode.EncryptOffloadUnavailable]: false, // the worker realm is unusable for this page; a retry hits the same environment\n  [ZamaErrorCode.TransactionReverted]: false,\n  [ZamaErrorCode.TransportKeyPairExpired]: false,\n  [ZamaErrorCode.InvalidTransportKeyPair]: false,\n  [ZamaErrorCode.RevokedKmsContext]: false, // the retry already re-granted; a blind retry re-hits the stale validity cache\n  [ZamaErrorCode.NoCiphertext]: false,\n  [ZamaErrorCode.RelayerRequestFailed]: false, // conditional — see doc above\n  [ZamaErrorCode.NotEntitled]: false,\n  [ZamaErrorCode.RpcRateLimited]: true,\n  [ZamaErrorCode.Configuration]: false,\n  [ZamaErrorCode.DelegationSelfNotAllowed]: false,\n  [ZamaErrorCode.DelegationCooldown]: true, // per-block timing gate, resolves on next-block retry\n  [ZamaErrorCode.DelegationNotFound]: false,\n  [ZamaErrorCode.DelegationExpired]: false,\n  [ZamaErrorCode.InsufficientConfidentialBalance]: false,\n  [ZamaErrorCode.InsufficientERC20Balance]: false,\n  [ZamaErrorCode.InsufficientAllowance]: false, // terminal: caller must approve a larger allowance\n  [ZamaErrorCode.BalanceCheckUnavailable]: false,\n  [ZamaErrorCode.ERC20ReadFailed]: false, // conservative: conflates network (transient) and contract (terminal) faults, see class doc\n  [ZamaErrorCode.DelegationExpiryUnchanged]: false,\n  [ZamaErrorCode.DelegationDelegateEqualsContract]: false,\n  [ZamaErrorCode.DelegationContractIsSelf]: false,\n  [ZamaErrorCode.AclPaused]: false,\n  [ZamaErrorCode.DelegationExpirationTooSoon]: false,\n  [ZamaErrorCode.DelegationNotPropagated]: true,\n  [ZamaErrorCode.ChainMismatch]: false,\n  [ZamaErrorCode.SignerNotConfigured]: false,\n  [ZamaErrorCode.WalletNotConnected]: false,\n  [ZamaErrorCode.WalletAccountNotReady]: true, // async wallet-account discovery still resolving\n  [ZamaErrorCode.KeyWrappingFailed]: false, // a transportKeyPairDerivationSecret mismatch or environment capability issue, not transient\n  [ZamaErrorCode.TransportKeyPairChanged]: false, // caller must re-run preparePermit against the current key pair\n  [ZamaErrorCode.PreparedPermitChainMismatch]: false, // caller must register against the chain the permit was prepared for\n  [ZamaErrorCode.PreparedPermitExpired]: false, // caller must re-run preparePermit for a fresh validity window\n  [ZamaErrorCode.UnshieldAlreadyFinalized]: false, // the funds already arrived; the stale pointer is cleared\n};\n\n/**\n * Base error thrown by all SDK operations.\n * Carries a {@link ZamaErrorCode} for programmatic error handling.\n * Prefer catching specific subclasses (e.g. {@link EncryptionFailedError}).\n */\nexport class ZamaError extends Error {\n  /** Machine-readable error code. */\n  readonly code: ZamaErrorCode;\n\n  /**\n   * Whether the operation that threw this error is safe to retry. Defaults to\n   * {@link RETRYABLE_BY_CODE}'s entry for `code`; only {@link RelayerRequestFailedError}\n   * overrides it per-instance (its retryability depends on the HTTP status).\n   * Prefer {@link isRetryable} over reading this directly, so a new `unknown`\n   * caught value doesn't need an `instanceof ZamaError` check first.\n   */\n  readonly retryable: boolean;\n\n  constructor(\n    code: ZamaErrorCode,\n    message: string,\n    options?: ErrorOptions & { retryable?: boolean },\n  ) {\n    super(message, options);\n    Object.setPrototypeOf(this, new.target.prototype);\n    this.name = \"ZamaError\";\n    this.code = code;\n    this.retryable = options?.retryable ?? RETRYABLE_BY_CODE[code];\n  }\n}\n\n/**\n * True if `error` is a {@link ZamaError} whose failure is transient and safe to\n * retry (rate-limited, back-pressured, a delegation still propagating or in\n * its per-block cooldown, or a wallet account still resolving).\n * Compiler-guaranteed to stay in sync with the\n * taxonomy: every {@link ZamaError} subclass declares its own retryability via\n * {@link ZamaError.retryable}, so a consumer never has to hardcode a set of\n * retryable codes.\n *\n * @example\n * ```ts\n * try {\n *   await sdk.decryption.decryptValues([{ encryptedValue, contractAddress }]);\n * } catch (e) {\n *   if (isRetryable(e)) {\n *     // back off and retry (see retryAfterSeconds for a server-suggested delay)\n *   } else {\n *     throw e; // terminal — surface it\n *   }\n * }\n * ```\n */\nexport function isRetryable(error: unknown): error is ZamaError & { retryable: true } {\n  return error instanceof ZamaError && error.retryable;\n}\n\n/**\n * The server-suggested retry delay, in **seconds**, for a retryable\n * {@link ZamaError} — unifying the `retryAfter` field that today lives on\n * {@link RelayerRequestFailedError} and {@link RpcRateLimitError} only.\n * `undefined` when the error isn't retryable, or is retryable but carries no\n * server-driven delay (e.g. {@link DelegationNotPropagatedError} — retry that\n * with your own backoff).\n */\nexport function retryAfterSeconds(error: unknown): number | undefined {\n  if (!isRetryable(error) || !(\"retryAfter\" in error)) {\n    return undefined;\n  }\n  const retryAfter = (error as ZamaError & { retryAfter?: unknown }).retryAfter;\n  return isValidRetryAfterSeconds(retryAfter) ? retryAfter : undefined;\n}\n","import { ZamaError, ZamaErrorCode } from \"./base\";\n\n/** Relayer HTTP request failed. */\nexport class RelayerRequestFailedError extends ZamaError {\n  /** HTTP status code from the relayer, if available. */\n  readonly statusCode: number | undefined;\n\n  /**\n   * Server-driven retry delay in **seconds** (the SDK's duration unit and the\n   * header's own unit), from the relayer's `Retry-After` header. Set only on\n   * back-pressure (HTTP 429) responses that carry the header; `undefined`\n   * otherwise. Implies {@link ZamaError.retryable}.\n   */\n  readonly retryAfter: number | undefined;\n\n  constructor(\n    message: string,\n    statusCode?: number,\n    options?: ErrorOptions & { retryAfter?: number; retryable?: boolean },\n  ) {\n    // Retryable on relayer back-pressure (HTTP 429) by default, or when the\n    // caller forces it (a relayer timeout has no status but is safe to retry).\n    const retryable = options?.retryable ?? statusCode === 429;\n    super(ZamaErrorCode.RelayerRequestFailed, message, { ...options, retryable });\n    this.name = \"RelayerRequestFailedError\";\n    this.statusCode = statusCode;\n    // Keep the two fields consistent: a delay only makes sense when retryable,\n    // and only a 429 actually carries a server-supplied `Retry-After`.\n    this.retryAfter = retryable ? options?.retryAfter : undefined;\n  }\n}\n\n/** SDK configuration is invalid (e.g. forbidden chain ID, unsupported type). */\nexport class ConfigurationError extends ZamaError {\n  constructor(message: string, options?: ErrorOptions) {\n    super(ZamaErrorCode.Configuration, message, options);\n    this.name = \"ConfigurationError\";\n  }\n}\n"],"mappings":"AACA,SAAgB,EAAQ,EAAuB,CAO7C,OANI,aAAiB,MACZ,EAEL,OAAO,GAAU,UAAY,GAAkB,YAAa,EACnD,MAAM,OAAO,EAAM,OAAO,CAAC,EAE7B,MAAM,OAAO,CAAK,CAAC,CAChC,CAOA,SAAgB,EAAoB,EAAyB,CAC3D,GAAI,EAAE,aAAiB,OACrB,MAAO,GAUT,GANE,EAAM,OAAS,kCACf,EAAM,OAAS,iCAKb,SAAU,GAAS,EAAM,OAAS,iBACpC,MAAO,GAGT,IAAM,EAAM,EAAM,QAAQ,YAAY,EACtC,OAAO,EAAI,SAAS,oBAAoB,GAAK,EAAI,SAAS,uBAAuB,CACnF,CAGA,MAGM,EAAoB,CAAC,QAAS,QAAS,MAAM,EAQnD,SAAS,EACP,EACA,EACA,EAAQ,EAC6B,CACrC,GAAI,EAAQ,GAA8C,OAAO,GAAU,WAA1D,EACf,OAEF,IAAM,EAAO,EACb,GAAI,EAAU,CAAI,EAChB,OAAO,EAET,IAAK,IAAM,KAAO,EAAmB,CACnC,IAAM,EAAO,EAAK,GAClB,GAA2C,OAAO,GAAS,UAAvD,EAAiE,CACnE,IAAM,EAAQ,EAAiB,EAAM,EAAW,EAAQ,CAAC,EACzD,GAAI,EACF,OAAO,CAEX,CACF,CAEF,CAoBA,SAAS,EAA2B,EAAwC,CAC1E,GAAI,EAAK,OAAS,QAA2B,EAAK,SAAW,KAAO,EAAK,OAAS,IAChF,MAAO,GAGT,GAAI,EAAK,OAAS,gBAAkB,OAAO,EAAK,MAAS,UAAY,EAAK,OAAS,KAAM,CACvF,IAAM,EAAkB,EAAK,KAAiC,eAC9D,GAAI,OAAO,GAAmB,UAAY,YAAY,KAAK,CAAc,EACvE,MAAO,EAEX,CACA,MAAO,EACT,CAEA,SAAS,EAAmB,EAAwC,CAClE,GAAI,EAA2B,CAAI,EACjC,MAAO,GAKT,GAAI,OAAO,EAAK,SAAY,SAAU,CACpC,IAAM,EAAM,EAAK,QAAQ,YAAY,EACrC,OACE,EAAI,SAAS,mBAAmB,GAAK,EAAI,SAAS,YAAY,GAAK,EAAI,SAAS,YAAY,CAEhG,CACA,MAAO,EACT,CAUA,SAAgB,EAAe,EAAyB,CACtD,OACE,EACE,EACC,GAAS,OAAO,EAAK,MAAS,UAAY,EAAK,KAAK,WAAW,SAAS,CAC3E,IAAM,IAAA,EAEV,CASA,SAAgB,EAAsB,EAAyB,CAC7D,OAAO,EAAiB,EAAQ,GAAS,EAAK,OAAS,qBAAqB,IAAM,IAAA,EACpF,CAMA,SAAgB,EAAoB,EAAyB,CAI3D,MAHA,CAAI,EAAe,CAAK,GAGjB,EAAiB,EAAO,CAAkB,IAAM,IAAA,EACzD,CASA,SAAgB,EAAgC,EAAyB,CAIvE,MAHA,CAAI,EAAe,CAAK,GAGjB,EAAiB,EAAO,CAA0B,IAAM,IAAA,EACjE,CAuDA,SAAgB,EAAqB,EAA0B,CAC7D,OAAO,EAAQ,YAAY,CAAC,CAAC,SAAS,qCAAqC,CAC7E,CAUA,SAAgB,EAAiC,EAA0B,CACzE,OAAO,EAAQ,YAAY,CAAC,CAAC,SAAS,0BAA0B,CAClE,CAUA,MAAM,EAAmB,CAAC,OAAQ,MAAO,WAAW,EAEpD,SAAS,EAA+B,EAAwC,CAC9E,IAAK,IAAM,KAAO,EAAkB,CAClC,IAAM,EAAQ,EAAK,GACnB,GAAI,OAAO,GAAU,UAAY,EAAM,YAAY,CAAC,CAAC,WAAA,YAAuC,EAC1F,MAAO,EAEX,CAGA,GAAI,OAAO,EAAK,SAAY,SAAU,CACpC,IAAM,EAAM,EAAK,QAAQ,YAAY,EACrC,OAAO,EAAI,SAAA,YAAqC,GAAK,EAAI,SAAS,mBAAmB,CACvF,CACA,MAAO,EACT,CAYA,SAAgB,EAAyB,EAAyB,CAChE,OAAO,EAAiB,EAAO,CAA8B,IAAM,IAAA,EACrE,CAGA,SAAgB,EAAuB,EAAqC,CAC1E,MAAO,6BAA6B,KAAK,CAAO,CAAC,GAAG,EACtD,CAQA,SAAgB,EAAsB,EAAsD,CAC1F,GAAI,GAAU,KACZ,OAEF,IAAM,EAAU,EAAM,KAAK,EACvB,OAAY,GAIhB,IAAI,QAAQ,KAAK,CAAO,EACtB,OAAO,OAAO,CAAO,EAIvB,GAAI,WAAW,KAAK,CAAO,EAAG,CAC5B,IAAM,EAAS,KAAK,MAAM,CAAO,EACjC,GAAI,CAAC,OAAO,MAAM,CAAM,EACtB,OAAO,KAAK,IAAI,EAAG,KAAK,OAAO,EAAS,KAAK,IAAI,GAAK,GAAI,CAAC,CAE/D,CATuB,CAWzB,CAGA,SAAgB,EAAqB,EAAsC,CACzE,GAAwB,OAAO,GAAY,WAAvC,EACF,OAEF,IAAM,EAAO,EAA8B,IACvC,UAAO,GAAQ,WAGnB,OAAO,EACJ,EAAwC,KAAK,EAAS,aAAa,CACtE,CACF,CAaA,SAAS,EAAqB,EAAmD,CAC/E,IAAM,EAAW,EAAK,SACtB,GAAyB,OAAO,GAAa,UAAzC,EACF,OAAO,EAAsB,EAAqC,OAAO,CAG7E,CASA,SAAgB,EAAyB,EAAiC,CACxE,OAAO,OAAO,GAAU,UAAY,OAAO,SAAS,CAAK,GAAK,EAAQ,CACxE,CAMA,SAAS,EAAmB,EAAmD,CAI7E,OAHI,EAAyB,EAAK,UAAU,EACnC,EAAK,WAEP,EAAqB,CAAI,CAClC,CASA,SAAgB,EAAkB,EAAoC,CACpE,IAAM,EAAO,EAAiB,EAAQ,GAAM,EAAmB,CAAC,IAAM,IAAA,EAAS,EAC/E,OAAO,EAAO,EAAmB,CAAI,EAAI,IAAA,EAC3C,CAQA,SAAgB,EAAkB,EAAoC,CACpE,IAAM,EAAO,EACX,EACC,GAAM,OAAO,EAAE,YAAe,UAAY,OAAO,EAAE,QAAW,QACjE,EACK,KAGL,OAAQ,OAAO,EAAK,YAAe,SAAW,EAAK,WAAa,EAAK,MACvE,CAaA,SAAgB,EAAoB,EAAoC,CACtE,IAAM,EAAO,EAAiB,EAAQ,GAAM,OAAO,EAAE,MAAS,UAAY,EAAE,OAAS,EAAE,EACvF,OAAO,EAAQ,EAAK,KAAkB,IAAA,EACxC,CAWA,SAAgB,EAAuB,EAAoC,CACzE,OAAO,aAAiB,OAAS,EAAM,OAAS,QAAU,EAAM,KAAO,IAAA,EACzE,CC1ZA,MAAa,EAAgB,CAE3B,gBAAiB,mBAEjB,cAAe,iBAEf,iBAAkB,oBAElB,iBAAkB,oBAElB,0BAA2B,8BAE3B,oBAAqB,uBAErB,wBAAyB,kBAEzB,wBAAyB,kBAEzB,kBAAmB,sBAEnB,aAAc,gBAEd,qBAAsB,yBAEtB,YAAa,eAEb,eAAgB,mBAEhB,cAAe,gBAEf,yBAA0B,8BAE1B,mBAAoB,sBAEpB,mBAAoB,uBAEpB,kBAAmB,qBAEnB,gCAAiC,oCAEjC,yBAA0B,6BAE1B,sBAAuB,yBAEvB,wBAAyB,4BAEzB,gBAAiB,oBAEjB,0BAA2B,8BAE3B,iCAAkC,sCAElC,yBAA0B,8BAE1B,UAAW,aAEX,4BAA6B,iCAE7B,wBAAyB,4BAEzB,cAAe,iBAEf,oBAAqB,wBAErB,mBAAoB,uBAEpB,sBAAuB,2BAEvB,kBAAmB,sBAEnB,wBAAyB,6BAEzB,4BAA6B,iCAE7B,sBAAuB,0BAEvB,yBAA0B,4BAC5B,EAmBM,EAA8D,EACjE,EAAc,iBAAkB,IAChC,EAAc,eAAgB,IAC9B,EAAc,kBAAmB,IACjC,EAAc,kBAAmB,IACjC,EAAc,2BAA4B,IAC1C,EAAc,qBAAsB,IACpC,EAAc,yBAA0B,IACxC,EAAc,yBAA0B,IACxC,EAAc,mBAAoB,IAClC,EAAc,cAAe,IAC7B,EAAc,sBAAuB,IACrC,EAAc,aAAc,IAC5B,EAAc,gBAAiB,IAC/B,EAAc,eAAgB,IAC9B,EAAc,0BAA2B,IACzC,EAAc,oBAAqB,IACnC,EAAc,oBAAqB,IACnC,EAAc,mBAAoB,IAClC,EAAc,iCAAkC,IAChD,EAAc,0BAA2B,IACzC,EAAc,uBAAwB,IACtC,EAAc,yBAA0B,IACxC,EAAc,iBAAkB,IAChC,EAAc,2BAA4B,IAC1C,EAAc,kCAAmC,IACjD,EAAc,0BAA2B,IACzC,EAAc,WAAY,IAC1B,EAAc,6BAA8B,IAC5C,EAAc,yBAA0B,IACxC,EAAc,eAAgB,IAC9B,EAAc,qBAAsB,IACpC,EAAc,oBAAqB,IACnC,EAAc,uBAAwB,IACtC,EAAc,mBAAoB,IAClC,EAAc,yBAA0B,IACxC,EAAc,6BAA8B,IAC5C,EAAc,uBAAwB,IACtC,EAAc,0BAA2B,EAC5C,EAOA,IAAa,EAAb,cAA+B,KAAM,CAEnC,KASA,UAEA,YACE,EACA,EACA,EACA,CACA,MAAM,EAAS,CAAO,EACtB,OAAO,eAAe,KAAM,IAAI,OAAO,SAAS,EAChD,KAAK,KAAO,YACZ,KAAK,KAAO,EACZ,KAAK,UAAY,GAAS,WAAa,EAAkB,EAC3D,CACF,EAwBA,SAAgB,EAAY,EAA0D,CACpF,OAAO,aAAiB,GAAa,EAAM,SAC7C,CAUA,SAAgB,EAAkB,EAAoC,CACpE,GAAI,CAAC,EAAY,CAAK,GAAK,EAAE,eAAgB,GAC3C,OAEF,IAAM,EAAc,EAA+C,WACnE,OAAO,EAAyB,CAAU,EAAI,EAAa,IAAA,EAC7D,CC9NA,IAAa,EAAb,cAA+C,CAAU,CAEvD,WAQA,WAEA,YACE,EACA,EACA,EACA,CAGA,IAAM,EAAY,GAAS,WAAa,IAAe,IACvD,MAAM,EAAc,qBAAsB,EAAS,CAAE,GAAG,EAAS,WAAU,CAAC,EAC5E,KAAK,KAAO,4BACZ,KAAK,WAAa,EAGlB,KAAK,WAAa,EAAY,GAAS,WAAa,IAAA,EACtD,CACF,EAGa,EAAb,cAAwC,CAAU,CAChD,YAAY,EAAiB,EAAwB,CACnD,MAAM,EAAc,cAAe,EAAS,CAAO,EACnD,KAAK,KAAO,oBACd,CACF"}

package/dist/esm/token-BejFVO8m.js

@@ -1,2 +0,0 @@
-import{S as e,i as t,r as n,t as r}from"./relayer-CVKO9GmQ.js";import{A as i,B as a,D as o,E as s,G as c,J as l,K as u,M as d,R as f,S as p,T as m,U as h,V as g,Z as _,b as v,l as y,m as b,q as x,tt as S,u as C,v as w,w as T,x as E,z as D}from"./wrappers-registry-BLe7PkZi.js";import{r as O,t as k}from"./encryption-BKoalB4o.js";import{t as A}from"./assertions-Ca1ePdRJ.js";import{getAddress as j}from"viem";var M=class extends n{retryAfter;constructor(e,n){let{retryAfter:r,...i}=n??{};super(t.RpcRateLimited,e,i),this.name=`RpcRateLimitError`,this.retryAfter=r}},N=class extends n{operation;signerChainId;providerChainId;constructor({operation:e,signerChainId:n,providerChainId:r},i){super(t.ChainMismatch,`Operation "${e}" requires signer and provider to be on the same chain, but signer is on chain ${n} and provider is on chain ${r}.`,i),this.name=`ChainMismatchError`,this.operation=e,this.signerChainId=n,this.providerChainId=r}},P=class extends n{requested;available;token;constructor(e,n,r){super(t.InsufficientConfidentialBalance,e,r),this.name=`InsufficientConfidentialBalanceError`,this.requested=n.requested,this.available=n.available,this.token=n.token}},F=class extends n{requested;available;token;constructor(e,n,r){super(t.InsufficientERC20Balance,e,r),this.name=`InsufficientERC20BalanceError`,this.requested=n.requested,this.available=n.available,this.token=n.token}},I=class extends n{requested;available;token;constructor(e,n,r){super(t.InsufficientAllowance,e,r),this.name=`InsufficientAllowanceError`,this.requested=n.requested,this.available=n.available,this.token=n.token}},L=class extends n{constructor(e,n){super(t.BalanceCheckUnavailable,e,n),this.name=`BalanceCheckUnavailableError`}},R=class extends n{constructor(e,n){super(t.ERC20ReadFailed,e,n),this.name=`ERC20ReadFailedError`}};function z(e){return e instanceof l||e instanceof x||e instanceof r||e instanceof M||e instanceof _||e instanceof S}const B={ebool:0,euint8:2,euint16:3,euint32:4,euint64:5,euint128:6,eaddress:7,euint256:8},V={0:`ebool`,2:`euint8`,3:`euint16`,4:`euint32`,5:`euint64`,6:`euint128`,7:`eaddress`,8:`euint256`},H={0:2,2:8,3:16,4:32,5:64,6:128,7:160,8:256};Object.freeze(B),Object.freeze(V),Object.freeze(H),Object.freeze({2:0,8:2,16:3,32:4,64:5,128:6,160:7,256:8});function U(e){switch(e){case 0:case 2:case 3:case 4:case 5:case 6:case 7:case 8:return!0;default:return!1}}function W(e){if(!U(e))throw Error(`Invalid FheType id '${e}'`);let t=H[e];if(t<2)throw Error(`Invalid FheType encryption bit width: ${t}. Minimum is 2 bits.`);return t}const G=`0x0000000000000000000000000000000000000000000000000000000000000000`;function K(e){return e===`0x0000000000000000000000000000000000000000000000000000000000000000`||e===`0x`}function q(e){let t;try{t=BigInt(e)}catch{return 256}let n=Number(t>>8n&255n);return U(n)?W(n):256}function J(e,t=2048){let n=[],r=[],i=0;for(let a of e){let e=q(a);r.length>0&&i+e>t&&(n.push(r),r=[],i=0),r.push(a),i+=e}return r.length>0&&n.push(r),n}async function Y(e,t,n){if(!t)throw new g(e);let r;try{r=t.requireWalletAccount(e)}catch(n){if(!(n instanceof h)||!t.refreshWalletAccount)throw n;await t.refreshWalletAccount(),r=t.requireWalletAccount(e)}let i=await n.getChainId();if(r.chainId!==i)throw new N({operation:e,signerChainId:r.chainId,providerChainId:i});return r}async function X(e,t,n){return(await Y(e,t,n)).chainId}async function Z(e,t=1/0){if(Number.isFinite(t)&&t<=0)throw Error(`maxConcurrency must be a positive number`);if(!Number.isFinite(t)||t>=e.length)return Promise.all(e.map(e=>e()));let n=Array.from({length:e.length}),r=0;async function i(){for(;r<e.length;){let t=r++;e[t]&&(n[t]=await e[t]())}}return await Promise.all(Array.from({length:t},i)),n}async function Q(e){let{operation:t,signer:r,provider:i,config:o,emit:s,onSubmitted:c,logger:l}=e,d=a[t];try{let e=await r.writeContract(o);return s(d.submittedEvent(e)),f(`${t}: onSubmitted`,()=>c?.(e),l),{txHash:e,receipt:await i.waitForTransactionReceipt(e)}}catch(e){let r=e instanceof n?e:new u(`Transaction failed during ${t}`,{cause:e});throw s({type:D.TransactionError,operation:t,error:r}),r}}var $=class t{sdk;address;constructor(e,t){this.sdk=e,this.address=j(t)}#e(e){return c(this.sdk.signer,e)}async name(){return this.sdk.provider.readContract(v(this.address))}async symbol(){return this.sdk.provider.readContract(E(this.address))}async decimals(){return this.sdk.provider.readContract(w(this.address))}async isConfidential(){return this.sdk.provider.readContract(b(this.address,y))}async isWrapper(){return this.sdk.provider.readContract(b(this.address,C))}async balanceOf(e){let t=j(e),n=await this.readConfidentialBalanceOf(t),r=(await this.sdk.decryption.decryptValues([{encryptedValue:n,contractAddress:this.address}]))[n];if(r===void 0)throw new k(`Decryption returned no value for ${n}`);return A(r,`balanceOf: result[encryptedValue]`),r}async confidentialBalanceOf(e){return this.readConfidentialBalanceOf(j(e))}async decryptBalanceAs({delegatorAddress:e,accountAddress:t}){await X(`decryptBalanceAs`,this.sdk.signer,this.sdk.provider);let n=j(e),r=t?j(t):n,i=await this.readConfidentialBalanceOf(r);if(K(i))return 0n;let a=(await this.sdk.decryption.delegatedDecryptValues([{encryptedValue:i,contractAddress:this.address}],n,r))[i];if(a===void 0)throw new k(`Delegated decryption returned no value for ${i}`);return A(a,`decryptBalanceAs: result[encryptedValue]`),a}static async batchBalancesOf(r,i){let a=new Map,o=new Map;if(r.length===0)return{results:a,errors:o};let s=t.assertSameSdk(r);await X(`batchBalancesOf`,s.signer,s.provider),await s.permits.grantPermit(r.map(e=>e.address));let c=!1,l,u=await Z(r.map(e=>async()=>{if(c)return{status:`aborted`};try{return{status:`fulfilled`,value:await e.balanceOf(i)}}catch(e){return z(e)?(c=!0,l??=e,{status:`aborted`}):{status:`rejected`,reason:e}}}),5);if(l!==void 0)throw l;for(let t=0;t<r.length;t++){let i=r[t].address,s=u[t];if(s.status!==`aborted`)if(s.status===`fulfilled`)a.set(i,s.value);else{let t=s.reason,r=t instanceof n?t:new k(e(t).message,{cause:t});o.set(i,r)}}if(o.size===r.length)throw o.values().next().value??new k(`All token balance decryptions failed`);return{results:a,errors:o}}static async batchDecryptBalancesAs(n,r){if(n.length===0)return new Map;let i=t.assertSameSdk(n),a=new Map,o=new Map,s=r.accountAddress?j(r.accountAddress):j(r.delegatorAddress),c=r.maxConcurrency??10;if(r.encryptedValues&&n.length!==r.encryptedValues.length)throw new k(`tokens.length (${n.length}) must equal encryptedValues.length (${r.encryptedValues.length})`);let l=r.encryptedValues??await t.readBalanceHandlesBatch(n,s,o,c),u=[];for(let[e,t]of n.entries()){let n=l[e];!n||o.has(t.address)||(K(n)?a.set(t.address,0n):u.push({token:t,encryptedValue:n}))}if(u.length>0){let e=await i.decryption.delegatedBatchDecryptValues({encryptedInputs:u.map(({token:e,encryptedValue:t})=>({encryptedValue:t,contractAddress:e.address})),delegatorAddress:r.delegatorAddress,accountAddress:r.accountAddress,maxConcurrency:c});for(let[t,n]of e.items.entries()){let e=u[t];if(!e)continue;if(n.error){o.set(e.token.address,n.error);continue}let r=n.value;if(r===void 0){o.set(e.token.address,new k(`Batch delegated decryption returned no value for ${n.encryptedValue} on token ${e.token.address}`));continue}A(r,`batchDecryptBalancesAs: result[encryptedValue]`),a.set(e.token.address,r)}}if(o.size===0)return a;if(r.onError){let t=[];for(let[n,i]of o)try{a.set(n,r.onError(i,n))}catch(r){t.push({address:n,error:e(r)})}if(t.length>0){let e=t.map(({address:e,error:t})=>`${e}: ${t.message}`).join(`; `);throw new k(`Batch delegated decryption onError callback failed for ${t.length} token(s): ${e}`,{cause:t[0]?.error})}return a}let d=Array.from(o.entries()),f=d.map(([e,t])=>`${e}: ${t.message}`).join(`; `);throw new k(`Batch delegated decryption failed for ${o.size} token(s): ${f}`,{cause:d[0]?.[1]})}static async readBalanceHandlesBatch(t,r,i,a){let o=!1,s,c=await Z(t.map(e=>async()=>{if(o)return{status:`aborted`};try{return{status:`fulfilled`,value:await e.readConfidentialBalanceOf(r)}}catch(e){return z(e)?(o=!0,s??=e,{status:`aborted`}):{status:`rejected`,reason:e}}}),a);if(s!==void 0)throw s;let l=[];for(let[r,a]of t.entries()){let t=c[r];if(!(!t||t.status===`aborted`)){if(t.status===`fulfilled`){l[r]=t.value;continue}i.set(a.address,t.reason instanceof n?t.reason:new k(e(t.reason).message,{cause:t.reason}))}}return l}async confidentialTransfer(e,t,n){this.#e(`confidentialTransfer`);let r=await Y(`confidentialTransfer`,this.sdk.signer,this.sdk.provider),{skipBalanceCheck:i=!1,onEncryptComplete:a,onTransferSubmitted:o}=n??{},s=j(e);i||await this.assertConfidentialBalance(t);let{encryptedValues:c,inputProof:l}=await this.sdk.encrypt({values:[{value:t,type:`euint64`}],contractAddress:this.address,userAddress:j(r.address)});if(f(`transfer: onEncryptComplete`,()=>a?.(),this.sdk.logger),c.length===0)throw new O(`Encryption returned no encrypted values`);return this.submitTransaction({operation:`transfer`,config:m(this.address,s,c[0],l),onSubmitted:o})}async confidentialTransferFrom(e,t,n,r){this.#e(`confidentialTransferFrom`);let i=await Y(`confidentialTransferFrom`,this.sdk.signer,this.sdk.provider),a=j(e),s=j(t),{encryptedValues:c,inputProof:l}=await this.sdk.encrypt({values:[{value:n,type:`euint64`}],contractAddress:this.address,userAddress:j(i.address)});if(f(`transferFrom: onEncryptComplete`,()=>r?.onEncryptComplete?.(),this.sdk.logger),c.length===0)throw new O(`Encryption returned no encrypted values`);return this.submitTransaction({operation:`transferFrom`,config:o(this.address,a,s,c[0],l),onSubmitted:r?.onTransferSubmitted})}async confidentialTransferAndCall(e,t,n,r){this.#e(`confidentialTransferAndCall`);let i=await Y(`confidentialTransferAndCall`,this.sdk.signer,this.sdk.provider),{skipBalanceCheck:a=!1,onEncryptComplete:o,onTransferSubmitted:s}=r??{},c=j(e);a||await this.assertConfidentialBalance(t);let{encryptedValues:l,inputProof:u}=await this.sdk.encrypt({values:[{value:t,type:`euint64`}],contractAddress:this.address,userAddress:j(i.address)});if(f(`transferAndCall: onEncryptComplete`,()=>o?.(),this.sdk.logger),l.length===0)throw new O(`Encryption returned no encrypted values`);return this.submitTransaction({operation:`transferAndCall`,config:T(this.address,c,l[0],u,n),onSubmitted:s})}async confidentialTransferFromAndCall(e,t,n,r,i){this.#e(`confidentialTransferFromAndCall`);let a=await Y(`confidentialTransferFromAndCall`,this.sdk.signer,this.sdk.provider),o=j(e),c=j(t),{encryptedValues:l,inputProof:u}=await this.sdk.encrypt({values:[{value:n,type:`euint64`}],contractAddress:this.address,userAddress:j(a.address)});if(f(`transferFromAndCall: onEncryptComplete`,()=>i?.onEncryptComplete?.(),this.sdk.logger),l.length===0)throw new O(`Encryption returned no encrypted values`);return this.submitTransaction({operation:`transferFromAndCall`,config:s(this.address,o,c,l[0],u,r),onSubmitted:i?.onTransferSubmitted})}async setOperator(e,t){this.#e(`setOperator`),await X(`setOperator`,this.sdk.signer,this.sdk.provider);let n=j(e);return this.submitTransaction({operation:`setOperator`,config:d(this.address,n,t)})}async isOperator(e,t){return this.sdk.provider.readContract(i(this.address,j(e),j(t)))}async readConfidentialBalanceOf(e){return await this.sdk.provider.readContract(p(this.address,e))}async assertConfidentialBalance(e){if(e===0n)return;let t;try{let e=await Y(`assertConfidentialBalance`,this.sdk.signer,this.sdk.provider);t=await this.balanceOf(j(e.address))}catch(e){throw e instanceof n?e:new L(`Balance validation failed (token: ${this.address})`,{cause:e})}if(t<e)throw new P(`Insufficient confidential balance: requested ${e}, available ${t} (token: ${this.address})`,{requested:e,available:t,token:this.address})}emit(e){this.sdk.emitEvent(e,this.address)}async submitTransaction(e){let{operation:t,config:n,onSubmitted:r}=e;return Q({operation:t,signer:this.#e(t),provider:this.sdk.provider,config:n,emit:e=>this.emit(e),onSubmitted:r,logger:this.sdk.logger})}static assertSameSdk(e){let t=e[0].sdk;for(let n=1;n<e.length;n++)if(e[n].sdk!==t)throw new r(`All tokens in a batch operation must share the same ZamaSDK instance`);return t}};export{X as a,K as c,R as d,I as f,M as g,N as h,Y as i,z as l,F as m,Q as n,G as o,P as p,Z as r,J as s,$ as t,L as u};
-//# sourceMappingURL=token-BejFVO8m.js.map

package/dist/esm/wrappers-registry-BLe7PkZi.js

@@ -1,2 +0,0 @@
-import{i as e,l as t,p as n,r,u as i}from"./relayer-CVKO9GmQ.js";import{erc20Abi as a}from"viem";var o=class extends r{constructor(t,n){super(e.TransportKeyPairExpired,t,n),this.name=`TransportKeyPairExpiredError`}},s=class extends r{constructor(t,n){super(e.InvalidTransportKeyPair,t,n),this.name=`InvalidTransportKeyPairError`}},c=class extends r{constructor(t,n){super(e.RevokedKmsContext,t,n),this.name=`RevokedKmsContextError`}},l=class extends r{constructor(t,n){super(e.NoCiphertext,t,n),this.name=`NoCiphertextError`}},u=class extends r{constructor(t,n){super(e.KeyWrappingFailed,t,n),this.name=`KeyWrappingError`}},d=class extends r{constructor(t,n){super(e.TransportKeyPairChanged,t,n),this.name=`TransportKeyPairChangedError`}},f=class extends r{preparedChainId;activeChainId;constructor({preparedChainId:t,activeChainId:n},r){super(e.PreparedPermitChainMismatch,`registerPermit: prepared.chainId (${t}) does not match the active chain (${n}). Register the permit while the SDK is configured for the chain it was prepared for.`,r),this.name=`PreparedPermitChainMismatchError`,this.preparedChainId=t,this.activeChainId=n}},p=class extends r{constructor(t,n){super(e.PreparedPermitExpired,t,n),this.name=`PreparedPermitExpiredError`}},m=class extends r{operation;rpcCode;walletErrorName;constructor(t,n){let{operation:r,rpcCode:i,walletErrorName:a,...o}=n??{};super(e.SigningRejected,t,o),this.name=`SigningRejectedError`,this.operation=r,this.rpcCode=i,this.walletErrorName=a}},h=class extends r{operation;rpcCode;walletErrorName;constructor(t,n){let{operation:r,rpcCode:i,walletErrorName:a,...o}=n??{};super(e.SigningFailed,t,o),this.name=`SigningFailedError`,this.operation=r,this.rpcCode=i,this.walletErrorName=a}};function g(e,a){if(e instanceof r)return e;let{operation:o}=a,c=typeof e==`object`&&!!e&&`code`in e&&e.code===4001,l=e instanceof Error?e.message:String(e),u=l.toLowerCase(),d=u.includes(`user rejected`)||u.includes(`user denied`),f=`${o}: ${l}`;return c||d?new m(f,{cause:e,operation:o,rpcCode:t(e),walletErrorName:i(e)}):n(l)?new s(f,{cause:e}):new h(f,{cause:e,operation:o,rpcCode:t(e),walletErrorName:i(e)})}var ee=class extends r{constructor(t,n){super(e.TransactionReverted,t,n),this.name=`TransactionRevertedError`}},_=class extends r{operation;constructor(e,t,n,r){super(e,n,r),this.name=`SignerRequiredError`,this.operation=t}},v=class extends _{constructor(t,n){super(e.SignerNotConfigured,t,`Cannot ${t} without a signer. Configure one via createConfig({ signer: ... }) or <ZamaProvider config={createConfig({ signer: ... })}>.`,n),this.name=`SignerNotConfiguredError`}},y=class extends _{constructor(t,n){super(e.WalletNotConnected,t,`Cannot ${t} without a connected wallet account.`,n),this.name=`WalletNotConnectedError`}},b=class extends _{constructor(t,n){super(e.WalletAccountNotReady,t,`Cannot ${t} before the wallet account is ready.`,n),this.name=`WalletAccountNotReadyError`}};function x(e,t){if(e==null)throw new v(t);return e}const S={EncryptStart:`encrypt:start`,EncryptEnd:`encrypt:end`,EncryptError:`encrypt:error`,DecryptStart:`decrypt:start`,DecryptEnd:`decrypt:end`,DecryptError:`decrypt:error`,PermitError:`permit:error`,TransactionError:`transaction:error`,ShieldSubmitted:`shield:submitted`,TransferSubmitted:`transfer:submitted`,TransferFromSubmitted:`transferFrom:submitted`,SetOperatorSubmitted:`setOperator:submitted`,ApproveUnderlyingSubmitted:`approveUnderlying:submitted`,WrapSubmitted:`wrap:submitted`,UnwrapSubmitted:`unwrap:submitted`,FinalizeUnwrapSubmitted:`finalizeUnwrap:submitted`,DelegationSubmitted:`delegation:submitted`,RevokeDelegationSubmitted:`revokeDelegation:submitted`,UnshieldPhase1Submitted:`unshield:phase1_submitted`,UnshieldPhase2Started:`unshield:phase2_started`,UnshieldPhase2Submitted:`unshield:phase2_submitted`},te={approveUnderlying:{submittedEvent:e=>({type:S.ApproveUnderlyingSubmitted,txHash:e,step:`approve`})},"approveUnderlying:reset":{submittedEvent:e=>({type:S.ApproveUnderlyingSubmitted,txHash:e,step:`reset`})},delegateDecryption:{submittedEvent:e=>({type:S.DelegationSubmitted,txHash:e})},finalizeUnwrap:{submittedEvent:e=>({type:S.FinalizeUnwrapSubmitted,txHash:e})},revokeDelegation:{submittedEvent:e=>({type:S.RevokeDelegationSubmitted,txHash:e})},setOperator:{submittedEvent:e=>({type:S.SetOperatorSubmitted,txHash:e})},"shield:transferAndCall":{submittedEvent:e=>({type:S.ShieldSubmitted,txHash:e,shieldPath:`transferAndCall`})},"shield:approveAndWrap":{submittedEvent:e=>({type:S.ShieldSubmitted,txHash:e,shieldPath:`approveAndWrap`})},wrap:{submittedEvent:e=>({type:S.WrapSubmitted,txHash:e})},transfer:{submittedEvent:e=>({type:S.TransferSubmitted,txHash:e})},transferAndCall:{submittedEvent:e=>({type:S.TransferSubmitted,txHash:e})},transferFrom:{submittedEvent:e=>({type:S.TransferFromSubmitted,txHash:e})},transferFromAndCall:{submittedEvent:e=>({type:S.TransferFromSubmitted,txHash:e})},unwrap:{submittedEvent:e=>({type:S.UnwrapSubmitted,txHash:e})},unwrapAll:{submittedEvent:e=>({type:S.UnwrapSubmitted,txHash:e})}};async function C(e,t,n){try{await t()}catch(t){n?.warn(`${e} failed`,{error:t})}}const w=[{type:`function`,name:`UPGRADE_INTERFACE_VERSION`,inputs:[],outputs:[{name:``,type:`string`,internalType:`string`}],stateMutability:`view`},{type:`function`,name:`acceptOwnership`,inputs:[],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`blockUser`,inputs:[{name:`user`,type:`address`,internalType:`address`}],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`confidentialBalanceOf`,inputs:[{name:`account`,type:`address`,internalType:`address`}],outputs:[{name:``,type:`bytes32`,internalType:`euint64`}],stateMutability:`view`},{type:`function`,name:`confidentialProtocolId`,inputs:[],outputs:[{name:``,type:`uint256`,internalType:`uint256`}],stateMutability:`view`},{type:`function`,name:`confidentialTotalSupply`,inputs:[],outputs:[{name:``,type:`bytes32`,internalType:`euint64`}],stateMutability:`view`},{type:`function`,name:`confidentialTransfer`,inputs:[{name:`to`,type:`address`,internalType:`address`},{name:`encryptedAmount`,type:`bytes32`,internalType:`externalEuint64`},{name:`inputProof`,type:`bytes`,internalType:`bytes`}],outputs:[{name:``,type:`bytes32`,internalType:`euint64`}],stateMutability:`nonpayable`},{type:`function`,name:`confidentialTransfer`,inputs:[{name:`to`,type:`address`,internalType:`address`},{name:`amount`,type:`bytes32`,internalType:`euint64`}],outputs:[{name:``,type:`bytes32`,internalType:`euint64`}],stateMutability:`nonpayable`},{type:`function`,name:`confidentialTransferAndCall`,inputs:[{name:`to`,type:`address`,internalType:`address`},{name:`amount`,type:`bytes32`,internalType:`euint64`},{name:`data`,type:`bytes`,internalType:`bytes`}],outputs:[{name:`transferred`,type:`bytes32`,internalType:`euint64`}],stateMutability:`nonpayable`},{type:`function`,name:`confidentialTransferAndCall`,inputs:[{name:`to`,type:`address`,internalType:`address`},{name:`encryptedAmount`,type:`bytes32`,internalType:`externalEuint64`},{name:`inputProof`,type:`bytes`,internalType:`bytes`},{name:`data`,type:`bytes`,internalType:`bytes`}],outputs:[{name:`transferred`,type:`bytes32`,internalType:`euint64`}],stateMutability:`nonpayable`},{type:`function`,name:`confidentialTransferFrom`,inputs:[{name:`from`,type:`address`,internalType:`address`},{name:`to`,type:`address`,internalType:`address`},{name:`encryptedAmount`,type:`bytes32`,internalType:`externalEuint64`},{name:`inputProof`,type:`bytes`,internalType:`bytes`}],outputs:[{name:`transferred`,type:`bytes32`,internalType:`euint64`}],stateMutability:`nonpayable`},{type:`function`,name:`confidentialTransferFrom`,inputs:[{name:`from`,type:`address`,internalType:`address`},{name:`to`,type:`address`,internalType:`address`},{name:`amount`,type:`bytes32`,internalType:`euint64`}],outputs:[{name:`transferred`,type:`bytes32`,internalType:`euint64`}],stateMutability:`nonpayable`},{type:`function`,name:`confidentialTransferFromAndCall`,inputs:[{name:`from`,type:`address`,internalType:`address`},{name:`to`,type:`address`,internalType:`address`},{name:`encryptedAmount`,type:`bytes32`,internalType:`externalEuint64`},{name:`inputProof`,type:`bytes`,internalType:`bytes`},{name:`data`,type:`bytes`,internalType:`bytes`}],outputs:[{name:`transferred`,type:`bytes32`,internalType:`euint64`}],stateMutability:`nonpayable`},{type:`function`,name:`confidentialTransferFromAndCall`,inputs:[{name:`from`,type:`address`,internalType:`address`},{name:`to`,type:`address`,internalType:`address`},{name:`amount`,type:`bytes32`,internalType:`euint64`},{name:`data`,type:`bytes`,internalType:`bytes`}],outputs:[{name:`transferred`,type:`bytes32`,internalType:`euint64`}],stateMutability:`nonpayable`},{type:`function`,name:`contractURI`,inputs:[],outputs:[{name:``,type:`string`,internalType:`string`}],stateMutability:`view`},{type:`function`,name:`decimals`,inputs:[],outputs:[{name:``,type:`uint8`,internalType:`uint8`}],stateMutability:`view`},{type:`function`,name:`discloseEncryptedAmount`,inputs:[{name:`encryptedAmount`,type:`bytes32`,internalType:`euint64`},{name:`cleartextAmount`,type:`uint64`,internalType:`uint64`},{name:`decryptionProof`,type:`bytes`,internalType:`bytes`}],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`finalizeUnwrap`,inputs:[{name:`unwrapRequestId`,type:`bytes32`,internalType:`bytes32`},{name:`unwrapAmountCleartext`,type:`uint64`,internalType:`uint64`},{name:`decryptionProof`,type:`bytes`,internalType:`bytes`}],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`getUnderlyingDenyListSelector`,inputs:[],outputs:[{name:`isSet`,type:`bool`,internalType:`bool`},{name:`selector`,type:`bytes4`,internalType:`bytes4`}],stateMutability:`view`},{type:`function`,name:`inferredTotalSupply`,inputs:[],outputs:[{name:``,type:`uint256`,internalType:`uint256`}],stateMutability:`view`},{type:`function`,name:`initialize`,inputs:[{name:`name_`,type:`string`,internalType:`string`},{name:`symbol_`,type:`string`,internalType:`string`},{name:`contractURI_`,type:`string`,internalType:`string`},{name:`underlying_`,type:`address`,internalType:`contract IERC20`},{name:`owner_`,type:`address`,internalType:`address`}],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`isBlocked`,inputs:[{name:`user`,type:`address`,internalType:`address`}],outputs:[{name:``,type:`bool`,internalType:`bool`}],stateMutability:`view`},{type:`function`,name:`isOperator`,inputs:[{name:`holder`,type:`address`,internalType:`address`},{name:`spender`,type:`address`,internalType:`address`}],outputs:[{name:``,type:`bool`,internalType:`bool`}],stateMutability:`view`},{type:`function`,name:`maxTotalSupply`,inputs:[],outputs:[{name:``,type:`uint256`,internalType:`uint256`}],stateMutability:`view`},{type:`function`,name:`name`,inputs:[],outputs:[{name:``,type:`string`,internalType:`string`}],stateMutability:`view`},{type:`function`,name:`onTransferReceived`,inputs:[{name:`operator`,type:`address`,internalType:`address`},{name:`from`,type:`address`,internalType:`address`},{name:`amount`,type:`uint256`,internalType:`uint256`},{name:`data`,type:`bytes`,internalType:`bytes`}],outputs:[{name:``,type:`bytes4`,internalType:`bytes4`}],stateMutability:`nonpayable`},{type:`function`,name:`owner`,inputs:[],outputs:[{name:``,type:`address`,internalType:`address`}],stateMutability:`view`},{type:`function`,name:`pendingOwner`,inputs:[],outputs:[{name:``,type:`address`,internalType:`address`}],stateMutability:`view`},{type:`function`,name:`proxiableUUID`,inputs:[],outputs:[{name:``,type:`bytes32`,internalType:`bytes32`}],stateMutability:`view`},{type:`function`,name:`rate`,inputs:[],outputs:[{name:``,type:`uint256`,internalType:`uint256`}],stateMutability:`view`},{type:`function`,name:`reinitializeV2`,inputs:[],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`reinitializeV3`,inputs:[{name:`blockedUsers`,type:`address[]`,internalType:`address[]`},{name:`underlyingDenyListSelector`,type:`bytes4`,internalType:`bytes4`},{name:`hasUnderlyingDenyListSelector_`,type:`bool`,internalType:`bool`}],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`renounceOwnership`,inputs:[],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`requestDiscloseEncryptedAmount`,inputs:[{name:`encryptedAmount`,type:`bytes32`,internalType:`euint64`}],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`setOperator`,inputs:[{name:`operator`,type:`address`,internalType:`address`},{name:`until`,type:`uint48`,internalType:`uint48`}],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`supportsInterface`,inputs:[{name:`interfaceId`,type:`bytes4`,internalType:`bytes4`}],outputs:[{name:``,type:`bool`,internalType:`bool`}],stateMutability:`view`},{type:`function`,name:`symbol`,inputs:[],outputs:[{name:``,type:`string`,internalType:`string`}],stateMutability:`view`},{type:`function`,name:`transferOwnership`,inputs:[{name:`newOwner`,type:`address`,internalType:`address`}],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`unblockUser`,inputs:[{name:`user`,type:`address`,internalType:`address`}],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`underlying`,inputs:[],outputs:[{name:``,type:`address`,internalType:`address`}],stateMutability:`view`},{type:`function`,name:`unwrap`,inputs:[{name:`from`,type:`address`,internalType:`address`},{name:`to`,type:`address`,internalType:`address`},{name:`encryptedAmount`,type:`bytes32`,internalType:`externalEuint64`},{name:`inputProof`,type:`bytes`,internalType:`bytes`}],outputs:[{name:``,type:`bytes32`,internalType:`bytes32`}],stateMutability:`nonpayable`},{type:`function`,name:`unwrap`,inputs:[{name:`from`,type:`address`,internalType:`address`},{name:`to`,type:`address`,internalType:`address`},{name:`amount`,type:`bytes32`,internalType:`euint64`}],outputs:[{name:``,type:`bytes32`,internalType:`bytes32`}],stateMutability:`nonpayable`},{type:`function`,name:`unwrapAmount`,inputs:[{name:`unwrapRequestId`,type:`bytes32`,internalType:`bytes32`}],outputs:[{name:``,type:`bytes32`,internalType:`euint64`}],stateMutability:`view`},{type:`function`,name:`unwrapRequester`,inputs:[{name:`unwrapRequestId`,type:`bytes32`,internalType:`bytes32`}],outputs:[{name:``,type:`address`,internalType:`address`}],stateMutability:`view`},{type:`function`,name:`upgradeToAndCall`,inputs:[{name:`newImplementation`,type:`address`,internalType:`address`},{name:`data`,type:`bytes`,internalType:`bytes`}],outputs:[],stateMutability:`payable`},{type:`function`,name:`wrap`,inputs:[{name:`to`,type:`address`,internalType:`address`},{name:`amount`,type:`uint256`,internalType:`uint256`}],outputs:[{name:``,type:`bytes32`,internalType:`euint64`}],stateMutability:`nonpayable`},{type:`event`,name:`AmountDiscloseRequested`,inputs:[{name:`encryptedAmount`,type:`bytes32`,indexed:!0,internalType:`euint64`},{name:`requester`,type:`address`,indexed:!0,internalType:`address`}],anonymous:!1},{type:`event`,name:`AmountDisclosed`,inputs:[{name:`encryptedAmount`,type:`bytes32`,indexed:!0,internalType:`euint64`},{name:`amount`,type:`uint64`,indexed:!1,internalType:`uint64`}],anonymous:!1},{type:`event`,name:`ConfidentialTransfer`,inputs:[{name:`from`,type:`address`,indexed:!0,internalType:`address`},{name:`to`,type:`address`,indexed:!0,internalType:`address`},{name:`amount`,type:`bytes32`,indexed:!0,internalType:`euint64`}],anonymous:!1},{type:`event`,name:`Initialized`,inputs:[{name:`version`,type:`uint64`,indexed:!1,internalType:`uint64`}],anonymous:!1},{type:`event`,name:`OperatorSet`,inputs:[{name:`holder`,type:`address`,indexed:!0,internalType:`address`},{name:`operator`,type:`address`,indexed:!0,internalType:`address`},{name:`until`,type:`uint48`,indexed:!1,internalType:`uint48`}],anonymous:!1},{type:`event`,name:`OwnershipTransferStarted`,inputs:[{name:`previousOwner`,type:`address`,indexed:!0,internalType:`address`},{name:`newOwner`,type:`address`,indexed:!0,internalType:`address`}],anonymous:!1},{type:`event`,name:`OwnershipTransferred`,inputs:[{name:`previousOwner`,type:`address`,indexed:!0,internalType:`address`},{name:`newOwner`,type:`address`,indexed:!0,internalType:`address`}],anonymous:!1},{type:`event`,name:`PublicDecryptionVerified`,inputs:[{name:`handlesList`,type:`bytes32[]`,indexed:!1,internalType:`bytes32[]`},{name:`abiEncodedCleartexts`,type:`bytes`,indexed:!1,internalType:`bytes`}],anonymous:!1},{type:`event`,name:`UnwrapFinalized`,inputs:[{name:`receiver`,type:`address`,indexed:!0,internalType:`address`},{name:`unwrapRequestId`,type:`bytes32`,indexed:!0,internalType:`bytes32`},{name:`encryptedAmount`,type:`bytes32`,indexed:!1,internalType:`euint64`},{name:`cleartextAmount`,type:`uint64`,indexed:!1,internalType:`uint64`}],anonymous:!1},{type:`event`,name:`UnwrapRequested`,inputs:[{name:`receiver`,type:`address`,indexed:!0,internalType:`address`},{name:`unwrapRequestId`,type:`bytes32`,indexed:!0,internalType:`bytes32`},{name:`amount`,type:`bytes32`,indexed:!1,internalType:`euint64`}],anonymous:!1},{type:`event`,name:`Upgraded`,inputs:[{name:`implementation`,type:`address`,indexed:!0,internalType:`address`}],anonymous:!1},{type:`event`,name:`UserBlocked`,inputs:[{name:`user`,type:`address`,indexed:!0,internalType:`address`}],anonymous:!1},{type:`event`,name:`UserUnblocked`,inputs:[{name:`user`,type:`address`,indexed:!0,internalType:`address`}],anonymous:!1},{type:`event`,name:`Wrap`,inputs:[{name:`to`,type:`address`,indexed:!0,internalType:`address`},{name:`roundedAmount`,type:`uint256`,indexed:!1,internalType:`uint256`},{name:`encryptedWrappedAmount`,type:`bytes32`,indexed:!1,internalType:`euint64`}],anonymous:!1},{type:`error`,name:`AddressEmptyCode`,inputs:[{name:`target`,type:`address`,internalType:`address`}]},{type:`error`,name:`BlockedUser`,inputs:[{name:`user`,type:`address`,internalType:`address`}]},{type:`error`,name:`ERC1967InvalidImplementation`,inputs:[{name:`implementation`,type:`address`,internalType:`address`}]},{type:`error`,name:`ERC1967NonPayable`,inputs:[]},{type:`error`,name:`ERC7984InvalidReceiver`,inputs:[{name:`receiver`,type:`address`,internalType:`address`}]},{type:`error`,name:`ERC7984InvalidReceiver`,inputs:[{name:`receiver`,type:`address`,internalType:`address`}]},{type:`error`,name:`ERC7984InvalidSender`,inputs:[{name:`sender`,type:`address`,internalType:`address`}]},{type:`error`,name:`ERC7984TotalSupplyOverflow`,inputs:[]},{type:`error`,name:`ERC7984UnauthorizedCaller`,inputs:[{name:`caller`,type:`address`,internalType:`address`}]},{type:`error`,name:`ERC7984UnauthorizedSpender`,inputs:[{name:`holder`,type:`address`,internalType:`address`},{name:`spender`,type:`address`,internalType:`address`}]},{type:`error`,name:`ERC7984UnauthorizedUseOfEncryptedAmount`,inputs:[{name:`amount`,type:`bytes32`,internalType:`euint64`},{name:`user`,type:`address`,internalType:`address`}]},{type:`error`,name:`ERC7984ZeroBalance`,inputs:[{name:`holder`,type:`address`,internalType:`address`}]},{type:`error`,name:`FailedCall`,inputs:[]},{type:`error`,name:`InvalidInitialization`,inputs:[]},{type:`error`,name:`InvalidKMSSignatures`,inputs:[]},{type:`error`,name:`InvalidUnderlyingDenyListResponse`,inputs:[]},{type:`error`,name:`InvalidUnwrapRequest`,inputs:[{name:`unwrapRequestId`,type:`bytes32`,internalType:`bytes32`}]},{type:`error`,name:`NotInitializing`,inputs:[]},{type:`error`,name:`OwnableInvalidOwner`,inputs:[{name:`owner`,type:`address`,internalType:`address`}]},{type:`error`,name:`OwnableUnauthorizedAccount`,inputs:[{name:`account`,type:`address`,internalType:`address`}]},{type:`error`,name:`SafeCastOverflowedUintDowncast`,inputs:[{name:`bits`,type:`uint8`,internalType:`uint8`},{name:`value`,type:`uint256`,internalType:`uint256`}]},{type:`error`,name:`SafeERC20FailedOperation`,inputs:[{name:`token`,type:`address`,internalType:`address`}]},{type:`error`,name:`SenderNotAllowedToUseHandle`,inputs:[{name:`handle`,type:`bytes32`,internalType:`bytes32`},{name:`sender`,type:`address`,internalType:`address`}]},{type:`error`,name:`UUPSUnauthorizedCallContext`,inputs:[]},{type:`error`,name:`UUPSUnsupportedProxiableUUID`,inputs:[{name:`slot`,type:`bytes32`,internalType:`bytes32`}]},{type:`error`,name:`UnderlyingDenyListCallFailed`,inputs:[]},{type:`error`,name:`UnderlyingDenyListedAddress`,inputs:[{name:`user`,type:`address`,internalType:`address`}]},{type:`error`,name:`UserAlreadyBlocked`,inputs:[{name:`user`,type:`address`,internalType:`address`}]},{type:`error`,name:`UserAlreadyUnblocked`,inputs:[{name:`user`,type:`address`,internalType:`address`}]},{type:`error`,name:`ZamaProtocolUnsupported`,inputs:[]}];function T(e,t){return{address:e,abi:w,functionName:`confidentialBalanceOf`,args:[t]}}function E(e,t,n,r){return{address:e,abi:w,functionName:`confidentialTransfer`,args:[t,n,r]}}function D(e,t,n,r,i){return{address:e,abi:w,functionName:`confidentialTransferFrom`,args:[t,n,r,i]}}function O(e,t,n,r,i){return{address:e,abi:w,functionName:`confidentialTransferAndCall`,args:[t,n,r,i]}}function k(e,t,n,r,i,a){return{address:e,abi:w,functionName:`confidentialTransferFromAndCall`,args:[t,n,r,i,a]}}function A(e,t,n){return{address:e,abi:w,functionName:`isOperator`,args:[t,n]}}function j(e,t,n){return{address:e,abi:w,functionName:`setOperator`,args:[t,n??Math.floor(Date.now()/1e3)+3600]}}function M(e,t,n,r,i){return{address:e,abi:w,functionName:`unwrap`,args:[t,n,r,i]}}function N(e,t,n,r){return{address:e,abi:w,functionName:`unwrap`,args:[t,n,r]}}function P(e){return{address:e,abi:w,functionName:`confidentialTotalSupply`,args:[]}}function F(e){return{address:e,abi:w,functionName:`rate`,args:[]}}function I(e,t,n,r){return{address:e,abi:w,functionName:`finalizeUnwrap`,args:[t,n,r]}}function L(e,t){return{address:e,abi:w,functionName:`unwrapRequester`,args:[t]}}function R(e){return{address:e,abi:w,functionName:`underlying`,args:[]}}function z(e){return{address:e,abi:w,functionName:`inferredTotalSupply`,args:[]}}function B(e,t,n){return{address:e,abi:w,functionName:`wrap`,args:[t,n]}}function V(e){return{address:e,abi:a,functionName:`name`,args:[]}}function H(e){return{address:e,abi:a,functionName:`symbol`,args:[]}}function ne(e){return{address:e,abi:a,functionName:`decimals`,args:[]}}function U(e){return{address:e,abi:a,functionName:`totalSupply`,args:[]}}function W(e,t){return{address:e,abi:a,functionName:`balanceOf`,args:[t]}}function G(e,t,n){return{address:e,abi:a,functionName:`allowance`,args:[t,n]}}function K(e,t,n){return{address:e,abi:a,functionName:`approve`,args:[t,n]}}const q=[{type:`function`,name:`supportsInterface`,inputs:[{name:`interfaceId`,type:`bytes4`,internalType:`bytes4`}],outputs:[{name:``,type:`bool`,internalType:`bool`}],stateMutability:`view`}],J=`0x4958f2a4`,Y=`0x1f1c62b2`,X=`0xb0202a11`;function Z(e,t){return{address:e,abi:q,functionName:`supportsInterface`,args:[t]}}function re(e){return Z(e,J)}function ie(e){return Z(e,Y)}function ae(e){return Z(e,X)}const Q=[{inputs:[],name:`getTokenConfidentialTokenPairs`,outputs:[{components:[{internalType:`address`,name:`tokenAddress`,type:`address`},{internalType:`address`,name:`confidentialTokenAddress`,type:`address`},{internalType:`bool`,name:`isValid`,type:`bool`}],internalType:`struct ConfidentialTokenWrappersRegistry.TokenWrapperPair[]`,name:``,type:`tuple[]`}],stateMutability:`view`,type:`function`},{inputs:[],name:`getTokenConfidentialTokenPairsLength`,outputs:[{internalType:`uint256`,name:``,type:`uint256`}],stateMutability:`view`,type:`function`},{inputs:[{internalType:`uint256`,name:`fromIndex`,type:`uint256`},{internalType:`uint256`,name:`toIndex`,type:`uint256`}],name:`getTokenConfidentialTokenPairsSlice`,outputs:[{components:[{internalType:`address`,name:`tokenAddress`,type:`address`},{internalType:`address`,name:`confidentialTokenAddress`,type:`address`},{internalType:`bool`,name:`isValid`,type:`bool`}],internalType:`struct ConfidentialTokenWrappersRegistry.TokenWrapperPair[]`,name:``,type:`tuple[]`}],stateMutability:`view`,type:`function`},{inputs:[{internalType:`uint256`,name:`index`,type:`uint256`}],name:`getTokenConfidentialTokenPair`,outputs:[{components:[{internalType:`address`,name:`tokenAddress`,type:`address`},{internalType:`address`,name:`confidentialTokenAddress`,type:`address`},{internalType:`bool`,name:`isValid`,type:`bool`}],internalType:`struct ConfidentialTokenWrappersRegistry.TokenWrapperPair`,name:``,type:`tuple`}],stateMutability:`view`,type:`function`},{inputs:[{internalType:`address`,name:`tokenAddress`,type:`address`}],name:`getConfidentialTokenAddress`,outputs:[{internalType:`bool`,name:``,type:`bool`},{internalType:`address`,name:``,type:`address`}],stateMutability:`view`,type:`function`},{inputs:[{internalType:`address`,name:`confidentialTokenAddress`,type:`address`}],name:`getTokenAddress`,outputs:[{internalType:`bool`,name:``,type:`bool`},{internalType:`address`,name:``,type:`address`}],stateMutability:`view`,type:`function`},{inputs:[{internalType:`address`,name:`confidentialTokenAddress`,type:`address`}],name:`isConfidentialTokenValid`,outputs:[{internalType:`bool`,name:``,type:`bool`}],stateMutability:`view`,type:`function`},{inputs:[{internalType:`address`,name:`initialOwner`,type:`address`}],name:`initialize`,outputs:[],stateMutability:`nonpayable`,type:`function`},{inputs:[{internalType:`address`,name:`tokenAddress`,type:`address`},{internalType:`address`,name:`confidentialTokenAddress`,type:`address`}],name:`registerConfidentialToken`,outputs:[],stateMutability:`nonpayable`,type:`function`},{inputs:[{internalType:`address`,name:`confidentialTokenAddress`,type:`address`}],name:`revokeConfidentialToken`,outputs:[],stateMutability:`nonpayable`,type:`function`}];function oe(e){return{address:e,abi:Q,functionName:`getTokenConfidentialTokenPairs`,args:[]}}function $(e){return{address:e,abi:Q,functionName:`getTokenConfidentialTokenPairsLength`,args:[]}}function se(e,t,n){return{address:e,abi:Q,functionName:`getTokenConfidentialTokenPairsSlice`,args:[t,n]}}function ce(e,t){return{address:e,abi:Q,functionName:`getTokenConfidentialTokenPair`,args:[t]}}function le(e,t){return{address:e,abi:Q,functionName:`getConfidentialTokenAddress`,args:[t]}}function ue(e,t){return{address:e,abi:Q,functionName:`getTokenAddress`,args:[t]}}function de(e,t){return{address:e,abi:Q,functionName:`isConfidentialTokenValid`,args:[t]}}export{f as $,A,te as B,P as C,D,k as E,N as F,x as G,_ as H,L as I,m as J,ee as K,B as L,j as M,R as N,I as O,M as P,l as Q,C as R,T as S,E as T,b as U,v as V,y as W,s as X,g as Y,u as Z,W as _,$ as a,V as b,X as c,re as d,p as et,ie as f,K as g,G as h,oe as i,F as j,z as k,J as l,Z as m,ue as n,d as nt,se as o,ae as p,h as q,ce as r,o as rt,de as s,le as t,c as tt,Y as u,ne as v,O as w,H as x,U as y,S as z};
-//# sourceMappingURL=wrappers-registry-BLe7PkZi.js.map