@seams/wallet 0.7.1 → 0.8.0

package/dist/esm/react/core/signingEngine/routerAb/ecdsaDerivation/presignaturePool.js

@@ -1,1216 +0,0 @@
-import { base64UrlDecode, base64UrlEncode } from "../../../../shared-ts/src/utils/base64.js";
-import { secureRandomId } from "../../../../shared-ts/src/utils/secureRandomId.js";
-import { MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS } from "../../workerManager/ecdsaPresignLifecycle.js";
-import "../../../../shared-ts/src/utils/encoders.js";
-import { DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY } from "../../../config/defaultConfigs.js";
-import { canonicalRouterAbMpcMaterialActivationRefBytes } from "../../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import { ROUTER_AB_ECDSA_PRESIGN_CEREMONY_MAX_LIFETIME_MS, buildRouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1, buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1, parseRouterAbEcdsaDerivationNormalSigningScopeV1, routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1, routerAbEcdsaRerandomizationClientCommitmentV1 } from "../../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { formatEcdsaKeyHandleForWire, parseEcdsaClientVerifyingShareB64u } from "../../../../shared-ts/src/threshold/keyMaterialBrands.js";
-import { parseEcdsaThresholdKeyId } from "../../session/keyMaterialBrands.js";
-import { FIXED_ECDSA_PRESIGN_PROTOCOL_ID, ecdsaClientPresignPoolKey } from "../../workerManager/ecdsaPresignPoolIdentity.js";
-import { emitEcdsaServerTiming, emitEcdsaSigningTiming, emitSigningSessionFlowTrace } from "../../session/operationState/trace.js";
-import { RouterAbSigningRequestError, finalizeRouterAbEcdsaDerivationEvmDigestSigningV1, prepareRouterAbEcdsaDerivationEvmDigestSigningV1 } from "../../../rpcClients/relayer/routerAbNormalSigning.js";
-import { addSecp256k1PublicKeys33Wasm, validateSecp256k1PublicKey33Wasm, verifySecp256k1RecoverableSignatureAgainstPublicKey33Wasm } from "../../chains/evm/evmCryptoWasm.js";
-import { routerAbEcdsaDerivationPresignaturePoolFillInit, routerAbEcdsaDerivationPresignaturePoolFillStep } from "./poolFillRoutes.js";
-import { PresignatureRefillProgressV1 } from "./presignatureRefillProgress.js";
-//#region src/core/signingEngine/routerAb/ecdsaDerivation/presignaturePool.ts
-function secureRerandomizationContribution32() {
-	const cryptoApi = globalThis.crypto;
-	if (!cryptoApi || typeof cryptoApi.getRandomValues !== "function") throw new Error("WebCrypto getRandomValues is required for ECDSA rerandomization");
-	return cryptoApi.getRandomValues(new Uint8Array(32));
-}
-function ecdsaPoolFillAuthorization(input) {
-	switch (input.authorization.kind) {
-		case "reusable_wallet_session": return { authorization: input.authorization };
-		case "operation_step_up": {
-			const operation = input.operation;
-			if (!operation) throw new Error("Operation step-up pool fill requires exact operation preparation");
-			return {
-				authorization: input.authorization,
-				operation
-			};
-		}
-	}
-}
-function recoverableSignatureErrorMessage(error) {
-	return String(error && typeof error === "object" && "message" in error ? error.message : error || "signature recovery failed");
-}
-function zeroizeBytes(bytes) {
-	if (!(bytes instanceof Uint8Array)) return;
-	bytes.fill(0);
-}
-function assertRouterAbEcdsaDerivationClientSigningMaterialSource(source) {
-	if (source?.kind !== "router_ab_ecdsa_derivation_client_signing_material_source_v1") throw new Error("Router A/B ECDSA derivation client signing material source is required");
-}
-const MAX_HANDSHAKE_STEPS = 64;
-const ROUTER_AB_ECDSA_DERIVATION_SIGNING_TTL_MS = 6e4;
-const PRESIGN_CEREMONY_CLOCK_SKEW_MARGIN_MS = 3e4;
-const ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_EXPIRY_SKEW_MS = 2e3;
-const MAX_CLIENT_PRESIGNATURE_CLAIM_RETRIES = 4;
-const clientPresignaturePool = /* @__PURE__ */ new Map();
-const clientPresignaturePoolIdentityByPoolKey = /* @__PURE__ */ new Map();
-const clientPresignatureRefillInFlightByPoolKey = /* @__PURE__ */ new Map();
-const clientPresignatureHydrationInFlightByPoolKey = /* @__PURE__ */ new Map();
-const foregroundSignInFlightByPoolKey = /* @__PURE__ */ new Map();
-const clientPresignaturePoolGenerationByPoolKey = /* @__PURE__ */ new Map();
-function triplesAreComplete(stage) {
-	return stage === "triples_done" || stage === "presign" || stage === "done";
-}
-function resolvePresignExchangeStage(input) {
-	return triplesAreComplete(input.clientStage) && triplesAreComplete(input.serverStage) ? "presign" : "triples";
-}
-function normalizeIntInRange(value, fallback, min, max) {
-	const n = Math.floor(Number(value));
-	if (!Number.isFinite(n)) return fallback;
-	if (n < min) return min;
-	if (n > max) return max;
-	return n;
-}
-function normalizePresignPoolTargetDepth(value, fallback) {
-	return normalizeIntInRange(value, fallback, 1, 5);
-}
-function normalizePresignPoolLowWatermark(value, fallback, targetDepth) {
-	return normalizeIntInRange(value, fallback, 0, targetDepth);
-}
-function resolveRouterAbEcdsaDerivationPresignaturePoolPolicy(input) {
-	const source = input || DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY;
-	const targetDepth = normalizePresignPoolTargetDepth(source.targetDepth, DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY.targetDepth);
-	const lowWatermark = normalizePresignPoolLowWatermark(source.lowWatermark, DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY.lowWatermark, targetDepth);
-	return {
-		enabled: typeof source.enabled === "boolean" ? source.enabled : DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY.enabled,
-		targetDepth,
-		lowWatermark,
-		maxRefillInFlight: normalizeIntInRange(source.maxRefillInFlight, DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY.maxRefillInFlight, 1, 8),
-		refillAttemptTimeoutMs: normalizeIntInRange(source.refillAttemptTimeoutMs, DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY.refillAttemptTimeoutMs, 5e3, 12e4)
-	};
-}
-function makeClientPresignPoolIdentity(args) {
-	const parsedScope = parseRouterAbEcdsaDerivationNormalSigningScopeV1(args.scope);
-	const materialActivation = args.materialActivation;
-	return {
-		relayerUrl: String(args.relayerUrl || "").trim().replace(/\/+$/g, ""),
-		materialActivationB64u: base64UrlEncode(canonicalRouterAbMpcMaterialActivationRefBytes(materialActivation)),
-		materialActivationId: materialActivation.activation_id,
-		capability: materialActivation.capability,
-		keyBinding: materialActivation.key_binding,
-		walletId: parsedScope.wallet_id,
-		signingScopeB64u: base64UrlEncode(routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1(parsedScope)),
-		pairRole: "client",
-		keyEpoch: parsedScope.signing_worker.key_epoch,
-		activationEpoch: parsedScope.activation_epoch,
-		protocolId: FIXED_ECDSA_PRESIGN_PROTOCOL_ID
-	};
-}
-function popClientPresignature(poolKey) {
-	const list = clientPresignaturePool.get(poolKey);
-	if (!list?.length) return null;
-	const item = list.shift() ?? null;
-	if (!list.length) clientPresignaturePool.delete(poolKey);
-	else clientPresignaturePool.set(poolKey, list);
-	return item;
-}
-async function takeClientPresignature(input) {
-	await destroyExpiredClientPresignatures(input);
-	return popClientPresignature(input.poolKey);
-}
-function pushClientPresignature(poolKey, poolIdentity, item) {
-	if (!isClientPresignatureUsable(item)) return "invalid";
-	const list = clientPresignaturePool.get(poolKey) || [];
-	for (const existing of list) if (existing.materialHandle === item.materialHandle) return "duplicate";
-	if (list.filter((entry) => isClientPresignatureUsable(entry)).length >= 5) return "capacity_full";
-	list.push(item);
-	clientPresignaturePool.set(poolKey, list);
-	clientPresignaturePoolIdentityByPoolKey.set(poolKey, poolIdentity);
-	return "stored";
-}
-function removeExpiredClientPresignatures(poolKey, nowMs = Date.now()) {
-	const list = clientPresignaturePool.get(poolKey);
-	if (!list?.length) return [];
-	const live = [];
-	const expired = [];
-	for (const entry of list) if (isClientPresignatureUsable(entry, nowMs)) live.push(entry);
-	else expired.push(entry);
-	if (live.length > 0) clientPresignaturePool.set(poolKey, live);
-	else clientPresignaturePool.delete(poolKey);
-	return expired;
-}
-async function destroyClientPresignatureRefs(input) {
-	for (const ref of input.refs) await input.clientSigningMaterial.destroyClientPresignature({
-		materialHandle: ref.materialHandle,
-		poolIdentity: input.poolIdentity,
-		workerCtx: input.workerCtx
-	}).catch(() => {});
-}
-async function destroyExpiredClientPresignatures(input) {
-	await destroyClientPresignatureRefs({
-		refs: removeExpiredClientPresignatures(input.poolKey),
-		poolIdentity: input.poolIdentity,
-		clientSigningMaterial: input.clientSigningMaterial,
-		workerCtx: input.workerCtx
-	});
-}
-async function hydrateClientPresignaturePool(input) {
-	const existing = clientPresignatureHydrationInFlightByPoolKey.get(input.poolKey);
-	if (existing) {
-		await existing;
-		return;
-	}
-	const hydration = runClientPresignaturePoolHydration(input);
-	clientPresignatureHydrationInFlightByPoolKey.set(input.poolKey, hydration);
-	try {
-		await hydration;
-	} finally {
-		if (clientPresignatureHydrationInFlightByPoolKey.get(input.poolKey) === hydration) clientPresignatureHydrationInFlightByPoolKey.delete(input.poolKey);
-	}
-}
-async function runClientPresignaturePoolHydration(input) {
-	await destroyExpiredClientPresignatures(input);
-	let durableRefs;
-	durableRefs = await input.clientSigningMaterial.listAvailableClientPresignatures({
-		poolIdentity: input.poolIdentity,
-		workerCtx: input.workerCtx
-	});
-	if (getClientPresignaturePoolGeneration(input.poolKey) !== input.generation) {
-		for (const ref of durableRefs) {
-			zeroizeBytes(ref.bigR33);
-			await input.clientSigningMaterial.destroyClientPresignature({
-				materialHandle: ref.materialHandle,
-				poolIdentity: input.poolIdentity,
-				workerCtx: input.workerCtx
-			}).catch(() => {});
-		}
-		return;
-	}
-	for (const ref of durableRefs) {
-		const result = pushClientPresignature(input.poolKey, input.poolIdentity, {
-			presignatureId: ref.presignatureId,
-			materialHandle: ref.materialHandle,
-			bigRB64u: base64UrlEncode(ref.bigR33),
-			createdAtMs: ref.createdAtMs,
-			expiresAtMs: ref.expiresAtMs
-		});
-		zeroizeBytes(ref.bigR33);
-		if (result === "invalid" || result === "capacity_full") await input.clientSigningMaterial.destroyClientPresignature({
-			materialHandle: ref.materialHandle,
-			poolIdentity: input.poolIdentity,
-			workerCtx: input.workerCtx
-		}).catch(() => {});
-	}
-}
-function getClientPresignaturePoolDepth(poolKey) {
-	const list = clientPresignaturePool.get(poolKey);
-	if (!list) return 0;
-	return list.reduce((count, item) => count + (isClientPresignatureUsable(item) ? 1 : 0), 0);
-}
-function isClientPresignatureUsable(item, nowMs = Date.now()) {
-	const expiresAtMs = Math.floor(Number(item.expiresAtMs));
-	return Boolean(item.presignatureId && item.bigRB64u && item.materialHandle) && Number.isSafeInteger(expiresAtMs) && expiresAtMs > nowMs + ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_EXPIRY_SKEW_MS;
-}
-function getClientPresignaturePoolGeneration(poolKey) {
-	const generation = clientPresignaturePoolGenerationByPoolKey.get(poolKey);
-	if (generation !== void 0) return generation;
-	clientPresignaturePoolGenerationByPoolKey.set(poolKey, 0);
-	return 0;
-}
-function bumpClientPresignaturePoolGeneration(poolKey) {
-	stopPresignatureMaintenance(poolKey);
-	const nextGeneration = getClientPresignaturePoolGeneration(poolKey) + 1;
-	clientPresignaturePoolGenerationByPoolKey.set(poolKey, nextGeneration);
-	return nextGeneration;
-}
-async function invalidateClientPresignaturePool(input) {
-	const refs = clientPresignaturePool.get(input.poolKey) ?? [];
-	clientPresignaturePool.delete(input.poolKey);
-	clientPresignaturePoolIdentityByPoolKey.delete(input.poolKey);
-	bumpClientPresignaturePoolGeneration(input.poolKey);
-	await destroyClientPresignatureRefs({
-		...input,
-		refs
-	});
-}
-function getForegroundSignInFlightCount(poolKey) {
-	return foregroundSignInFlightByPoolKey.get(poolKey) || 0;
-}
-function startForegroundSign(poolKey) {
-	const current = getForegroundSignInFlightCount(poolKey);
-	foregroundSignInFlightByPoolKey.set(poolKey, current + 1);
-}
-function finishForegroundSign(poolKey) {
-	const current = getForegroundSignInFlightCount(poolKey);
-	if (current <= 1) {
-		foregroundSignInFlightByPoolKey.delete(poolKey);
-		armPresignatureMaintenance(poolKey, 0);
-		return;
-	}
-	foregroundSignInFlightByPoolKey.set(poolKey, current - 1);
-}
-async function waitForAvailablePresignatureFromInFlightRefill(poolKey, priority) {
-	const progress = clientPresignatureRefillInFlightByPoolKey.get(poolKey);
-	if (!progress) return;
-	let observed = progress.snapshot();
-	while (getClientPresignaturePoolDepth(poolKey) === 0 && observed.kind === "refilling") observed = await progress.waitForChange(observed, priority);
-}
-async function waitForRouterAbEcdsaDerivationClientPresignaturePoolReady(args) {
-	const poolKey = ecdsaClientPresignPoolKey(makeClientPresignPoolIdentity({
-		relayerUrl: args.relayerUrl,
-		scope: args.scope,
-		materialActivation: args.materialActivation
-	}));
-	if (getClientPresignaturePoolDepth(poolKey) > 0) return true;
-	await waitForAvailablePresignatureFromInFlightRefill(poolKey, "background");
-	return getClientPresignaturePoolDepth(poolKey) > 0;
-}
-function buildPresignatureRefillNotScheduledResult(reason, depth, targetDepth) {
-	return {
-		scheduled: false,
-		reason,
-		depth,
-		targetDepth
-	};
-}
-function clearAllRouterAbEcdsaDerivationClientPresignatures() {
-	const invalidatedPoolKeys = new Set([
-		...presignatureMaintenance.keys(),
-		...clientPresignaturePool.keys(),
-		...clientPresignatureRefillInFlightByPoolKey.keys(),
-		...foregroundSignInFlightByPoolKey.keys(),
-		...clientPresignaturePoolGenerationByPoolKey.keys()
-	]);
-	for (const poolKey of invalidatedPoolKeys) bumpClientPresignaturePoolGeneration(poolKey);
-	clientPresignaturePool.clear();
-	clientPresignaturePoolIdentityByPoolKey.clear();
-	for (const progress of clientPresignatureRefillInFlightByPoolKey.values()) progress.settle();
-	clientPresignatureRefillInFlightByPoolKey.clear();
-	foregroundSignInFlightByPoolKey.clear();
-}
-function clearRouterAbEcdsaDerivationClientPresignaturesForWallet(walletIdInput) {
-	const walletId = String(walletIdInput).trim();
-	if (!walletId) throw new Error("ECDSA presignature wallet id is required");
-	for (const [poolKey, identity] of [...clientPresignaturePoolIdentityByPoolKey]) {
-		if (identity.walletId !== walletId) continue;
-		clientPresignaturePool.delete(poolKey);
-		clientPresignaturePoolIdentityByPoolKey.delete(poolKey);
-		bumpClientPresignaturePoolGeneration(poolKey);
-		clientPresignatureRefillInFlightByPoolKey.get(poolKey)?.settle();
-		clientPresignatureRefillInFlightByPoolKey.delete(poolKey);
-		foregroundSignInFlightByPoolKey.delete(poolKey);
-	}
-}
-const presignatureMaintenance = /* @__PURE__ */ new Map();
-function stopPresignatureMaintenance(poolKey) {
-	const maintenance = presignatureMaintenance.get(poolKey);
-	if (maintenance && maintenance.timer !== null) clearTimeout(maintenance.timer);
-	presignatureMaintenance.delete(poolKey);
-	if (presignatureMaintenance.size === 0 && typeof window !== "undefined") {
-		window.removeEventListener("online", resumePresignatureMaintenance);
-		document.removeEventListener("visibilitychange", resumePresignatureMaintenance);
-	}
-}
-function armPresignatureMaintenance(poolKey, delayMs) {
-	const maintenance = presignatureMaintenance.get(poolKey);
-	if (!maintenance) return;
-	if (maintenance.timer !== null) clearTimeout(maintenance.timer);
-	const remainingMs = maintenance.input.routerAbEcdsaDerivationPoolFill.ceremonyExpiresAtMs - Date.now();
-	if (remainingMs <= 0 || getClientPresignaturePoolGeneration(poolKey) !== maintenance.generation) {
-		stopPresignatureMaintenance(poolKey);
-		return;
-	}
-	maintenance.timer = setTimeout(runPresignatureMaintenance, Math.min(delayMs, remainingMs), poolKey);
-}
-function resumePresignatureMaintenance() {
-	if (typeof document !== "undefined" && document.visibilityState === "hidden") return;
-	for (const poolKey of presignatureMaintenance.keys()) armPresignatureMaintenance(poolKey, 0);
-}
-function runPresignatureMaintenance(poolKey) {
-	const maintenance = presignatureMaintenance.get(poolKey);
-	if (!maintenance) return;
-	maintenance.timer = null;
-	if (Date.now() >= maintenance.input.routerAbEcdsaDerivationPoolFill.ceremonyExpiresAtMs) {
-		stopPresignatureMaintenance(poolKey);
-		return;
-	}
-	if (typeof navigator !== "undefined" && navigator.onLine === false) {
-		armPresignatureMaintenance(poolKey, 3e4);
-		return;
-	}
-	const result = scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill(maintenance.input);
-	if (!result.scheduled) armPresignatureMaintenance(poolKey, result.depth >= result.targetDepth ? 3e4 : 5e3);
-}
-function rememberPresignatureMaintenance(poolKey, input) {
-	if (input.authorization.kind !== "reusable_wallet_session") return;
-	if (presignatureMaintenance.get(poolKey)?.input === input) return;
-	stopPresignatureMaintenance(poolKey);
-	if (presignatureMaintenance.size === 0 && typeof window !== "undefined") {
-		window.addEventListener("online", resumePresignatureMaintenance);
-		document.addEventListener("visibilitychange", resumePresignatureMaintenance);
-	}
-	presignatureMaintenance.set(poolKey, {
-		input,
-		generation: getClientPresignaturePoolGeneration(poolKey),
-		failures: 0,
-		timer: null
-	});
-	armPresignatureMaintenance(poolKey, 3e4);
-}
-function recordPresignatureRefillFailure(poolKey, attemptMaintenance, code) {
-	const maintenance = presignatureMaintenance.get(poolKey);
-	if (!maintenance || maintenance !== attemptMaintenance) return;
-	switch (code) {
-		case "network_error":
-		case "internal":
-		case "presign_timeout":
-		case "temporarily_unavailable":
-		case "service_unavailable":
-		case "wallet_session_unavailable":
-			maintenance.failures += 1;
-			if (maintenance.failures <= 3) return;
-	}
-	stopPresignatureMaintenance(poolKey);
-}
-async function runBackgroundPresignatureRefill(input) {
-	const { args, refillInput, poolKey, poolIdentity, scheduledGeneration, targetDepth, refillAttemptTimeoutMs, progress } = input;
-	const attemptMaintenance = presignatureMaintenance.get(poolKey) ?? null;
-	try {
-		await hydrateClientPresignaturePool({
-			poolKey,
-			poolIdentity,
-			clientSigningMaterial: args.clientSigningMaterial,
-			workerCtx: args.workerCtx,
-			generation: scheduledGeneration
-		});
-		if (getClientPresignaturePoolDepth(poolKey) > 0) {
-			progress.publishAvailable();
-			if (getForegroundSignInFlightCount(poolKey) > 0) return;
-		}
-		while (Date.now() < args.routerAbEcdsaDerivationPoolFill.ceremonyExpiresAtMs) {
-			if (getClientPresignaturePoolGeneration(poolKey) !== scheduledGeneration) return;
-			if ((presignatureMaintenance.get(poolKey) ?? null) !== attemptMaintenance) return;
-			if (getClientPresignaturePoolDepth(poolKey) >= targetDepth) return;
-			if (typeof navigator !== "undefined" && navigator.onLine === false) return;
-			const attemptDeadlineAtMs = Math.min(Date.now() + refillAttemptTimeoutMs, args.routerAbEcdsaDerivationPoolFill.ceremonyExpiresAtMs);
-			const refill = await refillRouterAbEcdsaDerivationClientPresignaturePool({
-				...refillInput,
-				routerAbEcdsaDerivationPoolFill: {
-					kind: "router_ab_ecdsa_derivation_signing_worker_pool",
-					scope: refillInput.routerAbEcdsaDerivationPoolFill.scope,
-					ceremonyExpiresAtMs: attemptDeadlineAtMs,
-					materialExpiresAtMs: refillInput.routerAbEcdsaDerivationPoolFill.materialExpiresAtMs
-				},
-				trafficClass: "background"
-			});
-			emitSigningSessionFlowTrace("evm-family", {
-				event: "ecdsa_background_refill_result",
-				authorization: args.authorization.kind,
-				outcome: refill.ok ? "available" : "failed",
-				code: refill.ok ? null : refill.code,
-				depth: getClientPresignaturePoolDepth(poolKey),
-				targetDepth
-			});
-			if (!refill.ok) {
-				recordPresignatureRefillFailure(poolKey, attemptMaintenance, refill.code);
-				return;
-			}
-			const maintenance = presignatureMaintenance.get(poolKey);
-			if (maintenance && maintenance === attemptMaintenance) maintenance.failures = 0;
-			progress.publishAvailable();
-			if (getForegroundSignInFlightCount(poolKey) > 0) return;
-		}
-	} catch {
-		recordPresignatureRefillFailure(poolKey, attemptMaintenance, "internal");
-	} finally {
-		progress.settle();
-		if (clientPresignatureRefillInFlightByPoolKey.get(poolKey) === progress) clientPresignatureRefillInFlightByPoolKey.delete(poolKey);
-		const maintenance = presignatureMaintenance.get(poolKey);
-		if (maintenance) {
-			let delayMs = maintenance.failures > 0 ? 2e3 * 2 ** maintenance.failures : 1e3;
-			if (getClientPresignaturePoolDepth(poolKey) >= targetDepth) delayMs = 3e4;
-			if (maintenance !== attemptMaintenance) delayMs = 0;
-			armPresignatureMaintenance(poolKey, delayMs);
-		}
-	}
-}
-function scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill(args) {
-	try {
-		const policy = resolveRouterAbEcdsaDerivationPresignaturePoolPolicy(args.poolPolicy);
-		const poolIdentity = makeClientPresignPoolIdentity({
-			relayerUrl: args.relayerUrl,
-			scope: args.routerAbEcdsaDerivationPoolFill.scope,
-			materialActivation: args.materialActivation
-		});
-		const poolKey = ecdsaClientPresignPoolKey(poolIdentity);
-		clientPresignaturePoolIdentityByPoolKey.set(poolKey, poolIdentity);
-		const targetDepth = normalizePresignPoolTargetDepth(args.targetDepth, policy.targetDepth);
-		const triggerDepth = normalizePresignPoolLowWatermark(args.triggerIfDepthAtOrBelow, policy.lowWatermark, targetDepth);
-		const depth = getClientPresignaturePoolDepth(poolKey);
-		const scheduledGeneration = getClientPresignaturePoolGeneration(poolKey);
-		if (!policy.enabled) return buildPresignatureRefillNotScheduledResult("disabled", depth, targetDepth);
-		if (args.routerAbEcdsaDerivationPoolFill.ceremonyExpiresAtMs <= Date.now()) {
-			stopPresignatureMaintenance(poolKey);
-			return buildPresignatureRefillNotScheduledResult("invalid_args", depth, targetDepth);
-		}
-		rememberPresignatureMaintenance(poolKey, args);
-		if (depth > triggerDepth) return buildPresignatureRefillNotScheduledResult("depth_above_trigger", depth, targetDepth);
-		if (depth >= targetDepth) return buildPresignatureRefillNotScheduledResult("depth_at_or_above_target", depth, targetDepth);
-		if (clientPresignatureRefillInFlightByPoolKey.has(poolKey)) return buildPresignatureRefillNotScheduledResult("in_flight_for_pool_key", depth, targetDepth);
-		if (getForegroundSignInFlightCount(poolKey) > 0) return buildPresignatureRefillNotScheduledResult("in_flight_for_pool_key", depth, targetDepth);
-		if (clientPresignatureRefillInFlightByPoolKey.size >= policy.maxRefillInFlight) return buildPresignatureRefillNotScheduledResult("global_in_flight_limit", depth, targetDepth);
-		const refillInput = {
-			relayerUrl: args.relayerUrl,
-			keyHandle: args.keyHandle,
-			ecdsaThresholdKeyId: args.ecdsaThresholdKeyId,
-			clientVerifyingShareB64u: args.clientVerifyingShareB64u,
-			clientSigningMaterial: args.clientSigningMaterial,
-			thresholdEcdsaPublicKeyB64u: args.thresholdEcdsaPublicKeyB64u,
-			relayerVerifyingShareB64u: args.relayerVerifyingShareB64u,
-			credential: args.credential,
-			materialActivation: args.materialActivation,
-			routerAbEcdsaDerivationPoolFill: args.routerAbEcdsaDerivationPoolFill,
-			workerCtx: args.workerCtx,
-			...ecdsaPoolFillAuthorization(args)
-		};
-		const progress = new PresignatureRefillProgressV1();
-		clientPresignatureRefillInFlightByPoolKey.set(poolKey, progress);
-		runBackgroundPresignatureRefill({
-			args,
-			refillInput,
-			poolKey,
-			poolIdentity,
-			scheduledGeneration,
-			targetDepth,
-			refillAttemptTimeoutMs: policy.refillAttemptTimeoutMs,
-			progress
-		});
-		return {
-			scheduled: true,
-			reason: "scheduled",
-			depth,
-			targetDepth
-		};
-	} catch {
-		return buildPresignatureRefillNotScheduledResult("invalid_args", 0, 0);
-	}
-}
-function toB64uMessages(messages) {
-	return messages.map((entry) => base64UrlEncode(entry));
-}
-function fromB64uMessages(messagesB64u) {
-	if (!Array.isArray(messagesB64u)) return [];
-	return messagesB64u.map((entry) => String(entry || "").trim()).filter((entry) => Boolean(entry)).map((entry) => base64UrlDecode(entry));
-}
-async function resolveGroupPublicKey33(args) {
-	const thresholdEcdsaPublicKeyB64u = String(args.thresholdEcdsaPublicKeyB64u || "").trim();
-	if (thresholdEcdsaPublicKeyB64u) {
-		const bytes = base64UrlDecode(thresholdEcdsaPublicKeyB64u);
-		if (bytes.length !== 33) throw new Error("thresholdEcdsaPublicKeyB64u must decode to 33 bytes");
-		return await validateSecp256k1PublicKey33Wasm({
-			publicKey33: bytes,
-			workerCtx: args.workerCtx
-		});
-	}
-	const clientVerifyingShareB64u = String(args.clientVerifyingShareB64u || "").trim();
-	const relayerVerifyingShareB64u = String(args.relayerVerifyingShareB64u || "").trim();
-	if (!clientVerifyingShareB64u || !relayerVerifyingShareB64u) throw new Error("Missing thresholdEcdsaPublicKeyB64u (or relayerVerifyingShareB64u fallback) for Router A/B ECDSA derivation signing");
-	const clientBytes = base64UrlDecode(clientVerifyingShareB64u);
-	const relayerBytes = base64UrlDecode(relayerVerifyingShareB64u);
-	if (clientBytes.length !== 33) throw new Error("clientVerifyingShareB64u must decode to 33 bytes");
-	if (relayerBytes.length !== 33) throw new Error("relayerVerifyingShareB64u must decode to 33 bytes");
-	return await addSecp256k1PublicKeys33Wasm({
-		left33: await validateSecp256k1PublicKey33Wasm({
-			publicKey33: clientBytes,
-			workerCtx: args.workerCtx
-		}),
-		right33: await validateSecp256k1PublicKey33Wasm({
-			publicKey33: relayerBytes,
-			workerCtx: args.workerCtx
-		}),
-		workerCtx: args.workerCtx
-	});
-}
-function presignHandshakeRequestTag(args) {
-	if (args.trafficClass === "foreground" || clientPresignatureRefillInFlightByPoolKey.get(args.poolKey)?.hasForegroundWaiters()) return "foreground_presign_pool_refill";
-	return "background_presign_pool_refill";
-}
-async function runPresignHandshake(args) {
-	for (let attempt = 0; attempt < 2; attempt += 1) {
-		const result = await runPresignHandshakeAttempt(args);
-		if (result.ok || !isRetryablePoolFillStale(result) || attempt === 1) return result;
-	}
-	return {
-		ok: false,
-		code: "stale_session_state",
-		message: "Router A/B ECDSA derivation pool-fill session stayed stale after retry"
-	};
-}
-async function runPresignHandshakeAttempt(args) {
-	assertRouterAbEcdsaDerivationClientSigningMaterialSource(args.clientSigningMaterial);
-	const handshakeStartedAt = performance.now();
-	const ceremonyExpiresAtMs = args.routerAbEcdsaDerivationPoolFill.ceremonyExpiresAtMs;
-	const materialExpiresAtMs = args.routerAbEcdsaDerivationPoolFill.materialExpiresAtMs;
-	const presignSessionId = `ecdsa-presign-v2:${ceremonyExpiresAtMs}:${base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)))}`;
-	const localSessionId = presignSessionId;
-	const poolIdentity = makeClientPresignPoolIdentity({
-		relayerUrl: args.relayerUrl,
-		scope: args.routerAbEcdsaDerivationPoolFill.scope,
-		materialActivation: args.materialActivation
-	});
-	let localPresignatureHandle = null;
-	let localBigR33 = null;
-	let serverPresignatureId = null;
-	let serverBigRB64u = null;
-	let serverDone = false;
-	let clientStage = "triples";
-	let pendingClientOutgoing = [];
-	let shouldAbortLocalSession = true;
-	let keepLocalMaterial = false;
-	try {
-		const localInit = await args.clientSigningMaterial.initClientPresignSession({
-			sessionId: localSessionId,
-			groupPublicKey33: args.groupPublicKey33,
-			ceremonyExpiresAtMs,
-			materialExpiresAtMs,
-			poolIdentity,
-			workerCtx: args.workerCtx
-		});
-		if (localInit.stage !== "triples" || localInit.outgoingMessages.length !== 1) return {
-			ok: false,
-			code: "presign_init_failed",
-			message: "Client presign init must emit exactly one first message"
-		};
-		clientStage = localInit.stage;
-		const init = await routerAbEcdsaDerivationPresignaturePoolFillInit({
-			relayerUrl: args.relayerUrl,
-			...args.poolFillInitKeySelector,
-			count: 1,
-			presignSessionId,
-			firstMessageB64u: base64UrlEncode(localInit.outgoingMessages[0]),
-			credential: args.credential,
-			requestTag: presignHandshakeRequestTag(args),
-			poolFill: args.routerAbEcdsaDerivationPoolFill,
-			...ecdsaPoolFillAuthorization(args)
-		});
-		if (!init.ok) return {
-			ok: false,
-			code: init.code || "presign_init_failed",
-			message: init.message || "Presign initialization failed"
-		};
-		if (init.presignSessionId !== presignSessionId || init.ceremonyExpiresAtMs !== ceremonyExpiresAtMs || init.materialExpiresAtMs !== materialExpiresAtMs || ceremonyExpiresAtMs <= Date.now()) return {
-			ok: false,
-			code: "invalid_pool_fill_expiry",
-			message: "Presign initialization changed the bound identity or deadlines"
-		};
-		let serverStage = init.stage || "triples";
-		let pendingServerOutgoing = fromB64uMessages(init.outgoingMessagesB64u);
-		for (let i = 0; i < MAX_HANDSHAKE_STEPS; i++) {
-			if (pendingServerOutgoing.length > 0 && !localPresignatureHandle) {
-				const localStepped = await args.clientSigningMaterial.stepClientPresignSession({
-					sessionId: localSessionId,
-					stage: resolvePresignExchangeStage({
-						clientStage,
-						serverStage
-					}),
-					incomingMessages: pendingServerOutgoing,
-					workerCtx: args.workerCtx
-				});
-				clientStage = localStepped.stage;
-				pendingServerOutgoing = [];
-				pendingClientOutgoing.push(...localStepped.outgoingMessages);
-				if (localStepped.presignatureHandle && localStepped.presignatureBigR33) {
-					localPresignatureHandle = localStepped.presignatureHandle;
-					localBigR33 = localStepped.presignatureBigR33;
-				}
-			}
-			if (!serverDone) {
-				const roundStartedAt = performance.now();
-				const requestTag = presignHandshakeRequestTag(args);
-				const stepArgs = {
-					relayerUrl: args.relayerUrl,
-					presignSessionId,
-					ceremonyExpiresAtMs,
-					materialExpiresAtMs,
-					stage: resolvePresignExchangeStage({
-						clientStage,
-						serverStage
-					}),
-					outgoingMessagesB64u: toB64uMessages(pendingClientOutgoing),
-					credential: args.credential,
-					requestTag,
-					...ecdsaPoolFillAuthorization(args)
-				};
-				const stepped = await routerAbEcdsaDerivationPresignaturePoolFillStep(stepArgs);
-				emitSigningSessionFlowTrace("evm-family", {
-					event: "ecdsa_presignature_round",
-					requestTag,
-					presignSessionId,
-					authorization: args.authorization.kind,
-					round: i,
-					stage: stepArgs.stage,
-					durationMs: performance.now() - roundStartedAt,
-					outcome: stepped.ok ? "succeeded" : "failed"
-				});
-				pendingClientOutgoing = [];
-				if (!stepped.ok) return {
-					ok: false,
-					code: stepped.code || "presign_step_failed",
-					message: stepped.message || "Router A/B ECDSA derivation pool-fill step failed"
-				};
-				pendingServerOutgoing = fromB64uMessages(stepped.outgoingMessagesB64u);
-				serverStage = stepped.stage || serverStage;
-				if (stepped.event === "presign_done") {
-					serverPresignatureId = String(stepped.presignatureId || "").trim() || null;
-					serverBigRB64u = String(stepped.bigRB64u || "").trim() || null;
-					serverDone = true;
-				}
-			}
-			if (localPresignatureHandle && localBigR33 && serverPresignatureId && serverBigRB64u) break;
-		}
-		if (!localPresignatureHandle || !localBigR33) return {
-			ok: false,
-			code: "presign_timeout",
-			message: "Client presign session did not reach done state"
-		};
-		if (!serverPresignatureId || !serverBigRB64u) return {
-			ok: false,
-			code: "presign_timeout",
-			message: "Server presign session did not reach done state"
-		};
-		if (localBigR33.length !== 33) return {
-			ok: false,
-			code: "internal",
-			message: `Invalid local presignature bigR bytes (expected 33, got ${localBigR33.length})`
-		};
-		try {
-			const createdAtMs = Date.now();
-			const localBigRB64u = base64UrlEncode(localBigR33);
-			if (localBigRB64u !== serverBigRB64u) return {
-				ok: false,
-				code: "presign_mismatch",
-				message: "Client/server presignature mismatch (bigR mismatch)"
-			};
-			const admission = await args.clientSigningMaterial.admitClientPresignature({
-				materialHandle: localPresignatureHandle,
-				expectedPresignatureId: serverPresignatureId,
-				poolIdentity,
-				admissionMode: args.authorization.kind === "operation_step_up" ? "resident" : "durable",
-				workerCtx: args.workerCtx
-			});
-			if (admission.kind === "discarded_capacity") return {
-				ok: false,
-				code: "pool_full",
-				message: "Router A/B ECDSA derivation client presignature pool is full"
-			};
-			if (admission.kind === "discarded_ambiguous") return {
-				ok: false,
-				code: "presign_failed",
-				message: "Router A/B ECDSA derivation client presignature admission was ambiguous"
-			};
-			keepLocalMaterial = true;
-			shouldAbortLocalSession = false;
-			return {
-				ok: true,
-				kind: "available",
-				presignature: {
-					presignatureId: serverPresignatureId,
-					bigRB64u: localBigRB64u,
-					materialHandle: localPresignatureHandle,
-					createdAtMs,
-					expiresAtMs: materialExpiresAtMs
-				}
-			};
-		} finally {
-			zeroizeBytes(localBigR33);
-		}
-	} catch (e) {
-		return {
-			ok: false,
-			code: "presign_failed",
-			message: String(e && typeof e === "object" && "message" in e ? e.message : e || "Router A/B ECDSA derivation pool-fill handshake failed")
-		};
-	} finally {
-		emitSigningSessionFlowTrace("evm-family", {
-			event: "ecdsa_presignature_generation",
-			requestTag: presignHandshakeRequestTag(args),
-			presignSessionId,
-			authorization: args.authorization.kind,
-			durationMs: performance.now() - handshakeStartedAt,
-			outcome: keepLocalMaterial ? "available" : "failed"
-		});
-		zeroizeBytes(localBigR33);
-		if (!keepLocalMaterial && localPresignatureHandle) await args.clientSigningMaterial.destroyClientPresignature({
-			materialHandle: localPresignatureHandle,
-			poolIdentity,
-			workerCtx: args.workerCtx
-		}).catch(() => {});
-		if (shouldAbortLocalSession) await args.clientSigningMaterial.abortClientPresignSession({
-			sessionId: localSessionId,
-			workerCtx: args.workerCtx
-		}).catch(() => {});
-	}
-}
-function isRetryablePoolFillStale(result) {
-	return result.code === "stale_session_state" || result.code === "stale_pool_fill_session";
-}
-function routerAbEcdsaDerivationSigningIdentityFromScope(scope) {
-	const parsed = parseRouterAbEcdsaDerivationNormalSigningScopeV1(scope);
-	return {
-		ecdsaThresholdKeyId: parseEcdsaThresholdKeyId(parsed.ecdsa_threshold_key_id),
-		clientVerifyingShareB64u: parseEcdsaClientVerifyingShareB64u(parsed.public_identity.derivation_client_share_public_key33_b64u),
-		thresholdEcdsaPublicKeyB64u: parsed.public_identity.threshold_public_key33_b64u
-	};
-}
-function resolveSigningRequestExpiresAtMs(input) {
-	const materialExpiresAtMs = Math.floor(Number(input.materialExpiresAtMs));
-	const authorizationExpiresAtMs = Number.isSafeInteger(input.authorizationExpiresAtMs) ? Math.floor(Number(input.authorizationExpiresAtMs)) : input.nowMs + ROUTER_AB_ECDSA_DERIVATION_SIGNING_TTL_MS;
-	const expiresAtMs = Math.min(materialExpiresAtMs, authorizationExpiresAtMs, input.nowMs + ROUTER_AB_ECDSA_DERIVATION_SIGNING_TTL_MS);
-	return Number.isSafeInteger(expiresAtMs) && expiresAtMs > input.nowMs ? expiresAtMs : null;
-}
-async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCount, supply) {
-	let poolKey = null;
-	let poolIdentity = null;
-	let foregroundStarted = false;
-	let presignature = null;
-	let clientSignatureShare32 = null;
-	let clientRerandomizationContribution32 = null;
-	let clientPresignatureCleanupState = { kind: "unclaimed" };
-	let poolGeneration = null;
-	let preparationState = { kind: "before_prepare" };
-	try {
-		const relayerUrl = String(args.relayerUrl || "").trim().replace(/\/+$/g, "");
-		if (!relayerUrl) return {
-			ok: false,
-			code: "invalid_args",
-			message: "Missing relayerUrl for Router A/B ECDSA derivation signing"
-		};
-		const signingIdentity = routerAbEcdsaDerivationSigningIdentityFromScope(args.scope);
-		if (!signingIdentity.ecdsaThresholdKeyId) return {
-			ok: false,
-			code: "invalid_args",
-			message: "Missing ecdsaThresholdKeyId for Router A/B ECDSA derivation signing"
-		};
-		const clientVerifyingShareB64u = signingIdentity.clientVerifyingShareB64u;
-		if (!clientVerifyingShareB64u) return {
-			ok: false,
-			code: "invalid_args",
-			message: "Missing clientVerifyingShareB64u for Router A/B ECDSA derivation signing"
-		};
-		if (!(args.signingDigest32 instanceof Uint8Array) || args.signingDigest32.length !== 32) return {
-			ok: false,
-			code: "invalid_args",
-			message: "signingDigest32 must be 32 bytes for Router A/B ECDSA derivation signing"
-		};
-		const publicKeyStartedAt = performance.now();
-		const groupPublicKey33 = await resolveGroupPublicKey33({
-			clientVerifyingShareB64u,
-			thresholdEcdsaPublicKeyB64u: signingIdentity.thresholdEcdsaPublicKeyB64u,
-			workerCtx: args.workerCtx
-		});
-		emitEcdsaSigningTiming(args.operationId, "public_key_validation", publicKeyStartedAt);
-		poolIdentity = makeClientPresignPoolIdentity({
-			relayerUrl,
-			scope: args.scope,
-			materialActivation: args.materialActivation
-		});
-		poolKey = ecdsaClientPresignPoolKey(poolIdentity);
-		clientPresignaturePoolIdentityByPoolKey.set(poolKey, poolIdentity);
-		startForegroundSign(poolKey);
-		foregroundStarted = true;
-		poolGeneration = getClientPresignaturePoolGeneration(poolKey);
-		const lookupStartedAt = performance.now();
-		presignature = await takeClientPresignature({
-			poolKey,
-			poolIdentity,
-			clientSigningMaterial: args.clientSigningMaterial,
-			workerCtx: args.workerCtx
-		});
-		emitEcdsaSigningTiming(args.operationId, "pool_lookup", lookupStartedAt);
-		if (!presignature) {
-			const restoreStartedAt = performance.now();
-			await hydrateClientPresignaturePool({
-				poolKey,
-				poolIdentity,
-				clientSigningMaterial: args.clientSigningMaterial,
-				workerCtx: args.workerCtx,
-				generation: poolGeneration
-			});
-			emitEcdsaSigningTiming(args.operationId, "pool_restore", restoreStartedAt);
-			poolGeneration = getClientPresignaturePoolGeneration(poolKey);
-			presignature = await takeClientPresignature({
-				poolKey,
-				poolIdentity,
-				clientSigningMaterial: args.clientSigningMaterial,
-				workerCtx: args.workerCtx
-			});
-		}
-		if (!presignature) {
-			const refillWaitStartedAt = performance.now();
-			await waitForAvailablePresignatureFromInFlightRefill(poolKey, "foreground");
-			emitEcdsaSigningTiming(args.operationId, "refill_wait", refillWaitStartedAt);
-			poolGeneration = getClientPresignaturePoolGeneration(poolKey);
-			presignature = await takeClientPresignature({
-				poolKey,
-				poolIdentity,
-				clientSigningMaterial: args.clientSigningMaterial,
-				workerCtx: args.workerCtx
-			});
-		}
-		if (!presignature && supply.kind === "on_demand") {
-			let refill = await refillRouterAbEcdsaDerivationClientPresignaturePool({
-				...supply.refill,
-				trafficClass: "foreground"
-			});
-			if (!refill.ok && refill.code === "invalidated") refill = await refillRouterAbEcdsaDerivationClientPresignaturePool({
-				...supply.refill,
-				trafficClass: "foreground"
-			});
-			if (!refill.ok && refill.code !== "pool_full") return refill;
-			if (!refill.ok && refill.code === "pool_full") await hydrateClientPresignaturePool({
-				poolKey,
-				poolIdentity,
-				clientSigningMaterial: args.clientSigningMaterial,
-				workerCtx: args.workerCtx,
-				generation: getClientPresignaturePoolGeneration(poolKey)
-			});
-			poolGeneration = getClientPresignaturePoolGeneration(poolKey);
-			presignature = await takeClientPresignature({
-				poolKey,
-				poolIdentity,
-				clientSigningMaterial: args.clientSigningMaterial,
-				workerCtx: args.workerCtx
-			});
-		}
-		emitSigningSessionFlowTrace("evm-family", {
-			event: "ecdsa_presignature_selection",
-			operationId: args.operationId,
-			authorization: args.authorization.kind,
-			outcome: presignature ? "available" : "empty",
-			remainingDepth: getClientPresignaturePoolDepth(poolKey),
-			attempt: retryCount
-		});
-		if (!presignature) return {
-			ok: false,
-			code: "pool_empty",
-			message: "Router A/B ECDSA derivation client presignature pool is empty"
-		};
-		const nowMs = Date.now();
-		const expiresAtMs = resolveSigningRequestExpiresAtMs({
-			authorizationExpiresAtMs: args.expiresAtMs,
-			materialExpiresAtMs: presignature.expiresAtMs,
-			nowMs
-		});
-		if (!expiresAtMs) return {
-			ok: false,
-			code: "pool_entry_expired",
-			message: "Router A/B ECDSA derivation client presignature is expired"
-		};
-		if (poolGeneration !== getClientPresignaturePoolGeneration(poolKey)) return {
-			ok: false,
-			code: "pool_entry_unavailable",
-			message: "Router A/B ECDSA derivation client presignature pool was invalidated before prepare"
-		};
-		clientRerandomizationContribution32 = secureRerandomizationContribution32();
-		const clientRerandomizationCommitment32 = await routerAbEcdsaRerandomizationClientCommitmentV1(clientRerandomizationContribution32);
-		const prepareRequest = buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1({
-			scope: args.scope,
-			requestId: secureRandomId("router-ab-ecdsa-sign", 32, "Router A/B ECDSA derivation sign request"),
-			operationId: args.operationId,
-			operationDigests: args.operationDigests,
-			authorization: args.authorization,
-			materialActivation: args.materialActivation,
-			clientPresignatureId: presignature.presignatureId,
-			expiresAtMs,
-			signingDigest32: args.signingDigest32,
-			clientRerandomizationCommitment32
-		});
-		zeroizeBytes(clientRerandomizationCommitment32);
-		const reservationId = secureRandomId("router-ab-ecdsa-reservation", 32, "Router A/B ECDSA Client presignature reservation");
-		clientPresignatureCleanupState = { kind: "destroy" };
-		const reserveStartedAt = performance.now();
-		const reservation = await args.clientSigningMaterial.reserveClientPresignature({
-			materialHandle: presignature.materialHandle,
-			expectedPresignatureId: presignature.presignatureId,
-			poolIdentity,
-			requestBinding: prepareRequest.request_id,
-			reservationId,
-			leaseExpiresAtMs: prepareRequest.expires_at_ms,
-			workerCtx: args.workerCtx
-		});
-		emitEcdsaSigningTiming(args.operationId, "presignature_reserve", reserveStartedAt);
-		if (reservation.kind === "unavailable") {
-			if (reservation.reason === "claimed_elsewhere") clientPresignatureCleanupState = { kind: "owned_elsewhere" };
-			if (retryCount < MAX_CLIENT_PRESIGNATURE_CLAIM_RETRIES) return await signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCount + 1, supply);
-			return {
-				ok: false,
-				code: reservation.reason === "expired" ? "pool_entry_expired" : "pool_entry_unavailable",
-				message: `Router A/B ECDSA derivation client presignature is unavailable: ${reservation.reason}`
-			};
-		}
-		if (poolGeneration !== getClientPresignaturePoolGeneration(poolKey)) return {
-			ok: false,
-			code: "pool_entry_unavailable",
-			message: "Router A/B ECDSA derivation client presignature pool was invalidated before prepare"
-		};
-		preparationState = { kind: "prepare_submitted" };
-		const prepareStartedAt = performance.now();
-		const prepareResponse = await prepareRouterAbEcdsaDerivationEvmDigestSigningV1({
-			relayServerUrl: relayerUrl,
-			credential: args.credential,
-			request: prepareRequest,
-			onServerTiming: emitEcdsaServerTiming.bind(void 0, args.operationId, "prepare")
-		});
-		emitEcdsaSigningTiming(args.operationId, "prepare", prepareStartedAt);
-		if (prepareResponse.server_big_r33_b64u !== presignature.bigRB64u) return {
-			ok: false,
-			code: "presign_mismatch",
-			message: "Router A/B ECDSA derivation SigningWorker returned a different presignature bigR"
-		};
-		const commitStartedAt = performance.now();
-		await args.clientSigningMaterial.commitClientPresignature({
-			materialHandle: presignature.materialHandle,
-			poolIdentity,
-			requestBinding: prepareRequest.request_id,
-			reservationId,
-			workerCtx: args.workerCtx
-		});
-		emitEcdsaSigningTiming(args.operationId, "presignature_commit", commitStartedAt);
-		const bigR33 = base64UrlDecode(presignature.bigRB64u);
-		const signingWorkerRerandomizationContribution32 = base64UrlDecode(prepareResponse.signing_worker_rerandomization_contribution32_b64u);
-		try {
-			if (bigR33.length !== 33) return {
-				ok: false,
-				code: "internal",
-				message: "Router A/B ECDSA derivation presign bigR must decode to 33 bytes"
-			};
-			if (signingWorkerRerandomizationContribution32.length !== 32) return {
-				ok: false,
-				code: "internal",
-				message: "Router A/B ECDSA derivation SigningWorker rerandomization contribution must decode to 32 bytes"
-			};
-			const shareStartedAt = performance.now();
-			clientSignatureShare32 = await args.clientSigningMaterial.computeSignatureShareFromPresignatureHandle({
-				materialHandle: presignature.materialHandle,
-				poolIdentity,
-				requestBinding: prepareRequest.request_id,
-				reservationId,
-				groupPublicKey33,
-				expectedPresignBigR33: bigR33,
-				digest32: args.signingDigest32,
-				clientRerandomizationContribution32,
-				signingWorkerRerandomizationContribution32,
-				workerCtx: args.workerCtx
-			});
-			emitEcdsaSigningTiming(args.operationId, "client_share", shareStartedAt);
-			clientPresignatureCleanupState = { kind: "consumed" };
-		} finally {
-			zeroizeBytes(bigR33);
-			zeroizeBytes(signingWorkerRerandomizationContribution32);
-		}
-		if (clientSignatureShare32.length !== 32) return {
-			ok: false,
-			code: "internal",
-			message: `Invalid Router A/B ECDSA derivation client signature share length (expected 32, got ${clientSignatureShare32.length})`
-		};
-		const finalizeRequest = buildRouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1({
-			scope: args.scope,
-			requestId: prepareRequest.request_id,
-			operationId: prepareRequest.operation_id,
-			operationDigests: prepareRequest.operation_digests,
-			authorization: args.authorization,
-			materialActivation: args.materialActivation,
-			expiresAtMs: prepareRequest.expires_at_ms,
-			signingDigest32: args.signingDigest32,
-			serverPresignatureId: prepareResponse.server_presignature_id,
-			clientSignatureShare32,
-			clientRerandomizationContribution32
-		});
-		const finalizeStartedAt = performance.now();
-		const finalized = await finalizeRouterAbEcdsaDerivationEvmDigestSigningV1({
-			relayServerUrl: relayerUrl,
-			credential: args.credential,
-			request: finalizeRequest,
-			onServerTiming: emitEcdsaServerTiming.bind(void 0, args.operationId, "finalize")
-		});
-		emitEcdsaSigningTiming(args.operationId, "finalize", finalizeStartedAt);
-		const signature65 = base64UrlDecode(finalized.signature65_b64u);
-		if (signature65.length !== 65) return {
-			ok: false,
-			code: "internal",
-			message: `Router A/B ECDSA derivation returned invalid signature length (expected 65, got ${signature65.length})`
-		};
-		try {
-			const verifyStartedAt = performance.now();
-			await verifySecp256k1RecoverableSignatureAgainstPublicKey33Wasm({
-				digest32: args.signingDigest32,
-				signature65,
-				publicKey33: groupPublicKey33,
-				workerCtx: args.workerCtx
-			});
-			emitEcdsaSigningTiming(args.operationId, "signature_verify", verifyStartedAt);
-		} catch (error) {
-			return {
-				ok: false,
-				code: "internal",
-				message: `Router A/B ECDSA derivation returned a signature that does not recover to the threshold group public key: ${recoverableSignatureErrorMessage(error)}`
-			};
-		}
-		return {
-			ok: true,
-			signature65,
-			signature65B64u: finalized.signature65_b64u,
-			rB64u: base64UrlEncode(signature65.slice(0, 32)),
-			sB64u: base64UrlEncode(signature65.slice(32, 64)),
-			recId: signature65[64]
-		};
-	} catch (e) {
-		const msg = String(e && typeof e === "object" && "message" in e ? e.message : e || "Router A/B ECDSA derivation signing failed");
-		if (e instanceof RouterAbSigningRequestError && e.code === "expired_local_request") return {
-			ok: false,
-			code: "pool_entry_expired",
-			message: msg
-		};
-		if (poolKey && poolIdentity && poolGeneration !== null && preparationState.kind === "before_prepare" && getClientPresignaturePoolGeneration(poolKey) !== poolGeneration) {
-			await invalidateClientPresignaturePool({
-				poolKey,
-				poolIdentity,
-				clientSigningMaterial: args.clientSigningMaterial,
-				workerCtx: args.workerCtx
-			});
-			return {
-				ok: false,
-				code: "pool_entry_unavailable",
-				message: "Router A/B ECDSA derivation client presignature pool was invalidated before prepare"
-			};
-		}
-		return {
-			ok: false,
-			code: "router_ab_sign_failed",
-			message: msg
-		};
-	} finally {
-		zeroizeBytes(clientSignatureShare32);
-		zeroizeBytes(clientRerandomizationContribution32);
-		if (presignature && poolIdentity && clientPresignatureCleanupState.kind !== "consumed" && clientPresignatureCleanupState.kind !== "owned_elsewhere") {
-			let retainedUnclaimedEntry = false;
-			if (clientPresignatureCleanupState.kind === "unclaimed" && poolKey && poolGeneration !== null && poolGeneration === getClientPresignaturePoolGeneration(poolKey)) {
-				const pushResult = pushClientPresignature(poolKey, poolIdentity, presignature);
-				retainedUnclaimedEntry = pushResult === "stored" || pushResult === "duplicate";
-			}
-			if (!retainedUnclaimedEntry) await args.clientSigningMaterial.destroyClientPresignature({
-				materialHandle: presignature.materialHandle,
-				poolIdentity,
-				workerCtx: args.workerCtx
-			}).catch(() => {});
-		}
-		if (poolKey && foregroundStarted) finishForegroundSign(poolKey);
-	}
-}
-async function signRouterAbEcdsaDerivationDigestWithPool(args) {
-	const signingIdentity = routerAbEcdsaDerivationSigningIdentityFromScope(args.scope);
-	const expiresAtMs = Math.floor(Number(args.expiresAtMs));
-	if (!Number.isSafeInteger(expiresAtMs) || expiresAtMs <= Date.now()) return {
-		ok: false,
-		code: "invalid_pool_fill_expiry",
-		message: "Router A/B ECDSA derivation pool fill expiry is unavailable or expired"
-	};
-	const poolKey = ecdsaClientPresignPoolKey(makeClientPresignPoolIdentity({
-		relayerUrl: args.relayerUrl,
-		scope: args.scope,
-		materialActivation: args.materialActivation
-	}));
-	startForegroundSign(poolKey);
-	try {
-		const supply = {
-			kind: "on_demand",
-			refill: {
-				relayerUrl: args.relayerUrl,
-				keyHandle: args.keyHandle,
-				ecdsaThresholdKeyId: signingIdentity.ecdsaThresholdKeyId,
-				clientVerifyingShareB64u: signingIdentity.clientVerifyingShareB64u,
-				clientSigningMaterial: args.clientSigningMaterial,
-				thresholdEcdsaPublicKeyB64u: signingIdentity.thresholdEcdsaPublicKeyB64u,
-				credential: args.credential,
-				materialActivation: args.materialActivation,
-				routerAbEcdsaDerivationPoolFill: {
-					kind: "router_ab_ecdsa_derivation_signing_worker_pool",
-					scope: args.scope,
-					ceremonyExpiresAtMs: Math.min(expiresAtMs, Date.now() + ROUTER_AB_ECDSA_PRESIGN_CEREMONY_MAX_LIFETIME_MS - PRESIGN_CEREMONY_CLOCK_SKEW_MARGIN_MS),
-					materialExpiresAtMs: args.authorization.kind === "operation_step_up" ? expiresAtMs : Date.now() + MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS
-				},
-				workerCtx: args.workerCtx,
-				...ecdsaPoolFillAuthorization(args)
-			}
-		};
-		const result = await signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, 0, supply);
-		if (!result.ok && (result.code === "pool_entry_expired" || result.code === "pool_entry_unavailable")) return await signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, 0, supply);
-		return result;
-	} finally {
-		finishForegroundSign(poolKey);
-	}
-}
-async function refillRouterAbEcdsaDerivationClientPresignaturePool(args) {
-	try {
-		const poolIdentity = makeClientPresignPoolIdentity({
-			relayerUrl: args.relayerUrl,
-			scope: args.routerAbEcdsaDerivationPoolFill.scope,
-			materialActivation: args.materialActivation
-		});
-		const poolKey = ecdsaClientPresignPoolKey(poolIdentity);
-		await destroyExpiredClientPresignatures({
-			poolKey,
-			poolIdentity,
-			clientSigningMaterial: args.clientSigningMaterial,
-			workerCtx: args.workerCtx
-		});
-		const startedGeneration = getClientPresignaturePoolGeneration(poolKey);
-		const groupPublicKey33 = await resolveGroupPublicKey33({
-			clientVerifyingShareB64u: args.clientVerifyingShareB64u,
-			thresholdEcdsaPublicKeyB64u: args.thresholdEcdsaPublicKeyB64u,
-			relayerVerifyingShareB64u: args.relayerVerifyingShareB64u,
-			workerCtx: args.workerCtx
-		});
-		const generated = await runPresignHandshake({
-			relayerUrl: args.relayerUrl,
-			poolFillInitKeySelector: { keyHandle: formatEcdsaKeyHandleForWire(args.keyHandle) },
-			clientSigningMaterial: args.clientSigningMaterial,
-			groupPublicKey33,
-			materialActivation: args.materialActivation,
-			credential: args.credential,
-			poolKey,
-			trafficClass: args.trafficClass,
-			routerAbEcdsaDerivationPoolFill: args.routerAbEcdsaDerivationPoolFill,
-			workerCtx: args.workerCtx,
-			...ecdsaPoolFillAuthorization(args)
-		});
-		if (!generated.ok) return generated;
-		if (getClientPresignaturePoolGeneration(poolKey) !== startedGeneration) {
-			await args.clientSigningMaterial.destroyClientPresignature({
-				materialHandle: generated.presignature.materialHandle,
-				poolIdentity,
-				workerCtx: args.workerCtx
-			}).catch(() => {});
-			return {
-				ok: false,
-				code: "invalidated",
-				message: "Router A/B ECDSA derivation presignature pool invalidated"
-			};
-		}
-		const pushResult = pushClientPresignature(poolKey, poolIdentity, generated.presignature);
-		if (pushResult === "capacity_full" || pushResult === "invalid") await args.clientSigningMaterial.destroyClientPresignature({
-			materialHandle: generated.presignature.materialHandle,
-			poolIdentity,
-			workerCtx: args.workerCtx
-		}).catch(() => {});
-		return {
-			ok: true,
-			presignatureId: generated.presignature.presignatureId
-		};
-	} catch (e) {
-		return {
-			ok: false,
-			code: "internal",
-			message: String(e && typeof e === "object" && "message" in e ? e.message : e || "Router A/B ECDSA derivation presignature refill failed")
-		};
-	}
-}
-//#endregion
-export { clearAllRouterAbEcdsaDerivationClientPresignatures, clearRouterAbEcdsaDerivationClientPresignaturesForWallet, resolveRouterAbEcdsaDerivationPresignaturePoolPolicy, scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill, signRouterAbEcdsaDerivationDigestWithPool, waitForRouterAbEcdsaDerivationClientPresignaturePoolReady };
-
-//# sourceMappingURL=presignaturePool.js.map