@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/core/signingEngine/nonce/NonceCoordinator.js

@@ -1,1026 +0,0 @@
-import { isObject } from "../../../shared-ts/src/utils/validation.js";
-import { SigningSessionIds } from "../session/operationState/types.js";
-import { EvmNonceOutcomeReason, NonceCoordinatorDegradationReason, NonceCoordinatorFallback, NonceCoordinatorTraceEventName, NonceDurableLeaseState, NonceLeaseState } from "./nonceTypes.js";
-import { isActiveCoordinationLeaseRecord, isActiveEvmLeaseState, isActiveNearLeaseState, reduceNonceLeaseState } from "./nonceLeaseState.js";
-import { assertEvmLease, assertOperationMatches, createNonceBatchId, createNonceLeaseId, createRuntimeId, evmLaneToReserveNonceInput, nonceLaneKey, nonceLaneNetworkKey, nonceLaneSubjectId } from "./nonceLaneKeys.js";
-import { normalizePositiveInteger, normalizeSessionStatusRequiredString } from "./nonceUtils.js";
-import { createEvmNonceLaneBlockedError, getOrCreateEvmNonceLaneState, indexEvmNonceLaneBySubject, markEvmBroadcastAcceptedState, markEvmDroppedOrReplacedState, markEvmFinalizedState, readBlockedEvmInFlight, reconcileEvmLaneState, refreshEvmLaneFromChainLocked, releaseEvmNonceReservationState, shouldRefreshEvmLane } from "./evmNonceLane.js";
-import { clearNearAccessKeyState, clearNearPrefetchTimer, commitNearTransactionContextForState, createNearNonceLaneState, fetchNearFreshDataForState, hasNearInflightFetch, initializeNearAccessKeyState, isAccessKeyViewLike, markNearBroadcastAcceptedState, readNearAccessKeySubject, readNearActivePublicKey, reconcileNearLaneState, refreshNearNonceAfterBroadcastRejectedState, releaseNearNonceFromState, reserveNearNoncesFromState, shouldPrefetchNearContext, updateNearNonceFromBlockchainState } from "./nearNonceLane.js";
-import { appendOutcomeMetricEvent, createNonceCoordinatorDiagnostics, recordCoordinationDegradationOnce, recordDroppedReplacedAlertWindow } from "./nonceDiagnostics.js";
-import "./nearNonceLaneIdentity.js";
-//#region src/core/signingEngine/nonce/NonceCoordinator.ts
-const DEFAULT_NONCE_LEASE_TTL_MS = 12e4;
-const DEFAULT_SIGNED_NONCE_LEASE_TTL_MS = 3e4;
-const DEFAULT_EVM_REFRESH_TTL_MS = 5e3;
-const DEFAULT_EVM_STALE_INFLIGHT_THRESHOLD_MS = 45e3;
-const DEFAULT_DROPPED_REPLACED_ALERT_THRESHOLD = 3;
-const DEFAULT_DROPPED_REPLACED_ALERT_WINDOW_MS = 5 * 6e4;
-const DEFAULT_DURABLE_LOCK_TTL_MS = 5e3;
-const DEFAULT_DURABLE_LOCK_WAIT_TIMEOUT_MS = 3e3;
-const NEAR_NONCE_FRESHNESS_THRESHOLD_MS = 5e3;
-const NEAR_BLOCK_FRESHNESS_THRESHOLD_MS = 2e4;
-const NEAR_PREFETCH_DEBOUNCE_MS = 400;
-function createNonceCoordinator(deps) {
-	const leases = /* @__PURE__ */ new Map();
-	const evmStates = /* @__PURE__ */ new Map();
-	const evmAccountLaneKeys = /* @__PURE__ */ new Map();
-	const droppedReplacedAlerts = /* @__PURE__ */ new Map();
-	const outcomeMetricEvents = [];
-	const laneLocks = /* @__PURE__ */ new Map();
-	const now = deps.now || Date.now;
-	const leaseTtlMs = normalizePositiveInteger(deps.leaseTtlMs, DEFAULT_NONCE_LEASE_TTL_MS);
-	const signedLeaseTtlMs = normalizePositiveInteger(deps.signedLeaseTtlMs, DEFAULT_SIGNED_NONCE_LEASE_TTL_MS);
-	const evmRefreshTtlMs = normalizePositiveInteger(deps.evmRefreshTtlMs, DEFAULT_EVM_REFRESH_TTL_MS);
-	const evmStaleInFlightThresholdMs = normalizePositiveInteger(deps.evmStaleInFlightThresholdMs, DEFAULT_EVM_STALE_INFLIGHT_THRESHOLD_MS);
-	const droppedReplacedAlertThreshold = normalizePositiveInteger(deps.droppedReplacedAlertThreshold, DEFAULT_DROPPED_REPLACED_ALERT_THRESHOLD);
-	const droppedReplacedAlertWindowMs = normalizePositiveInteger(deps.droppedReplacedAlertWindowMs, DEFAULT_DROPPED_REPLACED_ALERT_WINDOW_MS);
-	const sameOriginLock = deps.sameOriginLock === void 0 ? createDefaultSameOriginLock() : deps.sameOriginLock;
-	const nonceLaneCoordinationStore = deps.nonceLaneCoordinationStore ?? null;
-	const shouldWarnOnMissingCoordinationStore = deps.nonceLaneCoordinationStore !== void 0;
-	const runtimeId = createRuntimeId();
-	const observedCoordinationDegradations = /* @__PURE__ */ new Map();
-	const emit = (event) => {
-		appendOutcomeMetricEvent(outcomeMetricEvents, event);
-		try {
-			deps.onTrace?.(event);
-		} catch {}
-	};
-	const emitCoordinationDegradedOnce = (reason, input) => {
-		const degradationEvent = recordCoordinationDegradationOnce({
-			observed: observedCoordinationDegradations,
-			reason,
-			...input
-		});
-		if (!degradationEvent) return;
-		emit({
-			event: NonceCoordinatorTraceEventName.CoordinationDegraded,
-			...degradationEvent
-		});
-		console.warn("[NonceCoordinator] nonce coordination degraded", degradationEvent.degradation);
-	};
-	const normalizeLeaseOperationInput = (input) => ({
-		leaseId: normalizeSessionStatusRequiredString(input.leaseId, "leaseId"),
-		operationId: SigningSessionIds.signingOperation(input.operationId),
-		operationFingerprint: SigningSessionIds.signingOperationFingerprint(input.operationFingerprint)
-	});
-	const readLease = (input) => {
-		const leaseId = normalizeSessionStatusRequiredString(input.leaseId, "leaseId");
-		const lease = leases.get(leaseId);
-		if (!lease) throw new Error("[NonceCoordinator] nonce lease not found");
-		assertOperationMatches(lease, input.operationId, input.operationFingerprint);
-		return lease;
-	};
-	const transitionLease = (args) => {
-		const previousState = args.lease.state;
-		const nextState = reduceNonceLeaseState(previousState, args.transition);
-		args.lease.state = nextState;
-		const expiresAtMs = args.expiresAtMs;
-		if (typeof expiresAtMs === "number" && Number.isSafeInteger(expiresAtMs)) args.lease.expiresAtMs = expiresAtMs;
-		emit({
-			event: args.event,
-			lease: args.lease,
-			previousState,
-			nextState,
-			...args.reason ? { reason: args.reason } : {},
-			...args.txHash ? { txHash: args.txHash } : {}
-		});
-	};
-	const preflightLeaseTransition = (lease, transition) => {
-		reduceNonceLeaseState(lease.state, transition);
-	};
-	const getOrCreateEvmState = (laneKey) => {
-		return getOrCreateEvmNonceLaneState(evmStates, laneKey);
-	};
-	const indexEvmLaneByAccount = (lane, laneKey) => {
-		indexEvmNonceLaneBySubject({
-			accountLaneKeys: evmAccountLaneKeys,
-			lane,
-			laneKey
-		});
-	};
-	const readCoordinationLaneRecords = async (laneKey, lane) => {
-		if (!nonceLaneCoordinationStore) {
-			if (shouldWarnOnMissingCoordinationStore) emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.IndexedDBUnavailable, { lane });
-			return [];
-		}
-		try {
-			await nonceLaneCoordinationStore.pruneExpired(now());
-		} catch {
-			emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError, { lane });
-		}
-		try {
-			return await nonceLaneCoordinationStore.readLane(laneKey);
-		} catch {
-			emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError, { lane });
-			return [];
-		}
-	};
-	const readActiveEvmLeaseNonces = async (laneKey, input) => {
-		const active = /* @__PURE__ */ new Set();
-		for (const lease of leases.values()) {
-			if (input?.excludeLeaseId && lease.leaseId === input.excludeLeaseId) continue;
-			if (!isEvmNonceLease(lease)) continue;
-			if (nonceLaneKey(lease.lane) !== laneKey) continue;
-			if (!isActiveEvmLeaseState(lease.state)) continue;
-			const nonce = lease.nonce;
-			if (input?.chainNextNonce != null && nonce < input.chainNextNonce) continue;
-			active.add(nonce.toString());
-		}
-		for (const parsed of await readCoordinationLaneRecords(laneKey, input?.lane)) {
-			if (parsed.record.family !== "evm") continue;
-			if (input?.excludeLeaseId && parsed.record.leaseId === input.excludeLeaseId) continue;
-			if (!isActiveCoordinationLeaseRecord(parsed.record, now())) continue;
-			if (input?.chainNextNonce != null && parsed.nonce < input.chainNextNonce) continue;
-			active.add(parsed.nonce.toString());
-		}
-		return active;
-	};
-	const readActiveNearLeaseNonces = async (laneKey, input) => {
-		const active = /* @__PURE__ */ new Set();
-		for (const lease of leases.values()) {
-			if (input?.excludeLeaseId && lease.leaseId === input.excludeLeaseId) continue;
-			if (!isNearNonceLease(lease)) continue;
-			if (nonceLaneKey(lease.lane) !== laneKey) continue;
-			if (!isActiveNearLeaseState(lease.state)) continue;
-			const nonce = BigInt(lease.nonce);
-			if (input?.chainNextNonce != null && nonce < input.chainNextNonce) continue;
-			active.add(nonce.toString());
-		}
-		for (const parsed of await readCoordinationLaneRecords(laneKey, input?.lane)) {
-			if (parsed.record.family !== "near") continue;
-			if (input?.excludeLeaseId && parsed.record.leaseId === input.excludeLeaseId) continue;
-			if (!isActiveCoordinationLeaseRecord(parsed.record, now())) continue;
-			if (input?.chainNextNonce != null && parsed.nonce < input.chainNextNonce) continue;
-			active.add(parsed.nonce.toString());
-		}
-		return active;
-	};
-	const persistCoordinationLease = async (lease, lifecycle, expiresAtMs = lease.expiresAtMs) => {
-		const coordinationStore = nonceLaneCoordinationStore;
-		if (!coordinationStore) {
-			if (shouldWarnOnMissingCoordinationStore) emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.IndexedDBUnavailable, { lane: lease.lane });
-			return;
-		}
-		if (isEvmNonceLease(lease)) await persistCoordinationRecord(coordinationStore, buildEvmCoordinationRecord({
-			lease,
-			lifecycle,
-			expiresAtMs,
-			updatedAtMs: now(),
-			runtimeId
-		}), lease.lane);
-		else if (isNearNonceLease(lease)) await persistCoordinationRecord(coordinationStore, buildNearCoordinationRecord({
-			lease,
-			lifecycle,
-			expiresAtMs,
-			updatedAtMs: now(),
-			runtimeId
-		}), lease.lane);
-		else assertNever(lease);
-	};
-	const persistCoordinationRecord = async (coordinationStore, record, lane) => {
-		try {
-			await coordinationStore.upsert(record);
-		} catch {
-			emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError, { lane });
-		}
-	};
-	const removeCoordinationLease = async (lease) => {
-		if (!nonceLaneCoordinationStore) return;
-		try {
-			await nonceLaneCoordinationStore.remove({
-				laneKey: nonceLaneKey(lease.lane),
-				leaseId: lease.leaseId
-			});
-		} catch {
-			emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError, { lane: lease.lane });
-		}
-	};
-	const refreshEvmLaneFromChainLocked$1 = async (lane, state) => {
-		const laneKey = nonceLaneKey(lane);
-		return await refreshEvmLaneFromChainLocked({
-			lane,
-			state,
-			nowMs: now(),
-			fetchChainNonce: async (targetLane) => await deps.evmNonceBackend.fetchChainNonce(evmLaneToReserveNonceInput(targetLane)),
-			readActiveLeaseNonces: async (input) => await readActiveEvmLeaseNonces(laneKey, input)
-		});
-	};
-	const shouldRefreshEvmLaneLocked = async (laneKey, state, lane) => {
-		return await shouldRefreshEvmLane({
-			state,
-			lane,
-			nowMs: now(),
-			refreshTtlMs: evmRefreshTtlMs,
-			readActiveLeaseNonces: async (input) => await readActiveEvmLeaseNonces(laneKey, input)
-		});
-	};
-	const reserveEvmNonceLeaseUnlocked = async (input) => {
-		await expireDueLeasesForLockedLane(input.lane);
-		const laneKey = nonceLaneKey(input.lane);
-		const state = getOrCreateEvmState(laneKey);
-		indexEvmLaneByAccount(input.lane, laneKey);
-		if (await shouldRefreshEvmLaneLocked(laneKey, state, input.lane)) await refreshEvmLaneFromChainLocked$1(input.lane, state);
-		const blocked = readBlockedEvmInFlight({
-			state,
-			nowMs: now(),
-			staleInFlightThresholdMs: evmStaleInFlightThresholdMs
-		});
-		if (blocked) throw createEvmNonceLaneBlockedError({
-			lane: input.lane,
-			blockedNonce: blocked.blockedNonce,
-			ageMs: blocked.ageMs
-		});
-		let candidate = state.chainNonce ?? state.nextCandidate ?? 0n;
-		const activeLeaseNonces = await readActiveEvmLeaseNonces(laneKey, { lane: input.lane });
-		while (activeLeaseNonces.has(candidate.toString()) || state.inFlight.has(candidate.toString())) candidate += 1n;
-		state.nextCandidate = candidate + 1n;
-		const reservedAtMs = now();
-		const lease = {
-			leaseId: createNonceLeaseId({
-				operationId: input.operation.operationId,
-				chain: input.lane.chainTarget.kind,
-				nonce: candidate
-			}),
-			lane: input.lane,
-			operationId: input.operation.operationId,
-			operationFingerprint: input.operation.operationFingerprint,
-			nonce: candidate,
-			state: NonceLeaseState.Reserved,
-			reservedAtMs,
-			expiresAtMs: reservedAtMs + leaseTtlMs
-		};
-		leases.set(lease.leaseId, lease);
-		await persistCoordinationLease(lease, { state: NonceDurableLeaseState.Reserved });
-		emit({
-			event: NonceCoordinatorTraceEventName.LeaseReserved,
-			lease
-		});
-		return { ...lease };
-	};
-	const releaseEvmNonceReservation = async (lease) => {
-		const laneKey = nonceLaneKey(lease.lane);
-		await releaseEvmNonceReservationState({
-			lease,
-			state: evmStates.get(laneKey),
-			removeCoordinationLease,
-			readActiveLeaseNonces: async (input) => await readActiveEvmLeaseNonces(laneKey, input)
-		});
-	};
-	const markEvmBroadcastAccepted = async (lease, txHash) => {
-		await markEvmBroadcastAcceptedState({
-			lease,
-			state: getOrCreateEvmState(nonceLaneKey(lease.lane)),
-			txHash,
-			nowMs: now(),
-			staleInFlightThresholdMs: evmStaleInFlightThresholdMs,
-			persistCoordinationLease
-		});
-	};
-	const markEvmFinalized = async (lease) => {
-		await markEvmFinalizedState({
-			lease,
-			state: getOrCreateEvmState(nonceLaneKey(lease.lane)),
-			nowMs: now(),
-			removeCoordinationLease
-		});
-	};
-	const markEvmDroppedOrReplaced = async (lease, input) => {
-		await markEvmDroppedOrReplacedState({
-			lease,
-			state: getOrCreateEvmState(nonceLaneKey(lease.lane)),
-			outcome: input,
-			nowMs: now(),
-			removeCoordinationLease
-		});
-	};
-	const reconcileEvmLaneLocked = async (lane) => {
-		const laneKey = nonceLaneKey(lane);
-		const state = getOrCreateEvmState(laneKey);
-		indexEvmLaneByAccount(lane, laneKey);
-		return await reconcileEvmLaneState({
-			lane,
-			state,
-			nowMs: now(),
-			staleInFlightThresholdMs: evmStaleInFlightThresholdMs,
-			refreshFromChain: refreshEvmLaneFromChainLocked$1
-		});
-	};
-	const recordDroppedReplacedAlert = (args) => {
-		const result = recordDroppedReplacedAlertWindow({
-			alerts: droppedReplacedAlerts,
-			lane: args.lane,
-			reason: args.reason,
-			nowMs: now(),
-			threshold: droppedReplacedAlertThreshold,
-			windowMs: droppedReplacedAlertWindowMs
-		});
-		if (!result) return;
-		emit({
-			event: NonceCoordinatorTraceEventName.LaneAlert,
-			lane: args.lane,
-			alert: result.alert
-		});
-		console.warn("[NonceCoordinator] repeated EVM-family dropped/replaced nonce outcomes", result.warning);
-	};
-	const nearState = createNearNonceLaneState();
-	const clearNearAccessKeyState$1 = () => {
-		clearNearAccessKeyState(nearState);
-	};
-	const requireNearClient = (nearClient) => {
-		const resolved = nearClient || deps.nearClient;
-		if (!resolved) throw new Error("[NonceCoordinator] NEAR client is not configured");
-		return resolved;
-	};
-	const initializeNearAccessKey = (input) => {
-		initializeNearAccessKeyState({
-			state: nearState,
-			...input
-		});
-	};
-	const reserveNearNonces = async (lane, countInput) => {
-		return await reserveNearNoncesFromState({
-			state: nearState,
-			lane,
-			countInput,
-			readActiveLeaseNonces: readActiveNearLeaseNonces
-		});
-	};
-	const releaseNearNonce = (nonce) => {
-		releaseNearNonceFromState(nearState, nonce);
-	};
-	const fetchNearFreshData = async (nearClient, force = false) => {
-		return await fetchNearFreshDataForState({
-			state: nearState,
-			nearClient,
-			force,
-			now,
-			nonceFreshnessThresholdMs: NEAR_NONCE_FRESHNESS_THRESHOLD_MS,
-			blockFreshnessThresholdMs: NEAR_BLOCK_FRESHNESS_THRESHOLD_MS
-		});
-	};
-	const fetchNearContextForLane = async (input) => {
-		initializeNearAccessKey({
-			walletId: input.lane.walletId,
-			nearAccountId: input.lane.nearAccountId,
-			publicKey: input.lane.publicKey
-		});
-		return { ...await fetchNearFreshData(requireNearClient(input.nearClient), input.force === true) };
-	};
-	const updateNearNonceFromBlockchain = async (nearClient, actualNonce) => {
-		await updateNearNonceFromBlockchainState({
-			state: nearState,
-			nearClient,
-			actualNonce,
-			now
-		});
-	};
-	const refreshNearNonceAfterBroadcastRejected = async (nearClient) => {
-		await refreshNearNonceAfterBroadcastRejectedState({
-			state: nearState,
-			nearClient,
-			now
-		});
-	};
-	const reconcileNearLaneLocked = async (lane) => {
-		const laneKey = nonceLaneKey(lane);
-		return await reconcileNearLaneState({
-			lane,
-			state: nearState,
-			nearClient: requireNearClient(),
-			now,
-			activeLeases: Array.from(leases.values()).filter((lease) => lease.lane.family === "near" && nonceLaneKey(lease.lane) === laneKey && lease.state === NonceLeaseState.BroadcastAccepted),
-			removeCoordinationLease,
-			transitionLease: ({ lease, transition, reason, txHash }) => {
-				transitionLease({
-					lease,
-					transition,
-					event: transition === "finalize" ? NonceCoordinatorTraceEventName.LeaseFinalized : NonceCoordinatorTraceEventName.LeaseDropped,
-					reason,
-					...txHash ? { txHash } : {}
-				});
-			}
-		});
-	};
-	const releaseBackendReservation = async (lease) => {
-		if (isEvmNonceLease(lease)) {
-			await releaseEvmNonceReservation(lease);
-			return;
-		}
-		releaseNearNonce(String(lease.nonce));
-		await removeCoordinationLease(lease);
-	};
-	const reconcileAfterSignedLeaseExpiry = async (lease) => {
-		await releaseBackendReservation(lease);
-		if (lease.lane.family !== "evm") return;
-		await reconcileEvmLaneLocked(lease.lane);
-		emit({
-			event: NonceCoordinatorTraceEventName.LaneReconciled,
-			lane: lease.lane
-		});
-	};
-	const withLocalLaneLock = async (laneKey, fn) => {
-		const previous = laneLocks.get(laneKey) ?? Promise.resolve();
-		let releaseCurrent;
-		const current = new Promise((resolve) => {
-			releaseCurrent = resolve;
-		});
-		const next = previous.catch(() => void 0).then(() => current);
-		laneLocks.set(laneKey, next);
-		await previous.catch(() => void 0);
-		try {
-			return await fn();
-		} finally {
-			releaseCurrent();
-			if (laneLocks.get(laneKey) === next) laneLocks.delete(laneKey);
-		}
-	};
-	const withLaneLock = async (lane, fn) => {
-		const laneKey = nonceLaneKey(lane);
-		const runLocal = async () => await withLocalLaneLock(laneKey, fn);
-		const lockKey = `nonce-coordinator:${laneKey}`;
-		if (sameOriginLock) return await sameOriginLock.withLock(lockKey, runLocal);
-		if (nonceLaneCoordinationStore?.withLock) {
-			let taskError = null;
-			const runLockedTask = async () => {
-				try {
-					return await runLocal();
-				} catch (error) {
-					taskError = error;
-					throw error;
-				}
-			};
-			try {
-				return await nonceLaneCoordinationStore.withLock({
-					lockKey,
-					ownerId: runtimeId,
-					ttlMs: DEFAULT_DURABLE_LOCK_TTL_MS,
-					waitTimeoutMs: DEFAULT_DURABLE_LOCK_WAIT_TIMEOUT_MS
-				}, runLockedTask);
-			} catch (error) {
-				if (taskError === error) throw error;
-				emitCoordinationDegradedOnce((isObject(error) ? String(error.code || "") : "") === NonceCoordinatorDegradationReason.DurableLockTimeout ? NonceCoordinatorDegradationReason.DurableLockTimeout : NonceCoordinatorDegradationReason.DurableStoreError, {
-					lane,
-					fallback: NonceCoordinatorFallback.None
-				});
-				throw error;
-			}
-		}
-		if (shouldWarnOnMissingCoordinationStore) emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.WebLocksUnavailable, { lane });
-		return await runLocal();
-	};
-	const expireLeaseLocked = async (lease, nowMs) => {
-		if (lease.expiresAtMs > nowMs) return null;
-		if (lease.state !== NonceLeaseState.Reserved && lease.state !== NonceLeaseState.Signed) return null;
-		const expiringFromState = lease.state;
-		if (lease.state === NonceLeaseState.Signed) await reconcileAfterSignedLeaseExpiry(lease);
-		else await releaseBackendReservation(lease);
-		transitionLease({
-			lease,
-			transition: "expire",
-			event: NonceCoordinatorTraceEventName.LeaseExpired,
-			reason: expiringFromState === NonceLeaseState.Signed ? "signed_lease_ttl_elapsed" : "lease_ttl_elapsed"
-		});
-		return { ...lease };
-	};
-	const expireDueLeasesForLockedLane = async (lane) => {
-		const nowMs = now();
-		const laneKey = nonceLaneKey(lane);
-		const expired = [];
-		for (const lease of Array.from(leases.values())) {
-			if (nonceLaneKey(lease.lane) !== laneKey) continue;
-			const expiredLease = await expireLeaseLocked(lease, nowMs);
-			if (expiredLease) expired.push(expiredLease);
-		}
-		return expired;
-	};
-	const expireDueLeasesForWallet = async (input) => {
-		const walletId = input?.walletId ? String(input.walletId).trim() : "";
-		const laneByKey = /* @__PURE__ */ new Map();
-		for (const lease of Array.from(leases.values())) {
-			if (walletId && nonceLaneSubjectId(lease.lane) !== walletId) continue;
-			laneByKey.set(nonceLaneKey(lease.lane), lease.lane);
-		}
-		const expired = [];
-		for (const lane of laneByKey.values()) expired.push(...await withLaneLock(lane, async () => expireDueLeasesForLockedLane(lane)));
-		return expired;
-	};
-	const recoverDurableLeases = async (input) => {
-		if (!nonceLaneCoordinationStore) {
-			if (shouldWarnOnMissingCoordinationStore) emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.IndexedDBUnavailable);
-			return;
-		}
-		let readResults = [];
-		try {
-			readResults = await nonceLaneCoordinationStore.readAllForRecovery(input);
-		} catch {
-			emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError);
-			return;
-		}
-		for (const readResult of readResults) {
-			if (!readResult.ok) {
-				if (readResult.leaseId) await nonceLaneCoordinationStore.remove({
-					laneKey: readResult.laneKey,
-					leaseId: readResult.leaseId
-				});
-				emitCoordinationDegradedOnce(readResult.degradation.reason, {
-					accountId: readResult.degradation.accountId,
-					networkKey: readResult.degradation.networkKey,
-					laneFamily: readResult.degradation.laneFamily,
-					fallback: readResult.degradation.fallback
-				});
-				continue;
-			}
-			const { record, lane, canonicalLaneKey, nonce: recordNonce } = readResult.parsed;
-			await withLaneLock(lane, async () => {
-				if (record.laneKey !== canonicalLaneKey) {
-					await nonceLaneCoordinationStore.remove({
-						laneKey: record.laneKey,
-						leaseId: record.leaseId
-					});
-					emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.MalformedDurableRecord, {
-						accountId: nonceLaneSubjectId(lane),
-						networkKey: record.networkKey,
-						laneFamily: record.family,
-						fallback: NonceCoordinatorFallback.None
-					});
-					return;
-				}
-				const isExpired = record.expiresAtMs <= now();
-				if (isExpired && record.state !== NonceDurableLeaseState.BroadcastAccepted) {
-					await nonceLaneCoordinationStore.remove({
-						laneKey: record.laneKey,
-						leaseId: record.leaseId
-					});
-					if (record.family === "evm") await reconcileEvmLaneLocked(lane).catch(() => null);
-					emit({
-						event: NonceCoordinatorTraceEventName.LaneReconciled,
-						lane,
-						reason: "startup_recovery_expired_lease"
-					});
-					return;
-				}
-				if (record.family === "evm") {
-					const evmLane = lane;
-					const state = getOrCreateEvmState(record.laneKey);
-					let broadcastStatus = null;
-					if (record.state === NonceDurableLeaseState.BroadcastAccepted) {
-						const txHash = requireRecoveredEvmTxHash(record.txHash);
-						state.inFlight.set(record.nonce.toString(), {
-							nonce: recordNonce,
-							txHash,
-							status: "accepted",
-							acceptedAtMs: record.reservedAtMs,
-							updatedAtMs: record.updatedAtMs
-						});
-						broadcastStatus = await deps.evmNonceBackend.fetchBroadcastTransactionStatus({
-							...evmLaneToReserveNonceInput(evmLane),
-							txHash
-						}).catch(() => null);
-						if (broadcastStatus?.kind === "finalized") {
-							state.inFlight.delete(record.nonce.toString());
-							await nonceLaneCoordinationStore.remove({
-								laneKey: record.laneKey,
-								leaseId: record.leaseId
-							});
-							await reconcileEvmLaneLocked(evmLane).catch(() => null);
-							emit({
-								event: NonceCoordinatorTraceEventName.LaneReconciled,
-								lane: evmLane,
-								reason: "startup_recovery_finalized_transaction",
-								txHash: record.txHash
-							});
-							return;
-						}
-					}
-					const status = await reconcileEvmLaneLocked(evmLane).catch(() => null);
-					const chainAdvanced = !!status && status.chainNextNonce > recordNonce;
-					const staleMissingBroadcast = record.state === NonceDurableLeaseState.BroadcastAccepted && broadcastStatus?.kind === "missing" && isExpired;
-					if (chainAdvanced || staleMissingBroadcast) {
-						state.inFlight.delete(record.nonce.toString());
-						await nonceLaneCoordinationStore.remove({
-							laneKey: record.laneKey,
-							leaseId: record.leaseId
-						});
-					}
-					emit({
-						event: NonceCoordinatorTraceEventName.LaneReconciled,
-						lane: evmLane,
-						reason: staleMissingBroadcast ? "startup_recovery_dropped_transaction" : "startup_recovery",
-						...staleMissingBroadcast && record.state === NonceDurableLeaseState.BroadcastAccepted ? { txHash: record.txHash } : {}
-					});
-					return;
-				}
-				if (record.family === "near" && deps.nearClient) try {
-					const accessKey = await deps.nearClient.viewAccessKey(record.nearAccountId, record.publicKey);
-					if (isAccessKeyViewLike(accessKey) && BigInt(accessKey.nonce) >= recordNonce) await nonceLaneCoordinationStore.remove({
-						laneKey: record.laneKey,
-						leaseId: record.leaseId
-					});
-				} catch {}
-			});
-		}
-	};
-	const reserveNearNonceBatchUnlocked = async (input) => {
-		await expireDueLeasesForLockedLane(input.lane);
-		const count = Math.max(1, Math.floor(Number(input.count || 1)));
-		const nonces = await reserveNearNonces(input.lane, count);
-		if (nonces.length !== count) throw new Error("[NonceCoordinator] NEAR nonce reservation returned an incomplete batch");
-		const reservedAtMs = now();
-		const batchId = createNonceBatchId({
-			operationId: input.operation.operationId,
-			chain: "near",
-			firstNonce: nonces[0],
-			count
-		});
-		const batchLeases = nonces.map((nonce, txIndex) => ({
-			leaseId: createNonceLeaseId({
-				operationId: input.operation.operationId,
-				chain: "near",
-				nonce
-			}),
-			lane: input.lane,
-			operationId: input.operation.operationId,
-			operationFingerprint: input.operation.operationFingerprint,
-			nonce,
-			state: NonceLeaseState.Reserved,
-			reservedAtMs,
-			expiresAtMs: reservedAtMs + leaseTtlMs,
-			batchId,
-			txIndex
-		}));
-		for (const lease of batchLeases) {
-			leases.set(lease.leaseId, lease);
-			await persistCoordinationLease(lease, { state: NonceDurableLeaseState.Reserved });
-			emit({
-				event: NonceCoordinatorTraceEventName.LeaseReserved,
-				lease
-			});
-		}
-		return batchLeases.map((lease) => ({ ...lease }));
-	};
-	const readDiagnostics = (input) => {
-		const accountId = input?.accountId ? String(input.accountId).trim() : "";
-		const diagnostics = createNonceCoordinatorDiagnostics({
-			options: input,
-			leases: leases.values(),
-			nearState,
-			observedCoordinationDegradations: observedCoordinationDegradations.values(),
-			outcomeMetricEvents,
-			nowMs: now()
-		});
-		if (input?.emitMetrics) emit({
-			event: NonceCoordinatorTraceEventName.Metrics,
-			metrics: diagnostics.metrics,
-			...accountId ? { accountId } : {}
-		});
-		return diagnostics;
-	};
-	return {
-		async reserve(input) {
-			if (input.lane.family === "near") {
-				const nearLane = input.lane;
-				return await withLaneLock(nearLane, async () => {
-					return (await reserveNearNonceBatchUnlocked({
-						lane: nearLane,
-						operation: input.operation,
-						count: 1
-					}))[0];
-				});
-			}
-			const evmLane = input.lane;
-			return await withLaneLock(evmLane, async () => {
-				return await reserveEvmNonceLeaseUnlocked({
-					lane: evmLane,
-					operation: input.operation
-				});
-			});
-		},
-		async reserveBatch(input) {
-			return await withLaneLock(input.lane, async () => {
-				return await reserveNearNonceBatchUnlocked(input);
-			});
-		},
-		async reserveNearContext(input) {
-			return await withLaneLock(input.lane, async () => {
-				initializeNearAccessKey({
-					walletId: input.lane.walletId,
-					nearAccountId: input.lane.nearAccountId,
-					publicKey: input.lane.publicKey
-				});
-				const context = { ...input.fetchContext ? await input.fetchContext() : await fetchNearContextForLane({
-					lane: input.lane,
-					nearClient: input.nearClient,
-					force: input.force === false ? false : true
-				}) };
-				commitNearTransactionContextForState({
-					state: nearState,
-					walletId: input.lane.walletId,
-					nearAccountId: input.lane.nearAccountId,
-					publicKey: input.lane.publicKey,
-					transactionContext: context,
-					nowMs: now()
-				});
-				const leases = await reserveNearNonceBatchUnlocked({
-					lane: input.lane,
-					operation: input.operation,
-					count: input.count
-				});
-				if (leases[0]) context.nextNonce = String(leases[0].nonce);
-				return {
-					context,
-					leases
-				};
-			});
-		},
-		initializeNearAccessKey,
-		getActiveNearPublicKey() {
-			return readNearActivePublicKey(nearState);
-		},
-		async fetchNearContext(input) {
-			return await withLaneLock(input.lane, async () => fetchNearContextForLane(input));
-		},
-		async prefetchNearContext(input) {
-			if (input?.kind === "access_key_subject") initializeNearAccessKey({
-				walletId: input.walletId,
-				nearAccountId: input.nearAccountId,
-				publicKey: input.publicKey
-			});
-			if (!readNearAccessKeySubject(nearState)) return;
-			clearNearPrefetchTimer(nearState);
-			const nearClient = requireNearClient(input?.nearClient);
-			nearState.prefetchTimer = setTimeout(() => {
-				nearState.prefetchTimer = null;
-				if (hasNearInflightFetch(nearState)) return;
-				if (!shouldPrefetchNearContext({
-					state: nearState,
-					nowMs: now(),
-					blockFreshnessThresholdMs: NEAR_BLOCK_FRESHNESS_THRESHOLD_MS
-				})) return;
-				fetchNearFreshData(nearClient).catch(() => void 0);
-			}, NEAR_PREFETCH_DEBOUNCE_MS);
-		},
-		clearNearAccessKey() {
-			clearNearAccessKeyState$1();
-			for (const [leaseId, lease] of leases.entries()) if (lease.lane.family === "near") leases.delete(leaseId);
-		},
-		async markSigned(input) {
-			const operationInput = normalizeLeaseOperationInput(input);
-			return await withLaneLock(readLease(operationInput).lane, async () => {
-				const lockedLease = readLease(operationInput);
-				const expiresAtMs = now() + signedLeaseTtlMs;
-				transitionLease({
-					lease: lockedLease,
-					transition: "mark_signed",
-					event: NonceCoordinatorTraceEventName.LeaseSigned,
-					expiresAtMs,
-					...input.signedTxHash ? { txHash: input.signedTxHash } : {}
-				});
-				await persistCoordinationLease(lockedLease, { state: NonceDurableLeaseState.Signed }, expiresAtMs);
-			});
-		},
-		async markBroadcastAccepted(input) {
-			const operationInput = normalizeLeaseOperationInput(input);
-			return await withLaneLock(readLease(operationInput).lane, async () => {
-				const lockedLease = readLease(operationInput);
-				preflightLeaseTransition(lockedLease, "broadcast_accepted");
-				if (isEvmNonceLease(lockedLease)) await markEvmBroadcastAccepted(lockedLease, String(input.txHash));
-				else if (isNearNonceLease(lockedLease)) await markNearBroadcastAcceptedState({
-					lease: lockedLease,
-					state: nearState,
-					txHash: String(input.txHash),
-					nowMs: now(),
-					persistCoordinationLease
-				});
-				else assertNever(lockedLease);
-				transitionLease({
-					lease: lockedLease,
-					transition: "broadcast_accepted",
-					event: NonceCoordinatorTraceEventName.LeaseBroadcastAccepted,
-					txHash: String(input.txHash)
-				});
-			});
-		},
-		async markBroadcastRejected(input) {
-			const operationInput = normalizeLeaseOperationInput(input);
-			return await withLaneLock(readLease(operationInput).lane, async () => {
-				const lockedLease = readLease(operationInput);
-				preflightLeaseTransition(lockedLease, "broadcast_rejected");
-				await releaseBackendReservation(lockedLease);
-				if (isNearNonceLease(lockedLease) && deps.nearClient) try {
-					await refreshNearNonceAfterBroadcastRejected(deps.nearClient);
-				} catch {}
-				transitionLease({
-					lease: lockedLease,
-					transition: "broadcast_rejected",
-					event: NonceCoordinatorTraceEventName.LeaseBroadcastRejected,
-					reason: input.error instanceof Error ? input.error.message : String(input.error || "")
-				});
-			});
-		},
-		async markFinalized(input) {
-			const operationInput = normalizeLeaseOperationInput(input);
-			return await withLaneLock(readLease(operationInput).lane, async () => {
-				const lockedLease = readLease(operationInput);
-				preflightLeaseTransition(lockedLease, "finalize");
-				if (isEvmNonceLease(lockedLease)) await markEvmFinalized(lockedLease);
-				else if (isNearNonceLease(lockedLease)) {
-					if (deps.nearClient) await updateNearNonceFromBlockchain(deps.nearClient, String(lockedLease.nonce));
-					else await releaseBackendReservation(lockedLease);
-					await removeCoordinationLease(lockedLease);
-				} else assertNever(lockedLease);
-				transitionLease({
-					lease: lockedLease,
-					transition: "finalize",
-					event: NonceCoordinatorTraceEventName.LeaseFinalized,
-					...input.txHash ? { txHash: String(input.txHash) } : {}
-				});
-			});
-		},
-		async markDroppedOrReplaced(input) {
-			const operationInput = normalizeLeaseOperationInput(input);
-			const lease = readLease(operationInput);
-			assertEvmLease(lease);
-			return await withLaneLock(lease.lane, async () => {
-				const lockedLease = readLease(operationInput);
-				assertEvmLease(lockedLease);
-				preflightLeaseTransition(lockedLease, input.reason === EvmNonceOutcomeReason.Replaced ? "replace" : "drop");
-				await markEvmDroppedOrReplaced(lockedLease, {
-					reason: input.reason,
-					...input.txHash ? { txHash: String(input.txHash) } : {}
-				});
-				transitionLease({
-					lease: lockedLease,
-					transition: input.reason === EvmNonceOutcomeReason.Replaced ? "replace" : "drop",
-					event: input.reason === EvmNonceOutcomeReason.Replaced ? NonceCoordinatorTraceEventName.LeaseReplaced : NonceCoordinatorTraceEventName.LeaseDropped,
-					reason: input.reason,
-					...input.txHash ? { txHash: String(input.txHash) } : {}
-				});
-				recordDroppedReplacedAlert({
-					lane: lockedLease.lane,
-					reason: input.reason
-				});
-			});
-		},
-		async release(input) {
-			const operationInput = normalizeLeaseOperationInput(input);
-			return await withLaneLock(readLease(operationInput).lane, async () => {
-				const lockedLease = readLease(operationInput);
-				preflightLeaseTransition(lockedLease, "release");
-				await releaseBackendReservation(lockedLease);
-				transitionLease({
-					lease: lockedLease,
-					transition: "release",
-					event: NonceCoordinatorTraceEventName.LeaseReleased,
-					reason: input.reason
-				});
-			});
-		},
-		async expireLeases(input) {
-			return await expireDueLeasesForWallet(input);
-		},
-		async recoverDurableLeases(input) {
-			await recoverDurableLeases(input);
-		},
-		async reconcile(input) {
-			return await withLaneLock(input.lane, async () => {
-				const status = input.lane.family === "evm" ? await reconcileEvmLaneLocked(input.lane) : await reconcileNearLaneLocked(input.lane);
-				emit({
-					event: NonceCoordinatorTraceEventName.LaneReconciled,
-					lane: input.lane
-				});
-				return status;
-			});
-		},
-		clearForWallet(walletId) {
-			const normalizedWalletId = String(walletId || "").trim();
-			if (!normalizedWalletId) return;
-			nonceLaneCoordinationStore?.clearForWallet(normalizedWalletId).catch(() => emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError));
-			const evmLaneKeys = evmAccountLaneKeys.get(normalizedWalletId);
-			if (evmLaneKeys) {
-				for (const key of evmLaneKeys) evmStates.delete(key);
-				evmAccountLaneKeys.delete(normalizedWalletId);
-			}
-			if (readNearAccessKeySubject(nearState)?.walletId === normalizedWalletId) clearNearAccessKeyState$1();
-			for (const [leaseId, lease] of leases.entries()) if (nonceLaneSubjectId(lease.lane) === normalizedWalletId) leases.delete(leaseId);
-			emit({
-				event: NonceCoordinatorTraceEventName.LanesCleared,
-				accountId: normalizedWalletId,
-				reason: "clear_for_account"
-			});
-		},
-		clearAll() {
-			evmStates.clear();
-			evmAccountLaneKeys.clear();
-			droppedReplacedAlerts.clear();
-			nonceLaneCoordinationStore?.clearAll().catch(() => emitCoordinationDegradedOnce(NonceCoordinatorDegradationReason.DurableStoreError));
-			clearNearAccessKeyState$1();
-			leases.clear();
-			laneLocks.clear();
-			emit({
-				event: NonceCoordinatorTraceEventName.LanesCleared,
-				reason: "clear_all"
-			});
-		},
-		getDiagnostics(input) {
-			return readDiagnostics(input);
-		}
-	};
-}
-function requireRecoveredEvmTxHash(value) {
-	const normalized = value.trim().toLowerCase();
-	if (!/^0x[0-9a-f]{64}$/.test(normalized)) throw new Error("[NonceCoordinator] recovered EVM broadcast record has invalid txHash");
-	return normalized;
-}
-function isEvmNonceLease(lease) {
-	return lease.lane.family === "evm";
-}
-function isNearNonceLease(lease) {
-	return lease.lane.family === "near";
-}
-function assertNever(value) {
-	throw new Error(`Unexpected nonce lease variant: ${String(value)}`);
-}
-function buildEvmCoordinationRecord(args) {
-	const lease = args.lease;
-	const common = {
-		v: 1,
-		laneKey: nonceLaneKey(lease.lane),
-		leaseId: lease.leaseId,
-		networkKey: nonceLaneNetworkKey(lease.lane),
-		nonce: lease.nonce,
-		operationId: String(lease.operationId),
-		operationFingerprint: String(lease.operationFingerprint),
-		reservedAtMs: lease.reservedAtMs,
-		expiresAtMs: args.expiresAtMs,
-		updatedAtMs: args.updatedAtMs,
-		runtimeId: args.runtimeId,
-		family: "evm",
-		chainTarget: lease.lane.chainTarget,
-		accountId: lease.lane.subjectId,
-		sender: lease.lane.sender,
-		...lease.lane.nonceKey != null ? { nonceKey: lease.lane.nonceKey } : {},
-		...buildLeaseRecordMetadata(lease)
-	};
-	switch (args.lifecycle.state) {
-		case NonceDurableLeaseState.Reserved:
-		case NonceDurableLeaseState.Signed: return {
-			...common,
-			state: args.lifecycle.state
-		};
-		case NonceDurableLeaseState.BroadcastAccepted: return {
-			...common,
-			state: NonceDurableLeaseState.BroadcastAccepted,
-			txHash: requireRecoveredEvmTxHash(args.lifecycle.txHash)
-		};
-	}
-}
-function buildNearCoordinationRecord(args) {
-	const lease = args.lease;
-	const common = {
-		v: 1,
-		laneKey: nonceLaneKey(lease.lane),
-		leaseId: lease.leaseId,
-		networkKey: nonceLaneNetworkKey(lease.lane),
-		nonce: BigInt(lease.nonce),
-		operationId: String(lease.operationId),
-		operationFingerprint: String(lease.operationFingerprint),
-		reservedAtMs: lease.reservedAtMs,
-		expiresAtMs: args.expiresAtMs,
-		updatedAtMs: args.updatedAtMs,
-		runtimeId: args.runtimeId,
-		family: "near",
-		walletId: lease.lane.walletId,
-		nearAccountId: lease.lane.nearAccountId,
-		publicKey: lease.lane.publicKey,
-		...buildLeaseRecordMetadata(lease)
-	};
-	switch (args.lifecycle.state) {
-		case NonceDurableLeaseState.Reserved:
-		case NonceDurableLeaseState.Signed: return {
-			...common,
-			state: args.lifecycle.state
-		};
-		case NonceDurableLeaseState.BroadcastAccepted: return {
-			...common,
-			state: NonceDurableLeaseState.BroadcastAccepted,
-			txHash: args.lifecycle.txHash
-		};
-	}
-}
-function buildLeaseRecordMetadata(lease) {
-	return {
-		...lease.batchId ? { batchId: lease.batchId } : {},
-		...Number.isSafeInteger(lease.txIndex) ? { txIndex: lease.txIndex } : {}
-	};
-}
-function createDefaultSameOriginLock() {
-	const locks = globalThis.navigator?.locks;
-	if (typeof locks?.request !== "function") return null;
-	return { async withLock(key, task) {
-		return await locks.request(key, { mode: "exclusive" }, task);
-	} };
-}
-//#endregion
-export { createNonceCoordinator };
-
-//# sourceMappingURL=NonceCoordinator.js.map