@seams/wallet 0.7.1 → 0.8.0

package/dist/esm/sdk/secp256k1-el9aE4Sv.js

@@ -1,2504 +0,0 @@
-import { n as __exportAll } from "./chunk-BtrIJ4_z.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 { F as routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1, I as routerAbEcdsaRerandomizationClientCommitmentV1, bt as canonicalRouterAbMpcMaterialActivationRefBytes, d as buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1, et as parseWalletAuthAuthorityRef, g as parseRouterAbEcdsaDerivationNormalSigningScopeV1, l as ROUTER_AB_ECDSA_PRESIGN_CEREMONY_MAX_LIFETIME_MS, 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, wt as routerAbMpcMaterialActivationRefToWire } from "./ecdsaPresignLifecycle-BFOTNYCK.js";
-import { a as parseEcdsaRoleLocalPersistedMaterialRef, c as formatEcdsaKeyHandleForWire, l as parseEcdsaClientVerifyingShareB64u, o as parseEcdsaRoleLocalWorkerHandle, s as parseEcdsaThresholdKeyId, u as parseEcdsaKeyHandle } from "./keyMaterialBrands-CX41hur6.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-rHe0wz7q.js";
-import { t as DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY } from "./defaultConfigs-B3c16M_8.js";
-import { c as prepareRouterAbEcdsaDerivationEvmDigestSigningV1, o as finalizeRouterAbEcdsaDerivationEvmDigestSigningV1, t as RouterAbSigningRequestError } from "./routerAbNormalSigning-fhvpDtmY.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.
-*
-* These messages are JS-only and do NOT go through the Rust WASM JSON request/response pipeline.
-* They are used for:
-* - Readiness signals for persisted signer-worker availability.
-*/
-const WorkerControlMessage = { WORKER_READY: "WORKER_READY" };
-const EcdsaDerivationClientCustomRequestType = {
-	PrepareThresholdEcdsaDerivationRoleLocalClientBootstrap: 7e4,
-	FinalizeThresholdEcdsaDerivationRoleLocalClientBootstrap: 70001,
-	CreateRouterAbEcdsaRegistrationCeremony: 70005,
-	VerifyRouterAbEcdsaRegistrationClientProofs: 70006,
-	CloseRouterAbEcdsaRegistrationCeremony: 70007,
-	FinalizeRouterAbEcdsaRegistrationActivation: 70008,
-	CreateRouterAbEcdsaPostRegistrationCeremony: 70009,
-	FinalizeRouterAbEcdsaExplicitExport: 70010,
-	CloseRouterAbEcdsaPostRegistrationCeremony: 70011,
-	StoreThresholdEcdsaRoleLocalSigningMaterial: 70004,
-	RehydrateEcdsaRoleLocalSigningMaterial: 70015,
-	PersistInitialCanonicalEcdsaActivation: 70016,
-	ReconcileCanonicalEcdsaActivation: 70017,
-	PrewarmEcdsaRegistrationCrypto: 70018,
-	VerifyRouterAbEcdsaPostRegistrationProofs: 70019,
-	SignWalletRecoveryEcdsaMaterialPossessionProof: 70020,
-	PrepareEcdsaAdditiveLaneHolder: 70021,
-	PrepareLinkedDeviceEcdsaSourceContribution: 70022,
-	StoreLinkedDeviceEcdsaHolderMaterial: 70023,
-	DisposeLinkedDeviceEcdsaHolderMaterials: 70024,
-	CreateEcdsaHolderOrdinaryExportRequest: 70027,
-	FinalizeEcdsaHolderOrdinaryExport: 70028
-};
-const EcdsaDerivationClientCustomResponseType = {
-	PrepareThresholdEcdsaDerivationRoleLocalClientBootstrapSuccess: 70100,
-	FinalizeThresholdEcdsaDerivationRoleLocalClientBootstrapSuccess: 70101,
-	CreateRouterAbEcdsaRegistrationCeremonySuccess: 70105,
-	VerifyRouterAbEcdsaRegistrationClientProofsSuccess: 70106,
-	CloseRouterAbEcdsaRegistrationCeremonySuccess: 70107,
-	FinalizeRouterAbEcdsaRegistrationActivationSuccess: 70108,
-	CreateRouterAbEcdsaPostRegistrationCeremonySuccess: 70109,
-	FinalizeRouterAbEcdsaExplicitExportSuccess: 70110,
-	CloseRouterAbEcdsaPostRegistrationCeremonySuccess: 70111,
-	StoreThresholdEcdsaRoleLocalSigningMaterialSuccess: 70104,
-	RehydrateEcdsaRoleLocalSigningMaterialSuccess: 70115,
-	PersistInitialCanonicalEcdsaActivationSuccess: 70116,
-	ReconcileCanonicalEcdsaActivationSuccess: 70117,
-	PrewarmEcdsaRegistrationCryptoSuccess: 70118,
-	VerifyRouterAbEcdsaPostRegistrationProofsSuccess: 70119,
-	SignWalletRecoveryEcdsaMaterialPossessionProofSuccess: 70120,
-	PrepareEcdsaAdditiveLaneHolderSuccess: 70121,
-	PrepareLinkedDeviceEcdsaSourceContributionSuccess: 70122,
-	StoreLinkedDeviceEcdsaHolderMaterialSuccess: 70123,
-	DisposeLinkedDeviceEcdsaHolderMaterialsSuccess: 70124,
-	CreateEcdsaHolderOrdinaryExportRequestSuccess: 70127,
-	FinalizeEcdsaHolderOrdinaryExportSuccess: 70128
-};
-const EcdsaPresignClientRequestType = {
-	SessionInit: 71e3,
-	SessionStep: 71001,
-	SessionAbort: 71002,
-	Admit: 71003,
-	Destroy: 71004,
-	Reserve: 71005,
-	Commit: 71006,
-	ListAvailable: 71007,
-	ClearWallet: 71008
-};
-const EcdsaPresignClientResponseType = {
-	SessionInitSuccess: 71100,
-	SessionStepSuccess: 71101,
-	SessionAbortSuccess: 71102,
-	AdmitSuccess: 71103,
-	DestroySuccess: 71104,
-	ReserveSuccess: 71105,
-	CommitSuccess: 71106,
-	ListAvailableSuccess: 71107,
-	ClearWalletSuccess: 71108
-};
-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 || DEFAULT_SIGNER_HOST_ERROR_CODE).trim();
-		this.coreCode = args.coreCode?.trim() || void 0;
-		this.workerKind = args.workerKind;
-	}
-};
-function getSignerWorkerOperationErrorCode(error) {
-	if (!error || typeof error !== "object") return void 0;
-	const code = error.code;
-	if (typeof code !== "string") return void 0;
-	const trimmed = code.trim();
-	return trimmed.length ? trimmed : void 0;
-}
-function getSignerWorkerOperationCoreCode(error) {
-	if (!error || typeof error !== "object") return void 0;
-	const code = error.coreCode;
-	if (typeof code !== "string") return void 0;
-	const trimmed = code.trim();
-	return trimmed.length ? trimmed : void 0;
-}
-//#endregion
-//#region src/core/signingEngine/threshold/crypto/ecdsaDerivationClientWasm.ts
-const ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS = 2e4;
-function parseListedClientPresignature(ref) {
-	return {
-		presignatureId: ref.presignatureId,
-		materialHandle: ref.materialHandle,
-		bigR33: new Uint8Array(ref.bigR33),
-		createdAtMs: ref.createdAtMs,
-		expiresAtMs: ref.expiresAtMs
-	};
-}
-async function requestEcdsaDerivationRoleLocalMaterialOperation(args) {
-	return await executeWorkerOperation({
-		ctx: args.workerCtx,
-		kind: "ecdsaDerivationClient",
-		request: args.request
-	});
-}
-async function requestEcdsaHolderOrdinaryExportOperation(args) {
-	return await executeWorkerOperation({
-		ctx: args.workerCtx,
-		kind: "ecdsaDerivationClient",
-		request: args.request
-	});
-}
-async function requestEcdsaPresignOperation(args) {
-	return await executeWorkerOperation({
-		ctx: args.workerCtx,
-		kind: "ecdsaPresignClient",
-		request: args.request
-	});
-}
-async function requestEcdsaOnlineOperation(args) {
-	return await executeWorkerOperation({
-		ctx: args.workerCtx,
-		kind: "ecdsaOnlineClient",
-		request: args.request
-	});
-}
-async function prepareEcdsaClientBootstrapCommandWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.PrepareThresholdEcdsaDerivationRoleLocalClientBootstrap,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: input.command
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.PrepareThresholdEcdsaDerivationRoleLocalClientBootstrapSuccess) throw new Error("PrepareThresholdEcdsaDerivationRoleLocalClientBootstrap failed");
-	return response.payload;
-}
-async function finalizeEcdsaClientBootstrapCommandWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.FinalizeThresholdEcdsaDerivationRoleLocalClientBootstrap,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: input.command
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.FinalizeThresholdEcdsaDerivationRoleLocalClientBootstrapSuccess) throw new Error("FinalizeThresholdEcdsaDerivationRoleLocalClientBootstrap failed");
-	return response.payload;
-}
-async function createRouterAbEcdsaRegistrationCeremonyWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.CreateRouterAbEcdsaRegistrationCeremony,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: input.command
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.CreateRouterAbEcdsaRegistrationCeremonySuccess) throw new Error("Router A/B ECDSA registration ceremony creation failed");
-	return response.payload;
-}
-async function verifyRouterAbEcdsaRegistrationClientProofsWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.VerifyRouterAbEcdsaRegistrationClientProofs,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: input.command
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.VerifyRouterAbEcdsaRegistrationClientProofsSuccess) throw new Error("Router A/B ECDSA registration client proof verification failed");
-	return response.payload;
-}
-async function finalizeRouterAbEcdsaRegistrationActivationWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.FinalizeRouterAbEcdsaRegistrationActivation,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: input.command
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.FinalizeRouterAbEcdsaRegistrationActivationSuccess) throw new Error("Router A/B ECDSA registration activation finalization failed");
-	return response.payload;
-}
-async function persistInitialCanonicalEcdsaActivationWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.PersistInitialCanonicalEcdsaActivation,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: input.command
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.PersistInitialCanonicalEcdsaActivationSuccess) throw new Error("Initial canonical ECDSA activation persistence failed");
-	return response.payload;
-}
-async function reconcileCanonicalEcdsaActivationWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.ReconcileCanonicalEcdsaActivation,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: input.command
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.ReconcileCanonicalEcdsaActivationSuccess) throw new Error("Canonical ECDSA activation reconciliation failed");
-	const result = response.payload;
-	if (result.kind !== "canonical_ecdsa_activation_committed_finalization_required_v1") return result;
-	return {
-		kind: "canonical_ecdsa_activation_reconciliation_pending_v1",
-		journalId: result.journalId,
-		reason: "wallet_custody_rejoin_required",
-		activationCommand: null
-	};
-}
-async function closeRouterAbEcdsaRegistrationCeremonyWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.CloseRouterAbEcdsaRegistrationCeremony,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: input.command
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.CloseRouterAbEcdsaRegistrationCeremonySuccess) throw new Error("Router A/B ECDSA registration ceremony close failed");
-	return response.payload;
-}
-async function createRouterAbEcdsaPostRegistrationCeremonyWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.CreateRouterAbEcdsaPostRegistrationCeremony,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: input.command
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.CreateRouterAbEcdsaPostRegistrationCeremonySuccess) throw new Error("Router A/B ECDSA post-registration ceremony creation failed");
-	return response.payload;
-}
-async function finalizeRouterAbEcdsaExplicitExportWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.FinalizeRouterAbEcdsaExplicitExport,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: input.command
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.FinalizeRouterAbEcdsaExplicitExportSuccess) throw new Error("Router A/B ECDSA post-registration client proof finalization failed");
-	return response.payload;
-}
-async function closeRouterAbEcdsaPostRegistrationCeremonyWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.CloseRouterAbEcdsaPostRegistrationCeremony,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: input.command
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.CloseRouterAbEcdsaPostRegistrationCeremonySuccess) throw new Error("Router A/B ECDSA post-registration ceremony close failed");
-	return response.payload;
-}
-async function storeEcdsaRoleLocalSigningMaterialWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.StoreThresholdEcdsaRoleLocalSigningMaterial,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				materialHandle: input.materialHandle,
-				bindingDigest: input.bindingDigest,
-				stateBlob: input.stateBlob
-			}
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.StoreThresholdEcdsaRoleLocalSigningMaterialSuccess) throw new Error("StoreThresholdEcdsaRoleLocalSigningMaterial failed");
-	return response.payload;
-}
-function ecdsaRoleLocalWorkerHandleMatchesPersistedRef(materialRef, liveHandle) {
-	return liveHandle.durableMaterialRef === materialRef.durableMaterialRef && liveHandle.bindingDigest === materialRef.bindingDigest;
-}
-async function openEcdsaRoleLocalSigningMaterialWasm(input) {
-	const authority = parseWalletAuthAuthorityRef(input.authority);
-	if (!authority) throw new Error("ECDSA role-local signing material authority is invalid");
-	const materialActivationResult = parseMpcMaterialActivationRef(input.materialActivation);
-	if (!materialActivationResult.ok) throw new Error(materialActivationResult.error.message);
-	const materialActivation = materialActivationResult.value;
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.RehydrateEcdsaRoleLocalSigningMaterial,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				kind: "open_ecdsa_role_local_signing_material_v1",
-				authority,
-				materialActivation
-			}
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.RehydrateEcdsaRoleLocalSigningMaterialSuccess) throw new Error("OpenEcdsaRoleLocalSigningMaterial failed");
-	const payload = response.payload;
-	switch (payload.kind) {
-		case "ecdsa_role_local_signing_material_unavailable_v1": return {
-			ok: false,
-			reason: payload.reason
-		};
-		case "ecdsa_role_local_signing_material_opened_v1": {
-			const materialRef = parseEcdsaRoleLocalPersistedMaterialRef(payload.materialRef);
-			if (!mpcMaterialActivationRefsEqual(materialActivation, materialRef.materialActivation)) throw new Error("ECDSA role-local signing material open changed its activation identity");
-			const liveHandle = parseEcdsaRoleLocalWorkerHandle(payload.liveHandle);
-			if (!ecdsaRoleLocalWorkerHandleMatchesPersistedRef(materialRef, liveHandle)) throw new Error("ECDSA role-local signing material hydration changed its identity");
-			return {
-				ok: true,
-				liveHandle,
-				materialRef
-			};
-		}
-		default: {
-			const exhaustive = payload;
-			throw new Error(`ECDSA role-local signing material hydration response kind is invalid: ${String(exhaustive)}`);
-		}
-	}
-}
-async function signWalletRecoveryEcdsaMaterialPossessionProofWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.SignWalletRecoveryEcdsaMaterialPossessionProof,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				kind: "sign_wallet_recovery_ecdsa_material_possession_proof_v1",
-				challenge: input.challenge,
-				stateBlob: input.stateBlob
-			}
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.SignWalletRecoveryEcdsaMaterialPossessionProofSuccess) throw new Error("Wallet recovery ECDSA possession proof signing failed");
-	return response.payload;
-}
-async function prepareLinkedDeviceEcdsaSourceContributionWasm(input) {
-	const response = await requestEcdsaDerivationRoleLocalMaterialOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.PrepareLinkedDeviceEcdsaSourceContribution,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				kind: "prepare_linked_device_ecdsa_source_contribution_v1",
-				preparation: input.preparation,
-				...input.linkedHolderHandleId === void 0 ? {} : { linkedHolderHandleId: input.linkedHolderHandleId }
-			}
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.PrepareLinkedDeviceEcdsaSourceContributionSuccess) throw new Error("Linked-device ECDSA source contribution preparation failed");
-	return response.payload;
-}
-function asEcdsaDerivationPresignProgress(raw) {
-	const outgoingMessages = Array.isArray(raw.outgoingMessages) ? raw.outgoingMessages.map((entry) => new Uint8Array(entry)) : [];
-	switch (raw.event) {
-		case "final_batch_ready": return {
-			stage: "presign",
-			event: raw.event,
-			outgoingMessages,
-			candidateBigR33: new Uint8Array(raw.candidateBigR33)
-		};
-		case "presign_done": return {
-			stage: "done",
-			event: raw.event,
-			outgoingMessages,
-			presignatureHandle: raw.presignatureHandle,
-			presignatureBigR33: new Uint8Array(raw.presignatureBigR33)
-		};
-		case "none":
-		case "triples_done": return {
-			stage: raw.stage,
-			event: raw.event,
-			outgoingMessages
-		};
-	}
-}
-async function thresholdEcdsaRoleLocalPresignSessionInitFromMaterialHandleWasm(input) {
-	const groupPublicKey33 = input.groupPublicKey33.slice();
-	const response = await requestEcdsaPresignOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaPresignClientRequestType.SessionInit,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				authority: {
-					kind: "role_local_derivation_handle",
-					materialHandle: input.materialHandle,
-					material: input.material
-				},
-				sessionId: input.sessionId,
-				groupPublicKey33: groupPublicKey33.buffer,
-				ceremonyExpiresAtMs: input.ceremonyExpiresAtMs,
-				materialExpiresAtMs: input.materialExpiresAtMs,
-				poolIdentity: input.poolIdentity
-			},
-			transfer: [groupPublicKey33.buffer]
-		}
-	});
-	if (response.type !== EcdsaPresignClientResponseType.SessionInitSuccess) throw new Error("ThresholdEcdsaRoleLocalPresignSessionInitFromMaterialHandle failed");
-	if (response.payload.authority.kind !== "role_local_derivation_handle") throw new Error("ECDSA role-local presign returned a different authority");
-	return asEcdsaDerivationPresignProgress(response.payload.progress);
-}
-async function thresholdEcdsaLinkedHolderPresignSessionInitWasm(input) {
-	const groupPublicKey33 = input.groupPublicKey33.slice();
-	const response = await requestEcdsaPresignOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaPresignClientRequestType.SessionInit,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				authority: {
-					kind: "linked_holder_signing_material",
-					holderHandleId: input.holderHandleId
-				},
-				sessionId: input.sessionId,
-				groupPublicKey33: groupPublicKey33.buffer,
-				ceremonyExpiresAtMs: input.ceremonyExpiresAtMs,
-				materialExpiresAtMs: input.materialExpiresAtMs,
-				poolIdentity: input.poolIdentity
-			},
-			transfer: [groupPublicKey33.buffer]
-		}
-	});
-	if (response.type !== EcdsaPresignClientResponseType.SessionInitSuccess) throw new Error("Linked holder ECDSA presign initialization failed");
-	if (response.payload.authority.kind !== "linked_holder_signing_material") throw new Error("Linked holder ECDSA presign returned a different authority");
-	return asEcdsaDerivationPresignProgress(response.payload.progress);
-}
-async function createEcdsaHolderOrdinaryExportRequestWasm(input) {
-	if (input.holderHandleId.trim().length === 0) throw new Error("ECDSA holder handle must be non-empty");
-	const response = await requestEcdsaHolderOrdinaryExportOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.CreateEcdsaHolderOrdinaryExportRequest,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				kind: "create_ecdsa_holder_ordinary_export_request_v1",
-				holderHandleId: input.holderHandleId,
-				request: input.request
-			},
-			transfer: []
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.CreateEcdsaHolderOrdinaryExportRequestSuccess) throw new Error("ECDSA holder ordinary-export request preparation failed");
-	if (response.payload.holderHandleId !== input.holderHandleId) throw new Error("ECDSA holder ordinary-export request returned a different holder");
-	if (response.payload.requestDigestB64u.trim().length === 0) throw new Error("ECDSA holder ordinary-export request digest is empty");
-	return response.payload;
-}
-async function finalizeEcdsaHolderOrdinaryExportWasm(input) {
-	if (input.holderHandleId.trim().length === 0) throw new Error("ECDSA holder handle must be non-empty");
-	if (input.requestDigestB64u !== input.expectedBinding.export_request_digest_b64u) throw new Error("ECDSA holder ordinary-export request digest differs from its binding");
-	const response = await requestEcdsaHolderOrdinaryExportOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.FinalizeEcdsaHolderOrdinaryExport,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				kind: "finalize_ecdsa_holder_ordinary_export_v1",
-				holderHandleId: input.holderHandleId,
-				requestDigestB64u: input.requestDigestB64u,
-				expectedBinding: input.expectedBinding,
-				forwardedResponse: input.forwardedResponse
-			},
-			transfer: []
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.FinalizeEcdsaHolderOrdinaryExportSuccess) throw new Error("ECDSA holder ordinary-export finalization failed");
-	if (response.payload.holderHandleId !== input.holderHandleId) throw new Error("ECDSA holder ordinary-export finalization returned a different holder");
-	return response.payload;
-}
-async function storeLinkedDeviceEcdsaHolderMaterialWasm(input) {
-	if (input.holderHandleId.trim().length === 0) throw new Error("Linked holder ECDSA handle must be non-empty");
-	if (input.ownedSigningShare32.byteLength !== 32) throw new Error("Linked holder ECDSA signing share must contain 32 bytes");
-	if (input.activationReceiptJson.trim().length === 0) throw new Error("Linked holder ECDSA activation receipt must be non-empty");
-	const ownedSigningShare32 = input.ownedSigningShare32.slice();
-	try {
-		const response = await executeWorkerOperation({
-			kind: "ecdsaDerivationClient",
-			ctx: input.workerCtx,
-			request: {
-				type: EcdsaDerivationClientCustomRequestType.StoreLinkedDeviceEcdsaHolderMaterial,
-				timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-				payload: {
-					holderHandleId: input.holderHandleId,
-					ownedSigningShare32: ownedSigningShare32.buffer,
-					activationReceiptJson: input.activationReceiptJson
-				},
-				transfer: [ownedSigningShare32.buffer]
-			}
-		});
-		if (response.type !== EcdsaDerivationClientCustomResponseType.StoreLinkedDeviceEcdsaHolderMaterialSuccess) throw new Error("Linked holder ECDSA material import failed");
-		if (response.payload.holderHandleId !== input.holderHandleId) throw new Error("Linked holder ECDSA material import returned a different handle");
-		return response.payload;
-	} finally {
-		if (ownedSigningShare32.byteLength > 0) ownedSigningShare32.fill(0);
-	}
-}
-async function disposeLinkedDeviceEcdsaHolderMaterialsWasm(input) {
-	const response = await executeWorkerOperation({
-		kind: "ecdsaDerivationClient",
-		ctx: input.workerCtx,
-		request: {
-			type: EcdsaDerivationClientCustomRequestType.DisposeLinkedDeviceEcdsaHolderMaterials,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: input.disposal,
-			transfer: []
-		}
-	});
-	if (response.type !== EcdsaDerivationClientCustomResponseType.DisposeLinkedDeviceEcdsaHolderMaterialsSuccess) throw new Error("Linked holder ECDSA material disposal failed");
-	if (response.payload.kind !== input.disposal.kind) throw new Error("Linked holder ECDSA material disposal returned a different scope");
-	if (input.disposal.kind === "one" && response.payload.kind === "one" && response.payload.holderHandleId !== input.disposal.holderHandleId) throw new Error("Linked holder ECDSA material disposal returned a different handle");
-}
-async function destroyLinkedDeviceEcdsaHolderMaterialWasm(input) {
-	if (input.holderHandleId.trim().length === 0) throw new Error("Linked holder ECDSA handle must be non-empty");
-	await disposeLinkedDeviceEcdsaHolderMaterialsWasm({
-		disposal: {
-			kind: "one",
-			holderHandleId: input.holderHandleId
-		},
-		workerCtx: input.workerCtx
-	});
-}
-async function destroyLinkedDeviceEcdsaHolderMaterialsWasm(input) {
-	let cleanupFailed = false;
-	let firstCleanupError;
-	for (const holderHandleId of input.holderHandleIds) try {
-		await destroyLinkedDeviceEcdsaHolderMaterialWasm({
-			holderHandleId,
-			workerCtx: input.workerCtx
-		});
-	} catch (error) {
-		if (!cleanupFailed) {
-			cleanupFailed = true;
-			firstCleanupError = error;
-		}
-	}
-	if (cleanupFailed) throw firstCleanupError;
-}
-async function clearLinkedDeviceEcdsaHolderMaterialsWasm(input) {
-	await disposeLinkedDeviceEcdsaHolderMaterialsWasm({
-		disposal: { kind: "all" },
-		workerCtx: input.workerCtx
-	});
-}
-async function thresholdEcdsaRoleLocalPresignSessionStepWasm(input) {
-	const incomingMessages = input.incomingMessages.map((entry) => entry.slice());
-	const transfer = incomingMessages.map((entry) => entry.buffer);
-	const response = await requestEcdsaPresignOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaPresignClientRequestType.SessionStep,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				sessionId: input.sessionId,
-				stage: input.stage,
-				incomingMessages: incomingMessages.map((entry) => entry.buffer)
-			},
-			transfer
-		}
-	});
-	if (response.type !== EcdsaPresignClientResponseType.SessionStepSuccess) throw new Error("ThresholdEcdsaRoleLocalPresignSessionStep failed");
-	return asEcdsaDerivationPresignProgress(response.payload);
-}
-async function thresholdEcdsaRoleLocalPresignSessionAbortWasm(input) {
-	const response = await requestEcdsaPresignOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaPresignClientRequestType.SessionAbort,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: { sessionId: input.sessionId }
-		}
-	});
-	if (response.type !== EcdsaPresignClientResponseType.SessionAbortSuccess) throw new Error("ThresholdEcdsaRoleLocalPresignSessionAbort failed");
-	const result = response.payload;
-	if (result.kind !== "threshold_ecdsa_presign_session_aborted" || result.sessionId !== input.sessionId) throw new Error("ThresholdEcdsaRoleLocalPresignSessionAbort returned invalid result");
-}
-async function thresholdEcdsaRoleLocalAdmitPresignatureWasm(input) {
-	const response = await requestEcdsaPresignOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaPresignClientRequestType.Admit,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				materialHandle: input.materialHandle,
-				expectedPresignatureId: input.expectedPresignatureId,
-				poolIdentity: input.poolIdentity,
-				admissionMode: input.admissionMode
-			}
-		}
-	});
-	if (response.type !== EcdsaPresignClientResponseType.AdmitSuccess) throw new Error("ThresholdEcdsaRoleLocalAdmitPresignature failed");
-	if (response.payload.kind !== "ecdsa_client_presignature_admitted_v1" || response.payload.materialHandle !== input.materialHandle || response.payload.presignatureId !== input.expectedPresignatureId) throw new Error("ThresholdEcdsaRoleLocalAdmitPresignature returned invalid binding");
-	return response.payload.storage;
-}
-async function thresholdEcdsaRoleLocalDestroyPresignatureWasm(input) {
-	const response = await requestEcdsaPresignOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaPresignClientRequestType.Destroy,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				materialHandle: input.materialHandle,
-				poolIdentity: input.poolIdentity
-			}
-		}
-	});
-	if (response.type !== EcdsaPresignClientResponseType.DestroySuccess) throw new Error("ThresholdEcdsaRoleLocalDestroyPresignature failed");
-	if (response.payload.kind !== "ecdsa_client_presignature_destroyed_v1" || response.payload.materialHandle !== input.materialHandle) throw new Error("ThresholdEcdsaRoleLocalDestroyPresignature returned invalid handle");
-}
-async function thresholdEcdsaRoleLocalReservePresignatureWasm(input) {
-	const response = await requestEcdsaPresignOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaPresignClientRequestType.Reserve,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				materialHandle: input.materialHandle,
-				expectedPresignatureId: input.expectedPresignatureId,
-				poolIdentity: input.poolIdentity,
-				requestBinding: input.requestBinding,
-				reservationId: input.reservationId,
-				leaseExpiresAtMs: input.leaseExpiresAtMs
-			}
-		}
-	});
-	if (response.type !== EcdsaPresignClientResponseType.ReserveSuccess) throw new Error("ThresholdEcdsaRoleLocalReservePresignature failed");
-	return response.payload;
-}
-async function thresholdEcdsaRoleLocalCommitPresignatureWasm(input) {
-	if ((await requestEcdsaPresignOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaPresignClientRequestType.Commit,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				materialHandle: input.materialHandle,
-				poolIdentity: input.poolIdentity,
-				requestBinding: input.requestBinding,
-				reservationId: input.reservationId
-			}
-		}
-	})).type !== EcdsaPresignClientResponseType.CommitSuccess) throw new Error("ThresholdEcdsaRoleLocalCommitPresignature failed");
-}
-async function thresholdEcdsaRoleLocalListAvailablePresignaturesWasm(input) {
-	const response = await requestEcdsaPresignOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaPresignClientRequestType.ListAvailable,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: { poolIdentity: input.poolIdentity }
-		}
-	});
-	if (response.type !== EcdsaPresignClientResponseType.ListAvailableSuccess) throw new Error("ThresholdEcdsaRoleLocalListAvailablePresignatures failed");
-	return response.payload.map(parseListedClientPresignature);
-}
-async function thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm(input) {
-	const groupPublicKey33 = input.groupPublicKey33.slice();
-	const expectedPresignBigR33 = input.expectedPresignBigR33.slice();
-	const digest32 = input.digest32.slice();
-	const clientRerandomizationContribution32 = input.clientRerandomizationContribution32.slice();
-	const signingWorkerRerandomizationContribution32 = input.signingWorkerRerandomizationContribution32.slice();
-	const response = await requestEcdsaOnlineOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaOnlineClientRequestType.ComputeSignatureShare,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				materialHandle: input.materialHandle,
-				poolIdentity: input.poolIdentity,
-				requestBinding: input.requestBinding,
-				reservationId: input.reservationId,
-				groupPublicKey33: groupPublicKey33.buffer,
-				expectedPresignBigR33: expectedPresignBigR33.buffer,
-				digest32: digest32.buffer,
-				clientRerandomizationContribution32: clientRerandomizationContribution32.buffer,
-				signingWorkerRerandomizationContribution32: signingWorkerRerandomizationContribution32.buffer
-			},
-			transfer: [
-				groupPublicKey33.buffer,
-				expectedPresignBigR33.buffer,
-				digest32.buffer,
-				clientRerandomizationContribution32.buffer,
-				signingWorkerRerandomizationContribution32.buffer
-			]
-		}
-	});
-	if (response.type !== EcdsaOnlineClientResponseType.ComputeSignatureShareSuccess) throw new Error("ThresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandle failed");
-	return new Uint8Array(response.payload);
-}
-//#endregion
-//#region src/core/signingEngine/routerAb/ecdsaDerivation/httpRequest.ts
-const DEFAULT_ROUTER_AB_ECDSA_DERIVATION_REQUEST_TIMEOUT_MS = 2e4;
-function resolveRequestTimeoutMs(timeoutMs) {
-	const parsed = Math.floor(Number(timeoutMs));
-	if (Number.isFinite(parsed) && parsed > 0) return parsed;
-	return DEFAULT_ROUTER_AB_ECDSA_DERIVATION_REQUEST_TIMEOUT_MS;
-}
-function toErrorMessage(error) {
-	return String(error && typeof error === "object" && "message" in error ? error.message : error || "");
-}
-function createRouterAbEcdsaDerivationTimeoutError(args) {
-	return /* @__PURE__ */ new Error(`[router-ab-ecdsa-derivation] ${args.operation} request timed out after ${args.timeoutMs}ms`);
-}
-async function fetchRouterAbEcdsaDerivationJson(args) {
-	const timeoutMs = resolveRequestTimeoutMs(args.timeoutMs);
-	const abortController = typeof AbortController === "function" ? new AbortController() : null;
-	const baseInit = { ...args.init };
-	let timeoutId = null;
-	let abortCleanup = null;
-	let didTimeout = false;
-	try {
-		let response;
-		if (abortController) {
-			const upstreamSignal = args.init.signal;
-			if (upstreamSignal) {
-				if (upstreamSignal.aborted) abortController.abort();
-				else if (typeof upstreamSignal.addEventListener === "function") {
-					const onAbort = () => abortController.abort();
-					upstreamSignal.addEventListener("abort", onAbort, { once: true });
-					abortCleanup = () => upstreamSignal.removeEventListener("abort", onAbort);
-				}
-			}
-			timeoutId = setTimeout(() => {
-				didTimeout = true;
-				abortController.abort();
-			}, timeoutMs);
-			response = await fetch(args.url, {
-				...baseInit,
-				signal: abortController.signal
-			});
-		} else response = await Promise.race([fetch(args.url, baseInit), new Promise((_, reject) => {
-			timeoutId = setTimeout(() => {
-				didTimeout = true;
-				reject(createRouterAbEcdsaDerivationTimeoutError({
-					operation: args.operation,
-					timeoutMs
-				}));
-			}, timeoutMs);
-		})]);
-		const data = await response.json().catch(() => ({}));
-		if (didTimeout) throw createRouterAbEcdsaDerivationTimeoutError({
-			operation: args.operation,
-			timeoutMs
-		});
-		return {
-			response,
-			data
-		};
-	} catch (error) {
-		if (didTimeout) throw createRouterAbEcdsaDerivationTimeoutError({
-			operation: args.operation,
-			timeoutMs
-		});
-		const message = toErrorMessage(error);
-		throw new Error(message || `[router-ab-ecdsa-derivation] ${args.operation} request failed`);
-	} finally {
-		if (timeoutId) clearTimeout(timeoutId);
-		abortCleanup?.();
-	}
-}
-//#endregion
-//#region src/core/signingEngine/routerAb/ecdsaDerivation/poolFillRoutes.ts
-const PRESIGN_EXCHANGE_TIMEOUT_MS = 5e3;
-function presignRequestTimeoutMs(expiresAtMs, requestedMs) {
-	const remainingMs = Math.min(expiresAtMs - Date.now(), requestedMs ?? PRESIGN_EXCHANGE_TIMEOUT_MS, PRESIGN_EXCHANGE_TIMEOUT_MS);
-	return Number.isFinite(remainingMs) && remainingMs > 0 ? remainingMs : null;
-}
-function resolveRelayerUrl(input) {
-	return stripTrailingSlashes(normalizeTrimmedString(input)) || null;
-}
-function resolvePresignAuthHeaders(args) {
-	const headers = { "Content-Type": "application/json" };
-	switch (args.credential.kind) {
-		case "operation_step_up": return {
-			ok: true,
-			headers,
-			credentials: "omit"
-		};
-		case "wallet_session_opaque": {
-			const walletSessionToken = String(args.credential.walletSessionToken || "").trim();
-			if (!walletSessionToken) return {
-				ok: false,
-				code: "invalid_args",
-				message: "Missing opaque Wallet Session token for Router A/B ECDSA derivation presign pool fill"
-			};
-			headers.Authorization = `Bearer ${walletSessionToken}`;
-			return {
-				ok: true,
-				headers,
-				credentials: "omit"
-			};
-		}
-	}
-}
-function poolFillAuthorizationBody(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 resolveRouterAbEcdsaDerivationPoolFillInitKeySelector(args) {
-	const keyHandle = String(args.keyHandle || "").trim();
-	if (!keyHandle) return {
-		ok: false,
-		code: "invalid_args",
-		message: "Missing keyHandle for Router A/B ECDSA derivation pool-fill init"
-	};
-	return {
-		ok: true,
-		value: { keyHandle }
-	};
-}
-async function postEcdsaPresignInit(args) {
-	const relayerUrl = resolveRelayerUrl(args.relayerUrl);
-	if (!relayerUrl) return {
-		ok: false,
-		code: "invalid_args",
-		message: "Missing relayerUrl for Router A/B ECDSA derivation pool-fill init"
-	};
-	if (typeof fetch !== "function") return {
-		ok: false,
-		code: "unsupported",
-		message: "fetch is not available for Router A/B ECDSA derivation pool-fill init"
-	};
-	const keySelector = resolveRouterAbEcdsaDerivationPoolFillInitKeySelector(args);
-	if (!keySelector.ok) return keySelector;
-	const requestTag = String(args.requestTag || "").trim();
-	const auth = resolvePresignAuthHeaders(args);
-	if (!auth.ok) return auth;
-	const timeoutMs = presignRequestTimeoutMs(args.poolFill.ceremonyExpiresAtMs, args.requestTimeoutMs);
-	if (timeoutMs === null) return {
-		ok: false,
-		code: "presign_timeout",
-		message: "Presign ceremony deadline has elapsed"
-	};
-	try {
-		const { response, data } = await fetchRouterAbEcdsaDerivationJson({
-			url: `${relayerUrl}${args.path}`,
-			operation: "presign/init",
-			timeoutMs,
-			init: {
-				method: "POST",
-				headers: auth.headers,
-				credentials: auth.credentials,
-				body: JSON.stringify({
-					...keySelector.value,
-					count: Number.isFinite(args.count) ? Math.max(1, Math.floor(Number(args.count))) : 1,
-					...requestTag ? { requestTag } : {},
-					poolFill: args.poolFill,
-					presignSessionId: args.presignSessionId,
-					firstMessageB64u: args.firstMessageB64u,
-					...poolFillAuthorizationBody(args)
-				})
-			}
-		});
-		if (typeof data.presignSessionId === "string") emitEcdsaPresignServerTiming(data.presignSessionId, "init", response.headers.get("Server-Timing"));
-		if (!response.ok) return {
-			ok: false,
-			code: data.code || "http_error",
-			message: data.message || `HTTP ${response.status}`
-		};
-		return {
-			ok: data.ok === true,
-			presignSessionId: data.presignSessionId,
-			...Number.isSafeInteger(data.ceremonyExpiresAtMs) ? { ceremonyExpiresAtMs: data.ceremonyExpiresAtMs } : {},
-			...Number.isSafeInteger(data.materialExpiresAtMs) ? { materialExpiresAtMs: data.materialExpiresAtMs } : {},
-			stage: data.stage,
-			outgoingMessagesB64u: Array.isArray(data.outgoingMessagesB64u) ? data.outgoingMessagesB64u : [],
-			...data.code ? { code: data.code } : {},
-			...data.message ? { message: data.message } : {}
-		};
-	} catch (e) {
-		return {
-			ok: false,
-			code: "network_error",
-			message: String(e && typeof e === "object" && "message" in e ? e.message : e || "Failed Router A/B ECDSA derivation pool-fill init")
-		};
-	}
-}
-async function routerAbEcdsaDerivationPresignaturePoolFillInit(args) {
-	return postEcdsaPresignInit({
-		...args,
-		path: ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_INIT_PATH
-	});
-}
-async function postEcdsaPresignStep(args) {
-	const relayerUrl = resolveRelayerUrl(args.relayerUrl);
-	if (!relayerUrl) return {
-		ok: false,
-		code: "invalid_args",
-		message: "Missing relayerUrl for Router A/B ECDSA derivation pool-fill step"
-	};
-	if (typeof fetch !== "function") return {
-		ok: false,
-		code: "unsupported",
-		message: "fetch is not available for Router A/B ECDSA derivation pool-fill step"
-	};
-	const presignSessionId = String(args.presignSessionId || "").trim();
-	if (!presignSessionId) return {
-		ok: false,
-		code: "invalid_args",
-		message: "Missing presignSessionId for Router A/B ECDSA derivation pool-fill step"
-	};
-	const requestTag = String(args.requestTag || "").trim();
-	const auth = resolvePresignAuthHeaders(args);
-	if (!auth.ok) return auth;
-	const timeoutMs = presignRequestTimeoutMs(args.ceremonyExpiresAtMs, args.requestTimeoutMs);
-	if (timeoutMs === null) return {
-		ok: false,
-		code: "presign_timeout",
-		message: "Presign ceremony deadline has elapsed"
-	};
-	try {
-		const { response, data } = await fetchRouterAbEcdsaDerivationJson({
-			url: `${relayerUrl}${args.path}`,
-			operation: "presign/step",
-			timeoutMs,
-			init: {
-				method: "POST",
-				headers: auth.headers,
-				credentials: auth.credentials,
-				body: JSON.stringify({
-					presignSessionId,
-					ceremonyExpiresAtMs: args.ceremonyExpiresAtMs,
-					materialExpiresAtMs: args.materialExpiresAtMs,
-					stage: args.stage,
-					outgoingMessagesB64u: Array.isArray(args.outgoingMessagesB64u) ? args.outgoingMessagesB64u : [],
-					...requestTag ? { requestTag } : {},
-					...poolFillAuthorizationBody(args)
-				})
-			}
-		});
-		emitEcdsaPresignServerTiming(presignSessionId, "step", response.headers.get("Server-Timing"));
-		if (!response.ok) return {
-			ok: false,
-			code: data.code || "http_error",
-			message: data.message || `HTTP ${response.status}`
-		};
-		return {
-			ok: data.ok === true,
-			stage: data.stage,
-			event: data.event,
-			outgoingMessagesB64u: Array.isArray(data.outgoingMessagesB64u) ? data.outgoingMessagesB64u : [],
-			...data.presignatureId ? { presignatureId: data.presignatureId } : {},
-			...data.bigRB64u ? { bigRB64u: data.bigRB64u } : {},
-			...data.code ? { code: data.code } : {},
-			...data.message ? { message: data.message } : {}
-		};
-	} catch (e) {
-		return {
-			ok: false,
-			code: "network_error",
-			message: String(e && typeof e === "object" && "message" in e ? e.message : e || "Failed Router A/B ECDSA derivation pool-fill step")
-		};
-	}
-}
-async function routerAbEcdsaDerivationPresignaturePoolFillStep(args) {
-	return postEcdsaPresignStep({
-		...args,
-		path: ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_STEP_PATH
-	});
-}
-//#endregion
-//#region src/core/signingEngine/routerAb/ecdsaDerivation/presignatureRefillProgress.ts
-var PresignatureRefillProgressV1 = class {
-	constructor() {
-		this.state = {
-			kind: "refilling",
-			revision: 0
-		};
-		this.waiters = /* @__PURE__ */ new Map();
-	}
-	snapshot() {
-		return this.state;
-	}
-	hasForegroundWaiters() {
-		for (const priority of this.waiters.values()) if (priority === "foreground") return true;
-		return false;
-	}
-	publishAvailable() {
-		if (this.state.kind === "settled") return;
-		this.state = {
-			kind: "refilling",
-			revision: this.state.revision + 1
-		};
-		this.flushWaiters();
-	}
-	settle() {
-		if (this.state.kind === "settled") return;
-		this.state = {
-			kind: "settled",
-			revision: this.state.revision
-		};
-		this.flushWaiters();
-	}
-	waitForChange(observed, priority) {
-		if (this.state.kind === "settled" || this.state.revision !== observed.revision) return Promise.resolve(this.state);
-		return new Promise((resolve) => {
-			this.waiters.set(resolve, priority);
-			if (this.state.kind === "settled" || this.state.revision !== observed.revision) {
-				this.waiters.delete(resolve);
-				resolve(this.state);
-			}
-		});
-	}
-	flushWaiters() {
-		const snapshot = this.state;
-		const waiters = [...this.waiters.keys()];
-		this.waiters.clear();
-		for (const waiter of waiters) waiter(snapshot);
-	}
-};
-//#endregion
-//#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
-//#region src/core/signingEngine/flows/signEvmFamily/signers/ecdsaDerivationClientSigningMaterialSource.ts
-async function ensureRoleLocalSigningMaterialLoaded(args) {
-	const material = args.clientShare.material;
-	if (material.kind === "worker_loaded") return;
-	const stored = await storeEcdsaRoleLocalSigningMaterialWasm({
-		materialHandle: args.clientShare.handle.materialHandle,
-		bindingDigest: args.clientShare.handle.bindingDigest,
-		stateBlob: material.stateBlob,
-		workerCtx: args.workerCtx
-	});
-	if (stored.materialHandle !== args.clientShare.handle.materialHandle || stored.bindingDigest !== args.clientShare.handle.bindingDigest) throw new Error("[multichain] ECDSA role-local worker material handle mismatch");
-}
-async function loadRouterAbEcdsaDerivationSigningMaterialSource(args) {
-	const signerSession = args.signerSession;
-	const clientShare = signerSession.clientShare;
-	if (clientShare.kind === "linked_holder_worker_share") {
-		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
-			},
-			cleanupAfterSign: async () => void 0
-		};
-	}
-	const roleLocalClientShare = clientShare;
-	return {
-		signerSession,
-		clientSigningMaterial: {
-			kind: "router_ab_ecdsa_derivation_client_signing_material_source_v1",
-			initClientPresignSession: async (input) => {
-				await ensureRoleLocalSigningMaterialLoaded({
-					workerCtx: args.workerCtx,
-					clientShare: roleLocalClientShare
-				});
-				return await thresholdEcdsaRoleLocalPresignSessionInitFromMaterialHandleWasm({
-					materialHandle: roleLocalClientShare.handle.materialHandle,
-					material: roleLocalClientShare.material.kind === "worker_loaded" ? {
-						kind: "persisted",
-						materialRef: roleLocalClientShare.material.materialRef
-					} : {
-						kind: "runtime_loaded",
-						expectedBindingDigest: roleLocalClientShare.handle.bindingDigest
-					},
-					...input
-				});
-			},
-			stepClientPresignSession: thresholdEcdsaRoleLocalPresignSessionStepWasm,
-			abortClientPresignSession: thresholdEcdsaRoleLocalPresignSessionAbortWasm,
-			admitClientPresignature: thresholdEcdsaRoleLocalAdmitPresignatureWasm,
-			destroyClientPresignature: thresholdEcdsaRoleLocalDestroyPresignatureWasm,
-			reserveClientPresignature: thresholdEcdsaRoleLocalReservePresignatureWasm,
-			commitClientPresignature: thresholdEcdsaRoleLocalCommitPresignatureWasm,
-			listAvailableClientPresignatures: thresholdEcdsaRoleLocalListAvailablePresignaturesWasm,
-			computeSignatureShareFromPresignatureHandle: thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm
-		},
-		cleanupAfterSign: async () => void 0
-	};
-}
-//#endregion
-//#region src/core/signingEngine/flows/signEvmFamily/signers/secp256k1.ts
-var secp256k1_exports = /* @__PURE__ */ __exportAll({
-	Secp256k1Engine: () => Secp256k1Engine,
-	buildReadySecp256k1SigningMaterial: () => buildReadySecp256k1SigningMaterial
-});
-function buildReadySecp256k1SigningMaterial(args) {
-	const walletId = String(args.walletId || "").trim();
-	if (!walletId) throw new Error("[multichain] Missing wallet id for ready secp256k1 signing material");
-	const signerSession = args.signerSession;
-	if (walletId !== String(signerSession.walletId)) throw new Error("[multichain] ready secp256k1 material wallet identity mismatch");
-	const expiresAtMs = Math.floor(Number(args.expiresAtMs));
-	if (!Number.isSafeInteger(expiresAtMs) || expiresAtMs <= Date.now()) throw new Error("[multichain] ready secp256k1 authorization expiry is invalid");
-	const base = {
-		kind: "ready_secp256k1_signing_material",
-		walletId,
-		signerSession,
-		expiresAtMs,
-		singleUseEmailOtpSession: args.singleUseEmailOtpSession
-	};
-	switch (args.authorization.kind) {
-		case "reusable_wallet_session":
-			if (args.credential.kind !== "reusable_wallet_session") throw new Error("[multichain] exact Wallet Session authorization requires its operation credential");
-			return {
-				...base,
-				authorization: args.authorization,
-				credential: args.credential
-			};
-		case "operation_step_up":
-			if (!args.operationStepUpPreparation) throw new Error("[multichain] operation step-up preparation is required");
-			return {
-				...base,
-				authorization: args.authorization,
-				credential: args.credential,
-				operationStepUpPreparation: args.operationStepUpPreparation
-			};
-	}
-}
-function isSecp256k1DigestSignRequest(req) {
-	return req.kind === "digest" && req.algorithm === "secp256k1";
-}
-function requireEvmSigningOperationId(operation) {
-	const operationId = String(operation.intent.operationId || "").trim();
-	if (!operationId) throw new Error("[multichain] exact EVM signing operation id is required");
-	return operationId;
-}
-function routerAbTransportCredential(credential) {
-	switch (credential.kind) {
-		case "reusable_wallet_session": return {
-			kind: "wallet_session_opaque",
-			walletSessionToken: credential.walletSessionToken
-		};
-		case "operation_step_up": return {
-			kind: "wallet_session_opaque",
-			walletSessionToken: credential.walletSessionToken
-		};
-	}
-	throw new Error("[multichain] unsupported ECDSA signing credential");
-}
-function scheduleRouterAbEcdsaDerivationPostSignRefill(args) {
-	const signerSession = args.loadedMaterial.signerSession;
-	const publicFacts = signerSession.publicFacts;
-	const signingMaterial = signerSession.transport.signingMaterial;
-	const result = scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill({
-		relayerUrl: signerSession.transport.relayerUrl,
-		keyHandle: parseEcdsaKeyHandle(publicFacts.keyHandle),
-		ecdsaThresholdKeyId: signingMaterial.ecdsaThresholdKeyId,
-		clientVerifyingShareB64u: signingMaterial.clientVerifier33B64u,
-		clientSigningMaterial: args.loadedMaterial.clientSigningMaterial,
-		thresholdEcdsaPublicKeyB64u: publicFacts.publicKeyB64u,
-		relayerVerifyingShareB64u: signerSession.transport.relayerVerifyingShareB64u,
-		credential: args.credential,
-		materialActivation: routerAbMpcMaterialActivationRefToWire(signerSession.materialActivation),
-		routerAbEcdsaDerivationPoolFill: {
-			kind: "router_ab_ecdsa_derivation_signing_worker_pool",
-			scope: signerSession.routerAbEcdsaDerivationNormalSigning.state.scope,
-			ceremonyExpiresAtMs: args.expiresAtMs,
-			materialExpiresAtMs: Date.now() + MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS
-		},
-		workerCtx: args.workerCtx,
-		authorization: args.authorization
-	});
-	emitSigningSessionFlowTrace("evm-family", {
-		event: "ecdsa_post_sign_refill",
-		operationId: args.operationId,
-		scheduled: result.scheduled,
-		reason: result.reason,
-		depth: result.depth,
-		targetDepth: result.targetDepth
-	});
-}
-var Secp256k1Engine = class {
-	constructor(opts) {
-		this.algorithm = "secp256k1";
-		this.beforeSigning = opts.beforeSigning;
-		this.shouldAbort = opts.shouldAbort;
-		this.workerCtx = opts.workerCtx;
-	}
-	async signReadySecp256k1Digest(req, material, operation, operationDigests) {
-		const operationId = requireEvmSigningOperationId(operation);
-		const signStartedAt = performance.now();
-		const loadedMaterial = await loadRouterAbEcdsaDerivationSigningMaterialSource({
-			signerSession: material.signerSession,
-			workerCtx: this.workerCtx
-		});
-		emitEcdsaSigningTiming(operationId, "material_load", signStartedAt);
-		const signerSession = loadedMaterial.signerSession;
-		const publicFacts = signerSession.publicFacts;
-		const signerTransport = signerSession.transport;
-		const transportCredential = routerAbTransportCredential(material.credential);
-		let signatureCreated = false;
-		try {
-			const signingInput = {
-				relayerUrl: signerTransport.relayerUrl,
-				scope: signerSession.routerAbEcdsaDerivationNormalSigning.state.scope,
-				operationId,
-				operationDigests: {
-					lane_digest_b64u: operationDigests.laneDigest,
-					intent_digest_b64u: operationDigests.intentDigest,
-					display_digest_b64u: operationDigests.displayDigest
-				},
-				materialActivation: routerAbMpcMaterialActivationRefToWire(signerSession.materialActivation),
-				credential: transportCredential,
-				keyHandle: parseEcdsaKeyHandle(publicFacts.keyHandle),
-				signingDigest32: req.digest32,
-				clientSigningMaterial: loadedMaterial.clientSigningMaterial,
-				expiresAtMs: material.expiresAtMs,
-				workerCtx: this.workerCtx
-			};
-			this.beforeSigning?.();
-			let signed;
-			if (material.authorization.kind === "reusable_wallet_session") signed = await signRouterAbEcdsaDerivationDigestWithPool({
-				...signingInput,
-				authorization: material.authorization
-			});
-			else {
-				const operationStepUpPreparation = material.operationStepUpPreparation;
-				if (!operationStepUpPreparation) throw new Error("[multichain] operation step-up preparation is required for signing");
-				signed = await signRouterAbEcdsaDerivationDigestWithPool({
-					...signingInput,
-					authorization: material.authorization,
-					operation: operationStepUpPreparation
-				});
-			}
-			if (!signed.ok) throw new Error(signed.message || signed.code || "[multichain] Router A/B ECDSA derivation signing failed");
-			if (material.authorization.kind === "reusable_wallet_session") scheduleRouterAbEcdsaDerivationPostSignRefill({
-				operationId,
-				loadedMaterial,
-				workerCtx: this.workerCtx,
-				credential: transportCredential,
-				expiresAtMs: material.expiresAtMs,
-				authorization: material.authorization
-			});
-			else emitSigningSessionFlowTrace("evm-family", {
-				event: "ecdsa_post_sign_refill",
-				operationId,
-				scheduled: false,
-				reason: "operation_step_up"
-			});
-			signatureCreated = true;
-			return signed.signature65;
-		} finally {
-			await loadedMaterial.cleanupAfterSign({ singleUseEmailOtpSession: material.singleUseEmailOtpSession });
-			emitEcdsaSigningTiming(operationId, "sign_total", signStartedAt, signatureCreated ? "succeeded" : "failed");
-		}
-	}
-	async signReady(req, material, operation, operationDigests) {
-		if (!isSecp256k1DigestSignRequest(req)) throw new Error("[Secp256k1Engine] unsupported sign request");
-		if (req.digest32.length !== 32) throw new Error("[Secp256k1Engine] digest32 must be 32 bytes");
-		if (this.shouldAbort?.()) {
-			const aborted = /* @__PURE__ */ new Error("Request cancelled");
-			aborted.code = "cancelled";
-			throw aborted;
-		}
-		return await this.signReadySecp256k1Digest(req, material, operation, operationDigests);
-	}
-};
-//#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 };