@seams/wallet 0.6.2 → 0.7.3

package/dist/{esm/sdk/runtimeLoader-ZXsvx9zX.js → public/sdk/runtimeLoader-DQVEFVaW.js}

@@ -5,7 +5,7 @@ let registrationPreparationPromise = null;
 let recoveryCodeSurfacePromise = null;
 function loadWalletHostRuntime(route) {
 	if (route.type === "PM_ACKNOWLEDGE_WALLET_RECOVERY_CODE_BACKUP") {
-		recoveryCodeRuntimePromise ??= import("./runtime-recovery-codes-DW7bB2tO.js");
+		recoveryCodeRuntimePromise ??= import("./runtime-recovery-codes-BSCLVHQj.js");
 		return recoveryCodeRuntimePromise;
 	}
 	runtimePromises[route.kind] ??= loadRuntimeForKind(route.kind);
@@ -16,24 +16,24 @@ async function preloadWalletHostRegistrationSurface() {
 	await Promise.all([runtimePromises.near, preloadRegistrationPreparation()]);
 }
 async function preloadWalletHostRecoveryCodeSurface() {
-	recoveryCodeRuntimePromise ??= import("./runtime-recovery-codes-DW7bB2tO.js");
-	recoveryCodeSurfacePromise ??= Promise.all([recoveryCodeRuntimePromise, import("./mountRecoveryCodeBackupSurface-ChwzwnYG.js")]).then(() => void 0);
+	recoveryCodeRuntimePromise ??= import("./runtime-recovery-codes-BSCLVHQj.js");
+	recoveryCodeSurfacePromise ??= Promise.all([recoveryCodeRuntimePromise, import("./mountRecoveryCodeBackupSurface-DXrExiJ7.js")]).then(() => void 0);
 	await recoveryCodeSurfacePromise;
 }
 async function preloadRegistrationPreparation() {
-	registrationPreparationPromise ??= import("./registrationPreparationPreload-BZfAC_ba.js");
+	registrationPreparationPromise ??= import("./registrationPreparationPreload-D6zpWp4O.js");
 	await (await registrationPreparationPromise).preloadWalletHostRegistrationPreparation();
 }
 function loadRuntimeForKind(kind) {
 	switch (kind) {
-		case "auth": return import("./runtime-auth-D_lUQQlc.js");
-		case "near": return import("./runtime-near-CGoWxu7u.js");
-		case "ecdsa": return import("./runtime-ecdsa-tempo-tUWnafRo.js");
-		case "email_otp": return import("./runtime-email-otp-1wIPTDim.js");
-		case "recovery": return import("./runtime-recovery-BEqBdpyo.js");
-		case "export": return import("./runtime-export-Du2d4_Vu.js");
-		case "device_link": return import("./runtime-device-link-CEph1iM0.js");
-		case "preferences": return import("./runtime-preferences-JwJK_xP3.js");
+		case "auth": return import("./runtime-auth-DdfynDKt.js");
+		case "near": return import("./runtime-near-CxtQi4b2.js");
+		case "ecdsa": return import("./runtime-ecdsa-tempo-BGLsTAWR.js");
+		case "email_otp": return import("./runtime-email-otp-CpX88VZJ.js");
+		case "recovery": return import("./runtime-recovery-i08vCJST.js");
+		case "export": return import("./runtime-export-DIVY473L.js");
+		case "device_link": return import("./runtime-device-link-HJ2ptFux.js");
+		case "preferences": return import("./runtime-preferences-vnJc5Svg.js");
 	}
 	return assertNever(kind);
 }

package/dist/{esm/sdk/sdkSentEvents-5Pi-hjHB.js → public/sdk/sdkSentEvents-MqDkbQg1.js}

@@ -1,6 +1,8 @@
-import { R as parseWalletId, b as parseLinkedDeviceEnrollmentId } from "./normalize-BephcEIF.js";
-import { o as isWalletAuthMethod } from "./signerDomain-DDLiwuYS.js";
-import { h as parseWalletSessionId } from "./capabilityKinds-jwCEaqBU.js";
+import { O as parseWalletId, u as parseLinkedDeviceEnrollmentId } from "./domainIds-lcrFg6Sa.js";
+import { h as parseWalletSessionId } from "./capabilityKinds-hvYqa6S_.js";
+import { o as isWalletAuthMethod } from "./signerDomain-IEAVrOrc.js";
+//#region src/core/types/sdkSentEvents.ts
+const SDK_LIFECYCLE_EVENT_VERSION = 1;
 const SIGNING_SESSION_EXPIRY_DETECTION_SOURCES = {
 	restore: "restore",
 	visibility: "visibility",
@@ -10,7 +12,7 @@ const SIGNING_SESSION_EXPIRY_DETECTION_SOURCES = {
 };
 function createNearProvisioningStateChangedEvent(input) {
 	return {
-		version: 1,
+		version: SDK_LIFECYCLE_EVENT_VERSION,
 		event: "registration.near_provisioning_changed",
 		walletId: input.walletId,
 		state: input.state
@@ -84,7 +86,7 @@ function createSigningSessionExpiredEvent(input) {
 	if (!isPositiveSafeInteger(input.detectedAtMs)) throw new Error("signing_session.expired detectedAtMs must be a positive safe integer");
 	if (input.expiresAtMs > input.detectedAtMs) throw new Error("signing_session.expired timeline is invalid");
 	return {
-		version: 1,
+		version: SDK_LIFECYCLE_EVENT_VERSION,
 		event: "signing_session.expired",
 		walletId: input.walletId,
 		walletSessionId: input.walletSessionId,
@@ -96,14 +98,14 @@ function createSigningSessionExpiredEvent(input) {
 }
 function parseSdkLifecycleEvent(value) {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
-	if (Reflect.get(value, "version") !== 1) return null;
+	if (Reflect.get(value, "version") !== SDK_LIFECYCLE_EVENT_VERSION) return null;
 	switch (Reflect.get(value, "event")) {
 		case "registration.near_provisioning_changed": {
 			const walletId = parseWalletId(Reflect.get(value, "walletId"));
 			const state = parseNearProvisioningState(Reflect.get(value, "state"));
 			if (!walletId.ok || !state) return null;
 			return {
-				version: 1,
+				version: SDK_LIFECYCLE_EVENT_VERSION,
 				event: "registration.near_provisioning_changed",
 				walletId: walletId.value,
 				state
@@ -126,7 +128,7 @@ function parseSdkLifecycleEvent(value) {
 	const source = parseSigningSessionExpiryDetectionSource(Reflect.get(value, "source"));
 	if (!source) return null;
 	return {
-		version: 1,
+		version: SDK_LIFECYCLE_EVENT_VERSION,
 		event: "signing_session.expired",
 		walletId: walletId.value,
 		walletSessionId: walletSessionId.value,

package/dist/public/sdk/{secp256k1-CWDid9WH.js → secp256k1-D-I6Gh4D.js}

@@ -1,15 +1,15 @@
 import { n as __exportAll } from "./chunk-BtrIJ4_z.js";
-import { T as parseMpcMaterialActivationRef, c as normalizeTrimmedString, l as stripTrailingSlashes, p as mpcMaterialActivationRefsEqual } from "./normalize-BephcEIF.js";
+import { B as normalizeTrimmedString, V as stripTrailingSlashes, h as parseMpcMaterialActivationRef, r as mpcMaterialActivationRefsEqual } from "./domainIds-lcrFg6Sa.js";
 import { i as base64UrlEncode, r as base64UrlDecode } from "./base64-Clm8C-e9.js";
 import { r as secureRandomId } from "./secureRandomId-BORsmdS4.js";
-import { Bt as parseWalletAuthAuthorityRef, Cn as routerAbMpcMaterialActivationRefToWire, J as ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_STEP_PATH, St as routerAbEcdsaRerandomizationClientCommitmentV1, X as buildRouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1, Z as buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1, nt as parseRouterAbEcdsaDerivationNormalSigningScopeV1, q as ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_INIT_PATH, t as MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS, xt as routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1, yn as canonicalRouterAbMpcMaterialActivationRefBytes } from "./ecdsaPresignLifecycle-CnSnzoRJ.js";
-import { d as parseEcdsaThresholdKeyId, i as parseEcdsaKeyHandle, l as parseEcdsaRoleLocalPersistedMaterialRef, r as parseEcdsaClientVerifyingShareB64u, t as formatEcdsaKeyHandleForWire, u as parseEcdsaRoleLocalWorkerHandle } from "./keyMaterialBrands-BbjCfzXv.js";
-import { t as executeWorkerOperation } from "./executeWorkerOperation-Bn8GEuT_.js";
-import { n as ecdsaClientPresignPoolKey, t as FIXED_ECDSA_PRESIGN_PROTOCOL_ID } from "./ecdsaPresignPoolIdentity-Yopr4jvS.js";
-import { i as emitEcdsaSigningTiming, n as emitEcdsaPresignServerTiming, r as emitEcdsaServerTiming, u as emitSigningSessionFlowTrace } from "./trace-08ayoiNp.js";
-import { t as DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY } from "./defaultConfigs-CyNOW4Sy.js";
-import { c as prepareRouterAbEcdsaDerivationEvmDigestSigningV1, l as prepareRouterAbEcdsaFinalPresignBatchV1, o as finalizeRouterAbEcdsaDerivationEvmDigestSigningV1, t as RouterAbSigningRequestError } from "./routerAbNormalSigning-DktZKnf1.js";
-import { o as validateSecp256k1PublicKey33Wasm, s as verifySecp256k1RecoverableSignatureAgainstPublicKey33Wasm, t as addSecp256k1PublicKeys33Wasm } from "./evmCryptoWasm-BVj135bZ.js";
+import { Et as routerAbMpcMaterialActivationRefToWire, F as routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1, I as routerAbEcdsaRerandomizationClientCommitmentV1, St as canonicalRouterAbMpcMaterialActivationRefBytes, d as buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1, g as parseRouterAbEcdsaDerivationNormalSigningScopeV1, l as ROUTER_AB_ECDSA_PRESIGN_CEREMONY_MAX_LIFETIME_MS, nt as parseWalletAuthAuthorityRef, o as ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_INIT_PATH, s as ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_STEP_PATH, t as MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS, u as buildRouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1 } from "./ecdsaPresignLifecycle-Bfx2AQKb.js";
+import { a as parseEcdsaRoleLocalPersistedMaterialRef, c as formatEcdsaKeyHandleForWire, l as parseEcdsaClientVerifyingShareB64u, o as parseEcdsaRoleLocalWorkerHandle, s as parseEcdsaThresholdKeyId, u as parseEcdsaKeyHandle } from "./keyMaterialBrands-CogGAAZn.js";
+import { t as executeWorkerOperation } from "./executeWorkerOperation-Cl9whMK7.js";
+import { n as ecdsaClientPresignPoolKey, t as FIXED_ECDSA_PRESIGN_PROTOCOL_ID } from "./ecdsaPresignPoolIdentity-BjxZVIqn.js";
+import { i as emitEcdsaSigningTiming, n as emitEcdsaPresignServerTiming, r as emitEcdsaServerTiming, u as emitSigningSessionFlowTrace } from "./trace-DKLQZvec.js";
+import { t as DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY } from "./defaultConfigs-D_33pPT9.js";
+import { c as prepareRouterAbEcdsaDerivationEvmDigestSigningV1, o as finalizeRouterAbEcdsaDerivationEvmDigestSigningV1, t as RouterAbSigningRequestError } from "./routerAbNormalSigning-CVFEOZ2m.js";
+import { o as validateSecp256k1PublicKey33Wasm, s as verifySecp256k1RecoverableSignatureAgainstPublicKey33Wasm, t as addSecp256k1PublicKeys33Wasm } from "./evmCryptoWasm-DWklhEEb.js";
 //#region src/core/signingEngine/workerManager/workerTypes.ts
 /**
 * Control messages exchanged between worker shims and the main thread.
@@ -91,11 +91,12 @@ const EcdsaPresignClientResponseType = {
 };
 const EcdsaOnlineClientRequestType = { ComputeSignatureShare: 72e3 };
 const EcdsaOnlineClientResponseType = { ComputeSignatureShareSuccess: 72100 };
+const DEFAULT_SIGNER_HOST_ERROR_CODE = "SIGNER_INTERNAL";
 var SignerWorkerOperationError = class extends Error {
 	constructor(args) {
 		super(args.message);
 		this.name = "SignerWorkerOperationError";
-		this.code = (args.code || "SIGNER_INTERNAL").trim();
+		this.code = (args.code || DEFAULT_SIGNER_HOST_ERROR_CODE).trim();
 		this.coreCode = args.coreCode?.trim() || void 0;
 		this.workerKind = args.workerKind;
 	}
@@ -378,7 +379,8 @@ async function prepareLinkedDeviceEcdsaSourceContributionWasm(input) {
 			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
 			payload: {
 				kind: "prepare_linked_device_ecdsa_source_contribution_v1",
-				preparation: input.preparation
+				preparation: input.preparation,
+				...input.linkedHolderHandleId === void 0 ? {} : { linkedHolderHandleId: input.linkedHolderHandleId }
 			}
 		}
 	});
@@ -675,16 +677,19 @@ async function thresholdEcdsaRoleLocalCommitPresignatureWasm(input) {
 		}
 	})).type !== EcdsaPresignClientResponseType.CommitSuccess) throw new Error("ThresholdEcdsaRoleLocalCommitPresignature failed");
 }
-async function thresholdEcdsaRoleLocalListAvailablePresignaturesWasm(input) {
+async function thresholdEcdsaListAvailablePresignaturesWasm(authorityKind, input) {
 	const response = await requestEcdsaPresignOperation({
 		workerCtx: input.workerCtx,
 		request: {
 			type: EcdsaPresignClientRequestType.ListAvailable,
 			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: { poolIdentity: input.poolIdentity }
+			payload: {
+				authority: { kind: authorityKind },
+				poolIdentity: input.poolIdentity
+			}
 		}
 	});
-	if (response.type !== EcdsaPresignClientResponseType.ListAvailableSuccess) throw new Error("ThresholdEcdsaRoleLocalListAvailablePresignatures failed");
+	if (response.type !== EcdsaPresignClientResponseType.ListAvailableSuccess) throw new Error("ThresholdEcdsaListAvailablePresignatures failed");
 	return response.payload.map(parseListedClientPresignature);
 }
 async function thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm(input) {
@@ -1083,6 +1088,7 @@ function assertRouterAbEcdsaDerivationClientSigningMaterialSource(source) {
 }
 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();
@@ -1591,8 +1597,6 @@ async function runPresignHandshakeAttempt(args) {
 		scope: args.routerAbEcdsaDerivationPoolFill.scope,
 		materialActivation: args.materialActivation
 	});
-	let terminalCandidate = null;
-	let handoff = null;
 	let localPresignatureHandle = null;
 	let localBigR33 = null;
 	let serverPresignatureId = null;
@@ -1651,7 +1655,6 @@ async function runPresignHandshakeAttempt(args) {
 					incomingMessages: pendingServerOutgoing,
 					workerCtx: args.workerCtx
 				});
-				if (localStepped.event === "final_batch_ready") terminalCandidate = localStepped.candidateBigR33;
 				clientStage = localStepped.stage;
 				pendingServerOutgoing = [];
 				pendingClientOutgoing.push(...localStepped.outgoingMessages);
@@ -1660,32 +1663,6 @@ async function runPresignHandshakeAttempt(args) {
 					localBigR33 = localStepped.presignatureBigR33;
 				}
 			}
-			if (terminalCandidate && !serverDone) {
-				const waiting = finalBatchHandoffs.get(args.poolKey);
-				if (waiting?.state.kind === "waiting") {
-					handoff = waiting;
-					finalBatchHandoffs.delete(args.poolKey);
-					if (pendingClientOutgoing.length !== 2) throw new Error("Final batch must contain two messages");
-					const prepared = await handoff.prepare(terminalCandidate, {
-						kind: "final_presign_batch",
-						batch: {
-							scope: args.routerAbEcdsaDerivationPoolFill.scope,
-							presign_session_id: presignSessionId,
-							requested_stage: "presign",
-							outgoing_messages_b64u: [base64UrlEncode(pendingClientOutgoing[0]), base64UrlEncode(pendingClientOutgoing[1])],
-							ceremony_expires_at_ms: ceremonyExpiresAtMs,
-							material_expires_at_ms: materialExpiresAtMs
-						}
-					});
-					pendingClientOutgoing = [];
-					pendingServerOutgoing = fromB64uMessages(prepared.outgoingMessagesB64u);
-					serverStage = "presign";
-					serverPresignatureId = prepared.preparedResponse.server_presignature_id;
-					serverBigRB64u = prepared.preparedResponse.server_big_r33_b64u;
-					serverDone = true;
-				}
-				terminalCandidate = null;
-			}
 			if (!serverDone) {
 				const roundStartedAt = performance.now();
 				const requestTag = presignHandshakeRequestTag(args);
@@ -1753,22 +1730,6 @@ async function runPresignHandshakeAttempt(args) {
 				code: "presign_mismatch",
 				message: "Client/server presignature mismatch (bigR mismatch)"
 			};
-			if (handoff) {
-				handoff.complete({
-					presignatureId: serverPresignatureId,
-					bigRB64u: localBigRB64u,
-					materialHandle: localPresignatureHandle,
-					createdAtMs,
-					expiresAtMs: materialExpiresAtMs
-				});
-				keepLocalMaterial = true;
-				shouldAbortLocalSession = false;
-				return {
-					ok: true,
-					kind: "handed_off",
-					presignatureId: serverPresignatureId
-				};
-			}
 			const admission = await args.clientSigningMaterial.admitClientPresignature({
 				materialHandle: localPresignatureHandle,
 				expectedPresignatureId: serverPresignatureId,
@@ -1803,10 +1764,6 @@ async function runPresignHandshakeAttempt(args) {
 			zeroizeBytes(localBigR33);
 		}
 	} catch (e) {
-		if (handoff) handoff.state = {
-			kind: "failed",
-			error: e
-		};
 		return {
 			ok: false,
 			code: "presign_failed",
@@ -1850,68 +1807,7 @@ function resolveSigningRequestExpiresAtMs(input) {
 	const expiresAtMs = Math.min(materialExpiresAtMs, authorizationExpiresAtMs, input.nowMs + ROUTER_AB_ECDSA_DERIVATION_SIGNING_TTL_MS);
 	return Number.isSafeInteger(expiresAtMs) && expiresAtMs > input.nowMs ? expiresAtMs : null;
 }
-var EcdsaFinalBatchHandoff = class {
-	constructor(input, poolKey, generation) {
-		this.input = input;
-		this.poolKey = poolKey;
-		this.generation = generation;
-		this.state = { kind: "waiting" };
-		this.contribution = secureRerandomizationContribution32();
-	}
-	async prepare(candidateBigR33, source) {
-		if (this.state.kind !== "waiting" || getClientPresignaturePoolGeneration(this.poolKey) !== this.generation) throw new Error("Signing handoff was cancelled before prepare");
-		this.state = { kind: "submitted" };
-		const idDigest = await crypto.subtle.digest("SHA-256", new Uint8Array(candidateBigR33));
-		const expiresAtMs = resolveSigningRequestExpiresAtMs({
-			authorizationExpiresAtMs: this.input.expiresAtMs,
-			materialExpiresAtMs: source.batch.material_expires_at_ms,
-			nowMs: Date.now()
-		});
-		if (!expiresAtMs) throw new Error("Signing handoff expired before prepare");
-		const commitment = await routerAbEcdsaRerandomizationClientCommitmentV1(this.contribution);
-		const request = buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1({
-			scope: this.input.scope,
-			requestId: secureRandomId("router-ab-ecdsa-sign", 32, "ECDSA signing request"),
-			operationId: this.input.operationId,
-			operationDigests: this.input.operationDigests,
-			authorization: this.input.authorization,
-			materialActivation: this.input.materialActivation,
-			clientPresignatureId: `presig-${base64UrlEncode(new Uint8Array(idDigest))}`,
-			expiresAtMs,
-			signingDigest32: this.input.signingDigest32,
-			clientRerandomizationCommitment32: commitment
-		});
-		zeroizeBytes(commitment);
-		if (getClientPresignaturePoolGeneration(this.poolKey) !== this.generation) throw new Error("Signing handoff was cancelled before submission");
-		const result = await prepareRouterAbEcdsaFinalPresignBatchV1({
-			relayServerUrl: this.input.relayerUrl,
-			credential: this.input.credential,
-			request,
-			source
-		});
-		if (getClientPresignaturePoolGeneration(this.poolKey) !== this.generation) throw new Error("Signing handoff was cancelled during prepare");
-		this.state = {
-			kind: "prepared",
-			prepared: {
-				request,
-				response: result.preparedResponse
-			}
-		};
-		return result;
-	}
-	complete(presignature) {
-		if (this.state.kind !== "prepared" || getClientPresignaturePoolGeneration(this.poolKey) !== this.generation) throw new Error("Signing handoff cannot claim completed material");
-		this.state = {
-			kind: "ready",
-			prepared: this.state.prepared,
-			presignature
-		};
-	}
-};
-const finalBatchHandoffs = /* @__PURE__ */ new Map();
 async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCount, supply) {
-	let handoff = null;
-	let handedOffPrepare = null;
 	let poolKey = null;
 	let poolIdentity = null;
 	let foregroundStarted = false;
@@ -1989,10 +1885,6 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 			});
 		}
 		if (!presignature) {
-			if (!finalBatchHandoffs.has(poolKey)) {
-				handoff = new EcdsaFinalBatchHandoff(args, poolKey, poolGeneration);
-				finalBatchHandoffs.set(poolKey, handoff);
-			}
 			const refillWaitStartedAt = performance.now();
 			await waitForAvailablePresignatureFromInFlightRefill(poolKey, "foreground");
 			emitEcdsaSigningTiming(args.operationId, "refill_wait", refillWaitStartedAt);
@@ -2004,16 +1896,17 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 				workerCtx: args.workerCtx
 			});
 		}
-		if (!presignature && handoff?.state.kind === "waiting" && supply.kind === "on_demand") {
+		if (!presignature && supply.kind === "on_demand") {
+			const foregroundRefillStartedAt = performance.now();
 			let refill = await refillRouterAbEcdsaDerivationClientPresignaturePool({
 				...supply.refill,
 				trafficClass: "foreground"
 			});
-			if (!refill.ok && refill.code === "invalidated" && handoff.state.kind === "waiting") refill = await refillRouterAbEcdsaDerivationClientPresignaturePool({
+			if (!refill.ok && refill.code === "invalidated") refill = await refillRouterAbEcdsaDerivationClientPresignaturePool({
 				...supply.refill,
 				trafficClass: "foreground"
 			});
-			if (!refill.ok && handoff.state.kind === "waiting" && refill.code !== "pool_full") return refill;
+			if (!refill.ok && refill.code !== "pool_full") return refill;
 			if (!refill.ok && refill.code === "pool_full") await hydrateClientPresignaturePool({
 				poolKey,
 				poolIdentity,
@@ -2028,14 +1921,7 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 				clientSigningMaterial: args.clientSigningMaterial,
 				workerCtx: args.workerCtx
 			});
-		}
-		if (handoff && handoff.state.kind !== "waiting") {
-			if (handoff.state.kind !== "ready") throw new Error("Terminal signing prepare did not complete; automatic replacement is prohibited");
-			if (presignature) pushClientPresignature(poolKey, poolIdentity, presignature);
-			presignature = handoff.state.presignature;
-			handedOffPrepare = handoff.state.prepared;
-			preparationState = { kind: "prepare_submitted" };
-			clientPresignatureCleanupState = { kind: "destroy" };
+			emitEcdsaSigningTiming(args.operationId, "foreground_refill", foregroundRefillStartedAt);
 		}
 		emitSigningSessionFlowTrace("evm-family", {
 			event: "ecdsa_presignature_selection",
@@ -2066,9 +1952,9 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 			code: "pool_entry_unavailable",
 			message: "Router A/B ECDSA derivation client presignature pool was invalidated before prepare"
 		};
-		clientRerandomizationContribution32 = handedOffPrepare && handoff ? handoff.contribution : secureRerandomizationContribution32();
+		clientRerandomizationContribution32 = secureRerandomizationContribution32();
 		const clientRerandomizationCommitment32 = await routerAbEcdsaRerandomizationClientCommitmentV1(clientRerandomizationContribution32);
-		const prepareRequest = handedOffPrepare?.request ?? buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1({
+		const prepareRequest = buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1({
 			scope: args.scope,
 			requestId: secureRandomId("router-ab-ecdsa-sign", 32, "Router A/B ECDSA derivation sign request"),
 			operationId: args.operationId,
@@ -2096,7 +1982,7 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 		emitEcdsaSigningTiming(args.operationId, "presignature_reserve", reserveStartedAt);
 		if (reservation.kind === "unavailable") {
 			if (reservation.reason === "claimed_elsewhere") clientPresignatureCleanupState = { kind: "owned_elsewhere" };
-			if (!handedOffPrepare && retryCount < MAX_CLIENT_PRESIGNATURE_CLAIM_RETRIES) return await signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCount + 1, supply);
+			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",
@@ -2110,7 +1996,7 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 		};
 		preparationState = { kind: "prepare_submitted" };
 		const prepareStartedAt = performance.now();
-		const prepareResponse = handedOffPrepare?.response ?? await prepareRouterAbEcdsaDerivationEvmDigestSigningV1({
+		const prepareResponse = await prepareRouterAbEcdsaDerivationEvmDigestSigningV1({
 			relayServerUrl: relayerUrl,
 			credential: args.credential,
 			request: prepareRequest,
@@ -2221,11 +2107,6 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 		};
 	} catch (e) {
 		const msg = String(e && typeof e === "object" && "message" in e ? e.message : e || "Router A/B ECDSA derivation signing failed");
-		if (handoff && handoff.state.kind !== "waiting" && handoff.state.kind !== "cancelled") return {
-			ok: false,
-			code: "router_ab_sign_failed",
-			message: msg
-		};
 		if (e instanceof RouterAbSigningRequestError && e.code === "expired_local_request") return {
 			ok: false,
 			code: "pool_entry_expired",
@@ -2250,11 +2131,6 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 			message: msg
 		};
 	} finally {
-		if (handoff) {
-			if (finalBatchHandoffs.get(handoff.poolKey) === handoff) finalBatchHandoffs.delete(handoff.poolKey);
-			zeroizeBytes(handoff.contribution);
-			if (handoff.state.kind === "waiting") handoff.state = { kind: "cancelled" };
-		}
 		zeroizeBytes(clientSignatureShare32);
 		zeroizeBytes(clientRerandomizationContribution32);
 		if (presignature && poolIdentity && clientPresignatureCleanupState.kind !== "consumed" && clientPresignatureCleanupState.kind !== "owned_elsewhere") {
@@ -2301,7 +2177,7 @@ async function signRouterAbEcdsaDerivationDigestWithPool(args) {
 				routerAbEcdsaDerivationPoolFill: {
 					kind: "router_ab_ecdsa_derivation_signing_worker_pool",
 					scope: args.scope,
-					ceremonyExpiresAtMs: expiresAtMs,
+					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,
@@ -2350,10 +2226,6 @@ async function refillRouterAbEcdsaDerivationClientPresignaturePool(args) {
 			...ecdsaPoolFillAuthorization(args)
 		});
 		if (!generated.ok) return generated;
-		if (generated.kind === "handed_off") return {
-			ok: true,
-			presignatureId: generated.presignatureId
-		};
 		if (getClientPresignaturePoolGeneration(poolKey) !== startedGeneration) {
 			await args.clientSigningMaterial.destroyClientPresignature({
 				materialHandle: generated.presignature.materialHandle,
@@ -2404,21 +2276,7 @@ async function loadRouterAbEcdsaDerivationSigningMaterialSource(args) {
 		const holderHandleId = clientShare.holderHandleId;
 		return {
 			signerSession,
-			clientSigningMaterial: {
-				kind: "router_ab_ecdsa_derivation_client_signing_material_source_v1",
-				initClientPresignSession: async (input) => await thresholdEcdsaLinkedHolderPresignSessionInitWasm({
-					holderHandleId,
-					...input
-				}),
-				stepClientPresignSession: thresholdEcdsaRoleLocalPresignSessionStepWasm,
-				abortClientPresignSession: thresholdEcdsaRoleLocalPresignSessionAbortWasm,
-				admitClientPresignature: thresholdEcdsaRoleLocalAdmitPresignatureWasm,
-				destroyClientPresignature: thresholdEcdsaRoleLocalDestroyPresignatureWasm,
-				reserveClientPresignature: thresholdEcdsaRoleLocalReservePresignatureWasm,
-				commitClientPresignature: thresholdEcdsaRoleLocalCommitPresignatureWasm,
-				listAvailableClientPresignatures: thresholdEcdsaRoleLocalListAvailablePresignaturesWasm,
-				computeSignatureShareFromPresignatureHandle: thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm
-			},
+			clientSigningMaterial: createLinkedHolderClientSigningMaterialSource(holderHandleId),
 			cleanupAfterSign: async () => void 0
 		};
 	}
@@ -2450,12 +2308,32 @@ async function loadRouterAbEcdsaDerivationSigningMaterialSource(args) {
 			destroyClientPresignature: thresholdEcdsaRoleLocalDestroyPresignatureWasm,
 			reserveClientPresignature: thresholdEcdsaRoleLocalReservePresignatureWasm,
 			commitClientPresignature: thresholdEcdsaRoleLocalCommitPresignatureWasm,
-			listAvailableClientPresignatures: thresholdEcdsaRoleLocalListAvailablePresignaturesWasm,
+			listAvailableClientPresignatures: thresholdEcdsaListAvailablePresignaturesWasm.bind(void 0, "role_local_derivation_handle"),
 			computeSignatureShareFromPresignatureHandle: thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm
 		},
 		cleanupAfterSign: async () => void 0
 	};
 }
+async function initLinkedHolderPresignSession(holderHandleId, input) {
+	return await thresholdEcdsaLinkedHolderPresignSessionInitWasm({
+		holderHandleId,
+		...input
+	});
+}
+function createLinkedHolderClientSigningMaterialSource(holderHandleId) {
+	return {
+		kind: "router_ab_ecdsa_derivation_client_signing_material_source_v1",
+		initClientPresignSession: initLinkedHolderPresignSession.bind(void 0, holderHandleId),
+		stepClientPresignSession: thresholdEcdsaRoleLocalPresignSessionStepWasm,
+		abortClientPresignSession: thresholdEcdsaRoleLocalPresignSessionAbortWasm,
+		admitClientPresignature: thresholdEcdsaRoleLocalAdmitPresignatureWasm,
+		destroyClientPresignature: thresholdEcdsaRoleLocalDestroyPresignatureWasm,
+		reserveClientPresignature: thresholdEcdsaRoleLocalReservePresignatureWasm,
+		commitClientPresignature: thresholdEcdsaRoleLocalCommitPresignatureWasm,
+		listAvailableClientPresignatures: thresholdEcdsaListAvailablePresignaturesWasm.bind(void 0, "linked_holder_signing_material"),
+		computeSignatureShareFromPresignatureHandle: thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm
+	};
+}
 //#endregion
 //#region src/core/signingEngine/flows/signEvmFamily/signers/secp256k1.ts
 var secp256k1_exports = /* @__PURE__ */ __exportAll({
@@ -2551,7 +2429,6 @@ var Secp256k1Engine = class {
 	constructor(opts) {
 		this.algorithm = "secp256k1";
 		this.beforeSigning = opts.beforeSigning;
-		this.getRpId = opts.getRpId;
 		this.shouldAbort = opts.shouldAbort;
 		this.workerCtx = opts.workerCtx;
 	}
@@ -2635,4 +2512,4 @@ var Secp256k1Engine = class {
 	}
 };
 //#endregion
-export { thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm as A, SignerWorkerOperationError as B, prepareLinkedDeviceEcdsaSourceContributionWasm as C, storeLinkedDeviceEcdsaHolderMaterialWasm as D, storeEcdsaRoleLocalSigningMaterialWasm as E, thresholdEcdsaRoleLocalPresignSessionStepWasm as F, getSignerWorkerOperationCoreCode as H, thresholdEcdsaRoleLocalReservePresignatureWasm as I, verifyRouterAbEcdsaRegistrationClientProofsWasm as L, thresholdEcdsaRoleLocalListAvailablePresignaturesWasm as M, thresholdEcdsaRoleLocalPresignSessionAbortWasm as N, thresholdEcdsaRoleLocalAdmitPresignatureWasm as O, thresholdEcdsaRoleLocalPresignSessionInitFromMaterialHandleWasm as P, EcdsaDerivationClientCustomRequestType as R, prepareEcdsaClientBootstrapCommandWasm as S, signWalletRecoveryEcdsaMaterialPossessionProofWasm as T, getSignerWorkerOperationErrorCode as U, WorkerControlMessage as V, finalizeEcdsaHolderOrdinaryExportWasm as _, resolveRouterAbEcdsaDerivationPresignaturePoolPolicy as a, openEcdsaRoleLocalSigningMaterialWasm as b, clearLinkedDeviceEcdsaHolderMaterialsWasm as c, createEcdsaHolderOrdinaryExportRequestWasm as d, createRouterAbEcdsaPostRegistrationCeremonyWasm as f, finalizeEcdsaClientBootstrapCommandWasm as g, destroyLinkedDeviceEcdsaHolderMaterialsWasm as h, clearRouterAbEcdsaDerivationClientPresignaturesForWallet as i, thresholdEcdsaRoleLocalDestroyPresignatureWasm as j, thresholdEcdsaRoleLocalCommitPresignatureWasm as k, closeRouterAbEcdsaPostRegistrationCeremonyWasm as l, destroyLinkedDeviceEcdsaHolderMaterialWasm as m, secp256k1_exports as n, scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill as o, createRouterAbEcdsaRegistrationCeremonyWasm as p, clearAllRouterAbEcdsaDerivationClientPresignatures as r, waitForRouterAbEcdsaDerivationClientPresignaturePoolReady as s, buildReadySecp256k1SigningMaterial as t, closeRouterAbEcdsaRegistrationCeremonyWasm as u, finalizeRouterAbEcdsaExplicitExportWasm as v, reconcileCanonicalEcdsaActivationWasm as w, persistInitialCanonicalEcdsaActivationWasm as x, finalizeRouterAbEcdsaRegistrationActivationWasm as y, EcdsaPresignClientRequestType as z };
+export { thresholdEcdsaRoleLocalAdmitPresignatureWasm as A, EcdsaPresignClientRequestType as B, prepareEcdsaClientBootstrapCommandWasm as C, storeEcdsaRoleLocalSigningMaterialWasm as D, signWalletRecoveryEcdsaMaterialPossessionProofWasm as E, thresholdEcdsaRoleLocalPresignSessionInitFromMaterialHandleWasm as F, WorkerControlMessage as H, thresholdEcdsaRoleLocalPresignSessionStepWasm as I, thresholdEcdsaRoleLocalReservePresignatureWasm as L, thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm as M, thresholdEcdsaRoleLocalDestroyPresignatureWasm as N, storeLinkedDeviceEcdsaHolderMaterialWasm as O, thresholdEcdsaRoleLocalPresignSessionAbortWasm as P, verifyRouterAbEcdsaRegistrationClientProofsWasm as R, persistInitialCanonicalEcdsaActivationWasm as S, reconcileCanonicalEcdsaActivationWasm as T, getSignerWorkerOperationCoreCode as U, SignerWorkerOperationError as V, getSignerWorkerOperationErrorCode as W, finalizeEcdsaClientBootstrapCommandWasm as _, clearRouterAbEcdsaDerivationClientPresignaturesForWallet as a, finalizeRouterAbEcdsaRegistrationActivationWasm as b, waitForRouterAbEcdsaDerivationClientPresignaturePoolReady as c, closeRouterAbEcdsaRegistrationCeremonyWasm as d, createEcdsaHolderOrdinaryExportRequestWasm as f, destroyLinkedDeviceEcdsaHolderMaterialsWasm as g, destroyLinkedDeviceEcdsaHolderMaterialWasm as h, clearAllRouterAbEcdsaDerivationClientPresignatures as i, thresholdEcdsaRoleLocalCommitPresignatureWasm as j, thresholdEcdsaListAvailablePresignaturesWasm as k, clearLinkedDeviceEcdsaHolderMaterialsWasm as l, createRouterAbEcdsaRegistrationCeremonyWasm as m, secp256k1_exports as n, resolveRouterAbEcdsaDerivationPresignaturePoolPolicy as o, createRouterAbEcdsaPostRegistrationCeremonyWasm as p, createLinkedHolderClientSigningMaterialSource as r, scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill as s, buildReadySecp256k1SigningMaterial as t, closeRouterAbEcdsaPostRegistrationCeremonyWasm as u, finalizeEcdsaHolderOrdinaryExportWasm as v, prepareLinkedDeviceEcdsaSourceContributionWasm as w, openEcdsaRoleLocalSigningMaterialWasm as x, finalizeRouterAbEcdsaExplicitExportWasm as y, EcdsaDerivationClientCustomRequestType as z };