@heliuslabs/zolana-web-prover 0.2.0-alpha → 0.3.0-alpha

package/dist/index.js

@@ -1,909 +1,5 @@
-//#region src/key-digests.ts
-/** The pinned key set's version folder on the proving-keys CDN. */
-var KEY_SET = "3a1c88f90f609eb1";
-/** Where the pinned key set is served from; the default `keyBaseUrl`. */
-var KEY_BASE_URL = "https://d3gbdb0egjwcw9.cloudfront.net/proving-keys/3a1c88f90f609eb1/";
-/** Size and sha256 of every proving key the browser prover can load. */
-var KEY_DIGESTS = Object.freeze({
-	"merge_24_1.key": {
-		size: 173052578,
-		sha256: "a0dfaa1e73d2d9e1159d2ebab82baa6d0602482d75f24dcbff596322dc389c88"
-	},
-	"merge_54_1.key": {
-		size: 379646246,
-		sha256: "951ec83dc53d112a46a1eb9cd308e6abd933291eb3109647a479e2321fce7423"
-	},
-	"merge_8_1.key": {
-		size: 55767611,
-		sha256: "f59571876452541eaf20cfc583a082b9b6cc788bf85719bd337398b2d962ad23"
-	},
-	"transfer_confidential_1_16.key": {
-		size: 18119894,
-		sha256: "aecae052aeb709ef4656d6da110bd1403d21bc5891e60691ee9cbc0ebb46dcb9"
-	},
-	"transfer_confidential_1_2.key": {
-		size: 9268057,
-		sha256: "7ef987966b0dfba5d86eab7c67068be00dbe581d823d45cdbbf6d338bfacb640"
-	},
-	"transfer_confidential_1_4.key": {
-		size: 11320903,
-		sha256: "94bddced9e46a0e0c4fbf6bc59c6d083e1d577a60bf4d8520129f41505f4f1dd"
-	},
-	"transfer_confidential_1_8.key": {
-		size: 13695140,
-		sha256: "3471ab2908cbe15b757164db5bb7c7f82a89036c557fc26fe66a7148a4338f58"
-	},
-	"transfer_confidential_12_2.key": {
-		size: 90894233,
-		sha256: "3415363ec3ae33b730c7445aeb7850aa1bc044443e6ef8a7731e2c56fd1df6e7"
-	},
-	"transfer_confidential_12_4.key": {
-		size: 91932405,
-		sha256: "36519896a5e5b4d1ef008d6883548944027eb21ea3e6bc72ba00fde9ea9efa4a"
-	},
-	"transfer_confidential_12_8.key": {
-		size: 94355203,
-		sha256: "131973e42165b1222ecfd2692796cfb035d5aa4a08ce7bf5e545795283ee344d"
-	},
-	"transfer_confidential_16_2.key": {
-		size: 114870607,
-		sha256: "27370f44f8b9c0c05f9d2c6738ab5294582fd40c869114baf0d7fb15e6d08e2a"
-	},
-	"transfer_confidential_16_4.key": {
-		size: 115913395,
-		sha256: "7cdef518b59307d578c2eecb71e811945ee56b1906283e8c70fe0924343dfb2a"
-	},
-	"transfer_confidential_16_8.key": {
-		size: 118361316,
-		sha256: "d8052824a163d41ddf8540bc72dbfe94b5c52be21b6a0f3039b2f01f7380641f"
-	},
-	"transfer_confidential_2_16.key": {
-		size: 26327780,
-		sha256: "27ef8be4d400bb9c724f79a4928f7f6ff4dc95a970f17c365b38430267986bfd"
-	},
-	"transfer_confidential_2_2.key": {
-		size: 16407295,
-		sha256: "e810d52962f4558b0bd50b768a89490759e15a0623d4c2c43318f541b8cc61ff"
-	},
-	"transfer_confidential_2_4.key": {
-		size: 17416909,
-		sha256: "c93338402cdc8fd8ec2f70f2de9fa29ee3e35b064ca803f8ad4d18070e4861fe"
-	},
-	"transfer_confidential_2_8.key": {
-		size: 21887446,
-		sha256: "a38085e7a38b725909e7fe81be544c6e5a1b4ec3561cc07f941eac15825c578a"
-	},
-	"transfer_confidential_24_2.key": {
-		size: 179892108,
-		sha256: "7b98beac6e0f89d568a30f569c690267bc37fcb8472ad88c292b89433c2f91d9"
-	},
-	"transfer_confidential_24_4.key": {
-		size: 180955692,
-		sha256: "4e3c664a197a7b2cc5616b7c01dc463e92fa666f2990ee42ceb2d7ae81f1ece4"
-	},
-	"transfer_confidential_3_2.key": {
-		size: 24424541,
-		sha256: "0537e6669e6dae3304648bd427bf3f9ec3e5aaa66134d15e0ff142794f2e966b"
-	},
-	"transfer_confidential_3_4.key": {
-		size: 25433887,
-		sha256: "4710053ed9a08908c419ede4c9a3138d9f78e6d185c6846a2a9c2f4f846c0d4d"
-	},
-	"transfer_confidential_3_8.key": {
-		size: 27804471,
-		sha256: "e559f7256c67be5dc857f601b22c0e929ba615f91032da09db32c00cd98255d1"
-	},
-	"transfer_confidential_32_2.key": {
-		size: 228023589,
-		sha256: "70f4a61a248d240ca6b20730e6ab8a88acb9f4153c1e4688f6861bf6339a5a0b"
-	},
-	"transfer_confidential_4_16.key": {
-		size: 38204323,
-		sha256: "917cf5f0976d245b08756b1147e04a1f0924c5f5b800d57bd57d305b43e8f432"
-	},
-	"transfer_confidential_4_2.key": {
-		size: 30346432,
-		sha256: "aea0c474e4c67499c45f11f30d2d03e53ee5dd7c6b7940a0f61cfefa2e61e38e"
-	},
-	"transfer_confidential_4_4.key": {
-		size: 31361454,
-		sha256: "6d83eef0b16f03b8f2b2a469441d67264bc34932d8b261f344f5bb39f29a1fbe"
-	},
-	"transfer_confidential_4_8.key": {
-		size: 33727897,
-		sha256: "27fe418512ee0be5cb2f82290eab4ab20ed2d32549e1d8d7bfa1fa5b45df62e9"
-	},
-	"transfer_confidential_40_2.key": {
-		size: 275193373,
-		sha256: "530779155340a05cbd90dedc5e94c5960cf5105f2866bdb041e3a56d06c9bb8b"
-	},
-	"transfer_confidential_48_2.key": {
-		size: 356237189,
-		sha256: "4738674f40f19233f1963954ae4f96a763d11f1adcd82b4828ca8c420cc5b049"
-	},
-	"transfer_confidential_49_2.key": {
-		size: 362114005,
-		sha256: "e39b30ba966198a03158276989d91f1b2fb05f695e56550fec6452d8a3110b6b"
-	},
-	"transfer_confidential_5_16.key": {
-		size: 48520274,
-		sha256: "1faf95183f53bd29610ebda52703244ef63f45a2d26706e88bfd3197132bc20e"
-	},
-	"transfer_confidential_5_2.key": {
-		size: 36449879,
-		sha256: "ae6699a19d810a7e0ef663dff3fc32e0b8e4bdeae9089c583746f95ae3b0e1e9"
-	},
-	"transfer_confidential_5_4.key": {
-		size: 37464519,
-		sha256: "6779a069f3abc85f853b754ff2b58021532d26fe9642eb9ba42744da91733517"
-	},
-	"transfer_confidential_5_8.key": {
-		size: 44025900,
-		sha256: "2806aff6bc7bd34233a2ff42a42e5524c680930944c3fc84d6d58e773c033cb5"
-	},
-	"transfer_confidential_6_2.key": {
-		size: 46571502,
-		sha256: "fe62dff0397662cb25d89ac9de976cc3d23adfd2b7a72f5f8ad8671d677da605"
-	},
-	"transfer_confidential_6_4.key": {
-		size: 47591772,
-		sha256: "116a3d4030047d182eedcc9effa66dd9c66ed9bd3ad9d82c2242dc47eef1f244"
-	},
-	"transfer_confidential_6_8.key": {
-		size: 49957349,
-		sha256: "79281967e4aac47dc187d3a6555ab54800cef3928e5696969dcf4afb69b339da"
-	},
-	"transfer_confidential_8_16.key": {
-		size: 66535995,
-		sha256: "8adc64d3886619e3b8e65b3b0c98eaac61bfdfbc8a51aa6ba05166b853feb328"
-	},
-	"transfer_confidential_8_2.key": {
-		size: 58604067,
-		sha256: "24250fd74a86f1a07847e9dbb769cf9b2bebf20d29f18018186ea7900f69bbe4"
-	},
-	"transfer_confidential_8_4.key": {
-		size: 59617404,
-		sha256: "82975fe1145c827a76f8b76e229bb9c8501f993b1a4f7709446b7717f30bd07a"
-	},
-	"transfer_confidential_8_8.key": {
-		size: 62007104,
-		sha256: "f8972d03f57baef87702aaddb87a3b831d2377723e930fb25675fe3e473d8aec"
-	}
-});
-//#endregion
-//#region src/shapes.ts
-/**
-* The transfer circuit shapes and the proving keys that back them.
-*
-* The shape list mirrors `SPP_SUPPORTED_SHAPES` in the SDK, `SupportedShapes` in
-* `prover-test/spp/protocol/shape.go`, and the on-chain verifier -- cheapest
-* first, so the order doubles as the smallest-fit search order.
-*
-* Key sizes come from `key-digests.ts`, generated from `proving-keys.lock`, which
-* is also what a downloaded key is validated against.
-*/
-function pinnedSize(keyFile) {
-	const digest = KEY_DIGESTS[keyFile];
-	if (digest === void 0) throw new Error(`${keyFile} is not in the pinned key set`);
-	return digest.size;
-}
-function entry(inputs, outputs) {
-	const keyFile = `transfer_confidential_${String(inputs)}_${String(outputs)}.key`;
-	return Object.freeze({
-		inputs,
-		outputs,
-		label: `${String(inputs)}x${String(outputs)}`,
-		keyFile,
-		keyBytes: pinnedSize(keyFile)
-	});
-}
-/** Confidential (default transact) rail only, ring rail keys are out of scope. */
-var TRANSFER_SHAPES = Object.freeze([
-	entry(1, 2),
-	entry(1, 4),
-	entry(1, 8),
-	entry(2, 2),
-	entry(2, 4),
-	entry(1, 16),
-	entry(2, 8),
-	entry(3, 2),
-	entry(3, 4),
-	entry(2, 16),
-	entry(3, 8),
-	entry(4, 2),
-	entry(4, 4),
-	entry(4, 8),
-	entry(5, 2),
-	entry(5, 4),
-	entry(4, 16),
-	entry(5, 8),
-	entry(6, 2),
-	entry(6, 4),
-	entry(5, 16),
-	entry(6, 8),
-	entry(8, 2),
-	entry(8, 4),
-	entry(8, 8),
-	entry(8, 16),
-	entry(12, 2),
-	entry(12, 4),
-	entry(12, 8),
-	entry(16, 2),
-	entry(16, 4),
-	entry(16, 8),
-	entry(24, 2),
-	entry(24, 4),
-	entry(32, 2),
-	entry(40, 2),
-	entry(48, 2),
-	entry(49, 2)
-]);
-function mergeEntry(inputs) {
-	const keyFile = `merge_${String(inputs)}_1.key`;
-	return Object.freeze({
-		inputs,
-		outputs: 1,
-		label: `merge ${String(inputs)}x1`,
-		keyFile,
-		keyBytes: pinnedSize(keyFile)
-	});
-}
-/** The smallest merge circuit. */
-var MERGE_SHAPE = mergeEntry(8);
-/** The merge circuits, by input count, mirroring `SupportedInputCounts` in `spp_merge/shared`. */
-var MERGE_SHAPES = Object.freeze([
-	MERGE_SHAPE,
-	mergeEntry(24),
-	mergeEntry(54)
-]);
-var MERGE_KEY_FILE = MERGE_SHAPE.keyFile;
-var MERGE_KEY_BYTES = MERGE_SHAPE.keyBytes;
-/**
-* The proving key a `/prove` request needs, resolved from the request itself
-* rather than guessed ahead of time.
-*
-* The protocol derives the shape from the real input/output counts with a
-* smallest-fit rule, so a caller cannot reliably predict which key a given
-* transfer will use; reading it off the request is the only way to be right.
-* Mirrors the server's LazyKeyManager cache key.
-*/
-function keyForProveRequest(circuitType, inputs, outputs) {
-	if (circuitType === "merge") return MERGE_SHAPES.find((shape) => shape.inputs === inputs && shape.outputs === outputs);
-	if (circuitType !== "transfer-confidential") return void 0;
-	return TRANSFER_SHAPES.find((shape) => shape.inputs === inputs && shape.outputs === outputs);
-}
-/** Smallest shape that holds `inputs`/`outputs`, matching `CanonicalShape`. */
-function canonicalShape(inputs, outputs) {
-	const found = TRANSFER_SHAPES.find((shape) => inputs <= shape.inputs && outputs <= shape.outputs);
-	if (found === void 0) throw new Error(`no supported shape holds ${String(inputs)}x${String(outputs)}`);
-	return found;
-}
-function shapeByLabel(label) {
-	const found = TRANSFER_SHAPES.find((shape) => shape.label === label);
-	if (found === void 0) throw new Error(`unknown shape ${label}`);
-	return found;
-}
-function formatBytes(bytes) {
-	if (bytes < 1024) return `${String(bytes)} B`;
-	if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
-	return `${(bytes / 1048576).toFixed(1)} MB`;
-}
-//#endregion
-//#region src/abortable.ts
-/** Race work against cancellation even when an I/O implementation ignores signals. */
-function abortable(work, signal) {
-	if (signal === void 0) return work;
-	return new Promise((resolve, reject) => {
-		const abort = () => reject(signal.reason);
-		const cleanup = () => signal.removeEventListener("abort", abort);
-		work.then((value) => {
-			cleanup();
-			if (signal.aborted) reject(signal.reason);
-			else resolve(value);
-		}, (error) => {
-			cleanup();
-			reject(signal.aborted ? signal.reason : error);
-		});
-		if (signal.aborted) abort();
-		else signal.addEventListener("abort", abort, { once: true });
-	});
-}
-//#endregion
-//#region src/errors.ts
-var messages = {
-	wasm_prover_error: "Prover operation failed",
-	wasm_init_failed: "Prover initialization failed; check runtime assets, threads and isolation headers",
-	wasm_worker_failed: "Prover worker failed",
-	wasm_worker_not_started: "Prover worker is not started",
-	wasm_worker_terminated: "Prover worker terminated",
-	wasm_invalid_response: "Invalid prover response",
-	wasm_invalid_request: "Unsupported circuit or malformed request",
-	wasm_key_manifest_error: "The proving key is not in the pinned key set",
-	wasm_key_download_failed: "Proving-key download failed",
-	wasm_key_digest_mismatch: "Proving key does not match the lockfile; stage the pinned assets",
-	wasm_key_load_failed: "Proving-key loading failed",
-	wasm_prove_failed: "Proof generation failed",
-	wasm_verify_failed: "Native gnark verification rejected the proof"
-};
-var WasmProverError = class extends Error {
-	code;
-	constructor(code = "wasm_prover_error") {
-		const safeCode = Object.hasOwn(messages, code) ? code : "wasm_prover_error";
-		super(messages[safeCode]);
-		this.name = "WasmProverError";
-		this.code = safeCode;
-	}
-};
-function operationError(kind) {
-	switch (kind) {
-		case "init": return new WasmProverError("wasm_init_failed");
-		case "loadKey": return new WasmProverError("wasm_key_load_failed");
-		case "prove": return new WasmProverError("wasm_prove_failed");
-		case "verify": return new WasmProverError("wasm_verify_failed");
-		default: return new WasmProverError("wasm_worker_failed");
-	}
-}
-//#endregion
-//#region src/proving-threads.ts
-/**
-* Starting point for the arithmetic pool, using the browser's available logical
-* processors. Cap large machines at the 18-worker configuration benchmarked by
-* this demo. This is a default, not a measurement of the fastest pool size.
-*/
-function automaticProvingThreads(reported = globalThis.navigator?.hardwareConcurrency) {
-	if (reported === void 0 || !Number.isFinite(reported) || reported < 1) return 4;
-	return Math.min(18, Math.floor(reported));
-}
-//#endregion
-//#region src/proof-requests.ts
-/** How `url` addresses the prover at `proverUrl`; undefined if it is not a proving route. */
-function proveRoute(url, proverUrl) {
-	const endpoint = new URL(proverUrl);
-	const prove = `${endpoint.pathname.replace(/\/+$/u, "")}/prove`;
-	if (url.origin !== endpoint.origin) return void 0;
-	if (url.pathname === prove) return { kind: "prove" };
-	if (!url.pathname.startsWith(`${prove}/`)) return void 0;
-	const key = url.pathname.slice(prove.length + 1);
-	return /^[a-z0-9_-]+_\d+_\d+$/u.test(key) ? {
-		kind: "prove",
-		keyFile: `${key}.key`
-	} : { kind: "unsupported" };
-}
-/** Observe only public circuit metadata; never retain the witness body. */
-function observeProofRequests(fetch, proverUrl, onShape) {
-	return async (input, init) => {
-		if (proveRoute(new URL(input instanceof Request ? input.url : String(input)), proverUrl)?.kind === "prove") {
-			const signal = init?.signal !== void 0 ? init.signal ?? void 0 : input instanceof Request ? input.signal : void 0;
-			signal?.throwIfAborted();
-			const body = typeof init?.body === "string" ? init.body : input instanceof Request ? await abortable(input.clone().text(), signal) : void 0;
-			if (body !== void 0) {
-				const shape = proofRequestShape(body);
-				if (shape !== void 0) onShape(shape);
-			}
-		}
-		return fetch(input, init);
-	};
-}
-function proofRequestShape(body) {
-	try {
-		const parsed = JSON.parse(body);
-		if (typeof parsed !== "object" || parsed === null || !("circuitType" in parsed) || typeof parsed.circuitType !== "string") return void 0;
-		if (parsed.circuitType === "merge") {
-			if (!("inputs" in parsed) || !Array.isArray(parsed.inputs)) return void 0;
-			return keyForProveRequest(parsed.circuitType, parsed.inputs.length, 1);
-		}
-		if (!("nInputs" in parsed) || !("nOutputs" in parsed) || typeof parsed.nInputs !== "number" || typeof parsed.nOutputs !== "number") return void 0;
-		return keyForProveRequest(parsed.circuitType, parsed.nInputs, parsed.nOutputs);
-	} catch {
-		return;
-	}
-}
-//#endregion
-//#region src/wasm-prover.ts
-/**
-* Local proving in the browser, wired into the SDK without patching it.
-*
-* `ProverClient` takes an injectable `fetch`, and the wasm module's `prove`
-* accepts and returns exactly the JSON a `POST /prove/<key>` exchange uses (it mirrors
-* `server.processProofSync`). So the whole integration is a `fetch` that
-* recognizes the prover URL and answers it from wasm instead of the network.
-* Everything else -- indexer calls, Solana RPC -- falls through untouched.
-*
-* Mopro supplies the threaded Rust arithmetic kernel; Zolana retains its
-* native witness and proof formats.
-*/
-/**
-* Owns the worker, the key cache, and the `fetch` shim.
-*
-* Proving keys are cached in the Cache API rather than memory: they are 9-380 MB
-* each and immutable (the lockfile pins their sha256 and the CloudFront prefix
-* is version-hashed), so re-downloading one per page load is pure waste. After
-* a shape's first load the cache keeps the bridge's raw re-encoding instead of
-* the pinned file: the pinned file's compressed points take about 240 ms per MB
-* to decompress in wasm on every load, and the raw form skips that.
-*/
-var WasmProver = class {
-	#worker;
-	#factory;
-	#initialization;
-	#lifetime = new AbortController();
-	/** The encoding of the raw keys the started worker's bridge exports and accepts. */
-	#rawKeyFormat = "";
-	#cachePrepared = false;
-	#nextId = 1;
-	#queue = Promise.resolve();
-	#threads = 0;
-	get threads() {
-		return this.#threads;
-	}
-	#enqueue(operation, external) {
-		const lifetime = this.#lifetime.signal;
-		const signal = external === void 0 ? lifetime : AbortSignal.any([lifetime, external]);
-		const next = this.#queue.then(async () => {
-			signal.throwIfAborted();
-			const abort = () => {
-				if (!lifetime.aborted) this.#fail(signal.reason);
-			};
-			signal.addEventListener("abort", abort, { once: true });
-			try {
-				return await abortable(operation(signal), signal);
-			} finally {
-				signal.removeEventListener("abort", abort);
-			}
-		});
-		this.#queue = next.catch(() => {});
-		return abortable(next, signal);
-	}
-	#pending = /* @__PURE__ */ new Map();
-	#loaded = /* @__PURE__ */ new Set();
-	#options;
-	#fetch;
-	constructor(options) {
-		this.#options = options;
-		this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-		this.#factory = options.workerFactory ?? createProverWorker;
-	}
-	/**
-	* Starts the worker and instantiates the module.
-	*
-	* The module must run in a worker: Go's js/wasm runtime shares the thread it
-	* is instantiated on, and `groth16.Prove` blocks for seconds, so on the main
-	* thread it would freeze the page for the whole proof.
-	*/
-	start(source = this.#factory) {
-		if (this.#initialization !== void 0) return this.#initialization;
-		if (source === void 0) return Promise.reject(new WasmProverError("wasm_worker_not_started"));
-		this.#factory = typeof source === "function" ? source : void 0;
-		let worker;
-		try {
-			worker = typeof source === "function" ? source() : source;
-		} catch {
-			return Promise.reject(new WasmProverError("wasm_init_failed"));
-		}
-		this.#worker = worker;
-		worker.addEventListener("message", (event) => {
-			if (this.#worker !== worker) return;
-			const response = event.data;
-			if ("fatal" in response) {
-				this.#fail(new WasmProverError("wasm_worker_failed"));
-				return;
-			}
-			const pending = this.#pending.get(response.id);
-			if (pending === void 0) return;
-			this.#pending.delete(response.id);
-			pending.resolve(response);
-		});
-		worker.addEventListener("error", (event) => {
-			event.preventDefault();
-			if (this.#worker !== worker) return;
-			this.#fail(new WasmProverError("wasm_worker_failed"));
-		});
-		worker.addEventListener("messageerror", () => {
-			if (this.#worker === worker) this.#fail(new WasmProverError("wasm_invalid_response"));
-		});
-		const initialization = this.#call({
-			kind: "init",
-			wasmUrl: this.#options.wasmUrl,
-			threads: this.#options.threads ?? automaticProvingThreads()
-		}).then((ready) => {
-			if (this.#worker !== worker) throw new WasmProverError("wasm_worker_terminated");
-			const value = ready.value;
-			if (typeof value !== "object" || value === null || !("threads" in value) || typeof value.threads !== "number" || !("rawKeyFormat" in value) || typeof value.rawKeyFormat !== "string") throw new WasmProverError("wasm_invalid_response");
-			this.#threads = value.threads;
-			this.#rawKeyFormat = value.rawKeyFormat;
-		}).catch((error) => {
-			if (this.#worker === worker || this.#initialization === initialization) this.#fail(error);
-			throw error;
-		});
-		this.#initialization = initialization;
-		return initialization;
-	}
-	async #ensureStarted(signal) {
-		signal.throwIfAborted();
-		if (this.#initialization !== void 0) await abortable(this.#initialization, signal);
-		else if (this.#factory !== void 0) await abortable(this.start(this.#factory), signal);
-		else throw new WasmProverError("wasm_worker_not_started");
-		signal.throwIfAborted();
-	}
-	/** Downloads (or reads from cache) and deserializes one shape's proving key. */
-	async ensureKey(shape, signal) {
-		return this.#enqueue((active) => this.#loadKey(shape, active), signal);
-	}
-	/**
-	* Downloads, checks and decodes `shapes` ahead of the proofs that need them, so
-	* a first proof doesn't wait seconds for its key. With the Cache API each
-	* shape's decoded form is kept and later loads take a fraction of a second;
-	* shapes already kept are skipped. Each shape is queued on its own, so a proof
-	* requested meanwhile runs after the shape in progress. Aborting skips the
-	* remaining shapes; aborting the one in progress restarts the worker. Without
-	* the Cache API only the last shape stays loaded.
-	*/
-	async prefetch(options) {
-		for (const shape of options.shapes) await this.#enqueue(async (active) => {
-			if (!await this.#rawKeyKept(shape, active)) await this.#loadKey(shape, active, options.onProgress);
-		}, options.signal);
-	}
-	/** Whether the cache holds this shape's raw form; the bytes are checked when loaded. */
-	async #rawKeyKept(shape, signal) {
-		await this.#ensureStarted(signal);
-		const expected = KEY_DIGESTS[shape.keyFile];
-		const cache = await this.#openKeyCache(signal);
-		if (expected === void 0 || cache === void 0) return false;
-		const url = this.#keyUrl(shape);
-		const hit = await optionalCache(() => cache.match(rawKeyUrl(url)), signal);
-		return hit?.headers.get(rawSourceHeader) === expected.sha256 && hit.headers.get(rawFormatHeader) === this.#rawKeyFormat;
-	}
-	async #loadKey(shape, signal, onProgress) {
-		await this.#ensureStarted(signal);
-		if (this.#loaded.has(shape.keyFile)) {
-			this.#options.onMeasurement?.({
-				step: "key-load",
-				ms: 0,
-				bytes: shape.keyBytes,
-				note: `${shape.keyFile} already deserialized in this instance`
-			});
-			return;
-		}
-		const url = this.#keyUrl(shape);
-		const expected = KEY_DIGESTS[shape.keyFile];
-		if (expected === void 0) throw new WasmProverError("wasm_key_manifest_error");
-		const cache = await this.#openKeyCache(signal);
-		const progress = (stage, loaded) => {
-			const update = {
-				keyFile: shape.keyFile,
-				stage,
-				loaded,
-				total: expected.size
-			};
-			this.#options.onKeyProgress?.(update);
-			onProgress?.(update);
-		};
-		const downloaded = this.#options.onKeyProgress === void 0 && onProgress === void 0 ? void 0 : (loaded) => progress("download", loaded);
-		const started = performance.now();
-		let key = await this.#cachedRawKey(cache, url, expected, signal) ?? await this.#pinnedKey(cache, url, expected, signal, downloaded);
-		signal.throwIfAborted();
-		this.#options.onMeasurement?.({
-			step: "key-fetch",
-			ms: performance.now() - started,
-			bytes: key.bytes.byteLength,
-			note: `${shape.keyFile} from ${key.raw ? "the raw-key cache" : key.source}`
-		});
-		signal.throwIfAborted();
-		this.#loaded.clear();
-		progress("decode", expected.size);
-		let response;
-		try {
-			response = await this.#installKey(shape, key, expected, cache);
-		} catch (error) {
-			if (!key.raw) throw error;
-			signal.throwIfAborted();
-			await optionalCache(() => cache?.delete(rawKeyUrl(url)), signal);
-			key = await this.#pinnedKey(cache, url, expected, signal, downloaded);
-			signal.throwIfAborted();
-			response = await this.#installKey(shape, key, expected, cache);
-		}
-		signal.throwIfAborted();
-		const info = response.value;
-		this.#options.onMeasurement?.({
-			step: "key-load",
-			ms: response.ms,
-			bytes: shape.keyBytes,
-			note: info?.nbPublic === void 0 ? shape.keyFile : `${shape.keyFile} as ${String(info.key)} nbPublic=${String(info.nbPublic)} nbSecret=${String(info.nbSecret)}`
-		});
-		signal.throwIfAborted();
-		const raw = info?.raw;
-		if (cache !== void 0 && raw instanceof Uint8Array && raw.buffer instanceof ArrayBuffer) await this.#storeRawKey(cache, url, expected, new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength), signal);
-		this.#loaded.clear();
-		this.#loaded.add(shape.keyFile);
-	}
-	#keyUrl(shape) {
-		return `${(this.#options.keyBaseUrl ?? "https://d3gbdb0egjwcw9.cloudfront.net/proving-keys/3a1c88f90f609eb1/").replace(/\/+$/u, "")}/${shape.keyFile}`;
-	}
-	/**
-	* Opens this key set's cache. The first call also deletes the stores of other
-	* key sets, so a rotation frees its keys at once, and asks for persistence
-	* when the caller opted in.
-	*/
-	async #openKeyCache(signal) {
-		if (!this.#cachePrepared) {
-			this.#cachePrepared = true;
-			const names = await optionalCache(() => globalThis.caches?.keys(), signal);
-			for (const name of names ?? []) if (name.startsWith(keyCachePrefix) && name !== keyCacheName) await optionalCache(() => globalThis.caches?.delete(name), signal);
-			if (this.#options.persistStorage === true) await optionalCache(() => globalThis.navigator?.storage?.persist(), signal);
-		}
-		return optionalCache(() => globalThis.caches?.open(keyCacheName), signal);
-	}
-	#installKey(shape, key, expected, cache) {
-		const exportRaw = !key.raw && cache !== void 0;
-		return this.#call({
-			kind: "loadKey",
-			fileName: shape.keyFile,
-			key: key.bytes,
-			sha256: expected.sha256,
-			exportRaw
-		}, [key.bytes]);
-	}
-	/**
-	* The raw re-encoding cached by an earlier load, if it was derived from this
-	* pinned key by a bridge writing the same format and is intact.
-	*/
-	async #cachedRawKey(cache, url, expected, signal) {
-		if (cache === void 0) return void 0;
-		const hit = await optionalCache(() => cache.match(rawKeyUrl(url)), signal);
-		if (hit === void 0) return void 0;
-		const digest = hit.headers.get(rawDigestHeader);
-		if (hit.headers.get(rawSourceHeader) === expected.sha256 && hit.headers.get(rawFormatHeader) === this.#rawKeyFormat && digest !== null) {
-			const bytes = await optionalCache(() => hit.arrayBuffer(), signal);
-			if (bytes !== void 0 && await abortable(sha256Hex(bytes), signal) === digest) return {
-				bytes,
-				raw: true,
-				source: "cache"
-			};
-		}
-		await optionalCache(() => cache.delete(rawKeyUrl(url)), signal);
-	}
-	async #pinnedKey(cache, url, expected, signal, downloaded) {
-		if (cache !== void 0) {
-			const hit = await optionalCache(() => cache.match(url), signal);
-			if (hit !== void 0) {
-				const cached = await optionalCache(() => hit.arrayBuffer(), signal);
-				if (cached !== void 0 && await abortable(matchesDigest(cached, expected), signal)) return {
-					bytes: cached,
-					raw: false,
-					source: "cache"
-				};
-				await optionalCache(() => cache.delete(url), signal);
-			}
-		}
-		const response = await abortable(this.#fetch(url, { signal }), signal);
-		if (!response.ok) throw new WasmProverError("wasm_key_download_failed");
-		const bytes = await abortable(readKey(response, expected.size, downloaded), signal);
-		if (!await abortable(matchesDigest(bytes, expected), signal)) throw new WasmProverError("wasm_key_digest_mismatch");
-		if (cache !== void 0) await optionalCache(() => cache.put(url, new Response(bytes.slice(0))), signal);
-		return {
-			bytes,
-			raw: false,
-			source: "network"
-		};
-	}
-	/** Keeps the raw form in place of the pinned file, which is no longer read. */
-	async #storeRawKey(cache, url, expected, raw, signal) {
-		const digest = await abortable(sha256Hex(raw), signal);
-		const headers = {
-			"content-type": "application/octet-stream",
-			[rawSourceHeader]: expected.sha256,
-			[rawFormatHeader]: this.#rawKeyFormat,
-			[rawDigestHeader]: digest
-		};
-		if (await optionalCache(async () => {
-			await cache.put(rawKeyUrl(url), new Response(raw, { headers }));
-			return true;
-		}, signal) === true) await optionalCache(() => cache.delete(url), signal);
-	}
-	/**
-	* A `fetch` for `ZolanaClientConfig.fetch`. Proof requests to `/prove/<key>`
-	* are answered from wasm, other paths below `/prove` are refused, and
-	* everything else is delegated, so one shim covers the client.
-	*/
-	createFetch() {
-		return async (input, init) => {
-			const url = requestUrl(input);
-			const route = url === void 0 ? void 0 : proveRoute(url, this.#options.proverUrl);
-			if (route === void 0) return await this.#fetch(input, init);
-			const signal = init?.signal !== void 0 ? init.signal ?? void 0 : input instanceof Request ? input.signal : void 0;
-			signal?.throwIfAborted();
-			try {
-				if (route.kind === "unsupported") throw new WasmProverError("wasm_invalid_request");
-				const body = await abortable(readBody(input, init), signal);
-				if (body === void 0) throw new WasmProverError("wasm_invalid_request");
-				if (route.keyFile !== void 0 && proofRequestShape(body)?.keyFile !== route.keyFile) throw new WasmProverError("wasm_invalid_request");
-				const result = await this.proveRequest(body, signal);
-				signal?.throwIfAborted();
-				return new Response(result.proof, {
-					status: 200,
-					headers: { "content-type": "application/json" }
-				});
-			} catch (error) {
-				rethrowAbort(error, signal);
-				return proverErrorResponse(error, this.#options.onMeasurement);
-			}
-		};
-	}
-	/**
-	* Prove and verify one request locally, keeping key switching atomic.
-	* Aborting queued work leaves the active request alone. Aborting active work
-	* discards the runtime and rejects its other outstanding requests. A factory
-	* supplied to start() lets a later request initialize a fresh worker.
-	*/
-	async proveRequest(body, signal) {
-		return this.#enqueue(async (active) => {
-			const shape = proofRequestShape(body);
-			if (shape === void 0) throw new WasmProverError("wasm_invalid_request");
-			await this.#loadKey(shape, active);
-			active.throwIfAborted();
-			const response = await this.#call({
-				kind: "prove",
-				body
-			});
-			if (typeof response.value !== "string") throw new WasmProverError("wasm_invalid_response");
-			const proof = response.value;
-			active.throwIfAborted();
-			const verified = await this.#call({
-				kind: "verify",
-				body,
-				proof
-			});
-			if (typeof verified.value !== "object" || verified.value === null || !("valid" in verified.value) || verified.value.valid !== true) throw new WasmProverError("wasm_verify_failed");
-			active.throwIfAborted();
-			this.#options.onMeasurement?.({
-				step: "transfer-prove",
-				ms: response.ms,
-				note: `Mopro proof, ${String(this.#threads)} arithmetic workers; locally verified`
-			});
-			return {
-				proof,
-				proveMs: response.ms,
-				verifyMs: verified.ms
-			};
-		}, signal);
-	}
-	async loadedKeys() {
-		return this.#enqueue(async (signal) => {
-			await this.#ensureStarted(signal);
-			const value = (await this.#call({ kind: "loadedKeys" })).value;
-			if (typeof value === "object" && value !== null && "keys" in value && Array.isArray(value.keys)) return value.keys.map(String);
-			throw new WasmProverError("wasm_invalid_response");
-		});
-	}
-	terminate() {
-		this.#factory = void 0;
-		this.#fail(new WasmProverError("wasm_worker_terminated"));
-	}
-	#fail(error) {
-		this.#worker?.terminate();
-		this.#worker = void 0;
-		this.#initialization = void 0;
-		this.#threads = 0;
-		this.#loaded.clear();
-		for (const pending of this.#pending.values()) pending.reject(error);
-		this.#pending.clear();
-		const lifetime = this.#lifetime;
-		this.#lifetime = new AbortController();
-		this.#queue = Promise.resolve();
-		lifetime.abort(error);
-	}
-	async #call(request, transfer = []) {
-		const worker = this.#worker;
-		if (worker === void 0) throw new WasmProverError("wasm_worker_not_started");
-		const id = this.#nextId++;
-		const response = await new Promise((resolve, reject) => {
-			this.#pending.set(id, {
-				resolve,
-				reject
-			});
-			try {
-				worker.postMessage({
-					...request,
-					id
-				}, [...transfer]);
-			} catch {
-				this.#fail(new WasmProverError("wasm_worker_failed"));
-			}
-		});
-		if (!response.ok) throw operationError(request.kind);
-		return response;
-	}
-};
-function createProverWorker() {
-	return new Worker(new URL(
-		/* @vite-ignore */
-		new URL("assets/prover.worker-sn1Mixyo.js", import.meta.url).href,
-		"" + import.meta.url
-	), {
-		type: "module",
-		name: "zolana-web-prover"
-	});
-}
-function requestUrl(input) {
-	try {
-		if (typeof input === "string") return new URL(input);
-		if (input instanceof URL) return input;
-		return new URL(input.url);
-	} catch {
-		return;
-	}
-}
-async function readBody(input, init) {
-	if (typeof init?.body === "string") return init.body;
-	if (input instanceof Request) return await input.clone().text();
-}
-/** Also matches 0.1.0's single `zolana-proving-keys` store. */
-var keyCachePrefix = "zolana-proving-keys";
-var keyCacheName = `${keyCachePrefix}-${KEY_SET}`;
-var rawSourceHeader = "x-zolana-pinned-sha256";
-var rawFormatHeader = "x-zolana-raw-format";
-var rawDigestHeader = "x-zolana-raw-sha256";
-/** The Cache API ignores fragments, so the raw entry gets its own query. */
-function rawKeyUrl(url) {
-	return `${url}?zolana-key=raw`;
-}
-/** Reads a key body, reporting bytes as they arrive and stopping past the pinned size. */
-async function readKey(response, size, downloaded) {
-	const reader = downloaded === void 0 ? void 0 : response.body?.getReader();
-	if (reader === void 0) return response.arrayBuffer();
-	const bytes = new Uint8Array(size);
-	let loaded = 0;
-	for (;;) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		if (loaded + value.byteLength > size) {
-			await reader.cancel();
-			throw new WasmProverError("wasm_key_digest_mismatch");
-		}
-		bytes.set(value, loaded);
-		loaded += value.byteLength;
-		downloaded?.(loaded);
-	}
-	return loaded === size ? bytes.buffer : bytes.buffer.slice(0, loaded);
-}
-async function sha256Hex(bytes) {
-	const digest = await crypto.subtle.digest("SHA-256", bytes);
-	return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-async function matchesDigest(bytes, expected) {
-	if (bytes.byteLength !== expected.size) return false;
-	return await sha256Hex(bytes) === expected.sha256;
-}
-/**
-* A 500 carrying the reason, so the SDK's prover error path handles it as a
-* server rejection rather than a retryable transport fault.
-*/
-function proverErrorResponse(error, onMeasurement) {
-	const safe = new WasmProverError(error instanceof WasmProverError ? error.code : void 0);
-	onMeasurement?.({
-		step: "transfer-prove",
-		ms: 0,
-		note: safe.code
-	});
-	return new Response(JSON.stringify({
-		code: safe.code,
-		message: safe.message
-	}), {
-		status: 500,
-		headers: { "content-type": "application/json" }
-	});
-}
-function rethrowAbort(error, signal) {
-	signal?.throwIfAborted();
-	if (error instanceof Error && error.name === "AbortError") throw error;
-}
-async function optionalCache(operation, signal) {
-	try {
-		return await abortable(Promise.resolve().then(operation), signal);
-	} catch (error) {
-		rethrowAbort(error, signal);
-		return;
-	}
-}
-//#endregion
-export { KEY_BASE_URL, MERGE_KEY_BYTES, MERGE_KEY_FILE, MERGE_SHAPE, MERGE_SHAPES, TRANSFER_SHAPES, WasmProver, WasmProver as ZolanaWebProver, WasmProverError, automaticProvingThreads, canonicalShape, formatBytes, keyForProveRequest, observeProofRequests, shapeByLabel };
+export { TRANSFER_SHAPES, MERGE_KEY_BYTES, MERGE_KEY_FILE, MERGE_SHAPE, MERGE_SHAPES, keyForProveRequest, canonicalShape, formatBytes, neededKeys, shapeByLabel, } from "./shapes.js";
+export { KEY_BASE_URL } from "./key-digests.js";
+export { WasmProver, WasmProver as ZolanaWebProver, WasmProverError, } from "./wasm-prover.js";
+export { automaticProvingThreads } from "./proving-threads.js";
+export { observeProofRequests } from "./proof-requests.js";