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

package/dist/esm/relayer-eavK5bfZ.js

@@ -1,2 +0,0 @@
-const e={SigningRejected:`SIGNING_REJECTED`,SigningFailed:`SIGNING_FAILED`,EncryptionFailed:`ENCRYPTION_FAILED`,DecryptionFailed:`DECRYPTION_FAILED`,TransactionReverted:`TRANSACTION_REVERTED`,TransportKeyPairExpired:`KEYPAIR_EXPIRED`,InvalidTransportKeyPair:`INVALID_KEYPAIR`,NoCiphertext:`NO_CIPHERTEXT`,RelayerRequestFailed:`RELAYER_REQUEST_FAILED`,NotEntitled:`NOT_ENTITLED`,RpcRateLimited:`RPC_RATE_LIMITED`,OperationTimeout:`OPERATION_TIMEOUT`,WorkerRecycled:`WORKER_RECYCLED`,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`,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`};var t=class extends Error{code;constructor(e,t,n){super(t,n),Object.setPrototypeOf(this,new.target.prototype),this.name=`ZamaError`,this.code=e}},n=class extends t{statusCode;retryAfter;retryable;constructor(t,n,r){super(e.RelayerRequestFailed,t,r),this.name=`RelayerRequestFailedError`,this.statusCode=n,this.retryable=n===429,this.retryAfter=this.retryable?r?.retryAfter:void 0}},r=class extends t{constructor(t,n){super(e.Configuration,t,n),this.name=`ConfigurationError`}};export{e as i,n,t as r,r as t};
-//# sourceMappingURL=relayer-eavK5bfZ.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"relayer-eavK5bfZ.js","names":[],"sources":["../../src/errors/base.ts","../../src/errors/relayer.ts"],"sourcesContent":["/**\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  /** 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  /** 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  /** A worker operation exceeded its configured timeout; the worker is recycled by default. Retryable. */\n  OperationTimeout: \"OPERATION_TIMEOUT\",\n  /** An in-flight worker operation was aborted as collateral of another operation's timeout recycle. Retryable. */\n  WorkerRecycled: \"WORKER_RECYCLED\",\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  /** 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} as const;\n\n/** Union of all {@link ZamaErrorCode} string values. */\nexport type ZamaErrorCode = (typeof ZamaErrorCode)[keyof typeof ZamaErrorCode];\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  constructor(code: ZamaErrorCode, message: string, options?: ErrorOptions) {\n    super(message, options);\n    Object.setPrototypeOf(this, new.target.prototype);\n    this.name = \"ZamaError\";\n    this.code = code;\n  }\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 retryable}.\n   */\n  readonly retryAfter: number | undefined;\n\n  /**\n   * Whether the request may be safely retried. `true` for relayer back-pressure\n   * (HTTP 429); pair with {@link retryAfter} for the server's suggested delay.\n   */\n  readonly retryable: boolean;\n\n  constructor(\n    message: string,\n    statusCode?: number,\n    options?: ErrorOptions & { retryAfter?: number },\n  ) {\n    super(ZamaErrorCode.RelayerRequestFailed, message, options);\n    this.name = \"RelayerRequestFailedError\";\n    this.statusCode = statusCode;\n    this.retryable = statusCode === 429;\n    // Keep the two fields consistent: a delay only makes sense when retryable.\n    this.retryAfter = this.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":"AAeA,MAAa,EAAgB,CAE3B,gBAAiB,mBAEjB,cAAe,iBAEf,iBAAkB,oBAElB,iBAAkB,oBAElB,oBAAqB,uBAErB,wBAAyB,kBAEzB,wBAAyB,kBAEzB,aAAc,gBAEd,qBAAsB,yBAEtB,YAAa,eAEb,eAAgB,mBAEhB,iBAAkB,oBAElB,eAAgB,kBAEhB,cAAe,gBAEf,yBAA0B,8BAE1B,mBAAoB,sBAEpB,mBAAoB,uBAEpB,kBAAmB,qBAEnB,gCAAiC,oCAEjC,yBAA0B,6BAE1B,wBAAyB,4BAEzB,gBAAiB,oBAEjB,0BAA2B,8BAE3B,iCAAkC,sCAElC,yBAA0B,8BAE1B,UAAW,aAEX,4BAA6B,iCAE7B,wBAAyB,4BAEzB,cAAe,iBAEf,oBAAqB,wBAErB,mBAAoB,uBAEpB,sBAAuB,0BACzB,EAUA,IAAa,EAAb,cAA+B,KAAM,CAEnC,KAEA,YAAY,EAAqB,EAAiB,EAAwB,CACxE,MAAM,EAAS,CAAO,EACtB,OAAO,eAAe,KAAM,IAAI,OAAO,SAAS,EAChD,KAAK,KAAO,YACZ,KAAK,KAAO,CACd,CACF,ECjGa,EAAb,cAA+C,CAAU,CAEvD,WAQA,WAMA,UAEA,YACE,EACA,EACA,EACA,CACA,MAAM,EAAc,qBAAsB,EAAS,CAAO,EAC1D,KAAK,KAAO,4BACZ,KAAK,WAAa,EAClB,KAAK,UAAY,IAAe,IAEhC,KAAK,WAAa,KAAK,UAAY,GAAS,WAAa,IAAA,EAC3D,CACF,EAGa,EAAb,cAAwC,CAAU,CAChD,YAAY,EAAiB,EAAwB,CACnD,MAAM,EAAc,cAAe,EAAS,CAAO,EACnD,KAAK,KAAO,oBACd,CACF"}

package/dist/esm/relayer-sdk.worker.js

@@ -1,589 +0,0 @@
-(function() {
-	//#region src/utils/error.ts
-	/** Coerce an unknown caught value to an Error instance. */
-	function toError(error) {
-		if (error instanceof Error) return error;
-		if (typeof error === "object" && error !== null && "message" in error) return new Error(String(error.message));
-		return new Error(String(error));
-	}
-	/** Properties that may nest a lower-level cause across viem / ethers / fetch. */
-	const NESTED_ERROR_KEYS = [
-		"cause",
-		"error",
-		"info"
-	];
-	/**
-	* ethers reports its HTTP status only as a string on `info.responseStatus`
-	* (e.g. `"429 Too Many Requests"`). Read it directly off the node — not via the
-	* cause-chain flattening, which descends a single branch — so it survives even
-	* when the error also carries an `error` link that would be walked first.
-	*/
-	function responseStatusFromNode(node) {
-		const info = node.info;
-		if (info !== null && typeof info === "object") {
-			const responseStatus = info.responseStatus;
-			if (typeof responseStatus === "string") return responseStatus;
-		}
-	}
-	/**
-	* Copy the scalar signal fields the classifier keys on from a raw error node
-	* onto the envelope, only where not already set — so a shallower node keeps
-	* priority. Also lifts ethers' string `info.responseStatus` and the relayer's
-	* `Retry-After` header (both destroyed by structured clone: the header lives on
-	* a non-cloneable `Headers`, the status on a nested `info` the flattening skips).
-	*/
-	function captureNodeSignals(node, into) {
-		if (into.code === void 0 && (typeof node.code === "string" || typeof node.code === "number")) into.code = node.code;
-		if (into.status === void 0 && typeof node.status === "number") into.status = node.status;
-		if (into.statusCode === void 0 && typeof node.statusCode === "number") into.statusCode = node.statusCode;
-		if (into.responseStatus === void 0) {
-			const responseStatus = responseStatusFromNode(node);
-			if (responseStatus !== void 0) into.responseStatus = responseStatus;
-		}
-		if (into.retryAfter === void 0) if (typeof node.retryAfter === "number") into.retryAfter = node.retryAfter;
-		else {
-			const fromHeader = retryAfterFromHeader(node);
-			if (fromHeader !== void 0) into.retryAfter = fromHeader;
-		}
-	}
-	/** Lift any still-missing scalar signal from an already-serialized child up. */
-	function hoistMissingSignals(from, into) {
-		if (into.code === void 0 && from.code !== void 0) into.code = from.code;
-		if (into.status === void 0 && from.status !== void 0) into.status = from.status;
-		if (into.statusCode === void 0 && from.statusCode !== void 0) into.statusCode = from.statusCode;
-		if (into.responseStatus === void 0 && from.responseStatus !== void 0) into.responseStatus = from.responseStatus;
-		if (into.retryAfter === void 0 && from.retryAfter !== void 0) into.retryAfter = from.retryAfter;
-	}
-	/**
-	* Flatten an error (and its `cause` / `error` / `info` chain) into a
-	* structured-clone-safe {@link SerializedError}. Depth-bounded to mirror
-	* {@link findInErrorChain} and guard against cyclic structures.
-	*/
-	function serializeError(error, depth = 6) {
-		const coerced = toError(error);
-		const node = typeof error === "object" && error !== null ? error : coerced;
-		const serialized = {
-			name: coerced.name,
-			message: coerced.message
-		};
-		captureNodeSignals(node, serialized);
-		if (depth > 0) for (const key of NESTED_ERROR_KEYS) {
-			const next = node[key];
-			if (next !== void 0 && next !== null && typeof next === "object") {
-				const child = serializeError(next, depth - 1);
-				if (serialized.cause === void 0) serialized.cause = child;
-				hoistMissingSignals(child, serialized);
-			}
-		}
-		return serialized;
-	}
-	/**
-	* Parse an HTTP `Retry-After` header value into **seconds** (the SDK's duration
-	* unit and the header's own unit), or `undefined` when absent/unparseable. Per
-	* RFC 9110 the value is either a non-negative number of seconds (`"120"`) or an
-	* HTTP-date; a past date floors to `0`.
-	*/
-	function parseRetryAfterHeader(value) {
-		if (value === null || value === void 0) return;
-		const trimmed = value.trim();
-		if (trimmed === "") return;
-		if (/^\d+$/.test(trimmed)) return Number(trimmed);
-		if (/[a-zA-Z]/.test(trimmed)) {
-			const dateMs = Date.parse(trimmed);
-			if (!Number.isNaN(dateMs)) return Math.max(0, Math.round((dateMs - Date.now()) / 1e3));
-		}
-	}
-	/** Read a `Retry-After` header (→ seconds) off a `Headers`-like object, if present. */
-	function readRetryAfterHeader(headers) {
-		if (headers === null || typeof headers !== "object") return;
-		const get = headers.get;
-		if (typeof get !== "function") return;
-		return parseRetryAfterHeader(get.call(headers, "Retry-After"));
-	}
-	/**
-	* A node's **relayer** `Retry-After` header (seconds), read from a wrapped fetch
-	* `Response` (the relayer SDK's `cause.response.headers`). The SDK owns the
-	* relayer fetch, so parsing the header there is legitimate.
-	*
-	* The viem/chain side (`HttpRequestError.headers`) is deliberately **not** read:
-	* for consumer RPC the integrator's viem/ethers transport already honors
-	* `Retry-After` in its own retry loop (and retries) before the error ever
-	* surfaces, so re-reading it here would re-implement a transport concern.
-	* Chain-RPC backoff is configured on the consumer's transport (`chain.network`).
-	*/
-	function retryAfterFromHeader(node) {
-		const response = node.response;
-		if (response !== null && typeof response === "object") return readRetryAfterHeader(response.headers);
-	}
-	//#endregion
-	//#region src/utils/assertions.ts
-	function assertObject(value, context) {
-		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError(`${context} must be an object, got ${typeof value}`);
-	}
-	function assertString(value, context) {
-		if (typeof value !== "string") throw new TypeError(`${context} must be a string, got ${typeof value}`);
-	}
-	function assertFunction(value, context) {
-		if (typeof value !== "function") throw new TypeError(`${context} must be a function, got ${typeof value}`);
-	}
-	/** Assert that `obj[key]` is a string. Narrows `obj` to include `{ [key]: string }`. */
-	function assertStringProp(obj, key, context) {
-		assertString(obj[key], context);
-	}
-	/** Assert that `obj[key]` is a function. Narrows `obj` to include `{ [key]: F }`. */
-	function assertFunctionProp(obj, key, context) {
-		assertFunction(obj[key], context);
-	}
-	function assertCondition(condition, message) {
-		if (!condition) throw new TypeError(message);
-	}
-	//#endregion
-	//#region src/utils/hex.ts
-	/** Normalize a un-prefixed hex payload to a 0x-prefixed `Hex` value. */
-	function prefixHex(value) {
-		return value.startsWith("0x") ? value : `0x${value}`;
-	}
-	/** Convert a public `Hex` value back an unprefixed format. */
-	function unprefixHex(value) {
-		assertCondition(value.startsWith("0x"), `Expected 0x-prefixed hex, got: ${value}`);
-		return value.slice(2);
-	}
-	//#endregion
-	//#region src/worker/browser-extension.ts
-	function isValidRuntime(runtime) {
-		try {
-			assertObject(runtime, "runtime");
-			assertStringProp(runtime, "id", "runtime.id");
-			assertFunctionProp(runtime, "getURL", "runtime.getURL");
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* Return the browser extension runtime object, or `undefined` outside extensions.
-	* Works across Chrome/Edge (`chrome.runtime`) and Firefox/Safari (`browser.runtime`).
-	* Extensions have restricted CSP that blocks `blob:` URLs, so callers use
-	* this to detect the environment and resolve file URLs via `runtime.getURL`.
-	*/
-	function getBrowserExtensionRuntime() {
-		const g = globalThis;
-		for (const ns of [g.chrome, g.browser]) try {
-			assertObject(ns, "ns");
-			if (isValidRuntime(ns.runtime)) return ns.runtime;
-		} catch {
-			continue;
-		}
-	}
-	//#endregion
-	//#region src/worker/relayer-sdk.worker.ts
-	const instances = /* @__PURE__ */ new Map();
-	const pending = /* @__PURE__ */ new Map();
-	const configs = /* @__PURE__ */ new Map();
-	/** Convert an FheChain to the FhevmInstanceConfig shape expected by createInstance. */
-	function toInstanceConfig(chain) {
-		return {
-			...chain,
-			chainId: chain.id
-		};
-	}
-	let sdkGlobal = null;
-	/**
-	* Get or lazily create an FhevmInstance for the given chain.
-	*/
-	async function getInstance(chainId) {
-		const existing = instances.get(chainId);
-		if (existing) return existing;
-		const inflight = pending.get(chainId);
-		if (inflight) return inflight;
-		const config = configs.get(chainId);
-		if (!config) throw new Error(`No config for chain ${chainId}. Available: [${[...configs.keys()].join(", ")}]`);
-		if (!sdkGlobal) throw new Error("Relayer SDK is not initialized. Call INIT first.");
-		const promise = sdkGlobal.createInstance({
-			...toInstanceConfig(config),
-			batchRpcCalls: false
-		}).then((instance) => {
-			instances.set(chainId, instance);
-			pending.delete(chainId);
-			return instance;
-		}).catch((err) => {
-			pending.delete(chainId);
-			throw err;
-		});
-		pending.set(chainId, promise);
-		return promise;
-	}
-	function unreachableFheType(_) {
-		throw new Error("Unsupported FHE type");
-	}
-	const relayerUrls = /* @__PURE__ */ new Set();
-	let csrfTokenBase = "";
-	const CSRF_HEADER_NAME = "x-csrf-token";
-	const MUTATING_METHODS = /* @__PURE__ */ new Set([
-		"POST",
-		"PUT",
-		"DELETE",
-		"PATCH"
-	]);
-	/**
-	* Register relayer URLs from chain configs for fetch interception.
-	*/
-	function registerRelayerUrls(chainConfigs) {
-		for (const c of chainConfigs) if (c.relayerUrl) relayerUrls.add(c.relayerUrl);
-	}
-	/**
-	* Send a success response back to the main thread.
-	* Optionally transfers ArrayBuffers for zero-copy performance.
-	*/
-	function sendSuccess(id, type, data, transfer) {
-		const response = {
-			id,
-			type,
-			success: true,
-			data
-		};
-		return transfer ? self.postMessage(response, transfer) : self.postMessage(response);
-	}
-	/**
-	* Send an error response back to the main thread.
-	*/
-	function sendError(id, type, error) {
-		self.postMessage({
-			id,
-			type,
-			success: false,
-			error: error instanceof Error ? error.message : String(error),
-			serialized: serializeError(error)
-		});
-	}
-	const originalFetch = fetch;
-	/** Allowed CDN hostnames for loading the relayer SDK script. */
-	const ALLOWED_CDN_HOSTS = /* @__PURE__ */ new Set(["cdn.zama.org"]);
-	/**
-	* Validate the CDN URL supplied by the caller.
-	* Ensures only HTTPS URLs from approved hosts are used when loading
-	* SDK code into the worker.
-	*/
-	function validateCdnUrl(rawUrl) {
-		let url;
-		try {
-			url = new URL(rawUrl);
-		} catch {
-			throw new Error("Invalid CDN URL");
-		}
-		if (url.protocol !== "https:") throw new Error("CDN URL must use https");
-		if (!ALLOWED_CDN_HOSTS.has(url.hostname)) throw new Error(`CDN URL host is not allowed: ${url.hostname}`);
-		return url.toString();
-	}
-	/**
-	* Set up fetch interceptor to add credentials and CSRF token for relayer requests.
-	* Workers don't automatically include cookies, so we intercept fetch calls
-	* targeting our relayer proxy to inject credentials and CSRF headers.
-	*/
-	function setupFetchInterceptor() {
-		globalThis.fetch = async (input, init) => {
-			const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-			const method = init?.method?.toUpperCase() ?? "GET";
-			if (relayerUrls.size > 0 && [...relayerUrls].some((base) => url.startsWith(base))) {
-				const headers = new Headers(init?.headers);
-				if (MUTATING_METHODS.has(method) && csrfTokenBase) headers.set(CSRF_HEADER_NAME, csrfTokenBase);
-				return originalFetch(input, {
-					...init,
-					headers,
-					credentials: "include"
-				});
-			}
-			return originalFetch(input, init);
-		};
-	}
-	/**
-	* Verify a fetched script's SHA-384 hash matches the expected integrity value.
-	*/
-	async function verifyIntegrity(content, expectedHash) {
-		const encoder = new TextEncoder();
-		const hashBuffer = await crypto.subtle.digest("SHA-384", encoder.encode(content));
-		const hashHex = [...new Uint8Array(hashBuffer)].map((b) => b.toString(16).padStart(2, "0")).join("");
-		if (hashHex !== expectedHash) throw new Error(`CDN integrity check failed: expected SHA-384 ${expectedHash}, got ${hashHex}`);
-	}
-	/**
-	* Load SDK script from CDN.
-	* Uses two strategies depending on the environment:
-	* - **Web apps (default):** fetch + blob URL + importScripts. Avoids MIME-type
-	*   rejections (some CDNs serve .cjs as `application/node`) and CSP
-	*   `unsafe-eval` violations.
-	* - **Browser extensions (Chrome/Firefox/Safari):** importScripts directly.
-	*   Blob URLs are blocked by extension CSP, but the CDN must be allowed
-	*   in the extension's manifest CSP.
-	*
-	* Integrity is always verified when a hash is provided, regardless of strategy.
-	*/
-	async function fetchScript(cdnUrl) {
-		const response = await originalFetch(cdnUrl);
-		if (!response.ok) throw new Error(`Failed to fetch SDK: ${response.status} ${response.statusText}`);
-		return response.text();
-	}
-	async function loadSdkScript(cdnUrl, integrity) {
-		const validatedUrl = validateCdnUrl(cdnUrl);
-		if (getBrowserExtensionRuntime()) {
-			if (integrity) await verifyIntegrity(await fetchScript(validatedUrl), integrity);
-			return self.importScripts(validatedUrl);
-		}
-		const scriptContent = await fetchScript(validatedUrl);
-		if (integrity) await verifyIntegrity(scriptContent, integrity);
-		const blob = new Blob([scriptContent], { type: "application/javascript" });
-		const blobUrl = URL.createObjectURL(blob);
-		try {
-			self.importScripts(blobUrl);
-		} finally {
-			URL.revokeObjectURL(blobUrl);
-		}
-	}
-	/**
-	* Handle INIT request - load SDK WASM and register chain configs (instances are lazy).
-	*/
-	async function handleInit(request) {
-		const { id, type, payload } = request;
-		try {
-			if (payload.env !== "web") throw new Error(`Web worker received unexpected env: ${payload.env}`);
-			const { cdnUrl, csrfToken, integrity, thread } = payload;
-			csrfTokenBase = csrfToken;
-			setupFetchInterceptor();
-			await loadSdkScript(cdnUrl, integrity);
-			if (!self.relayerSDK) throw new Error("Failed to load relayerSDK from CDN");
-			sdkGlobal = self.relayerSDK;
-			await sdkGlobal.initSDK(thread !== null && thread !== void 0 ? { thread } : void 0);
-			registerRelayerUrls(payload.chains);
-			for (const chain of payload.chains) configs.set(chain.id, chain);
-			sendSuccess(id, type, { initialized: true });
-		} catch (error) {
-			sendError(id, type, error);
-		}
-	}
-	/** Coerce a boolean to bigint for numeric FHE types. */
-	function toBigInt(value) {
-		return typeof value === "boolean" ? value ? 1n : 0n : value;
-	}
-	/**
-	* Add a single typed value to the encrypted input builder.
-	*/
-	function addTypedValue(input, entry) {
-		const { value, type: fheType } = entry;
-		switch (fheType) {
-			case "ebool":
-				input.addBool(typeof value === "boolean" ? value : value !== 0n);
-				break;
-			case "euint8":
-				input.add8(toBigInt(value));
-				break;
-			case "euint16":
-				input.add16(toBigInt(value));
-				break;
-			case "euint32":
-				input.add32(toBigInt(value));
-				break;
-			case "euint64":
-				input.add64(toBigInt(value));
-				break;
-			case "euint128":
-				input.add128(toBigInt(value));
-				break;
-			case "euint256":
-				input.add256(toBigInt(value));
-				break;
-			case "eaddress":
-				input.addAddress(value);
-				break;
-			default: unreachableFheType(fheType);
-		}
-	}
-	/**
-	* Handle ENCRYPT request.
-	*/
-	async function handleEncrypt(request) {
-		const { id, type, payload } = request;
-		const { values, contractAddress, userAddress } = payload;
-		try {
-			const input = (await getInstance(payload.chainId)).createEncryptedInput(contractAddress, userAddress);
-			for (const entry of values) addTypedValue(input, entry);
-			const encrypted = await input.encrypt();
-			sendSuccess(id, type, {
-				handles: encrypted.handles,
-				inputProof: encrypted.inputProof
-			}, [encrypted.inputProof.buffer, ...encrypted.handles.map((h) => h.buffer)]);
-		} catch (error) {
-			sendError(id, type, error);
-		}
-	}
-	/**
-	* Handle USER_DECRYPT request.
-	*/
-	async function handleUserDecrypt(request) {
-		const { id, type, payload } = request;
-		try {
-			const instance = await getInstance(payload.chainId);
-			const handleContractPairs = payload.encryptedValues.map((encryptedValue) => ({
-				handle: encryptedValue,
-				contractAddress: payload.contractAddress
-			}));
-			sendSuccess(id, type, { clearValues: await instance.userDecrypt(handleContractPairs, unprefixHex(payload.privateKey), unprefixHex(payload.publicKey), payload.signature, payload.signedContractAddresses, payload.signerAddress, payload.startTimestamp, payload.durationDays) });
-		} catch (error) {
-			sendError(id, type, error);
-		}
-	}
-	/**
-	* Handle PUBLIC_DECRYPT request.
-	*/
-	async function handlePublicDecrypt(request) {
-		const { id, type, payload } = request;
-		try {
-			sendSuccess(id, type, { ...await (await getInstance(payload.chainId)).publicDecrypt(payload.encryptedValues) });
-		} catch (error) {
-			sendError(id, type, error);
-		}
-	}
-	/**
-	* Handle GENERATE_KEYPAIR request.
-	*/
-	async function handleGenerateKeypair(request) {
-		const { id, type, payload } = request;
-		try {
-			const keypair = (await getInstance(payload.chainId)).generateKeypair();
-			sendSuccess(id, type, {
-				publicKey: prefixHex(keypair.publicKey),
-				privateKey: prefixHex(keypair.privateKey)
-			});
-		} catch (error) {
-			sendError(id, type, error);
-		}
-	}
-	/**
-	* Handle CREATE_EIP712 request.
-	*/
-	async function handleCreateEIP712(request) {
-		const { id, type, payload } = request;
-		try {
-			sendSuccess(id, type, (await getInstance(payload.chainId)).createEIP712(unprefixHex(payload.publicKey), payload.contractAddresses, payload.startTimestamp, payload.durationDays));
-		} catch (error) {
-			sendError(id, type, error);
-		}
-	}
-	/**
-	* Handle CREATE_DELEGATED_EIP712 request.
-	*/
-	async function handleCreateDelegatedEIP712(request) {
-		const { id, type, payload } = request;
-		try {
-			sendSuccess(id, type, (await getInstance(payload.chainId)).createDelegatedUserDecryptEIP712(unprefixHex(payload.publicKey), payload.contractAddresses, payload.delegatorAddress, payload.startTimestamp, payload.durationDays));
-		} catch (error) {
-			sendError(id, type, error);
-		}
-	}
-	/**
-	* Handle DELEGATED_USER_DECRYPT request.
-	*/
-	async function handleDelegatedUserDecrypt(request) {
-		const { id, type, payload } = request;
-		try {
-			const instance = await getInstance(payload.chainId);
-			const handleContractPairs = payload.encryptedValues.map((encryptedValue) => ({
-				handle: encryptedValue,
-				contractAddress: payload.contractAddress
-			}));
-			sendSuccess(id, type, { clearValues: await instance.delegatedUserDecrypt(handleContractPairs, unprefixHex(payload.privateKey), unprefixHex(payload.publicKey), payload.signature, payload.signedContractAddresses, payload.delegatorAddress, payload.delegateAddress, payload.startTimestamp, payload.durationDays) });
-		} catch (error) {
-			sendError(id, type, error);
-		}
-	}
-	/**
-	* Handle REQUEST_ZK_PROOF_VERIFICATION request.
-	*/
-	async function handleRequestZKProofVerification(request) {
-		const { id, type, payload } = request;
-		try {
-			const result = await (await getInstance(payload.chainId)).requestZKProofVerification(payload.zkProof);
-			sendSuccess(id, type, result, [result.inputProof.buffer, ...result.handles.map((h) => h.buffer)]);
-		} catch (error) {
-			sendError(id, type, error);
-		}
-	}
-	/**
-	* Handle GET_PUBLIC_KEY request.
-	*/
-	async function handleGetPublicKey(request) {
-		const { id, type, payload } = request;
-		try {
-			sendSuccess(id, type, { result: (await getInstance(payload.chainId)).getPublicKey() });
-		} catch (error) {
-			sendError(id, type, error);
-		}
-	}
-	/**
-	* Handle GET_PUBLIC_PARAMS request.
-	*/
-	async function handleGetPublicParams(request) {
-		const { id, type, payload } = request;
-		try {
-			sendSuccess(id, type, { result: (await getInstance(payload.chainId)).getPublicParams(payload.bits) });
-		} catch (error) {
-			sendError(id, type, error);
-		}
-	}
-	/**
-	* Handle UPDATE_CSRF request - update the stored CSRF token.
-	*/
-	function handleUpdateCsrf(request) {
-		const { id, type, payload } = request;
-		csrfTokenBase = payload.csrfToken;
-		sendSuccess(id, type, { updated: true });
-	}
-	/**
-	* Main message handler.
-	*/
-	self.onmessage = async (event) => {
-		const request = event.data;
-		try {
-			switch (request.type) {
-				case "INIT":
-					await handleInit(request);
-					break;
-				case "UPDATE_CSRF":
-					handleUpdateCsrf(request);
-					break;
-				case "ENCRYPT":
-					await handleEncrypt(request);
-					break;
-				case "USER_DECRYPT":
-					await handleUserDecrypt(request);
-					break;
-				case "PUBLIC_DECRYPT":
-					await handlePublicDecrypt(request);
-					break;
-				case "GENERATE_KEYPAIR":
-					await handleGenerateKeypair(request);
-					break;
-				case "CREATE_EIP712":
-					await handleCreateEIP712(request);
-					break;
-				case "CREATE_DELEGATED_EIP712":
-					await handleCreateDelegatedEIP712(request);
-					break;
-				case "DELEGATED_USER_DECRYPT":
-					await handleDelegatedUserDecrypt(request);
-					break;
-				case "REQUEST_ZK_PROOF_VERIFICATION":
-					await handleRequestZKProofVerification(request);
-					break;
-				case "GET_PUBLIC_KEY":
-					await handleGetPublicKey(request);
-					break;
-				case "GET_PUBLIC_PARAMS":
-					await handleGetPublicParams(request);
-					break;
-				default: throw new Error(`Unknown request type: ${request.type}`);
-			}
-		} catch (error) {
-			sendError(request?.id ?? "unknown", request?.type ?? "UNKNOWN", error);
-		}
-	};
-	//#endregion
-})();

package/dist/esm/timeout-CNVfiaJD.js

@@ -1,2 +0,0 @@
-import{i as e,r as t}from"./relayer-eavK5bfZ.js";var n=class extends t{operation;timeout;elapsed;worker;constructor(t,n){super(e.OperationTimeout,`Worker operation ${t.operation} timed out after ${t.timeout}s`+(t.worker?` (worker ${t.worker})`:``),n),this.name=`WorkerTimeoutError`,this.operation=t.operation,this.timeout=t.timeout,this.elapsed=t.elapsed,this.worker=t.worker}},r=class extends t{operation;worker;constructor(t,n){super(e.WorkerRecycled,`Worker operation ${t.operation} was aborted because its worker was recycled after a timeout`+(t.worker?` (worker ${t.worker})`:``),n),this.name=`WorkerRecycledError`,this.operation=t.operation,this.worker=t.worker}};export{n,r as t};
-//# sourceMappingURL=timeout-CNVfiaJD.js.map

package/dist/esm/timeout-CNVfiaJD.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeout-CNVfiaJD.js","names":[],"sources":["../../src/errors/timeout.ts"],"sourcesContent":["import { ZamaError, ZamaErrorCode } from \"./base\";\n\n/**\n * A worker operation (encrypt / decrypt / EIP-712 / key fetch) did not complete\n * within its configured timeout — typically a stuck relayer or WASM call. On the\n * Node pool the SDK **recycles the affected worker** (terminating the hung\n * thread) so it self-heals; the operation itself is **retryable**.\n *\n * Configure the bound (seconds) via `node({ operationTimeout })`. Distinct from a\n * decryption/entitlement failure — a timeout is an infrastructure/latency\n * condition, so it no longer collapses into {@link DecryptionFailedError}.\n *\n * @example\n * ```ts\n * try {\n *   await sdk.decryption.decryptValues([{ encryptedValue, contractAddress }]);\n * } catch (e) {\n *   if (e instanceof WorkerTimeoutError) {\n *     // retry (the worker was recycled); consider raising operationTimeout\n *   }\n * }\n * ```\n */\nexport class WorkerTimeoutError extends ZamaError {\n  /**\n   * The worker operation that timed out. This is the internal worker op code\n   * (e.g. `USER_DECRYPT`, `ENCRYPT`), not the public SDK method name.\n   */\n  readonly operation: string;\n  /** The configured timeout that was exceeded, in **seconds** (the SDK's duration unit). */\n  readonly timeout: number;\n  /** Wall-clock time the operation ran before being abandoned, in **seconds** (may be fractional). */\n  readonly elapsed: number;\n  /** Label of the worker that stalled, when known (e.g. `node-worker-2`). */\n  readonly worker: string | undefined;\n\n  constructor(\n    args: { operation: string; timeout: number; elapsed: number; worker?: string },\n    options?: ErrorOptions,\n  ) {\n    super(\n      ZamaErrorCode.OperationTimeout,\n      `Worker operation ${args.operation} timed out after ${args.timeout}s` +\n        (args.worker ? ` (worker ${args.worker})` : \"\"),\n      options,\n    );\n    this.name = \"WorkerTimeoutError\";\n    this.operation = args.operation;\n    this.timeout = args.timeout;\n    this.elapsed = args.elapsed;\n    this.worker = args.worker;\n  }\n}\n\n/**\n * An in-flight worker operation was aborted as **collateral** when its worker was\n * recycled — the worker was torn down to recover from *another* operation's\n * timeout (Node pool self-healing), not because this operation itself timed out.\n *\n * The operation never reached a verdict, so it is **retryable**: the next call\n * lazily re-inits a fresh worker. It is intentionally distinct from\n * {@link WorkerTimeoutError} (this op did not exceed its own bound) and from\n * {@link DecryptionFailedError} (nothing actually failed to decrypt) — so a\n * consumer can retry it instead of surfacing a terminal failure.\n *\n * @example\n * ```ts\n * matchZamaError(error, {\n *   WORKER_RECYCLED: () => retry(), // transient: the worker was replaced\n * });\n * ```\n */\nexport class WorkerRecycledError extends ZamaError {\n  /**\n   * The worker operation that was aborted. This is the internal worker op code\n   * (e.g. `USER_DECRYPT`, `ENCRYPT`), not the public SDK method name.\n   */\n  readonly operation: string;\n  /** Label of the recycled worker, when known (e.g. `node-worker-2`). */\n  readonly worker: string | undefined;\n\n  constructor(args: { operation: string; worker?: string }, options?: ErrorOptions) {\n    super(\n      ZamaErrorCode.WorkerRecycled,\n      `Worker operation ${args.operation} was aborted because its worker was recycled after a timeout` +\n        (args.worker ? ` (worker ${args.worker})` : \"\"),\n      options,\n    );\n    this.name = \"WorkerRecycledError\";\n    this.operation = args.operation;\n    this.worker = args.worker;\n  }\n}\n"],"mappings":"iDAuBA,IAAa,EAAb,cAAwC,CAAU,CAKhD,UAEA,QAEA,QAEA,OAEA,YACE,EACA,EACA,CACA,MACE,EAAc,iBACd,oBAAoB,EAAK,UAAU,mBAAmB,EAAK,QAAQ,IAChE,EAAK,OAAS,YAAY,EAAK,OAAO,GAAK,IAC9C,CACF,EACA,KAAK,KAAO,qBACZ,KAAK,UAAY,EAAK,UACtB,KAAK,QAAU,EAAK,QACpB,KAAK,QAAU,EAAK,QACpB,KAAK,OAAS,EAAK,MACrB,CACF,EAoBa,EAAb,cAAyC,CAAU,CAKjD,UAEA,OAEA,YAAY,EAA8C,EAAwB,CAChF,MACE,EAAc,eACd,oBAAoB,EAAK,UAAU,+DAChC,EAAK,OAAS,YAAY,EAAK,OAAO,GAAK,IAC9C,CACF,EACA,KAAK,KAAO,sBACZ,KAAK,UAAY,EAAK,UACtB,KAAK,OAAS,EAAK,MACrB,CACF"}

package/dist/esm/token-Bt33g0zQ.js

@@ -1,2 +0,0 @@
-import{i as e,r as t,t as n}from"./relayer-eavK5bfZ.js";import{A as r,B as i,D as a,E as o,H as s,L as c,M as l,R as u,S as d,T as f,U as p,W as m,b as h,l as g,m as _,u as v,v as y,w as b,x}from"./wrappers-registry-C1oK8Bi6.js";import{n as S,t as C}from"./encryption-x4Z_Icqk.js";import{_ as w,t as T}from"./assertions-zYseN5Xz.js";import{getAddress as E}from"viem";var D=class extends t{constructor(t,n){super(e.TransactionReverted,t,n),this.name=`TransactionRevertedError`}},O=class extends t{retryAfter;constructor(t,n){let{retryAfter:r,...i}=n??{};super(e.RpcRateLimited,t,i),this.name=`RpcRateLimitError`,this.retryAfter=r}},k=class extends t{operation;signerChainId;providerChainId;constructor({operation:t,signerChainId:n,providerChainId:r},i){super(e.ChainMismatch,`Operation "${t}" 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=t,this.signerChainId=n,this.providerChainId=r}},A=class extends t{requested;available;token;constructor(t,n,r){super(e.InsufficientConfidentialBalance,t,r),this.name=`InsufficientConfidentialBalanceError`,this.requested=n.requested,this.available=n.available,this.token=n.token}},j=class extends t{requested;available;token;constructor(t,n,r){super(e.InsufficientERC20Balance,t,r),this.name=`InsufficientERC20BalanceError`,this.requested=n.requested,this.available=n.available,this.token=n.token}},M=class extends t{constructor(t,n){super(e.BalanceCheckUnavailable,t,n),this.name=`BalanceCheckUnavailableError`}},N=class extends t{constructor(t,n){super(e.ERC20ReadFailed,t,n),this.name=`ERC20ReadFailedError`}};function P(e){return e instanceof m||e instanceof p||e instanceof n||e instanceof O}const F=[{type:`function`,name:`allow`,inputs:[{name:`handle`,type:`bytes32`,internalType:`bytes32`},{name:`account`,type:`address`,internalType:`address`}],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`allowForDecryption`,inputs:[{name:`handlesList`,type:`bytes32[]`,internalType:`bytes32[]`}],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`allowTransient`,inputs:[{name:`ciphertext`,type:`bytes32`,internalType:`bytes32`},{name:`account`,type:`address`,internalType:`address`}],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`cleanTransientStorage`,inputs:[],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`delegateForUserDecryption`,inputs:[{name:`delegate`,type:`address`,internalType:`address`},{name:`contractAddress`,type:`address`,internalType:`address`},{name:`expirationDate`,type:`uint64`,internalType:`uint64`}],outputs:[],stateMutability:`nonpayable`},{type:`function`,name:`getUserDecryptionDelegationExpirationDate`,inputs:[{name:`delegator`,type:`address`,internalType:`address`},{name:`delegate`,type:`address`,internalType:`address`},{name:`contractAddress`,type:`address`,internalType:`address`}],outputs:[{name:``,type:`uint64`,internalType:`uint64`}],stateMutability:`view`},{type:`function`,name:`isAccountDenied`,inputs:[{name:`account`,type:`address`,internalType:`address`}],outputs:[{name:``,type:`bool`,internalType:`bool`}],stateMutability:`view`},{type:`function`,name:`isAllowed`,inputs:[{name:`handle`,type:`bytes32`,internalType:`bytes32`},{name:`account`,type:`address`,internalType:`address`}],outputs:[{name:``,type:`bool`,internalType:`bool`}],stateMutability:`view`},{type:`function`,name:`isAllowedForDecryption`,inputs:[{name:`handle`,type:`bytes32`,internalType:`bytes32`}],outputs:[{name:``,type:`bool`,internalType:`bool`}],stateMutability:`view`},{type:`function`,name:`isHandleDelegatedForUserDecryption`,inputs:[{name:`delegator`,type:`address`,internalType:`address`},{name:`delegate`,type:`address`,internalType:`address`},{name:`contractAddress`,type:`address`,internalType:`address`},{name:`handle`,type:`bytes32`,internalType:`bytes32`}],outputs:[{name:``,type:`bool`,internalType:`bool`}],stateMutability:`view`},{type:`function`,name:`multicall`,inputs:[{name:`data`,type:`bytes[]`,internalType:`bytes[]`}],outputs:[{name:`results`,type:`bytes[]`,internalType:`bytes[]`}],stateMutability:`payable`},{type:`function`,name:`persistAllowed`,inputs:[{name:`handle`,type:`bytes32`,internalType:`bytes32`},{name:`account`,type:`address`,internalType:`address`}],outputs:[{name:``,type:`bool`,internalType:`bool`}],stateMutability:`view`},{type:`function`,name:`revokeDelegationForUserDecryption`,inputs:[{name:`delegate`,type:`address`,internalType:`address`},{name:`contractAddress`,type:`address`,internalType:`address`}],outputs:[],stateMutability:`nonpayable`}];function I(e,t,n,r){return{address:e,abi:F,functionName:`delegateForUserDecryption`,args:[t,n,r]}}function L(e,t,n){return{address:e,abi:F,functionName:`revokeDelegationForUserDecryption`,args:[t,n]}}function R(e,t,n,r){return{address:e,abi:F,functionName:`getUserDecryptionDelegationExpirationDate`,args:[t,n,r]}}function z(e,t,n,r,i){return{address:e,abi:F,functionName:`isHandleDelegatedForUserDecryption`,args:[t,n,r,i]}}const B=2n**64n-1n;async function V(e,t,n){if(!t)throw new u(e);let r;try{r=t.requireWalletAccount(e)}catch(n){if(!(n instanceof i)||!t.refreshWalletAccount)throw n;await t.refreshWalletAccount(),r=t.requireWalletAccount(e)}let a=await n.getChainId();if(r.chainId!==a)throw new k({operation:e,signerChainId:r.chainId,providerChainId:a});return r}async function H(e,t,n){return(await V(e,t,n)).chainId}const U={EncryptStart:`encrypt:start`,EncryptEnd:`encrypt:end`,EncryptError:`encrypt:error`,DecryptStart:`decrypt:start`,DecryptEnd:`decrypt:end`,DecryptError:`decrypt:error`,TransactionError:`transaction:error`,ShieldSubmitted:`shield:submitted`,TransferSubmitted:`transfer:submitted`,TransferFromSubmitted:`transferFrom:submitted`,SetOperatorSubmitted:`setOperator:submitted`,ApproveUnderlyingSubmitted:`approveUnderlying: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`},W={approveUnderlying:{submittedEvent:e=>({type:U.ApproveUnderlyingSubmitted,txHash:e,step:`approve`})},"approveUnderlying:reset":{submittedEvent:e=>({type:U.ApproveUnderlyingSubmitted,txHash:e,step:`reset`})},delegateDecryption:{submittedEvent:e=>({type:U.DelegationSubmitted,txHash:e})},finalizeUnwrap:{submittedEvent:e=>({type:U.FinalizeUnwrapSubmitted,txHash:e})},revokeDelegation:{submittedEvent:e=>({type:U.RevokeDelegationSubmitted,txHash:e})},setOperator:{submittedEvent:e=>({type:U.SetOperatorSubmitted,txHash:e})},"shield:transferAndCall":{submittedEvent:e=>({type:U.ShieldSubmitted,txHash:e,shieldPath:`transferAndCall`})},"shield:approveAndWrap":{submittedEvent:e=>({type:U.ShieldSubmitted,txHash:e,shieldPath:`approveAndWrap`})},transfer:{submittedEvent:e=>({type:U.TransferSubmitted,txHash:e})},transferAndCall:{submittedEvent:e=>({type:U.TransferSubmitted,txHash:e})},transferFrom:{submittedEvent:e=>({type:U.TransferFromSubmitted,txHash:e})},transferFromAndCall:{submittedEvent:e=>({type:U.TransferFromSubmitted,txHash:e})},unwrap:{submittedEvent:e=>({type:U.UnwrapSubmitted,txHash:e})},unwrapAll:{submittedEvent:e=>({type:U.UnwrapSubmitted,txHash:e})}};async function G(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}const K=`0x0000000000000000000000000000000000000000000000000000000000000000`;function q(e){return e===`0x0000000000000000000000000000000000000000000000000000000000000000`||e===`0x`}async function J(e){let{operation:n,signer:r,provider:i,config:a,emit:o,onSubmitted:s,logger:l}=e,u=W[n];try{let e=await r.writeContract(a);return o(u.submittedEvent(e)),c(`${n}: onSubmitted`,()=>s?.(e),l),{txHash:e,receipt:await i.waitForTransactionReceipt(e)}}catch(e){let r=e instanceof t?e:new D(`Transaction failed during ${n}`,{cause:e});throw o({type:U.TransactionError,operation:n,error:r}),r}}var Y=class e{sdk;address;constructor(e,t){this.sdk=e,this.address=E(t)}#e(e){return s(this.sdk.signer,e)}async name(){return this.sdk.provider.readContract(h(this.address))}async symbol(){return this.sdk.provider.readContract(x(this.address))}async decimals(){return this.sdk.provider.readContract(y(this.address))}async isConfidential(){return this.sdk.provider.readContract(_(this.address,g))}async isWrapper(){return this.sdk.provider.readContract(_(this.address,v))}async balanceOf(e){let t=E(e),n=await this.readConfidentialBalanceOf(t),r=(await this.sdk.decryption.decryptValues([{encryptedValue:n,contractAddress:this.address}]))[n];if(r===void 0)throw new C(`Decryption returned no value for ${n}`);return T(r,`balanceOf: result[encryptedValue]`),r}async confidentialBalanceOf(e){return this.readConfidentialBalanceOf(E(e))}async decryptBalanceAs({delegatorAddress:e,accountAddress:t}){await H(`decryptBalanceAs`,this.sdk.signer,this.sdk.provider);let n=E(e),r=t?E(t):n,i=await this.readConfidentialBalanceOf(r);if(q(i))return 0n;let a=(await this.sdk.decryption.delegatedDecryptValues([{encryptedValue:i,contractAddress:this.address}],n,r))[i];if(a===void 0)throw new C(`Delegated decryption returned no value for ${i}`);return T(a,`decryptBalanceAs: result[encryptedValue]`),a}static async batchBalancesOf(n,r){let i=new Map,a=new Map;if(n.length===0)return{results:i,errors:a};let o=e.assertSameSdk(n);await H(`batchBalancesOf`,o.signer,o.provider),await o.permits.grantPermit(n.map(e=>e.address));let s=await G(n.map(e=>async()=>{try{return{status:`fulfilled`,value:await e.balanceOf(r)}}catch(e){return{status:`rejected`,reason:e}}}),5);for(let e=0;e<n.length;e++){let r=n[e].address,o=s[e];if(o.status===`fulfilled`)i.set(r,o.value);else{let e=o.reason;if(P(e))throw e;let n=e instanceof t?e:new C(w(e).message,{cause:e});a.set(r,n)}}if(a.size===n.length)throw a.values().next().value??new C(`All token balance decryptions failed`);return{results:i,errors:a}}static async batchDecryptBalancesAs(t,n){if(t.length===0)return new Map;let r=e.assertSameSdk(t),i=new Map,a=new Map,o=n.accountAddress?E(n.accountAddress):E(n.delegatorAddress),s=n.maxConcurrency??10;if(n.encryptedValues&&t.length!==n.encryptedValues.length)throw new C(`tokens.length (${t.length}) must equal encryptedValues.length (${n.encryptedValues.length})`);let c=n.encryptedValues??await e.readBalanceHandlesBatch(t,o,a,s),l=[];for(let[e,n]of t.entries()){let t=c[e];!t||a.has(n.address)||(q(t)?i.set(n.address,0n):l.push({token:n,encryptedValue:t}))}if(l.length>0){let e=await r.decryption.delegatedBatchDecryptValues({encryptedInputs:l.map(({token:e,encryptedValue:t})=>({encryptedValue:t,contractAddress:e.address})),delegatorAddress:n.delegatorAddress,accountAddress:n.accountAddress,maxConcurrency:s});for(let[t,n]of e.items.entries()){let e=l[t];if(!e)continue;if(n.error){a.set(e.token.address,n.error);continue}let r=n.value;if(r===void 0){a.set(e.token.address,new C(`Batch delegated decryption returned no value for ${n.encryptedValue} on token ${e.token.address}`));continue}T(r,`batchDecryptBalancesAs: result[encryptedValue]`),i.set(e.token.address,r)}}if(a.size===0)return i;if(n.onError){let e=[];for(let[t,r]of a)try{i.set(t,n.onError(r,t))}catch(n){e.push({address:t,error:w(n)})}if(e.length>0){let t=e.map(({address:e,error:t})=>`${e}: ${t.message}`).join(`; `);throw new C(`Batch delegated decryption onError callback failed for ${e.length} token(s): ${t}`,{cause:e[0]?.error})}return i}let u=Array.from(a.entries()),d=u.map(([e,t])=>`${e}: ${t.message}`).join(`; `);throw new C(`Batch delegated decryption failed for ${a.size} token(s): ${d}`,{cause:u[0]?.[1]})}static async readBalanceHandlesBatch(e,n,r,i){let a=await G(e.map(e=>async()=>{try{return{status:`fulfilled`,value:await e.readConfidentialBalanceOf(n)}}catch(e){return{status:`rejected`,reason:e}}}),i),o=[];for(let[n,i]of e.entries()){let e=a[n];if(e){if(e.status===`fulfilled`){o[n]=e.value;continue}if(P(e.reason))throw e.reason;r.set(i.address,e.reason instanceof t?e.reason:new C(w(e.reason).message,{cause:e.reason}))}}return o}async confidentialTransfer(e,t,n){this.#e(`confidentialTransfer`);let r=await V(`confidentialTransfer`,this.sdk.signer,this.sdk.provider),{skipBalanceCheck:i=!1,onEncryptComplete:a,onTransferSubmitted:o}=n??{},s=E(e);i||await this.assertConfidentialBalance(t);let{encryptedValues:l,inputProof:u}=await this.sdk.encrypt({values:[{value:t,type:`euint64`}],contractAddress:this.address,userAddress:E(r.address)});if(c(`transfer: onEncryptComplete`,()=>a?.(),this.sdk.logger),l.length===0)throw new S(`Encryption returned no encrypted values`);return this.submitTransaction({operation:`transfer`,config:f(this.address,s,l[0],u),onSubmitted:o})}async confidentialTransferFrom(e,t,n,r){this.#e(`confidentialTransferFrom`),await V(`confidentialTransferFrom`,this.sdk.signer,this.sdk.provider);let i=E(e),o=E(t),{encryptedValues:s,inputProof:l}=await this.sdk.encrypt({values:[{value:n,type:`euint64`}],contractAddress:this.address,userAddress:i});if(c(`transferFrom: onEncryptComplete`,()=>r?.onEncryptComplete?.(),this.sdk.logger),s.length===0)throw new S(`Encryption returned no encrypted values`);return this.submitTransaction({operation:`transferFrom`,config:a(this.address,i,o,s[0],l),onSubmitted:r?.onTransferSubmitted})}async confidentialTransferAndCall(e,t,n,r){this.#e(`confidentialTransferAndCall`);let i=await V(`confidentialTransferAndCall`,this.sdk.signer,this.sdk.provider),{skipBalanceCheck:a=!1,onEncryptComplete:o,onTransferSubmitted:s}=r??{},l=E(e);a||await this.assertConfidentialBalance(t);let{encryptedValues:u,inputProof:d}=await this.sdk.encrypt({values:[{value:t,type:`euint64`}],contractAddress:this.address,userAddress:E(i.address)});if(c(`transferAndCall: onEncryptComplete`,()=>o?.(),this.sdk.logger),u.length===0)throw new S(`Encryption returned no encrypted values`);return this.submitTransaction({operation:`transferAndCall`,config:b(this.address,l,u[0],d,n),onSubmitted:s})}async confidentialTransferFromAndCall(e,t,n,r,i){this.#e(`confidentialTransferFromAndCall`),await V(`confidentialTransferFromAndCall`,this.sdk.signer,this.sdk.provider);let a=E(e),s=E(t),{encryptedValues:l,inputProof:u}=await this.sdk.encrypt({values:[{value:n,type:`euint64`}],contractAddress:this.address,userAddress:a});if(c(`transferFromAndCall: onEncryptComplete`,()=>i?.onEncryptComplete?.(),this.sdk.logger),l.length===0)throw new S(`Encryption returned no encrypted values`);return this.submitTransaction({operation:`transferFromAndCall`,config:o(this.address,a,s,l[0],u,r),onSubmitted:i?.onTransferSubmitted})}async setOperator(e,t){this.#e(`setOperator`),await H(`setOperator`,this.sdk.signer,this.sdk.provider);let n=E(e);return this.submitTransaction({operation:`setOperator`,config:l(this.address,n,t)})}async isOperator(e,t){return this.sdk.provider.readContract(r(this.address,E(e),E(t)))}async readConfidentialBalanceOf(e){return await this.sdk.provider.readContract(d(this.address,e))}async assertConfidentialBalance(e){if(e===0n)return;let n;try{let e=await V(`assertConfidentialBalance`,this.sdk.signer,this.sdk.provider);n=await this.balanceOf(E(e.address))}catch(e){throw e instanceof t?e:new M(`Balance validation failed (token: ${this.address})`,{cause:e})}if(n<e)throw new A(`Insufficient confidential balance: requested ${e}, available ${n} (token: ${this.address})`,{requested:e,available:n,token:this.address})}emit(e){this.sdk.emitEvent(e,this.address)}async submitTransaction(e){let{operation:t,config:n,onSubmitted:r}=e;return J({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 r=1;r<e.length;r++)if(e[r].sdk!==t)throw new n(`All tokens in a batch operation must share the same ZamaSDK instance`);return t}};export{A as _,G as a,O as b,H as c,R as d,z as f,N as g,M as h,q as i,B as l,P as m,J as n,U as o,L as p,K as r,V as s,Y as t,I as u,j as v,D as x,k as y};
-//# sourceMappingURL=token-Bt33g0zQ.js.map