@seams/wallet 0.7.3 → 0.8.0

package/dist/public/sdk/secp256k1-D-I6Gh4D.js

@@ -1,2515 +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 { Et as routerAbMpcMaterialActivationRefToWire, F as routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1, I as routerAbEcdsaRerandomizationClientCommitmentV1, St as canonicalRouterAbMpcMaterialActivationRefBytes, d as buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1, g as parseRouterAbEcdsaDerivationNormalSigningScopeV1, l as ROUTER_AB_ECDSA_PRESIGN_CEREMONY_MAX_LIFETIME_MS, nt as parseWalletAuthAuthorityRef, o as ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_INIT_PATH, s as ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_STEP_PATH, t as MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS, u as buildRouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1 } from "./ecdsaPresignLifecycle-Bfx2AQKb.js";
-import { a as parseEcdsaRoleLocalPersistedMaterialRef, c as formatEcdsaKeyHandleForWire, l as parseEcdsaClientVerifyingShareB64u, o as parseEcdsaRoleLocalWorkerHandle, s as parseEcdsaThresholdKeyId, u as parseEcdsaKeyHandle } from "./keyMaterialBrands-CogGAAZn.js";
-import { t as executeWorkerOperation } from "./executeWorkerOperation-Cl9whMK7.js";
-import { n as ecdsaClientPresignPoolKey, t as FIXED_ECDSA_PRESIGN_PROTOCOL_ID } from "./ecdsaPresignPoolIdentity-BjxZVIqn.js";
-import { i as emitEcdsaSigningTiming, n as emitEcdsaPresignServerTiming, r as emitEcdsaServerTiming, u as emitSigningSessionFlowTrace } from "./trace-DKLQZvec.js";
-import { t as DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY } from "./defaultConfigs-D_33pPT9.js";
-import { c as prepareRouterAbEcdsaDerivationEvmDigestSigningV1, o as finalizeRouterAbEcdsaDerivationEvmDigestSigningV1, t as RouterAbSigningRequestError } from "./routerAbNormalSigning-CVFEOZ2m.js";
-import { o as validateSecp256k1PublicKey33Wasm, s as verifySecp256k1RecoverableSignatureAgainstPublicKey33Wasm, t as addSecp256k1PublicKeys33Wasm } from "./evmCryptoWasm-DWklhEEb.js";
-//#region src/core/signingEngine/workerManager/workerTypes.ts
-/**
-* Control messages exchanged between worker shims and the main thread.
-*
-* 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 thresholdEcdsaListAvailablePresignaturesWasm(authorityKind, input) {
-	const response = await requestEcdsaPresignOperation({
-		workerCtx: input.workerCtx,
-		request: {
-			type: EcdsaPresignClientRequestType.ListAvailable,
-			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: {
-				authority: { kind: authorityKind },
-				poolIdentity: input.poolIdentity
-			}
-		}
-	});
-	if (response.type !== EcdsaPresignClientResponseType.ListAvailableSuccess) throw new Error("ThresholdEcdsaListAvailablePresignatures 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") {
-			const foregroundRefillStartedAt = performance.now();
-			let refill = await refillRouterAbEcdsaDerivationClientPresignaturePool({
-				...supply.refill,
-				trafficClass: "foreground"
-			});
-			if (!refill.ok && refill.code === "invalidated") refill = await refillRouterAbEcdsaDerivationClientPresignaturePool({
-				...supply.refill,
-				trafficClass: "foreground"
-			});
-			if (!refill.ok && refill.code !== "pool_full") return refill;
-			if (!refill.ok && refill.code === "pool_full") await hydrateClientPresignaturePool({
-				poolKey,
-				poolIdentity,
-				clientSigningMaterial: args.clientSigningMaterial,
-				workerCtx: args.workerCtx,
-				generation: getClientPresignaturePoolGeneration(poolKey)
-			});
-			poolGeneration = getClientPresignaturePoolGeneration(poolKey);
-			presignature = await takeClientPresignature({
-				poolKey,
-				poolIdentity,
-				clientSigningMaterial: args.clientSigningMaterial,
-				workerCtx: args.workerCtx
-			});
-			emitEcdsaSigningTiming(args.operationId, "foreground_refill", foregroundRefillStartedAt);
-		}
-		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: createLinkedHolderClientSigningMaterialSource(holderHandleId),
-			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: thresholdEcdsaListAvailablePresignaturesWasm.bind(void 0, "role_local_derivation_handle"),
-			computeSignatureShareFromPresignatureHandle: thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm
-		},
-		cleanupAfterSign: async () => void 0
-	};
-}
-async function initLinkedHolderPresignSession(holderHandleId, input) {
-	return await thresholdEcdsaLinkedHolderPresignSessionInitWasm({
-		holderHandleId,
-		...input
-	});
-}
-function createLinkedHolderClientSigningMaterialSource(holderHandleId) {
-	return {
-		kind: "router_ab_ecdsa_derivation_client_signing_material_source_v1",
-		initClientPresignSession: initLinkedHolderPresignSession.bind(void 0, holderHandleId),
-		stepClientPresignSession: thresholdEcdsaRoleLocalPresignSessionStepWasm,
-		abortClientPresignSession: thresholdEcdsaRoleLocalPresignSessionAbortWasm,
-		admitClientPresignature: thresholdEcdsaRoleLocalAdmitPresignatureWasm,
-		destroyClientPresignature: thresholdEcdsaRoleLocalDestroyPresignatureWasm,
-		reserveClientPresignature: thresholdEcdsaRoleLocalReservePresignatureWasm,
-		commitClientPresignature: thresholdEcdsaRoleLocalCommitPresignatureWasm,
-		listAvailableClientPresignatures: thresholdEcdsaListAvailablePresignaturesWasm.bind(void 0, "linked_holder_signing_material"),
-		computeSignatureShareFromPresignatureHandle: thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm
-	};
-}
-//#endregion
-//#region src/core/signingEngine/flows/signEvmFamily/signers/secp256k1.ts
-var secp256k1_exports = /* @__PURE__ */ __exportAll({
-	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 { thresholdEcdsaRoleLocalAdmitPresignatureWasm as A, EcdsaPresignClientRequestType as B, prepareEcdsaClientBootstrapCommandWasm as C, storeEcdsaRoleLocalSigningMaterialWasm as D, signWalletRecoveryEcdsaMaterialPossessionProofWasm as E, thresholdEcdsaRoleLocalPresignSessionInitFromMaterialHandleWasm as F, WorkerControlMessage as H, thresholdEcdsaRoleLocalPresignSessionStepWasm as I, thresholdEcdsaRoleLocalReservePresignatureWasm as L, thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm as M, thresholdEcdsaRoleLocalDestroyPresignatureWasm as N, storeLinkedDeviceEcdsaHolderMaterialWasm as O, thresholdEcdsaRoleLocalPresignSessionAbortWasm as P, verifyRouterAbEcdsaRegistrationClientProofsWasm as R, persistInitialCanonicalEcdsaActivationWasm as S, reconcileCanonicalEcdsaActivationWasm as T, getSignerWorkerOperationCoreCode as U, SignerWorkerOperationError as V, getSignerWorkerOperationErrorCode as W, finalizeEcdsaClientBootstrapCommandWasm as _, clearRouterAbEcdsaDerivationClientPresignaturesForWallet as a, finalizeRouterAbEcdsaRegistrationActivationWasm as b, waitForRouterAbEcdsaDerivationClientPresignaturePoolReady as c, closeRouterAbEcdsaRegistrationCeremonyWasm as d, createEcdsaHolderOrdinaryExportRequestWasm as f, destroyLinkedDeviceEcdsaHolderMaterialsWasm as g, destroyLinkedDeviceEcdsaHolderMaterialWasm as h, clearAllRouterAbEcdsaDerivationClientPresignatures as i, thresholdEcdsaRoleLocalCommitPresignatureWasm as j, thresholdEcdsaListAvailablePresignaturesWasm as k, clearLinkedDeviceEcdsaHolderMaterialsWasm as l, createRouterAbEcdsaRegistrationCeremonyWasm as m, secp256k1_exports as n, resolveRouterAbEcdsaDerivationPresignaturePoolPolicy as o, createRouterAbEcdsaPostRegistrationCeremonyWasm as p, createLinkedHolderClientSigningMaterialSource as r, scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill as s, buildReadySecp256k1SigningMaterial as t, closeRouterAbEcdsaPostRegistrationCeremonyWasm as u, finalizeEcdsaHolderOrdinaryExportWasm as v, prepareLinkedDeviceEcdsaSourceContributionWasm as w, openEcdsaRoleLocalSigningMaterialWasm as x, finalizeRouterAbEcdsaExplicitExportWasm as y, EcdsaDerivationClientCustomRequestType as z };