@seams/wallet 0.8.0 → 0.9.0

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

@@ -1,16 +1,18 @@
 import { base64UrlDecode, base64UrlEncode } from "../../../../shared-ts/src/utils/base64.js";
+import { MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS } from "../../../config/presignatures.js";
 import { secureRandomId } from "../../../../shared-ts/src/utils/secureRandomId.js";
-import { canonicalRouterAbMpcMaterialActivationRefBytes } from "../../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
+import { ROUTER_AB_ECDSA_PRESIGN_CEREMONY_MAX_LIFETIME_MS, buildRouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1, buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1, parseRouterAbEcdsaDerivationNormalSigningScopeV1, 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 { ROUTER_AB_ECDSA_PRESIGN_CEREMONY_MAX_LIFETIME_MS, buildRouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1, buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1, parseRouterAbEcdsaDerivationNormalSigningScopeV1, routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1, routerAbEcdsaRerandomizationClientCommitmentV1 } from "../../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { FIXED_ECDSA_PRESIGN_PROTOCOL_ID, ecdsaClientPresignPoolKey } from "../../workerManager/ecdsaPresignPoolIdentity.js";
-import { MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS } from "../../workerManager/ecdsaPresignLifecycle.js";
-import { DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY } from "../../../config/defaultConfigs.js";
-import { emitEcdsaServerTiming, emitEcdsaSigningTiming, emitSigningSessionFlowTrace } from "../../session/operationState/trace.js";
-import { RouterAbSigningRequestError, finalizeRouterAbEcdsaDerivationEvmDigestSigningV1, prepareRouterAbEcdsaDerivationEvmDigestSigningV1 } from "../../../rpcClients/relayer/routerAbNormalSigning.js";
+import { ecdsaClientPresignPoolKey, makeClientPresignPoolIdentity } from "../../workerManager/ecdsaPresignPoolIdentity.js";
+import { assertCurrentWalletOwnershipGeneration } from "../../../indexedDB/seamsWalletDB/walletOwnershipGeneration.js";
 import { addSecp256k1PublicKeys33Wasm, validateSecp256k1PublicKey33Wasm, verifySecp256k1RecoverableSignatureAgainstPublicKey33Wasm } from "../../chains/evm/evmCryptoWasm.js";
+import { emitEcdsaServerTiming, emitEcdsaSigningTiming, emitSigningSessionFlowTrace } from "../../session/operationState/trace.js";
+import { WalletSessionQuotaAdmissionError } from "../../session/operationState/authorizationAdmission.js";
+import { WalletSessionFailureError } from "../../session/lifecycle/walletSessionFailure.js";
+import { normalizePresignPoolLowWatermark, normalizePresignPoolTargetDepth, resolveRouterAbEcdsaDerivationPresignaturePoolPolicy } from "./presignaturePoolPolicy.js";
 import { routerAbEcdsaDerivationPresignaturePoolFillInit, routerAbEcdsaDerivationPresignaturePoolFillStep } from "./poolFillRoutes.js";
+import { RouterAbSigningRequestError, finalizeRouterAbEcdsaDerivationEvmDigestSigningV1, prepareRouterAbEcdsaDerivationEvmDigestSigningV1 } from "../../../rpcClients/relayer/routerAbNormalSigning.js";
 import { PresignatureRefillProgressV1 } from "./presignatureRefillProgress.js";
 //#region src/core/signingEngine/routerAb/ecdsaDerivation/presignaturePool.ts
 function secureRerandomizationContribution32() {
@@ -49,8 +51,8 @@ const MAX_CLIENT_PRESIGNATURE_CLAIM_RETRIES = 4;
 const clientPresignaturePool = /* @__PURE__ */ new Map();
 const clientPresignaturePoolIdentityByPoolKey = /* @__PURE__ */ new Map();
 const clientPresignatureRefillInFlightByPoolKey = /* @__PURE__ */ new Map();
+const foregroundRefillInFlightByPoolKey = /* @__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";
@@ -58,48 +60,6 @@ function triplesAreComplete(stage) {
 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;
@@ -148,7 +108,21 @@ async function destroyExpiredClientPresignatures(input) {
 		workerCtx: input.workerCtx
 	});
 }
+async function assertCurrentClientPresignaturePool(identity, clientSigningMaterial, workerCtx) {
+	try {
+		await assertCurrentWalletOwnershipGeneration(identity.walletId, identity.ownershipGeneration);
+	} catch (error) {
+		await invalidateClientPresignaturePool({
+			poolIdentity: identity,
+			poolKey: ecdsaClientPresignPoolKey(identity),
+			clientSigningMaterial,
+			workerCtx
+		});
+		throw error;
+	}
+}
 async function hydrateClientPresignaturePool(input) {
+	await assertCurrentClientPresignaturePool(input.poolIdentity, input.clientSigningMaterial, input.workerCtx);
 	const existing = clientPresignatureHydrationInFlightByPoolKey.get(input.poolKey);
 	if (existing) {
 		await existing;
@@ -169,6 +143,9 @@ async function runClientPresignaturePoolHydration(input) {
 		poolIdentity: input.poolIdentity,
 		workerCtx: input.workerCtx
 	});
+	try {
+		await assertCurrentClientPresignaturePool(input.poolIdentity, input.clientSigningMaterial, input.workerCtx);
+	} catch {}
 	if (getClientPresignaturePoolGeneration(input.poolKey) !== input.generation) {
 		for (const ref of durableRefs) {
 			zeroizeBytes(ref.bigR33);
@@ -219,29 +196,27 @@ function bumpClientPresignaturePoolGeneration(poolKey) {
 }
 async function invalidateClientPresignaturePool(input) {
 	const refs = clientPresignaturePool.get(input.poolKey) ?? [];
-	clientPresignaturePool.delete(input.poolKey);
-	clientPresignaturePoolIdentityByPoolKey.delete(input.poolKey);
-	bumpClientPresignaturePoolGeneration(input.poolKey);
+	clearClientPresignaturePool(input.poolKey);
 	await destroyClientPresignatureRefs({
 		...input,
 		refs
 	});
 }
-function getForegroundSignInFlightCount(poolKey) {
-	return foregroundSignInFlightByPoolKey.get(poolKey) || 0;
+function getForegroundRefillInFlightCount(poolKey) {
+	return foregroundRefillInFlightByPoolKey.get(poolKey) || 0;
 }
-function startForegroundSign(poolKey) {
-	const current = getForegroundSignInFlightCount(poolKey);
-	foregroundSignInFlightByPoolKey.set(poolKey, current + 1);
+function startForegroundRefill(poolKey) {
+	const current = getForegroundRefillInFlightCount(poolKey);
+	foregroundRefillInFlightByPoolKey.set(poolKey, current + 1);
 }
-function finishForegroundSign(poolKey) {
-	const current = getForegroundSignInFlightCount(poolKey);
+function finishForegroundRefill(poolKey) {
+	const current = getForegroundRefillInFlightCount(poolKey);
 	if (current <= 1) {
-		foregroundSignInFlightByPoolKey.delete(poolKey);
+		foregroundRefillInFlightByPoolKey.delete(poolKey);
 		armPresignatureMaintenance(poolKey, 0);
 		return;
 	}
-	foregroundSignInFlightByPoolKey.set(poolKey, current - 1);
+	foregroundRefillInFlightByPoolKey.set(poolKey, current - 1);
 }
 async function waitForAvailablePresignatureFromInFlightRefill(poolKey, priority) {
 	const progress = clientPresignatureRefillInFlightByPoolKey.get(poolKey);
@@ -249,16 +224,6 @@ async function waitForAvailablePresignatureFromInFlightRefill(poolKey, priority)
 	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,
@@ -267,33 +232,12 @@ function buildPresignatureRefillNotScheduledResult(reason, depth, targetDepth) {
 		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);
-	}
+function clearClientPresignaturePool(poolKey) {
+	clientPresignaturePool.delete(poolKey);
+	clientPresignaturePoolIdentityByPoolKey.delete(poolKey);
+	bumpClientPresignaturePoolGeneration(poolKey);
+	clientPresignatureRefillInFlightByPoolKey.get(poolKey)?.settle();
+	clientPresignatureRefillInFlightByPoolKey.delete(poolKey);
 }
 const presignatureMaintenance = /* @__PURE__ */ new Map();
 function stopPresignatureMaintenance(poolKey) {
@@ -377,14 +321,12 @@ async function runBackgroundPresignatureRefill(input) {
 			workerCtx: args.workerCtx,
 			generation: scheduledGeneration
 		});
-		if (getClientPresignaturePoolDepth(poolKey) > 0) {
-			progress.publishAvailable();
-			if (getForegroundSignInFlightCount(poolKey) > 0) return;
-		}
+		if (getClientPresignaturePoolDepth(poolKey) > 0) progress.publishAvailable();
 		while (Date.now() < args.routerAbEcdsaDerivationPoolFill.ceremonyExpiresAtMs) {
 			if (getClientPresignaturePoolGeneration(poolKey) !== scheduledGeneration) return;
 			if ((presignatureMaintenance.get(poolKey) ?? null) !== attemptMaintenance) return;
 			if (getClientPresignaturePoolDepth(poolKey) >= targetDepth) return;
+			if (getForegroundRefillInFlightCount(poolKey) > 0) return;
 			if (typeof navigator !== "undefined" && navigator.onLine === false) return;
 			const attemptDeadlineAtMs = Math.min(Date.now() + refillAttemptTimeoutMs, args.routerAbEcdsaDerivationPoolFill.ceremonyExpiresAtMs);
 			const refill = await refillRouterAbEcdsaDerivationClientPresignaturePool({
@@ -412,7 +354,6 @@ async function runBackgroundPresignatureRefill(input) {
 			const maintenance = presignatureMaintenance.get(poolKey);
 			if (maintenance && maintenance === attemptMaintenance) maintenance.failures = 0;
 			progress.publishAvailable();
-			if (getForegroundSignInFlightCount(poolKey) > 0) return;
 		}
 	} catch {
 		recordPresignatureRefillFailure(poolKey, attemptMaintenance, "internal");
@@ -432,6 +373,7 @@ function scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill(args) {
 	try {
 		const policy = resolveRouterAbEcdsaDerivationPresignaturePoolPolicy(args.poolPolicy);
 		const poolIdentity = makeClientPresignPoolIdentity({
+			ownershipGeneration: args.credential.ownershipGeneration,
 			relayerUrl: args.relayerUrl,
 			scope: args.routerAbEcdsaDerivationPoolFill.scope,
 			materialActivation: args.materialActivation
@@ -450,8 +392,7 @@ function scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill(args) {
 		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.has(poolKey) || getForegroundRefillInFlightCount(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,
@@ -548,6 +489,7 @@ async function runPresignHandshakeAttempt(args) {
 	const presignSessionId = `ecdsa-presign-v2:${ceremonyExpiresAtMs}:${base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)))}`;
 	const localSessionId = presignSessionId;
 	const poolIdentity = makeClientPresignPoolIdentity({
+		ownershipGeneration: args.credential.ownershipGeneration,
 		relayerUrl: args.relayerUrl,
 		scope: args.routerAbEcdsaDerivationPoolFill.scope,
 		materialActivation: args.materialActivation
@@ -765,7 +707,6 @@ function resolveSigningRequestExpiresAtMs(input) {
 async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCount, supply) {
 	let poolKey = null;
 	let poolIdentity = null;
-	let foregroundStarted = false;
 	let presignature = null;
 	let clientSignatureShare32 = null;
 	let clientRerandomizationContribution32 = null;
@@ -804,14 +745,14 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 		});
 		emitEcdsaSigningTiming(args.operationId, "public_key_validation", publicKeyStartedAt);
 		poolIdentity = makeClientPresignPoolIdentity({
+			ownershipGeneration: args.credential.ownershipGeneration,
 			relayerUrl,
 			scope: args.scope,
 			materialActivation: args.materialActivation
 		});
+		await assertCurrentClientPresignaturePool(poolIdentity, args.clientSigningMaterial, args.workerCtx);
 		poolKey = ecdsaClientPresignPoolKey(poolIdentity);
 		clientPresignaturePoolIdentityByPoolKey.set(poolKey, poolIdentity);
-		startForegroundSign(poolKey);
-		foregroundStarted = true;
 		poolGeneration = getClientPresignaturePoolGeneration(poolKey);
 		const lookupStartedAt = performance.now();
 		presignature = await takeClientPresignature({
@@ -853,22 +794,27 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 		}
 		if (!presignature && supply.kind === "on_demand") {
 			const foregroundRefillStartedAt = performance.now();
-			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)
-			});
+			startForegroundRefill(poolKey);
+			try {
+				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)
+				});
+			} finally {
+				finishForegroundRefill(poolKey);
+			}
 			poolGeneration = getClientPresignaturePoolGeneration(poolKey);
 			presignature = await takeClientPresignature({
 				poolKey,
@@ -902,6 +848,7 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 			code: "pool_entry_expired",
 			message: "Router A/B ECDSA derivation client presignature is expired"
 		};
+		await assertCurrentClientPresignaturePool(poolIdentity, args.clientSigningMaterial, args.workerCtx);
 		if (poolGeneration !== getClientPresignaturePoolGeneration(poolKey)) return {
 			ok: false,
 			code: "pool_entry_unavailable",
@@ -944,20 +891,27 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 				message: `Router A/B ECDSA derivation client presignature is unavailable: ${reservation.reason}`
 			};
 		}
+		await assertCurrentClientPresignaturePool(poolIdentity, args.clientSigningMaterial, args.workerCtx);
 		if (poolGeneration !== getClientPresignaturePoolGeneration(poolKey)) return {
 			ok: false,
 			code: "pool_entry_unavailable",
 			message: "Router A/B ECDSA derivation client presignature pool was invalidated before prepare"
 		};
+		armPresignatureMaintenance(poolKey, 0);
 		preparationState = { kind: "prepare_submitted" };
 		const prepareStartedAt = performance.now();
-		const prepareResponse = await prepareRouterAbEcdsaDerivationEvmDigestSigningV1({
+		const prepared = await prepareRouterAbEcdsaDerivationEvmDigestSigningV1({
 			relayServerUrl: relayerUrl,
 			credential: args.credential,
 			request: prepareRequest,
 			onServerTiming: emitEcdsaServerTiming.bind(void 0, args.operationId, "prepare")
 		});
 		emitEcdsaSigningTiming(args.operationId, "prepare", prepareStartedAt);
+		if (prepared.kind === "reusable_wallet_session") {
+			if (!args.reconcileSession) throw new Error("Wallet Session reconciliation is required");
+			await args.reconcileSession(prepared.sessionStatus);
+		}
+		const prepareResponse = prepared.signing;
 		if (prepareResponse.server_big_r33_b64u !== presignature.bigRB64u) return {
 			ok: false,
 			code: "presign_mismatch",
@@ -1061,6 +1015,7 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 			recId: signature65[64]
 		};
 	} catch (e) {
+		if (e instanceof WalletSessionQuotaAdmissionError || e instanceof WalletSessionFailureError) throw 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,
@@ -1100,7 +1055,7 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 				workerCtx: args.workerCtx
 			}).catch(() => {});
 		}
-		if (poolKey && foregroundStarted) finishForegroundSign(poolKey);
+		if (poolKey) armPresignatureMaintenance(poolKey, 0);
 	}
 }
 async function signRouterAbEcdsaDerivationDigestWithPool(args) {
@@ -1111,48 +1066,40 @@ async function signRouterAbEcdsaDerivationDigestWithPool(args) {
 		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);
-	}
+	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;
 }
 async function refillRouterAbEcdsaDerivationClientPresignaturePool(args) {
 	try {
 		const poolIdentity = makeClientPresignPoolIdentity({
+			ownershipGeneration: args.credential.ownershipGeneration,
 			relayerUrl: args.relayerUrl,
 			scope: args.routerAbEcdsaDerivationPoolFill.scope,
 			materialActivation: args.materialActivation
 		});
+		await assertCurrentClientPresignaturePool(poolIdentity, args.clientSigningMaterial, args.workerCtx);
 		const poolKey = ecdsaClientPresignPoolKey(poolIdentity);
 		await destroyExpiredClientPresignatures({
 			poolKey,
@@ -1181,6 +1128,9 @@ async function refillRouterAbEcdsaDerivationClientPresignaturePool(args) {
 			...ecdsaPoolFillAuthorization(args)
 		});
 		if (!generated.ok) return generated;
+		try {
+			await assertCurrentClientPresignaturePool(poolIdentity, args.clientSigningMaterial, args.workerCtx);
+		} catch {}
 		if (getClientPresignaturePoolGeneration(poolKey) !== startedGeneration) {
 			await args.clientSigningMaterial.destroyClientPresignature({
 				materialHandle: generated.presignature.materialHandle,
@@ -1212,6 +1162,6 @@ async function refillRouterAbEcdsaDerivationClientPresignaturePool(args) {
 	}
 }
 //#endregion
-export { clearAllRouterAbEcdsaDerivationClientPresignatures, clearRouterAbEcdsaDerivationClientPresignaturesForWallet, resolveRouterAbEcdsaDerivationPresignaturePoolPolicy, scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill, signRouterAbEcdsaDerivationDigestWithPool, waitForRouterAbEcdsaDerivationClientPresignaturePoolReady };
+export { scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill, signRouterAbEcdsaDerivationDigestWithPool };
 
 //# sourceMappingURL=presignaturePool.js.map

package/dist/esm/core/signingEngine/routerAb/ecdsaDerivation/presignaturePoolPolicy.js

@@ -0,0 +1,31 @@
+import { DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY } from "../../../config/defaultConfigs.js";
+//#region src/core/signingEngine/routerAb/ecdsaDerivation/presignaturePoolPolicy.ts
+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)
+	};
+}
+//#endregion
+export { normalizePresignPoolLowWatermark, normalizePresignPoolTargetDepth, resolveRouterAbEcdsaDerivationPresignaturePoolPolicy };
+
+//# sourceMappingURL=presignaturePoolPolicy.js.map

package/dist/esm/core/signingEngine/routerAb/ecdsaDerivation/signingMaterialRef.js

@@ -1,6 +1,6 @@
+import { requireRouterAbEcdsaDerivationNormalSigningStateV1, routerAbEcdsaDerivationActiveStateId } from "../../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
 import { parseEcdsaClientVerifyingShareB64u } from "../../../../shared-ts/src/threshold/keyMaterialBrands.js";
 import { parseEcdsaThresholdKeyId } from "../../session/keyMaterialBrands.js";
-import { requireRouterAbEcdsaDerivationNormalSigningStateV1, routerAbEcdsaDerivationActiveStateId } from "../../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
 //#region src/core/signingEngine/routerAb/ecdsaDerivation/signingMaterialRef.ts
 function buildRouterAbEcdsaDerivationSigningMaterialRef(args) {
 	const routerAbState = requireRouterAbEcdsaDerivationNormalSigningStateV1(args.routerAbState);