@seams/wallet 0.8.0 → 0.9.0

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

@@ -1,669 +0,0 @@
-import { isObject, isString } from "../../../shared-ts/src/utils/validation.js";
-import { isImplicitNearAccountId } from "../../../shared-ts/src/utils/near.js";
-import { errorMessage } from "../../../shared-ts/src/utils/errors.js";
-import { NearNonceReconcileReason, NonceDurableLeaseState } from "./nonceTypes.js";
-import { nonceLaneKey } from "./nonceLaneKeys.js";
-import { maxBigint, normalizeBigint, normalizeSessionStatusRequiredString } from "./nonceUtils.js";
-//#region src/core/signingEngine/nonce/nearNonceLane.ts
-function readinessNonceFromTransactionContext(transactionContext) {
-	const raw = String(transactionContext?.nextNonce ?? transactionContext?.accessKeyInfo?.nonce ?? "0").trim();
-	if (!raw) return 0n;
-	try {
-		return BigInt(raw);
-	} catch {
-		return 0n;
-	}
-}
-function classifyNearExecutionReadiness(input) {
-	const base = {
-		walletId: String(input.walletId || "").trim(),
-		nearAccountId: String(input.nearAccountId || "").trim(),
-		nearPublicKeyStr: String(input.nearPublicKeyStr || "").trim()
-	};
-	if (!input.accessKeyAvailable && isImplicitNearAccountId(base.nearAccountId)) return {
-		kind: "implicit_unfunded",
-		...base
-	};
-	const ready = {
-		...base,
-		nonce: readinessNonceFromTransactionContext(input.transactionContext),
-		accessKeyNonce: String(input.transactionContext?.accessKeyInfo?.nonce ?? "").trim(),
-		nextNonce: String(input.transactionContext?.nextNonce ?? "").trim(),
-		txBlockHeight: String(input.transactionContext?.txBlockHeight ?? "").trim(),
-		txBlockHash: String(input.transactionContext?.txBlockHash ?? "").trim()
-	};
-	if (isImplicitNearAccountId(base.nearAccountId)) return {
-		kind: "access_key_available",
-		...ready
-	};
-	return {
-		kind: "sponsored_named_ready",
-		...ready
-	};
-}
-function readNearAccessKeySubject(state) {
-	switch (state.lifecycle.kind) {
-		case "uninitialized": return null;
-		case "access_key_bound":
-		case "access_key_lookup_pending":
-		case "implicit_unfunded":
-		case "lookup_failed": return state.lifecycle.subject;
-		default: return assertNeverNearNonceLaneLifecycle(state.lifecycle);
-	}
-}
-function requireNearAccessKeySubject(state) {
-	const subject = readNearAccessKeySubject(state);
-	if (!subject) throw new Error("[NonceCoordinator] NEAR access key is not initialized");
-	return subject;
-}
-function readNearTransactionContext(state) {
-	return readNearReadyContext(state.lifecycle)?.transactionContext ?? null;
-}
-function hasNearTransactionContext(state) {
-	return readNearTransactionContext(state) !== null;
-}
-function hasNearInflightFetch(state) {
-	return readNearInflightFetch(state) !== null;
-}
-function readNearActiveAccountId(state) {
-	return readNearAccessKeySubject(state)?.nearAccountId ?? null;
-}
-function readNearActivePublicKey(state) {
-	return readNearAccessKeySubject(state)?.publicKey ?? null;
-}
-function readNearReadyContext(lifecycle) {
-	switch (lifecycle.kind) {
-		case "uninitialized":
-		case "implicit_unfunded":
-		case "lookup_failed": return null;
-		case "access_key_bound": return lifecycle.context.kind === "ready" ? lifecycle.context : null;
-		case "access_key_lookup_pending": return lifecycle.previousContext.kind === "ready" ? lifecycle.previousContext : null;
-		default: return assertNeverNearNonceLaneLifecycle(lifecycle);
-	}
-}
-function readNearPreviousContext(lifecycle) {
-	return readNearReadyContext(lifecycle) ?? { kind: "missing" };
-}
-function readNearInflightFetch(state) {
-	switch (state.lifecycle.kind) {
-		case "access_key_lookup_pending": return state.lifecycle.promise;
-		case "uninitialized":
-		case "access_key_bound":
-		case "implicit_unfunded":
-		case "lookup_failed": return null;
-		default: return assertNeverNearNonceLaneLifecycle(state.lifecycle);
-	}
-}
-function setNearAccessKeyReady(input) {
-	const previous = readNearReadyContext(input.state.lifecycle);
-	input.state.lifecycle = {
-		kind: "access_key_bound",
-		subject: input.subject,
-		context: {
-			kind: "ready",
-			transactionContext: input.transactionContext,
-			lastNonceUpdateMs: input.updateNonce ? input.nowMs : previous?.lastNonceUpdateMs ?? input.nowMs,
-			lastBlockHeightUpdateMs: input.updateBlock ? input.nowMs : previous?.lastBlockHeightUpdateMs ?? input.nowMs
-		}
-	};
-}
-function setNearAccessKeyLookupPending(input) {
-	input.state.lifecycle = {
-		kind: "access_key_lookup_pending",
-		subject: input.subject,
-		previousContext: readNearPreviousContext(input.state.lifecycle),
-		promise: input.promise
-	};
-}
-function setNearImplicitUnfunded(input) {
-	input.state.lifecycle = {
-		kind: "implicit_unfunded",
-		subject: input.subject,
-		readiness: {
-			kind: "implicit_unfunded",
-			walletId: input.subject.walletId,
-			nearAccountId: input.subject.nearAccountId,
-			nearPublicKeyStr: input.subject.publicKey
-		}
-	};
-}
-function setNearLookupFailed(input) {
-	input.state.lifecycle = {
-		kind: "lookup_failed",
-		subject: input.subject,
-		readiness: {
-			kind: "account_lookup_failed",
-			walletId: input.subject.walletId,
-			nearAccountId: input.subject.nearAccountId,
-			nearPublicKeyStr: input.subject.publicKey,
-			message: input.message
-		}
-	};
-}
-function assertNeverNearNonceLaneLifecycle(value) {
-	throw new Error(`[NonceCoordinator] unhandled NEAR nonce lane lifecycle: ${String(value)}`);
-}
-function createNearNonceLaneState() {
-	return {
-		lifecycle: { kind: "uninitialized" },
-		inflightId: 0,
-		refreshTimer: null,
-		prefetchTimer: null,
-		reservedNonces: /* @__PURE__ */ new Set(),
-		lastReservedNonce: null,
-		inFlight: /* @__PURE__ */ new Map()
-	};
-}
-function clearNearRefreshTimer(state) {
-	if (!state.refreshTimer) return;
-	clearTimeout(state.refreshTimer);
-	state.refreshTimer = null;
-}
-function clearNearPrefetchTimer(state) {
-	if (!state.prefetchTimer) return;
-	clearTimeout(state.prefetchTimer);
-	state.prefetchTimer = null;
-}
-function clearNearTransactionContext(state) {
-	const subject = readNearAccessKeySubject(state);
-	state.lifecycle = subject ? {
-		kind: "access_key_bound",
-		subject,
-		context: { kind: "missing" }
-	} : { kind: "uninitialized" };
-	state.reservedNonces.clear();
-	state.lastReservedNonce = null;
-	state.inFlight.clear();
-	clearNearRefreshTimer(state);
-	clearNearPrefetchTimer(state);
-}
-function clearNearAccessKeyState(state) {
-	state.lifecycle = { kind: "uninitialized" };
-	clearNearTransactionContext(state);
-}
-function initializeNearAccessKeyState(input) {
-	const nearAccountId = normalizeSessionStatusRequiredString(input.nearAccountId, "nearAccountId");
-	const publicKey = normalizeSessionStatusRequiredString(input.publicKey, "publicKey");
-	const walletId = normalizeSessionStatusRequiredString(input.walletId, "walletId");
-	if (!walletId) throw new Error("[NonceCoordinator] NEAR access key walletId is required");
-	const subject = {
-		walletId,
-		nearAccountId,
-		publicKey
-	};
-	const currentSubject = readNearAccessKeySubject(input.state);
-	if (currentSubject?.walletId === walletId && currentSubject.nearAccountId === nearAccountId && currentSubject.publicKey === publicKey) return;
-	input.state.lifecycle = {
-		kind: "access_key_bound",
-		subject,
-		context: { kind: "missing" }
-	};
-	clearNearTransactionContext(input.state);
-}
-function commitNearTransactionContextForState(input) {
-	initializeNearAccessKeyState({
-		state: input.state,
-		walletId: input.walletId,
-		nearAccountId: input.nearAccountId,
-		publicKey: input.publicKey
-	});
-	setNearAccessKeyReady({
-		state: input.state,
-		subject: requireNearAccessKeySubject(input.state),
-		transactionContext: input.transactionContext,
-		nowMs: input.nowMs,
-		updateNonce: true,
-		updateBlock: true
-	});
-}
-async function reserveNearNoncesFromState(input) {
-	const transactionContext = readNearTransactionContext(input.state);
-	if (!transactionContext) throw new Error("NEAR transaction context not available - call fetchNearContext() first");
-	const count = Math.max(0, Math.floor(Number(input.countInput || 0)));
-	if (count <= 0) return [];
-	const laneKey = nonceLaneKey(input.lane);
-	const activeDurableNonces = await input.readActiveLeaseNonces(laneKey, { lane: input.lane });
-	let highestDurable = 0n;
-	for (const nonce of activeDurableNonces) {
-		const value = BigInt(nonce);
-		if (value > highestDurable) highestDurable = value;
-	}
-	const start = maxBigint(input.state.lastReservedNonce ? BigInt(input.state.lastReservedNonce) + 1n : 0n, BigInt(transactionContext.nextNonce), highestDurable > 0n ? highestDurable + 1n : 0n);
-	const planned = [];
-	let candidateValue = start;
-	for (let index = 0; index < count; index += 1) {
-		while (input.state.reservedNonces.has(candidateValue.toString()) || activeDurableNonces.has(candidateValue.toString())) candidateValue += 1n;
-		const candidate = candidateValue.toString();
-		planned.push(candidate);
-		candidateValue += 1n;
-	}
-	for (const nonce of planned) input.state.reservedNonces.add(nonce);
-	input.state.lastReservedNonce = planned[planned.length - 1] || input.state.lastReservedNonce;
-	return planned;
-}
-function computeLastReservedNonce(reserved) {
-	let last = null;
-	for (const value of reserved) try {
-		const parsed = BigInt(value);
-		if (last === null || parsed > last) last = parsed;
-	} catch {}
-	return last === null ? null : last.toString();
-}
-function releaseNearNonceFromState(state, nonce) {
-	if (!state.reservedNonces.delete(String(nonce))) return;
-	state.lastReservedNonce = computeLastReservedNonce(state.reservedNonces);
-}
-async function markNearBroadcastAcceptedState(input) {
-	const nonce = BigInt(input.lease.nonce);
-	input.state.inFlight.set(nonce.toString(), {
-		nonce,
-		txHash: input.txHash,
-		acceptedAtMs: input.nowMs,
-		updatedAtMs: input.nowMs
-	});
-	await input.persistCoordinationLease(input.lease, {
-		state: NonceDurableLeaseState.BroadcastAccepted,
-		txHash: input.txHash
-	});
-}
-async function reconcileNearLaneState(input) {
-	initializeNearAccessKeyState({
-		state: input.state,
-		walletId: input.lane.walletId,
-		nearAccountId: input.lane.nearAccountId,
-		publicKey: input.lane.publicKey
-	});
-	const accessKeyInfoRaw = await input.nearClient.viewAccessKey(input.lane.nearAccountId, input.lane.publicKey);
-	if (!isAccessKeyViewLike(accessKeyInfoRaw)) throw new Error(`Access key not found or invalid for account ${input.lane.nearAccountId}`);
-	const accessKeyInfo = normalizeAccessKeyView(accessKeyInfoRaw);
-	const chainNonce = BigInt(accessKeyInfo.nonce);
-	const chainNextNonce = chainNonce + 1n;
-	const unresolvedInFlightNonces = [];
-	for (const lease of input.activeLeases) {
-		const leaseNonce = BigInt(lease.nonce);
-		const inFlight = input.state.inFlight.get(leaseNonce.toString());
-		if (leaseNonce > chainNonce) {
-			if (inFlight) unresolvedInFlightNonces.push(leaseNonce);
-			continue;
-		}
-		if (!inFlight?.txHash) continue;
-		const txOutcome = await readNearTxOutcome({
-			nearClient: input.nearClient,
-			txHash: inFlight.txHash,
-			accountId: input.lane.nearAccountId
-		});
-		if (txOutcome === "finalized") {
-			input.transitionLease({
-				lease,
-				transition: "finalize",
-				reason: "near_tx_status_finalized",
-				txHash: inFlight.txHash
-			});
-			await input.removeCoordinationLease(lease);
-			input.state.inFlight.delete(leaseNonce.toString());
-			releaseNearNonceFromState(input.state, leaseNonce.toString());
-			continue;
-		}
-		if (txOutcome === "missing") {
-			input.transitionLease({
-				lease,
-				transition: "drop",
-				reason: NearNonceReconcileReason.NonceAdvancedHashMissing,
-				txHash: inFlight.txHash
-			});
-			await input.removeCoordinationLease(lease);
-			input.state.inFlight.delete(leaseNonce.toString());
-			releaseNearNonceFromState(input.state, leaseNonce.toString());
-			continue;
-		}
-		unresolvedInFlightNonces.push(leaseNonce);
-	}
-	const previousContext = readNearTransactionContext(input.state);
-	const candidateNext = maxBigint(chainNextNonce, previousContext?.nextNonce ? BigInt(previousContext.nextNonce) : 0n, input.state.lastReservedNonce ? BigInt(input.state.lastReservedNonce) + 1n : 0n);
-	setNearAccessKeyReady({
-		state: input.state,
-		subject: {
-			walletId: input.lane.walletId,
-			nearAccountId: input.lane.nearAccountId,
-			publicKey: input.lane.publicKey
-		},
-		transactionContext: {
-			...previousContext || {
-				nearPublicKeyStr: input.lane.publicKey,
-				txBlockHeight: "0",
-				txBlockHash: ""
-			},
-			accessKeyInfo,
-			nextNonce: candidateNext.toString()
-		},
-		nowMs: input.now(),
-		updateNonce: true,
-		updateBlock: false
-	});
-	if (input.state.reservedNonces.size > 0) {
-		const pruned = pruneReservedNearNonces(chainNonce, input.state.reservedNonces);
-		input.state.reservedNonces = pruned.set;
-		input.state.lastReservedNonce = pruned.lastReserved;
-	}
-	return {
-		chainNextNonce,
-		unresolvedInFlightNonces: unresolvedInFlightNonces.sort((a, b) => a < b ? -1 : a > b ? 1 : 0),
-		blocked: false
-	};
-}
-async function readNearTxOutcome(input) {
-	try {
-		await input.nearClient.txStatus(input.txHash, input.accountId);
-		return "finalized";
-	} catch (error) {
-		const message = errorMessage(error);
-		if (/unknown transaction|does not exist|not found|not found in storage/i.test(message)) return "missing";
-		return "unknown";
-	}
-}
-function pruneReservedNearNonces(chainNonce, reserved) {
-	const next = /* @__PURE__ */ new Set();
-	let last = null;
-	for (const nonce of reserved) try {
-		const parsed = BigInt(nonce);
-		if (parsed <= chainNonce) continue;
-		next.add(nonce);
-		if (last === null || parsed > last) last = parsed;
-	} catch {}
-	return {
-		set: next,
-		lastReserved: last === null ? null : last.toString()
-	};
-}
-function isMissingNearAccessKeyError(message) {
-	const normalized = String(message || "").toLowerCase();
-	return normalized.includes("does not exist while viewing") || normalized.includes("access key not found") || normalized.includes("unknown public key") || normalized.includes("unknown_account") || normalized.includes("unknown account") || normalized.includes("unknown_access_key") || normalized.includes("does not exist") || normalized.includes("doesn't exist");
-}
-var NearImplicitAccountFundingRequiredError = class extends Error {
-	constructor(args) {
-		super(`NEAR account ${args.nearAccountId} needs funding before direct NEAR signing.`);
-		this.code = "near_implicit_account_unfunded";
-		this.name = "NearImplicitAccountFundingRequiredError";
-		this.nearAccountId = args.nearAccountId;
-		this.readiness = classifyNearExecutionReadiness({
-			walletId: args.walletId,
-			nearAccountId: args.nearAccountId,
-			nearPublicKeyStr: args.nearPublicKeyStr,
-			accessKeyAvailable: false
-		});
-	}
-};
-var NearAccountLookupFailedError = class extends Error {
-	constructor(args) {
-		super(args.message || `NEAR account ${args.nearAccountId} access key lookup failed.`);
-		this.code = "near_account_lookup_failed";
-		this.name = "NearAccountLookupFailedError";
-		this.nearAccountId = args.nearAccountId;
-		this.readiness = {
-			kind: "account_lookup_failed",
-			walletId: args.walletId,
-			nearAccountId: args.nearAccountId,
-			nearPublicKeyStr: args.nearPublicKeyStr,
-			message: this.message
-		};
-	}
-};
-async function fetchNearFreshDataForState(input) {
-	const { state } = input;
-	const inflightFetch = readNearInflightFetch(state);
-	if (inflightFetch && !input.force) return inflightFetch;
-	const capturedSubject = requireNearAccessKeySubject(state);
-	const requestId = ++state.inflightId;
-	const fetchPromise = (async () => {
-		try {
-			const nowMs = input.now();
-			const readyContext = readNearReadyContext(state.lifecycle);
-			const previousTransactionContext = readyContext?.transactionContext ?? null;
-			const isNonceStale = input.force || !readyContext || nowMs - readyContext.lastNonceUpdateMs >= input.nonceFreshnessThresholdMs;
-			const isBlockStale = input.force || !readyContext || nowMs - readyContext.lastBlockHeightUpdateMs >= input.blockFreshnessThresholdMs;
-			let accessKeyInfo = previousTransactionContext?.accessKeyInfo;
-			let txBlockHeight = previousTransactionContext?.txBlockHeight;
-			let txBlockHash = previousTransactionContext?.txBlockHash;
-			const fetchAccessKey = isNonceStale || !accessKeyInfo;
-			const fetchBlock = isBlockStale || !txBlockHeight || !txBlockHash;
-			let maybeAccessKey = accessKeyInfo ?? null;
-			let maybeBlock = null;
-			let accessKeyError = null;
-			let blockError = null;
-			const tasks = [];
-			if (fetchAccessKey) tasks.push((async () => {
-				try {
-					maybeAccessKey = await input.nearClient.viewAccessKey(capturedSubject.nearAccountId, capturedSubject.publicKey);
-				} catch (error) {
-					const message = errorMessage(error);
-					if (isMissingNearAccessKeyError(message)) {
-						if (isImplicitNearAccountId(capturedSubject.nearAccountId)) {
-							accessKeyError = new NearImplicitAccountFundingRequiredError({
-								walletId: capturedSubject.walletId,
-								nearAccountId: capturedSubject.nearAccountId,
-								nearPublicKeyStr: capturedSubject.publicKey
-							});
-							return;
-						}
-						accessKeyError = new NearAccountLookupFailedError({
-							walletId: capturedSubject.walletId,
-							nearAccountId: capturedSubject.nearAccountId,
-							nearPublicKeyStr: capturedSubject.publicKey,
-							message
-						});
-						return;
-					}
-					accessKeyError = error;
-				}
-			})());
-			if (fetchBlock) tasks.push((async () => {
-				try {
-					maybeBlock = await input.nearClient.viewBlock({ finality: "final" });
-				} catch (error) {
-					blockError = error;
-				}
-			})());
-			if (tasks.length > 0) await Promise.all(tasks);
-			if (accessKeyError) {
-				if (accessKeyError instanceof NearImplicitAccountFundingRequiredError) setNearImplicitUnfunded({
-					state,
-					subject: capturedSubject
-				});
-				else if (accessKeyError instanceof NearAccountLookupFailedError) setNearLookupFailed({
-					state,
-					subject: capturedSubject,
-					message: accessKeyError.message
-				});
-				throw accessKeyError;
-			}
-			if (blockError) throw blockError;
-			if (fetchAccessKey) accessKeyInfo = isAccessKeyViewLike(maybeAccessKey) ? normalizeAccessKeyView(maybeAccessKey) : previousTransactionContext?.accessKeyInfo || makePlaceholderAccessKey();
-			if (fetchBlock) {
-				if (!isBlockResultLike(maybeBlock)) throw new Error("[NonceCoordinator] failed to fetch NEAR block info");
-				txBlockHeight = String(maybeBlock.header.height);
-				txBlockHash = maybeBlock.header.hash;
-			}
-			const nextCandidate = maxBigint(accessKeyInfo?.nonce !== void 0 ? BigInt(accessKeyInfo.nonce) + 1n : 0n, previousTransactionContext?.nextNonce ? BigInt(previousTransactionContext.nextNonce) : 0n, state.lastReservedNonce ? BigInt(state.lastReservedNonce) + 1n : 0n, 1n);
-			const transactionContext = {
-				nearPublicKeyStr: capturedSubject.publicKey,
-				accessKeyInfo,
-				nextNonce: nextCandidate.toString(),
-				txBlockHeight,
-				txBlockHash
-			};
-			if (nearAccessKeySubjectsMatch(readNearAccessKeySubject(state), capturedSubject) && requestId === state.inflightId) setNearAccessKeyReady({
-				state,
-				subject: capturedSubject,
-				transactionContext,
-				nowMs: input.now(),
-				updateNonce: fetchAccessKey,
-				updateBlock: fetchBlock
-			});
-			return transactionContext;
-		} finally {
-			if (requestId === state.inflightId) {
-				const subject = readNearAccessKeySubject(state);
-				if (state.lifecycle.kind === "access_key_lookup_pending" && nearAccessKeySubjectsMatch(subject, capturedSubject)) state.lifecycle = {
-					kind: "access_key_bound",
-					subject: capturedSubject,
-					context: state.lifecycle.previousContext
-				};
-			}
-		}
-	})();
-	setNearAccessKeyLookupPending({
-		state,
-		subject: capturedSubject,
-		promise: fetchPromise
-	});
-	return fetchPromise;
-}
-async function updateNearNonceFromBlockchainState(input) {
-	const { state } = input;
-	const subject = requireNearAccessKeySubject(state);
-	try {
-		const accessKeyInfoRaw = await input.nearClient.viewAccessKey(subject.nearAccountId, subject.publicKey);
-		if (!isAccessKeyViewLike(accessKeyInfoRaw)) throw new Error(`Access key not found or invalid for account ${subject.nearAccountId}`);
-		const accessKeyInfo = normalizeAccessKeyView(accessKeyInfoRaw);
-		const chainNonce = BigInt(accessKeyInfo.nonce);
-		const actual = BigInt(input.actualNonce);
-		const previousContext = readNearTransactionContext(state);
-		const candidateNext = maxBigint(chainNonce + 1n, actual + 1n, previousContext?.nextNonce ? BigInt(previousContext.nextNonce) : 0n, state.lastReservedNonce ? BigInt(state.lastReservedNonce) + 1n : 0n);
-		setNearAccessKeyReady({
-			state,
-			subject,
-			transactionContext: previousContext ? {
-				...previousContext,
-				accessKeyInfo,
-				nextNonce: candidateNext.toString()
-			} : {
-				nearPublicKeyStr: subject.publicKey,
-				accessKeyInfo,
-				nextNonce: candidateNext.toString(),
-				txBlockHeight: "0",
-				txBlockHash: ""
-			},
-			nowMs: input.now(),
-			updateNonce: true,
-			updateBlock: false
-		});
-		state.inFlight.delete(input.actualNonce);
-		releaseNearNonceFromState(state, input.actualNonce);
-		if (state.reservedNonces.size > 0) {
-			const pruned = pruneReservedNearNonces(chainNonce, state.reservedNonces);
-			state.reservedNonces = pruned.set;
-			state.lastReservedNonce = pruned.lastReserved;
-		}
-	} catch (error) {
-		if (isMissingNearAccessKeyError(errorMessage(error))) {
-			const actual = BigInt(input.actualNonce);
-			const previousContext = readNearTransactionContext(state);
-			const candidateNext = maxBigint(actual + 1n, previousContext?.nextNonce ? BigInt(previousContext.nextNonce) : 0n, state.lastReservedNonce ? BigInt(state.lastReservedNonce) + 1n : 0n);
-			setNearAccessKeyReady({
-				state,
-				subject,
-				transactionContext: previousContext ? {
-					...previousContext,
-					nextNonce: candidateNext.toString()
-				} : {
-					nearPublicKeyStr: subject.publicKey,
-					accessKeyInfo: makePlaceholderAccessKey(),
-					txBlockHeight: "0",
-					txBlockHash: "",
-					nextNonce: candidateNext.toString()
-				},
-				nowMs: input.now(),
-				updateNonce: true,
-				updateBlock: false
-			});
-		}
-	}
-}
-async function refreshNearNonceAfterBroadcastRejectedState(input) {
-	const { state } = input;
-	const subject = requireNearAccessKeySubject(state);
-	const accessKeyInfoRaw = await input.nearClient.viewAccessKey(subject.nearAccountId, subject.publicKey);
-	if (!isAccessKeyViewLike(accessKeyInfoRaw)) throw new Error(`Access key not found or invalid for account ${subject.nearAccountId}`);
-	const accessKeyInfo = normalizeAccessKeyView(accessKeyInfoRaw);
-	const chainNonce = BigInt(accessKeyInfo.nonce);
-	const candidateNext = maxBigint(chainNonce + 1n, state.lastReservedNonce ? BigInt(state.lastReservedNonce) + 1n : 0n, 1n);
-	const previousContext = readNearTransactionContext(state);
-	setNearAccessKeyReady({
-		state,
-		subject,
-		transactionContext: previousContext ? {
-			...previousContext,
-			accessKeyInfo,
-			nextNonce: candidateNext.toString()
-		} : {
-			nearPublicKeyStr: subject.publicKey,
-			accessKeyInfo,
-			nextNonce: candidateNext.toString(),
-			txBlockHeight: "0",
-			txBlockHash: ""
-		},
-		nowMs: input.now(),
-		updateNonce: true,
-		updateBlock: false
-	});
-	if (state.reservedNonces.size > 0) {
-		const pruned = pruneReservedNearNonces(chainNonce, state.reservedNonces);
-		state.reservedNonces = pruned.set;
-		state.lastReservedNonce = pruned.lastReserved;
-	}
-}
-function shouldPrefetchNearContext(input) {
-	const readyContext = readNearReadyContext(input.state.lifecycle);
-	return !readyContext || input.nowMs - readyContext.lastBlockHeightUpdateMs >= input.blockFreshnessThresholdMs || !readyContext;
-}
-function isAccessKeyViewLike(value) {
-	if (!isObject(value)) return false;
-	try {
-		normalizeBigint(value.nonce, "near access-key nonce");
-		return true;
-	} catch {
-		return false;
-	}
-}
-function normalizeAccessKeyView(value) {
-	const record = value;
-	return {
-		nonce: normalizeBigint(record.nonce, "near access-key nonce"),
-		permission: normalizeAccessKeyPermission(record.permission),
-		block_hash: isString(record.block_hash) ? record.block_hash : "",
-		block_height: typeof record.block_height === "number" ? record.block_height : 0
-	};
-}
-function normalizeAccessKeyPermission(value) {
-	if (value === "FullAccess") return "FullAccess";
-	if (!isObject(value)) return "FullAccess";
-	const functionCall = value.FunctionCall;
-	if (!isObject(functionCall)) return "FullAccess";
-	const methodNames = Array.isArray(functionCall.method_names) ? functionCall.method_names.filter(isString) : [];
-	return { FunctionCall: {
-		allowance: isString(functionCall.allowance) ? functionCall.allowance : "",
-		receiver_id: isString(functionCall.receiver_id) ? functionCall.receiver_id : "",
-		method_names: methodNames
-	} };
-}
-function isBlockResultLike(value) {
-	const record = value;
-	if (!record || typeof record !== "object") return false;
-	const header = record.header;
-	return !!header && typeof header.hash === "string" && header.height !== void 0;
-}
-function makePlaceholderAccessKey() {
-	return {
-		nonce: 0n,
-		permission: "FullAccess",
-		block_height: 0,
-		block_hash: ""
-	};
-}
-function nearAccessKeySubjectsMatch(left, right) {
-	return left?.walletId === right.walletId && left.nearAccountId === right.nearAccountId && left.publicKey === right.publicKey;
-}
-//#endregion
-export { classifyNearExecutionReadiness, clearNearAccessKeyState, clearNearPrefetchTimer, commitNearTransactionContextForState, createNearNonceLaneState, fetchNearFreshDataForState, hasNearInflightFetch, hasNearTransactionContext, initializeNearAccessKeyState, isAccessKeyViewLike, markNearBroadcastAcceptedState, readNearAccessKeySubject, readNearActiveAccountId, readNearActivePublicKey, reconcileNearLaneState, refreshNearNonceAfterBroadcastRejectedState, releaseNearNonceFromState, reserveNearNoncesFromState, shouldPrefetchNearContext, updateNearNonceFromBlockchainState };
-
-//# sourceMappingURL=nearNonceLane.js.map