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

package/dist/esm/web/index.js

@@ -1,591 +1,2 @@
-import{a as e,o as t,r as n}from"../assertions-zYseN5Xz.js";import{t as r}from"../indexeddb-storage-Mi-fCWN3.js";import{t as i}from"../validation-DLszOweh.js";import{i as a,n as o,r as s,t as c}from"../worker.base-client-BVnT4yJa.js";import{toHex as l}from"viem";import{z as u}from"zod/mini";var d=class extends a{#e=null;#t=null;#n;constructor(e){super(),this.#n=e}get chain(){return this.#n.chain}async init(){await this.#r.initWorker()}get#r(){return this.#n.worker}#i(){return this.#e||=(this.#t||=this.#n.fheArtifactStorage??new r(`FheArtifactCache`,1,`artifacts`),new s({storage:this.#t,chainId:this.chain.id,relayerUrl:this.chain.relayerUrl,ttl:this.#n.fheArtifactCacheTTL,logger:this.#n.logger})),this.#e}terminate(){this.#e=null,this.resetInit()}[Symbol.dispose](){this.terminate()}async#a(){let e=this.#n.security?.getCsrfToken?.()??``;e&&await this.#r.updateCsrf(e)}async generateTransportKeyPair(){await this.ensureInit();let e=this.chain.id,t=await this.#r.generateKeypair({chainId:e});return{publicKey:t.publicKey,privateKey:t.privateKey}}async createEIP712(e,t,n,r=7){await this.ensureInit();let i=this.chain.id;return this.#r.createEIP712({chainId:i,publicKey:e,contractAddresses:t,startTimestamp:n,durationDays:r})}async encrypt(e){let{values:t,contractAddress:n,userAddress:r}=e;await this.ensureInit();let i=this.chain.id;return o(async()=>{await this.#a();let e=await this.#r.encrypt({chainId:i,values:t,contractAddress:n,userAddress:r});return{encryptedValues:e.handles.map(e=>l(e)),inputProof:l(e.inputProof)}})}async userDecrypt(e){await this.ensureInit();let t=this.chain.id;return o(async()=>(await this.#a(),(await this.#r.userDecrypt({chainId:t,...e})).clearValues))}async publicDecrypt(e){await this.ensureInit();let t=this.chain.id;return o(async()=>{await this.#a();let n=await this.#r.publicDecrypt({chainId:t,encryptedValues:e});return{clearValues:n.clearValues,abiEncodedClearValues:n.abiEncodedClearValues,decryptionProof:n.decryptionProof}})}async createDelegatedUserDecryptEIP712(e,t,n,r,i=7){await this.ensureInit();let a=this.chain.id;return this.#r.createDelegatedUserDecryptEIP712({chainId:a,publicKey:e,contractAddresses:t,delegatorAddress:n,startTimestamp:r,durationDays:i})}async delegatedUserDecrypt(e){await this.ensureInit();let t=this.chain.id;return o(async()=>(await this.#a(),(await this.#r.delegatedUserDecrypt({chainId:t,...e})).clearValues))}async requestZKProofVerification(e){await this.ensureInit();let t=this.chain.id;return o(async()=>(await this.#a(),this.#r.requestZKProofVerification({chainId:t,zkProof:e})))}async fetchFheEncryptionKeyBytes(){await this.ensureInit();let e=this.chain.id;return this.#i().fetchFheEncryptionKeyBytes(async()=>(await this.#r.getPublicKey({chainId:e})).result)}async getPublicParams(e){await this.ensureInit();let t=this.chain.id;return this.#i().getPublicParams(e,async()=>(await this.#r.getPublicParams({chainId:t,bits:e})).result)}};function f(r){try{return e(r,`runtime`),t(r,`id`,`runtime.id`),n(r,`getURL`,`runtime.getURL`),!0}catch{return!1}}function p(){let t=globalThis;for(let n of[t.chrome,t.browser])try{if(e(n,`ns`),f(n.runtime))return n.runtime}catch{continue}}var m=class extends c{env=`web`;constructor(e){super({workerLabel:`web-worker`,...e,recycleWorkerOnTimeout:!1},e.logger)}createWorker(){let e=p();if(e)return new Worker(e.getURL(`relayer-sdk.worker.js`));let t=URL.createObjectURL(new Blob([`(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
-})();
-`],{type:`application/javascript`}));try{return new Worker(t)}finally{URL.revokeObjectURL(t)}}wireEvents(e){e.onmessage=e=>this.handleResponse(e.data),e.onerror=e=>this.handleWorkerError(e.message),e.onmessageerror=()=>this.handleWorkerMessageError()}postMessage(e,t){e.postMessage(t)}terminateWorker(e){e.terminate()}generateRequestId(){return crypto.randomUUID()}getInitPayload(){let{cdnUrl:e,chains:t,csrfToken:n,integrity:r,thread:i}=this.config;return{type:`INIT`,payload:{env:`web`,cdnUrl:e,chains:t,csrfToken:n,integrity:r,thread:i}}}async updateCsrf(e){await this.sendRequest(`UPDATE_CSRF`,{csrfToken:e})}};const h=u.object({threads:u.optional(u.int().check(u.positive())),fheArtifactCacheTTL:u.optional(u.int().check(u.nonnegative()))});function g(e){return e!==void 0&&i(h,e),{type:`web`,createWorker:(t,n)=>new m({cdnUrl:`https://cdn.zama.org/relayer-sdk-js/0.4.4/relayer-sdk-js.umd.cjs`,chains:t,csrfToken:e?.security?.getCsrfToken?.()??``,integrity:e?.security?.integrityCheck===!1?void 0:`a50426aae8440e802102c8674dd8451f34fe79352d5e2cc6b89d9f1aa340296176c2ee33d9aa4657752f8ca96f74f921`,logger:n,thread:e?.threads}),createRelayer:(t,n,r)=>new d({chain:t,worker:n,...e,logger:r})}}export{d as RelayerWeb,g as web};
+import{t as e}from"../fhevm-relayer-B-lEKfPQ.js";function t(t){return{type:`web`,createRelayer:n=>new e({chain:n,options:t})}}export{t as web};
 //# sourceMappingURL=index.js.map

package/dist/esm/web/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["#config","#worker","#artifactCache","#artifactStorage","#refreshCsrfToken","#getArtifactCache","workerFilename","workerCode"],"sources":["../../../src/relayer/relayer-web.ts","../../../src/worker/browser-extension.ts","../../../src/worker/worker.client.ts","../../../src/config/web.ts"],"sourcesContent":["import type {\n  InputProofBytesType,\n  KmsDelegatedUserDecryptEIP712Type,\n  ZKProofLike,\n} from \"@zama-fhe/relayer-sdk/bundle\";\nimport { toHex } from \"viem\";\nimport type { Address, Hex } from \"viem\";\nimport { IndexedDBStorage } from \"../storage/indexeddb-storage\";\nimport type { GenericStorage } from \"../types\";\nimport type { RelayerWorkerClient } from \"../worker/worker.client\";\nimport type { FheChain } from \"../chains/types\";\nimport type { TransportKeyPair } from \"../credentials/types\";\nimport { BaseRelayer } from \"./base-relayer\";\nimport { FheArtifactCache } from \"./fhe-artifact-cache\";\nimport type { RelayerSDK } from \"./relayer-sdk\";\nimport type {\n  ClearValue,\n  DelegatedUserDecryptParams,\n  EIP712TypedData,\n  EncryptParams,\n  EncryptResult,\n  EncryptedValue,\n  FheEncryptionKey,\n  PublicDecryptResult,\n  PublicParamsData,\n  RelayerWebConfig,\n  UserDecryptParams,\n} from \"./relayer-sdk.types\";\nimport { withRetry } from \"./relayer-utils\";\n\n/**\n * Pinned relayer SDK version used for the WASM CDN bundle.\n * Update this when upgrading @zama-fhe/relayer-sdk, and keep the\n * peerDependencies range in package.json in sync (~x.y.z).\n */\nexport const RELAYER_SDK_VERSION = \"0.4.4\";\nexport const CDN_URL = `https://cdn.zama.org/relayer-sdk-js/${RELAYER_SDK_VERSION}/relayer-sdk-js.umd.cjs`;\n/** SHA-384 hex digest of the pinned CDN bundle for integrity verification. */\nexport const CDN_INTEGRITY =\n  \"a50426aae8440e802102c8674dd8451f34fe79352d5e2cc6b89d9f1aa340296176c2ee33d9aa4657752f8ca96f74f921\";\n\n/**\n * RelayerWeb — single-chain browser encryption/decryption layer.\n * The worker is injected at construction time; the relayer does not own its lifecycle.\n */\nexport class RelayerWeb extends BaseRelayer implements RelayerSDK, Disposable {\n  #artifactCache: FheArtifactCache | null = null;\n  #artifactStorage: GenericStorage | null = null;\n  readonly #config: RelayerWebConfig;\n\n  constructor(config: RelayerWebConfig) {\n    super();\n    this.#config = config;\n  }\n\n  protected get chain(): FheChain {\n    return this.#config.chain;\n  }\n\n  protected async init(): Promise<void> {\n    await this.#worker.initWorker();\n  }\n\n  get #worker(): RelayerWorkerClient {\n    return this.#config.worker;\n  }\n\n  #getArtifactCache(): FheArtifactCache {\n    if (!this.#artifactCache) {\n      if (!this.#artifactStorage) {\n        this.#artifactStorage =\n          this.#config.fheArtifactStorage ??\n          new IndexedDBStorage(\"FheArtifactCache\", 1, \"artifacts\");\n      }\n      this.#artifactCache = new FheArtifactCache({\n        storage: this.#artifactStorage,\n        chainId: this.chain.id,\n        relayerUrl: this.chain.relayerUrl,\n        ttl: this.#config.fheArtifactCacheTTL,\n        logger: this.#config.logger,\n      });\n    }\n    return this.#artifactCache;\n  }\n\n  /**\n   * Terminate clears the artifact cache only.\n   * The worker is externally owned — the relayer does not terminate it.\n   */\n  terminate(): void {\n    this.#artifactCache = null;\n    this.resetInit();\n  }\n\n  /** Calls {@link terminate}. */\n  [Symbol.dispose](): void {\n    this.terminate();\n  }\n\n  /**\n   * Refresh the CSRF token in the worker.\n   * Call this before making authenticated network requests.\n   */\n  async #refreshCsrfToken(): Promise<void> {\n    const token = this.#config.security?.getCsrfToken?.() ?? \"\";\n    if (token) {\n      await this.#worker.updateCsrf(token);\n    }\n  }\n\n  /**\n   * Generate a transport key pair (ML-KEM public + private key) used for user-decryption.\n   */\n  async generateTransportKeyPair(): Promise<TransportKeyPair> {\n    await this.ensureInit();\n    const chainId = this.chain.id;\n    const result = await this.#worker.generateKeypair({ chainId });\n    return { publicKey: result.publicKey, privateKey: result.privateKey };\n  }\n\n  /**\n   * Create EIP712 typed data for user decryption authorization.\n   */\n  async createEIP712(\n    publicKey: Hex,\n    contractAddresses: Address[],\n    startTimestamp: number,\n    durationDays = 7,\n  ): Promise<EIP712TypedData> {\n    await this.ensureInit();\n    const chainId = this.chain.id;\n    return this.#worker.createEIP712({\n      chainId,\n      publicKey,\n      contractAddresses,\n      startTimestamp,\n      durationDays,\n    });\n  }\n\n  /**\n   * Encrypt values for use in smart contract calls.\n   * Each value must specify its FHE type (ebool, euint8–256, eaddress).\n   */\n  async encrypt(params: EncryptParams): Promise<EncryptResult> {\n    const { values, contractAddress, userAddress } = params;\n    await this.ensureInit();\n    const chainId = this.chain.id;\n\n    return withRetry(async () => {\n      await this.#refreshCsrfToken();\n      const result = await this.#worker.encrypt({ chainId, values, contractAddress, userAddress });\n      return {\n        encryptedValues: result.handles.map((handle) => toHex(handle)),\n        inputProof: toHex(result.inputProof),\n      };\n    });\n  }\n\n  /**\n   * Decrypt ciphertexts using user's private key.\n   * Requires a valid EIP712 signature.\n   */\n  async userDecrypt(\n    params: UserDecryptParams,\n  ): Promise<Readonly<Record<EncryptedValue, ClearValue>>> {\n    await this.ensureInit();\n    const chainId = this.chain.id;\n    return withRetry(async () => {\n      await this.#refreshCsrfToken();\n      const result = await this.#worker.userDecrypt({ chainId, ...params });\n      return result.clearValues;\n    });\n  }\n\n  /**\n   * Public decryption - no authorization needed.\n   * Used for publicly visible encrypted values.\n   */\n  async publicDecrypt(encryptedValues: EncryptedValue[]): Promise<PublicDecryptResult> {\n    await this.ensureInit();\n    const chainId = this.chain.id;\n    return withRetry(async () => {\n      await this.#refreshCsrfToken();\n      const result = await this.#worker.publicDecrypt({ chainId, encryptedValues });\n      return {\n        clearValues: result.clearValues,\n        abiEncodedClearValues: result.abiEncodedClearValues,\n        decryptionProof: result.decryptionProof,\n      };\n    });\n  }\n\n  /**\n   * Create EIP712 typed data for delegated user decryption authorization.\n   */\n  async createDelegatedUserDecryptEIP712(\n    publicKey: Hex,\n    contractAddresses: Address[],\n    delegatorAddress: Address,\n    startTimestamp: number,\n    durationDays = 7,\n  ): Promise<KmsDelegatedUserDecryptEIP712Type> {\n    await this.ensureInit();\n    const chainId = this.chain.id;\n    return this.#worker.createDelegatedUserDecryptEIP712({\n      chainId,\n      publicKey,\n      contractAddresses,\n      delegatorAddress,\n      startTimestamp,\n      durationDays,\n    });\n  }\n\n  /**\n   * Decrypt ciphertexts via delegation.\n   * Requires a valid EIP712 signature from the delegator.\n   */\n  async delegatedUserDecrypt(\n    params: DelegatedUserDecryptParams,\n  ): Promise<Readonly<Record<EncryptedValue, ClearValue>>> {\n    await this.ensureInit();\n    const chainId = this.chain.id;\n    return withRetry(async () => {\n      await this.#refreshCsrfToken();\n      const result = await this.#worker.delegatedUserDecrypt({ chainId, ...params });\n      return result.clearValues;\n    });\n  }\n\n  /**\n   * Submit a ZK proof to the relayer for verification.\n   */\n  async requestZKProofVerification(zkProof: ZKProofLike): Promise<InputProofBytesType> {\n    await this.ensureInit();\n    const chainId = this.chain.id;\n    return withRetry(async () => {\n      await this.#refreshCsrfToken();\n      return this.#worker.requestZKProofVerification({ chainId, zkProof });\n    });\n  }\n\n  /**\n   * Fetch the network's FHE encryption key (ID + bytes).\n   * When storage is configured, the result is cached persistently.\n   */\n  async fetchFheEncryptionKeyBytes(): Promise<FheEncryptionKey | null> {\n    await this.ensureInit();\n    const chainId = this.chain.id;\n    const artifactCache = this.#getArtifactCache();\n    return artifactCache.fetchFheEncryptionKeyBytes(\n      async () => (await this.#worker.getPublicKey({ chainId })).result,\n    );\n  }\n\n  /**\n   * Get public parameters for encryption capacity.\n   * When storage is configured, the result is cached persistently.\n   */\n  async getPublicParams(bits: number): Promise<PublicParamsData | null> {\n    await this.ensureInit();\n    const chainId = this.chain.id;\n    const artifactCache = this.#getArtifactCache();\n    return artifactCache.getPublicParams(\n      bits,\n      async () => (await this.#worker.getPublicParams({ chainId, bits })).result,\n    );\n  }\n}\n","import { assertFunctionProp, assertObject, assertStringProp } from \"../utils/assertions\";\n\n/**\n * Subset of the WebExtensions `runtime` API used by the SDK.\n * @see https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime\n */\nexport interface BrowserExtensionRuntime {\n  /** The ID of the extension. */\n  id: string;\n  /** Convert a relative path within the extension to a fully-qualified URL. */\n  getURL: (path: string) => string;\n}\n\nfunction isValidRuntime(runtime: unknown): runtime is BrowserExtensionRuntime {\n  try {\n    assertObject(runtime, \"runtime\");\n    assertStringProp(runtime, \"id\", \"runtime.id\");\n    assertFunctionProp<\"getURL\", (path: string) => string>(runtime, \"getURL\", \"runtime.getURL\");\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Return the browser extension runtime object, or `undefined` outside extensions.\n * Works across Chrome/Edge (`chrome.runtime`) and Firefox/Safari (`browser.runtime`).\n * Extensions have restricted CSP that blocks `blob:` URLs, so callers use\n * this to detect the environment and resolve file URLs via `runtime.getURL`.\n */\nexport function getBrowserExtensionRuntime(): BrowserExtensionRuntime | undefined {\n  const g = globalThis as unknown as Record<string, unknown>;\n  for (const ns of [g.chrome, g.browser]) {\n    try {\n      assertObject(ns, \"ns\");\n      if (isValidRuntime(ns.runtime)) {\n        return ns.runtime;\n      }\n    } catch {\n      continue;\n    }\n  }\n  return undefined;\n}\n","import type { FheChain } from \"../chains/types\";\nimport type {\n  GenericLogger,\n  UpdateCsrfResponseData,\n  WorkerEnv,\n  WorkerRequest,\n  WorkerRequestType,\n  WorkerResponse,\n} from \"./worker.types\";\nimport { BaseWorkerClient } from \"./worker.base-client\";\nimport type { WorkerClientTimeoutConfig } from \"./worker.base-client\";\nimport { getBrowserExtensionRuntime } from \"./browser-extension\";\nimport { default as workerCode, filename as workerFilename } from \"./relayer-sdk.worker.ts?iife\";\n\n/** Configuration for the worker client */\nexport interface WorkerClientConfig extends WorkerClientTimeoutConfig {\n  cdnUrl: string;\n  chains: FheChain[];\n  csrfToken: string;\n  /** Expected SHA-384 hex digest of the CDN bundle for integrity verification. */\n  integrity?: string;\n  /** SDK-wide logger for tracing worker request lifecycle. */\n  logger: GenericLogger;\n  /** Number of WASM threads for parallel FHE operations (passed to `initSDK({ thread })`). */\n  thread?: number;\n}\n\n/**\n * Client for communicating with the RelayerSDK Web Worker.\n * Provides a promise-based API for FHE operations.\n */\nexport class RelayerWorkerClient extends BaseWorkerClient<Worker, WorkerClientConfig> {\n  protected readonly env: WorkerEnv = \"web\";\n\n  constructor(config: WorkerClientConfig) {\n    // Recycling (terminate + re-init) is a Node pool recovery: there a hung\n    // worker keeps attracting least-connections work, cascading timeouts. The\n    // browser runs a single worker with no such pool, and `web()` exposes no\n    // timeout knobs, so a timeout here stays a typed reject without tearing\n    // down the worker. Force it off after the spread so the browser worker is\n    // never recycled, regardless of config.\n    super({ workerLabel: \"web-worker\", ...config, recycleWorkerOnTimeout: false }, config.logger);\n  }\n\n  protected createWorker(): Worker {\n    const runtime = getBrowserExtensionRuntime();\n    if (runtime) {\n      return new Worker(runtime.getURL(workerFilename));\n    }\n    const blobUrl = URL.createObjectURL(new Blob([workerCode], { type: \"application/javascript\" }));\n    try {\n      return new Worker(blobUrl);\n    } finally {\n      URL.revokeObjectURL(blobUrl);\n    }\n  }\n\n  protected wireEvents(worker: Worker): void {\n    worker.onmessage = (event: MessageEvent<WorkerResponse<unknown>>) =>\n      this.handleResponse(event.data);\n    worker.onerror = (event: ErrorEvent) => this.handleWorkerError(event.message);\n    worker.onmessageerror = () => this.handleWorkerMessageError();\n  }\n\n  protected postMessage(worker: Worker, request: WorkerRequest): void {\n    worker.postMessage(request);\n  }\n\n  protected terminateWorker(worker: Worker): void {\n    worker.terminate();\n  }\n\n  protected generateRequestId(): string {\n    return crypto.randomUUID();\n  }\n\n  protected getInitPayload(): { type: WorkerRequestType; payload: WorkerRequest[\"payload\"] } {\n    // Explicitly construct the payload from serializable fields only.\n    // Functions (e.g. `logger`) cannot be cloned by the structured clone\n    // algorithm used by `worker.postMessage()`.\n    const { cdnUrl, chains, csrfToken, integrity, thread } = this.config;\n    return {\n      type: \"INIT\",\n      payload: { env: \"web\" as const, cdnUrl, chains, csrfToken, integrity, thread },\n    };\n  }\n\n  /**\n   * Update the CSRF token in the worker.\n   * Call this before making authenticated requests to ensure the token is fresh.\n   */\n  async updateCsrf(csrfToken: string): Promise<void> {\n    await this.sendRequest<UpdateCsrfResponseData>(\"UPDATE_CSRF\", { csrfToken });\n  }\n}\n","import { z } from \"zod/mini\";\nimport { CDN_INTEGRITY, CDN_URL, RelayerWeb } from \"../relayer/relayer-web\";\nimport { parseConfiguration } from \"../validation\";\nimport { RelayerWorkerClient } from \"../worker/worker.client\";\nimport type { WebRelayerConfig, WebRelayerOptions } from \"./types\";\n\nconst WebRelayerOptionsSchema = z.object({\n  threads: z.optional(z.int().check(z.positive())),\n  fheArtifactCacheTTL: z.optional(z.int().check(z.nonnegative())),\n});\n\n/**\n * Browser relayer — routes to RelayerWeb (Web Worker + WASM).\n *\n * @param options - Worker options (threads, security, logger, storage).\n *\n * @example\n * ```ts\n * relayers: {\n *   [sepolia.id]: web(),\n *   [mainnet.id]: web({ threads: 4 }),\n * }\n * ```\n */\nexport function web(options?: WebRelayerOptions): WebRelayerConfig {\n  if (options !== undefined) {\n    parseConfiguration(WebRelayerOptionsSchema, options);\n  }\n  return {\n    type: \"web\",\n    createWorker: (chains, logger) =>\n      new RelayerWorkerClient({\n        cdnUrl: CDN_URL,\n        chains,\n        csrfToken: options?.security?.getCsrfToken?.() ?? \"\",\n        integrity: options?.security?.integrityCheck === false ? undefined : CDN_INTEGRITY,\n        logger,\n        thread: options?.threads,\n      }),\n    createRelayer: (chain, worker, logger) => new RelayerWeb({ chain, worker, ...options, logger }),\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/config/web.ts"],"sourcesContent":["import { FhevmRelayer } from \"../relayer/fhevm-relayer\";\nimport type { RelayerOptions } from \"../relayer/types\";\nimport type { WebRelayerConfig } from \"./types\";\n\n/**\n * Browser relayer — drives `@fhevm/sdk` via {@link FhevmRelayer}.\n *\n * @example\n * ```ts\n * relayers: {\n *   [sepolia.id]: web({ timeout: 5 * 60_000 }),\n *   [mainnet.id]: web({ batchRpcCalls: true }),\n * }\n * ```\n */\nexport function web(options?: RelayerOptions): WebRelayerConfig {\n  return { type: \"web\", createRelayer: (chain) => new FhevmRelayer({ chain, options }) };\n}\n"],"mappings":"iDAeA,SAAgB,EAAI,EAA4C,CAC9D,MAAO,CAAE,KAAM,MAAO,cAAgB,GAAU,IAAI,EAAa,CAAE,QAAO,SAAQ,CAAC,CAAE,CACvF"}