@tatchi-xyz/sdk 0.21.0 → 0.31.1

package/dist/esm/react/src/core/digests/intentDigest.js

@@ -0,0 +1,95 @@
+import { base64UrlEncode } from "../../utils/base64.js";
+import { alphabetizeStringify, sha256BytesUtf8 } from "../../utils/digests.js";
+import { ActionType } from "../types/actions.js";
+
+//#region src/core/digests/intentDigest.ts
+async function sha256Base64UrlUtf8(input) {
+	const digest = await sha256BytesUtf8(input);
+	return base64UrlEncode(digest);
+}
+async function computeUiIntentDigestFromNep413(args) {
+	const json = alphabetizeStringify({
+		kind: "nep413",
+		...args
+	});
+	return sha256Base64UrlUtf8(json);
+}
+async function computeThresholdEd25519KeygenIntentDigest(args) {
+	const json = alphabetizeStringify({
+		kind: "threshold_ed25519_keygen",
+		...args
+	});
+	return sha256Base64UrlUtf8(json);
+}
+async function computeLoginIntentDigest(args) {
+	const json = alphabetizeStringify({
+		kind: "login_session",
+		...args
+	});
+	return sha256Base64UrlUtf8(json);
+}
+async function computeUiIntentDigestFromTxs(txInputs) {
+	const json = alphabetizeStringify(txInputs);
+	return sha256Base64UrlUtf8(json);
+}
+function orderActionForDigest(a) {
+	switch (a.action_type) {
+		case ActionType.FunctionCall: return {
+			action_type: a.action_type,
+			args: a.args,
+			deposit: a.deposit,
+			gas: a.gas,
+			method_name: a.method_name
+		};
+		case ActionType.Transfer: return {
+			action_type: a.action_type,
+			deposit: a.deposit
+		};
+		case ActionType.Stake: return {
+			action_type: a.action_type,
+			stake: a.stake,
+			public_key: a.public_key
+		};
+		case ActionType.AddKey: return {
+			action_type: a.action_type,
+			public_key: a.public_key,
+			access_key: a.access_key
+		};
+		case ActionType.DeleteKey: return {
+			action_type: a.action_type,
+			public_key: a.public_key
+		};
+		case ActionType.DeleteAccount: return {
+			action_type: a.action_type,
+			beneficiary_id: a.beneficiary_id
+		};
+		case ActionType.DeployContract: return {
+			action_type: a.action_type,
+			code: a.code
+		};
+		case ActionType.SignedDelegate: return {
+			action_type: a.action_type,
+			delegate_action: a.delegate_action,
+			signature: a.signature
+		};
+		case ActionType.DeployGlobalContract: return {
+			action_type: a.action_type,
+			code: a.code,
+			deploy_mode: a.deploy_mode
+		};
+		case ActionType.UseGlobalContract: return {
+			action_type: a.action_type,
+			account_id: a.account_id,
+			code_hash: a.code_hash
+		};
+		case ActionType.CreateAccount: return { action_type: a.action_type };
+		default: {
+			const _exhaustive = a;
+			return _exhaustive;
+		}
+	}
+}
+
+//#endregion
+export { computeLoginIntentDigest, computeThresholdEd25519KeygenIntentDigest, computeUiIntentDigestFromNep413, computeUiIntentDigestFromTxs, orderActionForDigest, sha256Base64UrlUtf8 };
+//# sourceMappingURL=intentDigest.js.map

package/dist/esm/react/src/core/digests/intentDigest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intentDigest.js","names":["_exhaustive: never"],"sources":["../../../../../../src/core/digests/intentDigest.ts"],"sourcesContent":["// Canonical intent digest helpers for UI/host validation.\n// Used by both VRF-driven flows and signer-worker signing flows.\n//\n// Uses Web Crypto API (crypto.subtle). Import a minimal base64url helper that does not pull bs58.\nimport { ActionType, type ActionArgsWasm, type TransactionInputWasm } from '@/core/types';\nimport { base64UrlEncode } from '@/utils/base64';\nimport { alphabetizeStringify, sha256BytesUtf8 } from '@/utils/digests';\n\nexport async function sha256Base64UrlUtf8(input: string): Promise<string> {\n  const digest = await sha256BytesUtf8(input);\n  return base64UrlEncode(digest);\n}\n\nexport async function computeUiIntentDigestFromNep413(args: {\n  nearAccountId: string;\n  recipient: string;\n  message: string;\n}): Promise<string> {\n  // This is a UI/host + VRF binding digest. It is NOT the NEP-413 signing hash.\n  const json = alphabetizeStringify({ kind: 'nep413', ...args });\n  return sha256Base64UrlUtf8(json);\n}\n\nexport async function computeThresholdEd25519KeygenIntentDigest(args: {\n  nearAccountId: string;\n  rpId: string;\n  clientVerifyingShareB64u: string;\n}): Promise<string> {\n  const json = alphabetizeStringify({ kind: 'threshold_ed25519_keygen', ...args });\n  return sha256Base64UrlUtf8(json);\n}\n\nexport async function computeLoginIntentDigest(args: {\n  nearAccountId: string;\n  rpId: string;\n}): Promise<string> {\n  const json = alphabetizeStringify({ kind: 'login_session', ...args });\n  return sha256Base64UrlUtf8(json);\n}\n\n// Canonical intent digest for signing flows.\n// This is a UI/host validation digest derived from `{ receiverId, actions }` only; it is NOT the\n// canonical NEAR signing hash (NEAR signs `sha256(borsh(Transaction))`, computed in the WASM signer).\n// Both VRF-side code (confirmAndPrepareSigningSession) and all UI confirmers MUST call this with\n// TransactionInputWasm[] built from:\n//   { receiverId, actions: ActionArgsWasm[] }\n// where each ActionArgsWasm has been normalized via orderActionForDigest.\n//\n// IMPORTANT:\n// - The order of transactions and the order of actions within each transaction is preserved.\n// - Only the *keys inside each object* are alphabetically sorted to produce a stable JSON encoding.\n//   The arrays themselves are not reordered.\n// - Do NOT include nonce or other per-tx fields in the digest input, or INTENT_DIGEST_MISMATCH errors will occur.\nexport async function computeUiIntentDigestFromTxs(txInputs: TransactionInputWasm[]): Promise<string> {\n  // Preserve array order; only object keys are sorted for stable encoding.\n  // This must match the relayer/server-side recomputation used for VRF binding.\n  const json = alphabetizeStringify(txInputs);\n  return sha256Base64UrlUtf8(json);\n}\n\nexport function orderActionForDigest(a: ActionArgsWasm): ActionArgsWasm {\n  switch (a.action_type) {\n    case ActionType.FunctionCall:\n      return { action_type: a.action_type, args: a.args, deposit: a.deposit, gas: a.gas, method_name: a.method_name };\n    case ActionType.Transfer:\n      return { action_type: a.action_type, deposit: a.deposit };\n    case ActionType.Stake:\n      return { action_type: a.action_type, stake: a.stake, public_key: a.public_key };\n    case ActionType.AddKey:\n      return { action_type: a.action_type, public_key: a.public_key, access_key: a.access_key };\n    case ActionType.DeleteKey:\n      return { action_type: a.action_type, public_key: a.public_key };\n    case ActionType.DeleteAccount:\n      return { action_type: a.action_type, beneficiary_id: a.beneficiary_id };\n    case ActionType.DeployContract:\n      return { action_type: a.action_type, code: a.code };\n    case ActionType.SignedDelegate:\n      return { action_type: a.action_type, delegate_action: a.delegate_action, signature: a.signature };\n    case ActionType.DeployGlobalContract:\n      return { action_type: a.action_type, code: a.code, deploy_mode: a.deploy_mode };\n    case ActionType.UseGlobalContract:\n      return { action_type: a.action_type, account_id: a.account_id, code_hash: a.code_hash };\n    case ActionType.CreateAccount:\n      return { action_type: a.action_type };\n    default: {\n      const _exhaustive: never = a;\n      return _exhaustive;\n    }\n  }\n}\n"],"mappings":";;;;;AAQA,eAAsB,oBAAoB,OAAgC;CACxE,MAAM,SAAS,MAAM,gBAAgB;AACrC,QAAO,gBAAgB;;AAGzB,eAAsB,gCAAgC,MAIlC;CAElB,MAAM,OAAO,qBAAqB;EAAE,MAAM;EAAU,GAAG;;AACvD,QAAO,oBAAoB;;AAG7B,eAAsB,0CAA0C,MAI5C;CAClB,MAAM,OAAO,qBAAqB;EAAE,MAAM;EAA4B,GAAG;;AACzE,QAAO,oBAAoB;;AAG7B,eAAsB,yBAAyB,MAG3B;CAClB,MAAM,OAAO,qBAAqB;EAAE,MAAM;EAAiB,GAAG;;AAC9D,QAAO,oBAAoB;;AAgB7B,eAAsB,6BAA6B,UAAmD;CAGpG,MAAM,OAAO,qBAAqB;AAClC,QAAO,oBAAoB;;AAG7B,SAAgB,qBAAqB,GAAmC;AACtE,SAAQ,EAAE,aAAV;EACE,KAAK,WAAW,aACd,QAAO;GAAE,aAAa,EAAE;GAAa,MAAM,EAAE;GAAM,SAAS,EAAE;GAAS,KAAK,EAAE;GAAK,aAAa,EAAE;;EACpG,KAAK,WAAW,SACd,QAAO;GAAE,aAAa,EAAE;GAAa,SAAS,EAAE;;EAClD,KAAK,WAAW,MACd,QAAO;GAAE,aAAa,EAAE;GAAa,OAAO,EAAE;GAAO,YAAY,EAAE;;EACrE,KAAK,WAAW,OACd,QAAO;GAAE,aAAa,EAAE;GAAa,YAAY,EAAE;GAAY,YAAY,EAAE;;EAC/E,KAAK,WAAW,UACd,QAAO;GAAE,aAAa,EAAE;GAAa,YAAY,EAAE;;EACrD,KAAK,WAAW,cACd,QAAO;GAAE,aAAa,EAAE;GAAa,gBAAgB,EAAE;;EACzD,KAAK,WAAW,eACd,QAAO;GAAE,aAAa,EAAE;GAAa,MAAM,EAAE;;EAC/C,KAAK,WAAW,eACd,QAAO;GAAE,aAAa,EAAE;GAAa,iBAAiB,EAAE;GAAiB,WAAW,EAAE;;EACxF,KAAK,WAAW,qBACd,QAAO;GAAE,aAAa,EAAE;GAAa,MAAM,EAAE;GAAM,aAAa,EAAE;;EACpE,KAAK,WAAW,kBACd,QAAO;GAAE,aAAa,EAAE;GAAa,YAAY,EAAE;GAAY,WAAW,EAAE;;EAC9E,KAAK,WAAW,cACd,QAAO,EAAE,aAAa,EAAE;EAC1B,SAAS;GACP,MAAMA,cAAqB;AAC3B,UAAO"}

package/dist/esm/react/src/core/nearCrypto.js

@@ -0,0 +1,27 @@
+import { ensureEd25519Prefix } from "../utils/validation.js";
+import bs58 from "bs58";
+import * as ed25519 from "@noble/ed25519";
+
+//#region src/core/nearCrypto.ts
+/**
+* Creates a NEAR-compatible Ed25519 keypair formatted as strings:
+* - publicKey:  'ed25519:' + base58(pub)
+* - privateKey: 'ed25519:' + base58(seed(32) | pub(32))
+*/
+async function createNearKeypair() {
+	const seed = ed25519.utils.randomPrivateKey();
+	const pub = await ed25519.getPublicKeyAsync(seed);
+	const secret = new Uint8Array(64);
+	secret.set(seed, 0);
+	secret.set(pub, 32);
+	const publicKey = ensureEd25519Prefix(bs58.encode(pub));
+	const privateKey = ensureEd25519Prefix(bs58.encode(secret));
+	return {
+		publicKey,
+		privateKey
+	};
+}
+
+//#endregion
+export { createNearKeypair };
+//# sourceMappingURL=nearCrypto.js.map

package/dist/esm/react/src/core/nearCrypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nearCrypto.js","names":[],"sources":["../../../../../src/core/nearCrypto.ts"],"sourcesContent":["import * as ed25519 from '@noble/ed25519';\nimport bs58 from 'bs58';\n\nimport { ensureEd25519Prefix } from '../utils/validation';\nexport { ensureEd25519Prefix };\n\nexport const NEAR_ED25519_KEY_PREFIX = 'ed25519:' as const;\n\n/**\n * Remove the NEAR Ed25519 prefix (`ed25519:`) if present.\n * Useful for comparing keys where one side may omit the prefix.\n */\nexport function stripEd25519Prefix(value: string): string {\n  const raw = String(value || '').trim();\n  return raw.replace(/^ed25519:/i, '');\n}\n\n/**\n * Creates a NEAR-compatible Ed25519 keypair formatted as strings:\n * - publicKey:  'ed25519:' + base58(pub)\n * - privateKey: 'ed25519:' + base58(seed(32) | pub(32))\n */\nexport async function createNearKeypair(): Promise<{ publicKey: string; privateKey: string }> {\n  const seed = ed25519.utils.randomPrivateKey(); // 32 bytes\n  const pub = await ed25519.getPublicKeyAsync(seed); // 32 bytes\n\n  const secret = new Uint8Array(64);\n  secret.set(seed, 0);\n  secret.set(pub, 32);\n\n  const publicKey = ensureEd25519Prefix(bs58.encode(pub));\n  const privateKey = ensureEd25519Prefix(bs58.encode(secret));\n  return { publicKey, privateKey };\n}\n\n/** Parse NEAR public key string ('ed25519:...') into 32-byte Uint8Array */\nexport function parseNearPublicKey(str: string): Uint8Array {\n  const b58 = stripEd25519Prefix(str);\n  const bytes = bs58.decode(b58);\n  if (bytes.length !== 32) {\n    throw new Error(`Invalid NEAR public key length: ${bytes.length}`);\n  }\n  return new Uint8Array(bytes);\n}\n\n/** Convert raw 32-byte public key to NEAR string ('ed25519:...') */\nexport function toPublicKeyString(pub: Uint8Array): string {\n  if (!(pub?.length === 32)) {\n    throw new Error('Public key must be 32 bytes');\n  }\n  return ensureEd25519Prefix(bs58.encode(pub));\n}\n\n/** Convert raw seed(32) + pub(32) to NEAR secret string ('ed25519:...') */\nexport function toSecretKeyString(seed: Uint8Array, pub: Uint8Array): string {\n  if (!(seed?.length === 32)) {\n    throw new Error('Seed must be 32 bytes');\n  }\n  if (!(pub?.length === 32)) {\n    throw new Error('Public key must be 32 bytes');\n  }\n  const secret = new Uint8Array(64);\n  secret.set(seed, 0);\n  secret.set(pub, 32);\n  return ensureEd25519Prefix(bs58.encode(secret));\n}\n"],"mappings":";;;;;;;;;;AAsBA,eAAsB,oBAAwE;CAC5F,MAAM,OAAO,QAAQ,MAAM;CAC3B,MAAM,MAAM,MAAM,QAAQ,kBAAkB;CAE5C,MAAM,SAAS,IAAI,WAAW;AAC9B,QAAO,IAAI,MAAM;AACjB,QAAO,IAAI,KAAK;CAEhB,MAAM,YAAY,oBAAoB,KAAK,OAAO;CAClD,MAAM,aAAa,oBAAoB,KAAK,OAAO;AACnD,QAAO;EAAE;EAAW"}

package/dist/esm/react/src/core/nonceManager.js

@@ -0,0 +1,393 @@
+import { isNumber, isObject, isString } from "../utils/validation.js";
+import { errorMessage } from "../utils/errors.js";
+
+//#region src/core/nonceManager.ts
+/**
+* NonceManager - Singleton for managing NEAR transaction context
+*
+* This class pre-fetches nonce and block height asynchronously at the start
+* of executeAction calls to avoid blocking renderUserConfirmUI().
+*
+* The manager is cleared on logout and instantiated with new user on login.
+*/
+var NonceManager = class NonceManager {
+	static instance = null;
+	lastNonceUpdate = null;
+	lastBlockHeightUpdate = null;
+	nearAccountId = null;
+	nearPublicKeyStr = null;
+	transactionContext = null;
+	inflightFetch = null;
+	inflightId = 0;
+	refreshTimer = null;
+	prefetchTimer = null;
+	reservedNonces = /* @__PURE__ */ new Set();
+	lastReservedNonce = null;
+	NONCE_FRESHNESS_THRESHOLD = 5 * 1e3;
+	BLOCK_FRESHNESS_THRESHOLD = 20 * 1e3;
+	PREFETCH_DEBOUNCE_MS = 400;
+	constructor() {}
+	/**
+	* Get singleton instance
+	*/
+	static getInstance() {
+		if (!NonceManager.instance) NonceManager.instance = new NonceManager();
+		return NonceManager.instance;
+	}
+	/**
+	* Prefetch block height/hash (and nonce if missing) in the background.
+	* - If block info is stale or context missing, triggers a non-blocking refresh.
+	* - Safe to call frequently (coalesces concurrent fetches).
+	*/
+	async prefetchBlockheight(nearClient) {
+		if (!this.nearAccountId || !this.nearPublicKeyStr) return;
+		this.clearPrefetchTimer();
+		this.prefetchTimer = setTimeout(async () => {
+			this.prefetchTimer = null;
+			if (this.inflightFetch) return;
+			const now = Date.now();
+			const isBlockStale = !this.lastBlockHeightUpdate || now - this.lastBlockHeightUpdate >= this.BLOCK_FRESHNESS_THRESHOLD;
+			const missingContext = !this.transactionContext;
+			if (!isBlockStale && !missingContext) return;
+			try {
+				await this.fetchFreshData(nearClient);
+			} catch (e) {
+				console.debug("[NonceManager]: prefetchBlockheight ignored error:", e);
+			}
+		}, this.PREFETCH_DEBOUNCE_MS);
+	}
+	/**
+	* Initialize or update the manager with user information
+	*/
+	initializeUser(nearAccountId, nearPublicKeyStr) {
+		this.nearAccountId = nearAccountId;
+		this.nearPublicKeyStr = nearPublicKeyStr;
+		this.clearTransactionContext();
+	}
+	/**
+	* Clear all data when user logs out
+	*/
+	clear() {
+		this.lastNonceUpdate = null;
+		this.lastBlockHeightUpdate = null;
+		this.nearAccountId = null;
+		this.nearPublicKeyStr = null;
+		this.transactionContext = null;
+		this.clearRefreshTimer();
+		this.clearPrefetchTimer();
+		this.inflightFetch = null;
+		this.reservedNonces.clear();
+		this.lastReservedNonce = null;
+	}
+	/**
+	* Smart caching method for nonce and block height data
+	* Returns cached data if fresh, otherwise fetches synchronously
+	*/
+	async getNonceBlockHashAndHeight(nearClient, opts) {
+		if (!this.nearAccountId || !this.nearPublicKeyStr) throw new Error("NonceManager not initialized with user data");
+		const force = opts?.force === true;
+		return await this.fetchFreshData(nearClient, force);
+	}
+	/**
+	* Schedule an asynchronous refresh of the transaction context
+	*/
+	maybeScheduleBackgroundRefresh(nearClient) {
+		if (!this.lastNonceUpdate || !this.lastBlockHeightUpdate) return;
+		if (this.inflightFetch) return;
+		const now = Date.now();
+		const nonceAge = now - this.lastNonceUpdate;
+		const blockAge = now - this.lastBlockHeightUpdate;
+		const halfNonceTtl = this.NONCE_FRESHNESS_THRESHOLD / 2;
+		const halfBlockTtl = this.BLOCK_FRESHNESS_THRESHOLD / 2;
+		if (nonceAge >= halfNonceTtl || blockAge >= halfBlockTtl) {
+			this.clearRefreshTimer();
+			this.fetchFreshData(nearClient).catch((error) => console.warn("[NonceManager]: Background refresh failed:", error));
+			return;
+		}
+		const delayToHalfNonce = Math.max(0, halfNonceTtl - nonceAge);
+		const delayToHalfBlock = Math.max(0, halfBlockTtl - blockAge);
+		const delay = Math.min(delayToHalfNonce, delayToHalfBlock);
+		this.clearRefreshTimer();
+		this.refreshTimer = setTimeout(() => {
+			this.refreshTimer = null;
+			if (this.inflightFetch) return;
+			this.fetchFreshData(nearClient).catch((error) => console.warn("[NonceManager]: Background refresh failed:", error));
+		}, delay);
+	}
+	/**
+	* Fetch fresh transaction context data from NEAR RPC
+	*/
+	async fetchFreshData(nearClient, force = false) {
+		if (this.inflightFetch && !force) return this.inflightFetch;
+		const capturedAccountId = this.nearAccountId;
+		const capturedPublicKey = this.nearPublicKeyStr;
+		const requestId = ++this.inflightId;
+		const fetchPromise = (async () => {
+			try {
+				const now = Date.now();
+				const isNonceStale = force || !this.lastNonceUpdate || now - this.lastNonceUpdate >= this.NONCE_FRESHNESS_THRESHOLD;
+				const isBlockStale = force || !this.lastBlockHeightUpdate || now - this.lastBlockHeightUpdate >= this.BLOCK_FRESHNESS_THRESHOLD;
+				let accessKeyInfo = this.transactionContext?.accessKeyInfo;
+				let txBlockHeight = this.transactionContext?.txBlockHeight;
+				let txBlockHash = this.transactionContext?.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 nearClient.viewAccessKey(capturedAccountId, capturedPublicKey);
+					} catch (akErr) {
+						const msg = errorMessage(akErr);
+						const missingAk = msg.includes("does not exist while viewing") || msg.includes("Access key not found") || msg.includes("unknown public key") || msg.includes("does not exist");
+						if (missingAk) maybeAccessKey = null;
+						else accessKeyError = akErr;
+					}
+				})());
+				if (fetchBlock) tasks.push((async () => {
+					try {
+						maybeBlock = await nearClient.viewBlock({ finality: "final" });
+					} catch (err) {
+						blockError = err;
+					}
+				})());
+				if (tasks.length > 0) await Promise.all(tasks);
+				if (accessKeyError) throw accessKeyError;
+				if (blockError) throw blockError;
+				if (fetchAccessKey) if (isAccessKeyView(maybeAccessKey)) accessKeyInfo = maybeAccessKey;
+				else accessKeyInfo = this.transactionContext?.accessKeyInfo || makePlaceholderAccessKey();
+				if (fetchBlock) {
+					if (!isBlockResult(maybeBlock)) throw new Error("Failed to fetch Block Info");
+					txBlockHeight = String(maybeBlock.header.height);
+					txBlockHash = maybeBlock.header.hash;
+				}
+				let nextCandidate = this.maxBigInt(accessKeyInfo?.nonce !== void 0 ? BigInt(accessKeyInfo.nonce) + 1n : 0n, this.transactionContext?.nextNonce ? BigInt(this.transactionContext.nextNonce) : 0n, this.lastReservedNonce ? BigInt(this.lastReservedNonce) + 1n : 0n);
+				if (nextCandidate <= 0n) nextCandidate = 1n;
+				const nextNonce = nextCandidate.toString();
+				const transactionContext = {
+					nearPublicKeyStr: capturedPublicKey,
+					accessKeyInfo,
+					nextNonce,
+					txBlockHeight,
+					txBlockHash
+				};
+				if (capturedAccountId === this.nearAccountId && capturedPublicKey === this.nearPublicKeyStr && requestId === this.inflightId) {
+					this.transactionContext = transactionContext;
+					const now$1 = Date.now();
+					if (fetchAccessKey) this.lastNonceUpdate = now$1;
+					if (fetchBlock) this.lastBlockHeightUpdate = now$1;
+				}
+				return transactionContext;
+			} catch (error) {
+				console.error("[NonceManager]: Failed to fetch fresh transaction context:", error);
+				throw error;
+			} finally {
+				if (requestId === this.inflightId) this.inflightFetch = null;
+			}
+		})();
+		this.inflightFetch = fetchPromise;
+		return fetchPromise;
+	}
+	/**
+	* Get the current transaction context
+	* Throws if data is not available or stale
+	*/
+	getTransactionContext() {
+		if (!this.transactionContext) throw new Error("Transaction context not available - call getNonceBlockHashAndHeight() first");
+		const now = Date.now();
+		const maxAge = 30 * 1e3;
+		if (this.lastNonceUpdate && now - this.lastNonceUpdate > maxAge) console.warn("[NonceManager]: Transaction context is stale, consider refreshing");
+		return this.transactionContext;
+	}
+	/**
+	* Check if transaction context is available and not stale
+	*/
+	isTransactionContextAvailable(maxAgeMs = 3e4) {
+		if (!this.transactionContext || !this.lastNonceUpdate) return false;
+		const now = Date.now();
+		return now - this.lastNonceUpdate <= maxAgeMs;
+	}
+	/**
+	* Clear transaction context (useful when nonce might be invalidated)
+	*/
+	clearTransactionContext() {
+		this.transactionContext = null;
+		this.lastNonceUpdate = null;
+		this.lastBlockHeightUpdate = null;
+		this.clearRefreshTimer();
+		this.clearPrefetchTimer();
+		this.inflightFetch = null;
+		this.reservedNonces.clear();
+		this.lastReservedNonce = null;
+	}
+	/**
+	* Force a synchronous refresh of nonce + block context.
+	* Useful after key rotations (e.g., link-device) or when encountering INVALID_NONCE.
+	* Optionally clears any locally reserved nonces to avoid collisions.
+	*/
+	async refreshNow(nearClient, opts) {
+		if (opts?.clearReservations) try {
+			this.releaseAllNonces();
+		} catch {}
+		return await this.fetchFreshData(nearClient, true);
+	}
+	/**
+	* Reserve a nonce for batch transactions
+	* This increments the nonce locally to prevent conflicts in batch operations
+	* @param count - Number of nonces to reserve (default: 1)
+	* @returns Array of reserved nonces
+	*/
+	reserveNonces(count = 1) {
+		if (!this.transactionContext) throw new Error("Transaction context not available - call getNonceBlockHashAndHeight() first");
+		if (count <= 0) return [];
+		const start = this.lastReservedNonce ? BigInt(this.lastReservedNonce) + 1n : BigInt(this.transactionContext.nextNonce);
+		const planned = [];
+		for (let i = 0; i < count; i++) {
+			const candidate = (start + BigInt(i)).toString();
+			if (this.reservedNonces.has(candidate)) throw new Error(`Nonce ${candidate} is already reserved`);
+			planned.push(candidate);
+		}
+		const newSet = new Set(this.reservedNonces);
+		for (const n of planned) newSet.add(n);
+		this.reservedNonces = newSet;
+		this.lastReservedNonce = planned[planned.length - 1];
+		return planned;
+	}
+	/**
+	* Release a reserved nonce (call when transaction is completed or failed)
+	* @param nonce - The nonce to release
+	*/
+	releaseNonce(nonce) {
+		if (this.reservedNonces.has(nonce)) this.reservedNonces.delete(nonce);
+	}
+	/**
+	* Release all reserved nonces
+	*/
+	releaseAllNonces() {
+		this.reservedNonces.size;
+		this.reservedNonces.clear();
+		this.lastReservedNonce = null;
+	}
+	/**
+	* Update nonce from blockchain after transaction completion
+	* This should be called after a transaction is successfully broadcasted
+	* @param nearClient - NEAR client for RPC calls
+	* @param actualNonce - The actual nonce used in the completed transaction
+	*/
+	async updateNonceFromBlockchain(nearClient, actualNonce) {
+		if (!this.nearAccountId || !this.nearPublicKeyStr) throw new Error("NonceManager not initialized with user data");
+		try {
+			const accessKeyInfo = await nearClient.viewAccessKey(this.nearAccountId, this.nearPublicKeyStr);
+			if (!accessKeyInfo || accessKeyInfo.nonce === void 0) throw new Error(`Access key not found or invalid for account ${this.nearAccountId}`);
+			const chainNonceBigInt = BigInt(accessKeyInfo.nonce);
+			const actualNonceBigInt = BigInt(actualNonce);
+			if (chainNonceBigInt < actualNonceBigInt - BigInt(1)) console.warn(`[NonceManager]: Chain nonce (${chainNonceBigInt}) behind expected (${actualNonceBigInt - BigInt(1)}). Updating...`);
+			const candidateNext = this.maxBigInt(chainNonceBigInt + 1n, actualNonceBigInt + 1n, this.transactionContext?.nextNonce ? BigInt(this.transactionContext.nextNonce) : 0n, this.lastReservedNonce ? BigInt(this.lastReservedNonce) + 1n : 0n);
+			if (this.transactionContext) {
+				this.transactionContext.accessKeyInfo = accessKeyInfo;
+				this.transactionContext.nextNonce = candidateNext.toString();
+			} else this.transactionContext = {
+				nearPublicKeyStr: this.nearPublicKeyStr,
+				accessKeyInfo,
+				nextNonce: candidateNext.toString(),
+				txBlockHeight: "0",
+				txBlockHash: ""
+			};
+			this.lastNonceUpdate = Date.now();
+			this.releaseNonce(actualNonce);
+			if (this.reservedNonces.size > 0) {
+				const { set: prunedSet, lastReserved } = this.pruneReserved(chainNonceBigInt, this.reservedNonces);
+				this.reservedNonces = prunedSet;
+				this.lastReservedNonce = lastReserved;
+			}
+			console.debug(`[NonceManager]: Updated from chain nonce=${chainNonceBigInt} actual=${actualNonceBigInt} next=${this.transactionContext.nextNonce}`);
+		} catch (error) {
+			const msg = errorMessage(error);
+			if (msg.includes("does not exist while viewing") || msg.includes("Access key not found")) try {
+				const actualNonceBigInt = BigInt(actualNonce);
+				const candidateNext = this.maxBigInt(actualNonceBigInt + 1n, this.transactionContext?.nextNonce ? BigInt(this.transactionContext.nextNonce) : 0n, this.lastReservedNonce ? BigInt(this.lastReservedNonce) + 1n : 0n);
+				if (this.transactionContext) this.transactionContext.nextNonce = candidateNext.toString();
+				else this.transactionContext = {
+					nearPublicKeyStr: this.nearPublicKeyStr,
+					accessKeyInfo: makePlaceholderAccessKey(),
+					nextNonce: candidateNext.toString(),
+					txBlockHeight: "0",
+					txBlockHash: ""
+				};
+				this.lastNonceUpdate = Date.now();
+				console.debug("[NonceManager]: Access key missing; advanced nextNonce optimistically to", this.transactionContext?.nextNonce);
+				return;
+			} catch {}
+			console.warn("[NonceManager]: Failed to update nonce from blockchain:", error);
+		}
+	}
+	/**
+	* Get the next available nonce for a single transaction
+	* This is a convenience method that reserves exactly one nonce
+	* @returns The next nonce to use
+	*/
+	getNextNonce() {
+		const nonces = this.reserveNonces(1);
+		return nonces[0];
+	}
+	clearRefreshTimer() {
+		if (this.refreshTimer) {
+			clearTimeout(this.refreshTimer);
+			this.refreshTimer = null;
+		}
+	}
+	clearPrefetchTimer() {
+		if (this.prefetchTimer) {
+			clearTimeout(this.prefetchTimer);
+			this.prefetchTimer = null;
+		}
+	}
+	maxBigInt(...values) {
+		if (values.length === 0) return 0n;
+		return values.reduce((a, b) => a > b ? a : b);
+	}
+	pruneReserved(chainNonceBigInt, reserved) {
+		const newSet = /* @__PURE__ */ new Set();
+		let newLast = null;
+		for (const r of reserved) try {
+			const rb = BigInt(r);
+			if (rb > chainNonceBigInt) {
+				newSet.add(r);
+				if (newLast === null || rb > newLast) newLast = rb;
+			}
+		} catch {}
+		return {
+			set: newSet,
+			lastReserved: newLast ? newLast.toString() : null
+		};
+	}
+};
+function isAccessKeyView(x) {
+	if (!isObject(x)) return false;
+	return isNumber(x.nonce);
+}
+function isBlockResult(x) {
+	if (!isObject(x)) return false;
+	const h = x.header;
+	if (!isObject(h)) return false;
+	const height = h.height;
+	const hash = h.hash;
+	return isNumber(height) && isString(hash);
+}
+function makePlaceholderAccessKey() {
+	return {
+		nonce: BigInt(0),
+		permission: "FullAccess",
+		block_hash: "",
+		block_height: 0
+	};
+}
+const NonceManagerInstance = NonceManager.getInstance();
+var nonceManager_default = NonceManagerInstance;
+
+//#endregion
+export { nonceManager_default as default };
+//# sourceMappingURL=nonceManager.js.map

package/dist/esm/react/src/core/nonceManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nonceManager.js","names":["maybeAccessKey: unknown","maybeBlock: unknown","accessKeyError: unknown","blockError: unknown","tasks: Promise<void>[]","akErr: unknown","err: unknown","transactionContext: TransactionContext","now","planned: string[]","error: unknown","newLast: bigint | null"],"sources":["../../../../../src/core/nonceManager.ts"],"sourcesContent":["import type { NearClient } from './NearClient';\nimport type { AccountId } from './types/accountIds';\nimport type { TransactionContext } from './types/rpc';\nimport type { AccessKeyView, BlockResult } from '@near-js/types';\nimport { isObject, isNumber, isString } from '@/utils/validation';\nimport { errorMessage } from '../utils/errors';\n\n/**\n * NonceManager - Singleton for managing NEAR transaction context\n *\n * This class pre-fetches nonce and block height asynchronously at the start\n * of executeAction calls to avoid blocking renderUserConfirmUI().\n *\n * The manager is cleared on logout and instantiated with new user on login.\n */\nexport class NonceManager {\n  private static instance: NonceManager | null = null;\n\n  public lastNonceUpdate: number | null = null;\n  public lastBlockHeightUpdate: number | null = null;\n  public nearAccountId: AccountId | null = null;\n  public nearPublicKeyStr: string | null = null;\n  public transactionContext: TransactionContext | null = null;\n  private inflightFetch: Promise<TransactionContext> | null = null;\n  // Monotonic identifier to disambiguate concurrent fetches and prevent stale commits/clears\n  private inflightId: number = 0;\n  private refreshTimer: ReturnType<typeof setTimeout> | null = null;\n  private prefetchTimer: ReturnType<typeof setTimeout> | null = null;\n\n  // Nonce reservation system for batch transactions\n  private reservedNonces: Set<string> = new Set();\n  private lastReservedNonce: string | null = null;\n\n  // Freshness thresholds (ms)\n  // Treat context older than 5s as stale enough to refetch\n  private readonly NONCE_FRESHNESS_THRESHOLD = 5 * 1000; // 5 seconds\n  private readonly BLOCK_FRESHNESS_THRESHOLD = 20 * 1000; // 20 seconds (less frequent block refreshes)\n  private readonly PREFETCH_DEBOUNCE_MS = 400; // less aggressive prefetch debounce to reduce churn\n\n  // Private constructor for singleton pattern\n  private constructor() {}\n\n  /**\n   * Get singleton instance\n   */\n  public static getInstance(): NonceManager {\n    if (!NonceManager.instance) {\n      NonceManager.instance = new NonceManager();\n    }\n    return NonceManager.instance;\n  }\n\n  /**\n   * Prefetch block height/hash (and nonce if missing) in the background.\n   * - If block info is stale or context missing, triggers a non-blocking refresh.\n   * - Safe to call frequently (coalesces concurrent fetches).\n   */\n  public async prefetchBlockheight(nearClient: NearClient): Promise<void> {\n    if (!this.nearAccountId || !this.nearPublicKeyStr) return;\n    // Debounce prefetch to avoid repeated calls on quick hover/focus toggles\n    this.clearPrefetchTimer();\n    this.prefetchTimer = setTimeout(async () => {\n      this.prefetchTimer = null;\n      if (this.inflightFetch) return; // already fetching\n\n      const now = Date.now();\n      const isBlockStale = !this.lastBlockHeightUpdate || (now - this.lastBlockHeightUpdate) >= this.BLOCK_FRESHNESS_THRESHOLD;\n      const missingContext = !this.transactionContext;\n      if (!isBlockStale && !missingContext) return;\n\n      try {\n        await this.fetchFreshData(nearClient);\n      } catch (e) {\n        // Swallow errors during prefetch; runtime path will retry as needed\n        console.debug('[NonceManager]: prefetchBlockheight ignored error:', e);\n      }\n    }, this.PREFETCH_DEBOUNCE_MS);\n  }\n\n  /**\n   * Initialize or update the manager with user information\n   */\n  public initializeUser(nearAccountId: AccountId, nearPublicKeyStr: string): void {\n    this.nearAccountId = nearAccountId;\n    this.nearPublicKeyStr = nearPublicKeyStr;\n    this.clearTransactionContext();\n  }\n\n  /**\n   * Clear all data when user logs out\n   */\n  public clear(): void {\n    this.lastNonceUpdate = null;\n    this.lastBlockHeightUpdate = null;\n    this.nearAccountId = null;\n    this.nearPublicKeyStr = null;\n    this.transactionContext = null;\n    this.clearRefreshTimer();\n    this.clearPrefetchTimer();\n    this.inflightFetch = null;\n    this.reservedNonces.clear();\n    this.lastReservedNonce = null;\n  }\n\n  /**\n   * Smart caching method for nonce and block height data\n   * Returns cached data if fresh, otherwise fetches synchronously\n   */\n  public async getNonceBlockHashAndHeight(nearClient: NearClient, opts?: { force?: boolean }): Promise<TransactionContext> {\n    // Always prefer a fresh fetch for critical paths; coalesced by fetchFreshData.\n    // This minimizes subtle cache bugs after key rotations/linking and across devices.\n    if (!this.nearAccountId || !this.nearPublicKeyStr) {\n      throw new Error('NonceManager not initialized with user data');\n    }\n    // Respect caller's intent to force or use freshness thresholds\n    const force = opts?.force === true;\n    return await this.fetchFreshData(nearClient, force);\n  }\n\n  /**\n   * Schedule an asynchronous refresh of the transaction context\n   */\n  private maybeScheduleBackgroundRefresh(nearClient: NearClient): void {\n    if (!this.lastNonceUpdate || !this.lastBlockHeightUpdate) return;\n    if (this.inflightFetch) return; // already fetching\n\n    const now = Date.now();\n    const nonceAge = now - this.lastNonceUpdate;\n    const blockAge = now - this.lastBlockHeightUpdate;\n\n    const halfNonceTtl = this.NONCE_FRESHNESS_THRESHOLD / 2;\n    const halfBlockTtl = this.BLOCK_FRESHNESS_THRESHOLD / 2;\n\n    // If we're past the half-life for either value, refresh NOW in background\n    if (nonceAge >= halfNonceTtl || blockAge >= halfBlockTtl) {\n      this.clearRefreshTimer();\n      // Fire-and-forget refresh to keep cache warm\n      void this.fetchFreshData(nearClient)\n        .catch((error) => console.warn('[NonceManager]: Background refresh failed:', error));\n      return;\n    }\n\n    // Otherwise, schedule a refresh for when the earliest metric hits half-life\n    const delayToHalfNonce = Math.max(0, halfNonceTtl - nonceAge);\n    const delayToHalfBlock = Math.max(0, halfBlockTtl - blockAge);\n    const delay = Math.min(delayToHalfNonce, delayToHalfBlock);\n\n    // Avoid multiple timers\n    this.clearRefreshTimer();\n    this.refreshTimer = setTimeout(() => {\n      this.refreshTimer = null;\n      if (this.inflightFetch) return;\n      void this.fetchFreshData(nearClient)\n        .catch((error) => console.warn('[NonceManager]: Background refresh failed:', error));\n    }, delay);\n  }\n\n  /**\n   * Fetch fresh transaction context data from NEAR RPC\n   */\n  private async fetchFreshData(nearClient: NearClient, force: boolean = false): Promise<TransactionContext> {\n    // Coalesce concurrent refreshes when not forced to reduce redundant network calls.\n    // Force=true is used by latency-critical paths (e.g., JIT VRF refresh) to guarantee a fresh block height.\n    if (this.inflightFetch && !force) {\n      return this.inflightFetch;\n    }\n\n    const capturedAccountId = this.nearAccountId;\n    const capturedPublicKey = this.nearPublicKeyStr;\n    // Start a new fetch; assign a unique id to guard commit and cleanup\n    const requestId = (++this.inflightId);\n    const fetchPromise = (async () => {\n      try {\n        // Determine what is actually stale so we only fetch what we need\n        const now = Date.now();\n        const isNonceStale = force || !this.lastNonceUpdate || (now - this.lastNonceUpdate) >= this.NONCE_FRESHNESS_THRESHOLD;\n        const isBlockStale = force || !this.lastBlockHeightUpdate || (now - this.lastBlockHeightUpdate) >= this.BLOCK_FRESHNESS_THRESHOLD;\n\n        let accessKeyInfo = this.transactionContext?.accessKeyInfo;\n        let txBlockHeight = this.transactionContext?.txBlockHeight;\n        let txBlockHash = this.transactionContext?.txBlockHash;\n\n        const fetchAccessKey = isNonceStale || !accessKeyInfo;\n        const fetchBlock = isBlockStale || !txBlockHeight || !txBlockHash;\n\n        // Fetch required parts with tolerance for missing access key just after creation\n        let maybeAccessKey: unknown = accessKeyInfo ?? null;\n        let maybeBlock: unknown = null;\n\n        // Run RPC calls in parallel where applicable, while preserving tolerant error handling\n        let accessKeyError: unknown = null;\n        let blockError: unknown = null;\n        const tasks: Promise<void>[] = [];\n\n        if (fetchAccessKey) {\n          tasks.push((async () => {\n            try {\n              maybeAccessKey = await nearClient.viewAccessKey(capturedAccountId!, capturedPublicKey!);\n            } catch (akErr: unknown) {\n              const msg = errorMessage(akErr);\n              const missingAk = msg.includes('does not exist while viewing')\n                || msg.includes('Access key not found')\n                || msg.includes('unknown public key')\n                || msg.includes('does not exist');\n              if (missingAk) {\n                // Non-fatal: proceed without live AK; compute nextNonce conservatively\n                maybeAccessKey = null;\n              } else {\n                accessKeyError = akErr;\n              }\n            }\n          })());\n        }\n\n        if (fetchBlock) {\n          tasks.push((async () => {\n            try {\n              maybeBlock = await nearClient.viewBlock({ finality: 'final' });\n            } catch (err: unknown) {\n              // Block info is required\n              blockError = err;\n            }\n          })());\n        }\n\n        if (tasks.length > 0) {\n          await Promise.all(tasks);\n        }\n\n        if (accessKeyError) {\n          throw accessKeyError;\n        }\n        if (blockError) {\n          throw blockError;\n        }\n\n        // Commit results\n        if (fetchAccessKey) {\n          if (isAccessKeyView(maybeAccessKey)) {\n            accessKeyInfo = maybeAccessKey;\n          } else {\n            // Keep previous accessKeyInfo if present; else set minimal placeholder\n            accessKeyInfo = this.transactionContext?.accessKeyInfo || makePlaceholderAccessKey();\n          }\n        }\n\n        if (fetchBlock) {\n          if (!isBlockResult(maybeBlock)) {\n            throw new Error('Failed to fetch Block Info');\n          }\n          txBlockHeight = String(maybeBlock.header.height);\n          txBlockHash = maybeBlock.header.hash;\n        }\n\n        // Derive nextNonce from access key info + current context + reservations\n        let nextCandidate = this.maxBigInt(\n          accessKeyInfo?.nonce !== undefined ? (BigInt(accessKeyInfo.nonce) + 1n) : 0n,\n          this.transactionContext?.nextNonce ? BigInt(this.transactionContext.nextNonce) : 0n,\n          this.lastReservedNonce ? BigInt(this.lastReservedNonce) + 1n : 0n\n        );\n        if (nextCandidate <= 0n) nextCandidate = 1n; // never use 0\n        const nextNonce = nextCandidate.toString();\n\n        const transactionContext: TransactionContext = {\n          nearPublicKeyStr: capturedPublicKey!,\n          accessKeyInfo: accessKeyInfo!,\n          nextNonce,\n          txBlockHeight: txBlockHeight!,\n          txBlockHash: txBlockHash!,\n        };\n\n        // Only commit if identity did not change AND this fetch is still the latest.\n        // This guards against stale commits from races when a forced refresh overtakes a cached one.\n        if (\n          capturedAccountId === this.nearAccountId &&\n          capturedPublicKey === this.nearPublicKeyStr &&\n          requestId === this.inflightId\n        ) {\n          this.transactionContext = transactionContext;\n          const now = Date.now();\n          if (fetchAccessKey) this.lastNonceUpdate = now;\n          if (fetchBlock) this.lastBlockHeightUpdate = now;\n        } else {\n          // Discard results from outdated or identity-mismatched fetches; a newer fetch has already committed.\n        }\n\n        return transactionContext;\n      } catch (error) {\n        console.error('[NonceManager]: Failed to fetch fresh transaction context:', error);\n        throw error;\n      } finally {\n        // Only clear inflight if this promise is still the latest.\n        if (requestId === this.inflightId) {\n          this.inflightFetch = null;\n        }\n      }\n    })();\n\n    this.inflightFetch = fetchPromise;\n    return fetchPromise;\n  }\n\n  /**\n   * Get the current transaction context\n   * Throws if data is not available or stale\n   */\n  public getTransactionContext(): TransactionContext {\n    if (!this.transactionContext) {\n      throw new Error('Transaction context not available - call getNonceBlockHashAndHeight() first');\n    }\n\n    // Check if data is stale (more than 30 seconds old)\n    const now = Date.now();\n    const maxAge = 30 * 1000; // 30 seconds\n\n    if (this.lastNonceUpdate && (now - this.lastNonceUpdate) > maxAge) {\n      console.warn('[NonceManager]: Transaction context is stale, consider refreshing');\n    }\n\n    return this.transactionContext;\n  }\n\n  /**\n   * Check if transaction context is available and not stale\n   */\n  public isTransactionContextAvailable(maxAgeMs: number = 30000): boolean {\n    if (!this.transactionContext || !this.lastNonceUpdate) {\n      return false;\n    }\n\n    const now = Date.now();\n    return (now - this.lastNonceUpdate) <= maxAgeMs;\n  }\n\n  /**\n   * Clear transaction context (useful when nonce might be invalidated)\n   */\n  public clearTransactionContext(): void {\n    this.transactionContext = null;\n    this.lastNonceUpdate = null;\n    this.lastBlockHeightUpdate = null;\n    this.clearRefreshTimer();\n    this.clearPrefetchTimer();\n    this.inflightFetch = null;\n    this.reservedNonces.clear();\n    this.lastReservedNonce = null;\n  }\n\n  /**\n   * Force a synchronous refresh of nonce + block context.\n   * Useful after key rotations (e.g., link-device) or when encountering INVALID_NONCE.\n   * Optionally clears any locally reserved nonces to avoid collisions.\n   */\n  public async refreshNow(nearClient: NearClient, opts?: { clearReservations?: boolean }): Promise<TransactionContext> {\n    if (opts?.clearReservations) {\n      try { this.releaseAllNonces(); } catch {}\n    }\n    return await this.fetchFreshData(nearClient, true);\n  }\n\n  /**\n   * Reserve a nonce for batch transactions\n   * This increments the nonce locally to prevent conflicts in batch operations\n   * @param count - Number of nonces to reserve (default: 1)\n   * @returns Array of reserved nonces\n   */\n  public reserveNonces(count: number = 1): string[] {\n    if (!this.transactionContext) {\n      throw new Error('Transaction context not available - call getNonceBlockHashAndHeight() first');\n    }\n\n    if (count <= 0) return [];\n\n    const start = this.lastReservedNonce\n      ? BigInt(this.lastReservedNonce) + 1n\n      : BigInt(this.transactionContext.nextNonce);\n\n    // Plan reservations first (pure), then commit atomically\n    const planned: string[] = [];\n    for (let i = 0; i < count; i++) {\n      const candidate = (start + BigInt(i)).toString();\n      if (this.reservedNonces.has(candidate)) {\n        throw new Error(`Nonce ${candidate} is already reserved`);\n      }\n      planned.push(candidate);\n    }\n\n    // Commit: extend set and bump lastReservedNonce\n    const newSet = new Set(this.reservedNonces);\n    for (const n of planned) newSet.add(n);\n    this.reservedNonces = newSet;\n    this.lastReservedNonce = planned[planned.length - 1];\n\n    return planned;\n  }\n\n  /**\n   * Release a reserved nonce (call when transaction is completed or failed)\n   * @param nonce - The nonce to release\n   */\n  public releaseNonce(nonce: string): void {\n    if (this.reservedNonces.has(nonce)) {\n      this.reservedNonces.delete(nonce);\n    }\n  }\n\n  /**\n   * Release all reserved nonces\n   */\n  public releaseAllNonces(): void {\n    const count = this.reservedNonces.size;\n    this.reservedNonces.clear();\n    this.lastReservedNonce = null;\n  }\n\n  /**\n   * Update nonce from blockchain after transaction completion\n   * This should be called after a transaction is successfully broadcasted\n   * @param nearClient - NEAR client for RPC calls\n   * @param actualNonce - The actual nonce used in the completed transaction\n   */\n  public async updateNonceFromBlockchain(nearClient: NearClient, actualNonce: string): Promise<void> {\n    if (!this.nearAccountId || !this.nearPublicKeyStr) {\n      throw new Error('NonceManager not initialized with user data');\n    }\n\n    try {\n      // Fetch fresh access key info to get the latest nonce\n      const accessKeyInfo = await nearClient.viewAccessKey(this.nearAccountId, this.nearPublicKeyStr);\n\n      if (!accessKeyInfo || accessKeyInfo.nonce === undefined) {\n        throw new Error(`Access key not found or invalid for account ${this.nearAccountId}`);\n      }\n\n      const chainNonceBigInt = BigInt(accessKeyInfo.nonce);\n      const actualNonceBigInt = BigInt(actualNonce);\n\n      // Tolerate both pre- and post-final states:\n      // - pre-final: chainNonce == actualNonce - 1\n      // - post-final: chainNonce >= actualNonce\n      if (chainNonceBigInt < actualNonceBigInt - BigInt(1)) {\n        console.warn(\n          `[NonceManager]: Chain nonce (${chainNonceBigInt}) behind expected (${actualNonceBigInt - BigInt(1)}). Updating...`\n        );\n      }\n\n      // Compute next usable nonce using maxBigInt for clarity\n      // Include (actualNonce + 1) to immediately advance locally after broadcast,\n      // even if chain finality has not reflected the new nonce yet.\n      const candidateNext = this.maxBigInt(\n        chainNonceBigInt + 1n,\n        actualNonceBigInt + 1n,\n        this.transactionContext?.nextNonce ? BigInt(this.transactionContext.nextNonce) : 0n,\n        this.lastReservedNonce ? BigInt(this.lastReservedNonce) + 1n : 0n,\n      );\n\n      // Update cached context with fresh access key info and computed next nonce\n      if (this.transactionContext) {\n        this.transactionContext.accessKeyInfo = accessKeyInfo;\n        this.transactionContext.nextNonce = candidateNext.toString();\n      } else {\n        // If no context exists (should be rare here), construct a minimal one\n        this.transactionContext = {\n          nearPublicKeyStr: this.nearPublicKeyStr!,\n          accessKeyInfo: accessKeyInfo,\n          nextNonce: candidateNext.toString(),\n          // Block values are unknown here; leave stale ones to be refreshed later\n          txBlockHeight: '0',\n          txBlockHash: '',\n        } as TransactionContext; // We'll refresh these via fetchFreshData when needed\n      }\n      this.lastNonceUpdate = Date.now();\n\n      // Release the used nonce (idempotent)\n      this.releaseNonce(actualNonce);\n\n      // Prune any reserved nonces that are now <= chain nonce (already used or invalid)\n      if (this.reservedNonces.size > 0) {\n        const { set: prunedSet, lastReserved } = this.pruneReserved(chainNonceBigInt, this.reservedNonces);\n        this.reservedNonces = prunedSet;\n        this.lastReservedNonce = lastReserved;\n      }\n\n      console.debug(\n        `[NonceManager]: Updated from chain nonce=${chainNonceBigInt} actual=${actualNonceBigInt} next=${this.transactionContext!.nextNonce}`\n      );\n\n      } catch (error: unknown) {\n        const msg = errorMessage(error);\n        // Tolerate missing/rotated keys: avoid noisy error and advance nextNonce optimistically\n        if (msg.includes('does not exist while viewing') || msg.includes('Access key not found')) {\n          try {\n            const actualNonceBigInt = BigInt(actualNonce);\n            const candidateNext = this.maxBigInt(\n              actualNonceBigInt + 1n,\n              this.transactionContext?.nextNonce ? BigInt(this.transactionContext.nextNonce) : 0n,\n              this.lastReservedNonce ? BigInt(this.lastReservedNonce) + 1n : 0n,\n            );\n            if (this.transactionContext) {\n              this.transactionContext.nextNonce = candidateNext.toString();\n            } else {\n            this.transactionContext = {\n              nearPublicKeyStr: this.nearPublicKeyStr!,\n              accessKeyInfo: makePlaceholderAccessKey(),\n              nextNonce: candidateNext.toString(),\n              txBlockHeight: '0',\n              txBlockHash: '',\n            } as TransactionContext;\n          }\n          this.lastNonceUpdate = Date.now();\n          console.debug('[NonceManager]: Access key missing; advanced nextNonce optimistically to', this.transactionContext?.nextNonce);\n          return;\n        } catch {}\n      }\n      console.warn('[NonceManager]: Failed to update nonce from blockchain:', error);\n      // Don't throw - this is a best-effort update\n    }\n  }\n\n  /**\n   * Get the next available nonce for a single transaction\n   * This is a convenience method that reserves exactly one nonce\n   * @returns The next nonce to use\n   */\n  public getNextNonce(): string {\n    const nonces = this.reserveNonces(1);\n    return nonces[0];\n  }\n\n  private clearRefreshTimer(): void {\n    if (this.refreshTimer) {\n      clearTimeout(this.refreshTimer);\n      this.refreshTimer = null;\n    }\n  }\n  private clearPrefetchTimer(): void {\n    if (this.prefetchTimer) {\n      clearTimeout(this.prefetchTimer);\n      this.prefetchTimer = null;\n    }\n  }\n\n  // Small helper to get max of BigInt values elegantly\n  private maxBigInt(...values: bigint[]): bigint {\n    if (values.length === 0) return 0n;\n    return values.reduce((a, b) => (a > b ? a : b));\n  }\n\n  // Return a new reserved set that excludes entries <= chain nonce, and compute new lastReserved\n  private pruneReserved(chainNonceBigInt: bigint, reserved: Set<string>): { set: Set<string>, lastReserved: string | null } {\n    const newSet = new Set<string>();\n    let newLast: bigint | null = null;\n    for (const r of reserved) {\n      try {\n        const rb = BigInt(r);\n        if (rb > chainNonceBigInt) {\n          newSet.add(r);\n          if (newLast === null || rb > newLast) newLast = rb;\n        }\n      } catch {\n        // skip malformed entries\n      }\n    }\n    return {\n      set: newSet,\n      lastReserved: newLast ? newLast.toString() : null\n    };\n  }\n\n}\n\n// ===== Type guards for NEAR RPC return shapes =====\nfunction isAccessKeyView(x: unknown): x is AccessKeyView {\n  if (!isObject(x)) return false;\n  // Only validate the fields we actually use\n  return isNumber((x as { nonce?: unknown }).nonce);\n}\n\nfunction isBlockResult(x: unknown): x is BlockResult {\n  if (!isObject(x)) return false;\n  const h = (x as { header?: unknown }).header;\n  if (!isObject(h)) return false;\n  const height = (h as { height?: unknown }).height;\n  const hash = (h as { hash?: unknown }).hash;\n  return isNumber(height) && isString(hash);\n}\n\nfunction makePlaceholderAccessKey(): AccessKeyView {\n  return {\n    nonce: BigInt(0),\n    permission: 'FullAccess',\n    block_hash: '',\n    block_height: 0\n  }\n}\n\n// Create and export singleton instance\nconst NonceManagerInstance = NonceManager.getInstance();\nexport default NonceManagerInstance;\n"],"mappings":"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"}