@tatchi-xyz/sdk 0.20.0 → 0.31.0

package/dist/cjs/react/src/core/WebAuthnManager/SignerWorkerManager/sessionMessages.js

@@ -0,0 +1,93 @@
+const require_workerControlMessages = require('../../workerControlMessages.js');
+
+//#region src/core/WebAuthnManager/SignerWorkerManager/sessionMessages.ts
+function asSessionMessage(msg) {
+	if (!isObject(msg)) return null;
+	if (typeof msg.type !== "string") return null;
+	if (msg.sessionId != null && typeof msg.sessionId !== "string") return null;
+	if (msg.error != null && typeof msg.error !== "string") return null;
+	return msg;
+}
+/**
+* Type guard to check if a message is a control message.
+*/
+function isSignerWorkerControlMessage(msg) {
+	if (!isObject(msg) || typeof msg.type !== "string") return false;
+	switch (msg.type) {
+		case require_workerControlMessages.WorkerControlMessage.ATTACH_WRAP_KEY_SEED_PORT_OK: return typeof msg.sessionId === "string";
+		case require_workerControlMessages.WorkerControlMessage.ATTACH_WRAP_KEY_SEED_PORT_ERROR: return typeof msg.sessionId === "string" && typeof msg.error === "string";
+		case require_workerControlMessages.WorkerControlMessage.WORKER_READY: return typeof msg.ready === "boolean";
+		default: return false;
+	}
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Generic helper for waiting on session messages from a worker.
+* Registers a listener, sends no message (caller handles that), and waits for a matching response.
+*
+* @param worker - The worker to listen to
+* @param options - Configuration for what to wait for
+* @returns Promise that resolves when the expected message arrives, rejects on timeout or error
+*/
+function waitForSessionMessage(worker, options) {
+	const { successType, errorType, sessionId, timeoutMs = 2e3, validator } = options;
+	const successTypes = Array.isArray(successType) ? successType : [successType];
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`Timeout waiting for session message (${successTypes.join("|")})${sessionId ? ` for session ${sessionId}` : ""}`));
+		}, timeoutMs);
+		const messageHandler = (event) => {
+			const msg = asSessionMessage(event.data);
+			if (!msg) return;
+			if (sessionId && msg.sessionId !== sessionId) return;
+			if (errorType && msg.type === errorType) {
+				cleanup();
+				const error = msg.error || "Unknown error";
+				reject(/* @__PURE__ */ new Error(`Session message error: ${error}`));
+				return;
+			}
+			if (successTypes.includes(msg.type)) {
+				if (validator) try {
+					const shouldResolve = validator(msg);
+					if (!shouldResolve) return;
+				} catch (err) {
+					cleanup();
+					reject(err);
+					return;
+				}
+				cleanup();
+				resolve();
+			}
+		};
+		const cleanup = () => {
+			clearTimeout(timeout);
+			worker.removeEventListener("message", messageHandler);
+		};
+		worker.addEventListener("message", messageHandler);
+	});
+}
+/**
+* Wait for the worker to acknowledge successful attachment of the WrapKeySeed port.
+* This provides early detection of attach failures instead of only seeing late WASM errors.
+*
+* @param worker - The worker that should send the ACK
+* @param sessionId - The session ID to match
+* @param timeoutMs - How long to wait before rejecting (default: 2000ms)
+* @returns Promise that resolves on success ACK, rejects on error or timeout
+*/
+function waitForWrapKeyPortAttach(worker, sessionId, timeoutMs = 2e3) {
+	return waitForSessionMessage(worker, {
+		successType: require_workerControlMessages.WorkerControlMessage.ATTACH_WRAP_KEY_SEED_PORT_OK,
+		errorType: require_workerControlMessages.WorkerControlMessage.ATTACH_WRAP_KEY_SEED_PORT_ERROR,
+		sessionId,
+		timeoutMs
+	});
+}
+
+//#endregion
+exports.isSignerWorkerControlMessage = isSignerWorkerControlMessage;
+exports.waitForWrapKeyPortAttach = waitForWrapKeyPortAttach;
+//# sourceMappingURL=sessionMessages.js.map

package/dist/cjs/react/src/core/WebAuthnManager/SignerWorkerManager/sessionMessages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionMessages.js","names":["WorkerControlMessage"],"sources":["../../../../../../../src/core/WebAuthnManager/SignerWorkerManager/sessionMessages.ts"],"sourcesContent":["/**\n * Session Message Handling for Signer Worker\n *\n * This module provides helpers for waiting on session lifecycle messages from the signer worker.\n * Session messages are JS-only messages that never go through the Rust JSON pipeline\n * and are used for worker lifecycle management and session setup.\n */\n\nimport { WorkerControlMessage } from '../../workerControlMessages';\n\n// === SESSION MESSAGE TYPES ===\n\n/**\n * Control message sent by the signer worker after successfully attaching\n * a WrapKeySeed MessagePort for a signing session.\n */\nexport interface AttachWrapKeySeedPortOkMessage {\n  type: typeof WorkerControlMessage.ATTACH_WRAP_KEY_SEED_PORT_OK;\n  sessionId: string;\n}\n\n/**\n * Control message sent by the signer worker when attaching a WrapKeySeed\n * MessagePort fails.\n */\nexport interface AttachWrapKeySeedPortErrorMessage {\n  type: typeof WorkerControlMessage.ATTACH_WRAP_KEY_SEED_PORT_ERROR;\n  sessionId: string;\n  error: string;\n}\n\n/**\n * Control message sent by the signer worker when it's ready to receive messages.\n */\nexport interface WorkerReadyMessage {\n  type: typeof WorkerControlMessage.WORKER_READY;\n  ready: boolean;\n}\n\n/**\n * All control messages that can be sent by the signer worker.\n */\nexport type SignerWorkerControlMessage =\n  | AttachWrapKeySeedPortOkMessage\n  | AttachWrapKeySeedPortErrorMessage\n  | WorkerReadyMessage;\n\nexport type SessionMessage = Record<string, unknown> & {\n  type: string;\n  sessionId?: string;\n  error?: string;\n};\n\nfunction asSessionMessage(msg: unknown): SessionMessage | null {\n  if (!isObject(msg)) return null;\n  if (typeof msg.type !== 'string') return null;\n  if (msg.sessionId != null && typeof msg.sessionId !== 'string') return null;\n  if (msg.error != null && typeof msg.error !== 'string') return null;\n  return msg as SessionMessage;\n}\n\n/**\n * Type guard to check if a message is a control message.\n */\nexport function isSignerWorkerControlMessage(msg: unknown): msg is SignerWorkerControlMessage {\n  if (!isObject(msg) || typeof msg.type !== 'string') {\n    return false;\n  }\n\n  switch (msg.type) {\n    case WorkerControlMessage.ATTACH_WRAP_KEY_SEED_PORT_OK:\n      return typeof msg.sessionId === 'string';\n    case WorkerControlMessage.ATTACH_WRAP_KEY_SEED_PORT_ERROR:\n      return typeof msg.sessionId === 'string' && typeof msg.error === 'string';\n    case WorkerControlMessage.WORKER_READY:\n      return typeof msg.ready === 'boolean';\n    default:\n      return false;\n  }\n}\n\nfunction isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null;\n}\n\n// === SESSION MESSAGE HELPERS ===\n\n/**\n * Generic helper for waiting on session messages from a worker.\n * Registers a listener, sends no message (caller handles that), and waits for a matching response.\n *\n * @param worker - The worker to listen to\n * @param options - Configuration for what to wait for\n * @returns Promise that resolves when the expected message arrives, rejects on timeout or error\n */\nexport function waitForSessionMessage(\n  worker: Worker,\n  options: {\n    /** Message type(s) to wait for (success) */\n    successType: string | string[];\n    /** Optional error type to reject on */\n    errorType?: string;\n    /** Session ID to match (if applicable) */\n    sessionId?: string;\n    /** Timeout in milliseconds */\n    timeoutMs?: number;\n    /** Custom message validator - return true to resolve, false to ignore, throw to reject */\n    validator?: (msg: SessionMessage) => boolean;\n  }\n): Promise<void> {\n  const {\n    successType,\n    errorType,\n    sessionId,\n    timeoutMs = 2000,\n    validator,\n  } = options;\n\n  const successTypes = Array.isArray(successType) ? successType : [successType];\n\n  return new Promise<void>((resolve, reject) => {\n    const timeout = setTimeout(() => {\n      cleanup();\n      reject(new Error(\n        `Timeout waiting for session message (${successTypes.join('|')})${sessionId ? ` for session ${sessionId}` : ''}`\n      ));\n    }, timeoutMs);\n\n    const messageHandler = (event: MessageEvent<unknown>) => {\n      const msg = asSessionMessage(event.data);\n\n      // Skip if message doesn't have a type\n      if (!msg) return;\n\n      // Check if sessionId matches (if specified)\n      if (sessionId && msg.sessionId !== sessionId) {\n        return;\n      }\n\n      // Check for error type\n      if (errorType && msg.type === errorType) {\n        cleanup();\n        const error = msg.error || 'Unknown error';\n        reject(new Error(`Session message error: ${error}`));\n        return;\n      }\n\n      // Check for success type\n      if (successTypes.includes(msg.type)) {\n        // Run custom validator if provided\n        if (validator) {\n          try {\n            const shouldResolve = validator(msg);\n            if (!shouldResolve) {\n              return; // Validator said to ignore this message\n            }\n          } catch (err) {\n            cleanup();\n            reject(err);\n            return;\n          }\n        }\n\n        cleanup();\n        resolve();\n      }\n    };\n\n    const cleanup = () => {\n      clearTimeout(timeout);\n      worker.removeEventListener('message', messageHandler);\n    };\n\n    worker.addEventListener('message', messageHandler);\n  });\n}\n\n/**\n * Wait for the worker to acknowledge successful attachment of the WrapKeySeed port.\n * This provides early detection of attach failures instead of only seeing late WASM errors.\n *\n * @param worker - The worker that should send the ACK\n * @param sessionId - The session ID to match\n * @param timeoutMs - How long to wait before rejecting (default: 2000ms)\n * @returns Promise that resolves on success ACK, rejects on error or timeout\n */\nexport function waitForWrapKeyPortAttach(\n  worker: Worker,\n  sessionId: string,\n  timeoutMs: number = 2000\n): Promise<void> {\n  return waitForSessionMessage(worker, {\n    successType: WorkerControlMessage.ATTACH_WRAP_KEY_SEED_PORT_OK,\n    errorType: WorkerControlMessage.ATTACH_WRAP_KEY_SEED_PORT_ERROR,\n    sessionId,\n    timeoutMs,\n  });\n}\n"],"mappings":";;;AAqDA,SAAS,iBAAiB,KAAqC;AAC7D,KAAI,CAAC,SAAS,KAAM,QAAO;AAC3B,KAAI,OAAO,IAAI,SAAS,SAAU,QAAO;AACzC,KAAI,IAAI,aAAa,QAAQ,OAAO,IAAI,cAAc,SAAU,QAAO;AACvE,KAAI,IAAI,SAAS,QAAQ,OAAO,IAAI,UAAU,SAAU,QAAO;AAC/D,QAAO;;;;;AAMT,SAAgB,6BAA6B,KAAiD;AAC5F,KAAI,CAAC,SAAS,QAAQ,OAAO,IAAI,SAAS,SACxC,QAAO;AAGT,SAAQ,IAAI,MAAZ;EACE,KAAKA,mDAAqB,6BACxB,QAAO,OAAO,IAAI,cAAc;EAClC,KAAKA,mDAAqB,gCACxB,QAAO,OAAO,IAAI,cAAc,YAAY,OAAO,IAAI,UAAU;EACnE,KAAKA,mDAAqB,aACxB,QAAO,OAAO,IAAI,UAAU;EAC9B,QACE,QAAO;;;AAIb,SAAS,SAAS,OAAkD;AAClE,QAAO,OAAO,UAAU,YAAY,UAAU;;;;;;;;;;AAahD,SAAgB,sBACd,QACA,SAYe;CACf,MAAM,EACJ,aACA,WACA,WACA,YAAY,KACZ,cACE;CAEJ,MAAM,eAAe,MAAM,QAAQ,eAAe,cAAc,CAAC;AAEjE,QAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,UAAU,iBAAiB;AAC/B;AACA,0BAAO,IAAI,MACT,wCAAwC,aAAa,KAAK,KAAK,GAAG,YAAY,gBAAgB,cAAc;KAE7G;EAEH,MAAM,kBAAkB,UAAiC;GACvD,MAAM,MAAM,iBAAiB,MAAM;AAGnC,OAAI,CAAC,IAAK;AAGV,OAAI,aAAa,IAAI,cAAc,UACjC;AAIF,OAAI,aAAa,IAAI,SAAS,WAAW;AACvC;IACA,MAAM,QAAQ,IAAI,SAAS;AAC3B,2BAAO,IAAI,MAAM,0BAA0B;AAC3C;;AAIF,OAAI,aAAa,SAAS,IAAI,OAAO;AAEnC,QAAI,UACF,KAAI;KACF,MAAM,gBAAgB,UAAU;AAChC,SAAI,CAAC,cACH;aAEK,KAAK;AACZ;AACA,YAAO;AACP;;AAIJ;AACA;;;EAIJ,MAAM,gBAAgB;AACpB,gBAAa;AACb,UAAO,oBAAoB,WAAW;;AAGxC,SAAO,iBAAiB,WAAW;;;;;;;;;;;;AAavC,SAAgB,yBACd,QACA,WACA,YAAoB,KACL;AACf,QAAO,sBAAsB,QAAQ;EACnC,aAAaA,mDAAqB;EAClC,WAAWA,mDAAqB;EAChC;EACA"}

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/common.js

@@ -0,0 +1,58 @@
+const require_validation = require('../../../../../utils/validation.js');
+const require_errors = require('../../../../../utils/errors.js');
+const require_types = require('../types.js');
+
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/common.ts
+function parseTransactionSummary(summaryData) {
+	if (!summaryData) return {};
+	if (require_validation.isString(summaryData)) try {
+		const parsed = JSON.parse(summaryData);
+		return require_validation.isObject(parsed) ? parsed : {};
+	} catch (parseError) {
+		console.warn("[SignerWorkerManager]: Failed to parse summary string:", parseError);
+		return {};
+	}
+	return require_validation.isObject(summaryData) ? summaryData : {};
+}
+function sanitizeForPostMessage(data) {
+	if (data == null) return data;
+	if (Array.isArray(data)) return data.map((v) => v);
+	if (require_validation.isObject(data)) {
+		const src = data;
+		const out = {};
+		for (const key of Object.keys(src)) {
+			if (key === "_confirmHandle") continue;
+			const value = src[key];
+			if (require_validation.isFunction(value)) continue;
+			out[key] = value;
+		}
+		return out;
+	}
+	return data;
+}
+const ERROR_MESSAGES = {
+	cancelled: "User cancelled secure confirm request",
+	collectCredentialsFailed: "Failed to collect credentials",
+	nearRpcFailed: "Failed to fetch NEAR data"
+};
+function sendConfirmResponse(worker, response) {
+	const sanitized = sanitizeForPostMessage(response);
+	worker.postMessage({
+		type: require_types.SecureConfirmMessageType.USER_PASSKEY_CONFIRM_RESPONSE,
+		data: sanitized
+	});
+}
+function isUserCancelledSecureConfirm(error) {
+	return require_errors.isTouchIdCancellationError(error) || (() => {
+		const e = require_errors.toError(error);
+		return e?.name === "NotAllowedError" || e?.name === "AbortError";
+	})();
+}
+
+//#endregion
+exports.ERROR_MESSAGES = ERROR_MESSAGES;
+exports.isUserCancelledSecureConfirm = isUserCancelledSecureConfirm;
+exports.parseTransactionSummary = parseTransactionSummary;
+exports.sanitizeForPostMessage = sanitizeForPostMessage;
+exports.sendConfirmResponse = sendConfirmResponse;
+//# sourceMappingURL=common.js.map

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","names":["isString","isObject","out: Record<string, unknown>","isFunction","SecureConfirmMessageType","isTouchIdCancellationError","toError"],"sources":["../../../../../../../../../src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/common.ts"],"sourcesContent":["import type { TransactionSummary, SecureConfirmDecision } from '../types';\nimport { SecureConfirmMessageType } from '../types';\nimport { isObject, isFunction, isString } from '@/utils/validation';\nimport { toError, isTouchIdCancellationError } from '../../../../../utils/errors';\n\nexport function parseTransactionSummary(summaryData: unknown): TransactionSummary {\n  if (!summaryData) return {};\n  if (isString(summaryData)) {\n    try {\n      const parsed = JSON.parse(summaryData) as unknown;\n      return isObject(parsed) ? (parsed as TransactionSummary) : {};\n    } catch (parseError) {\n      console.warn('[SignerWorkerManager]: Failed to parse summary string:', parseError);\n      return {};\n    }\n  }\n  return isObject(summaryData) ? (summaryData as TransactionSummary) : {};\n}\n\n// ===== Utility: postMessage sanitization (exported in case flows need to respond directly) =====\nexport type NonFunctionKeys<T> = { [K in keyof T]: T[K] extends Function ? never : K }[keyof T];\n\nexport type ShallowPostMessageSafe<T> = T extends object\n  ? Omit<Pick<T, NonFunctionKeys<T>>, '_confirmHandle'>\n  : T;\n\nexport function sanitizeForPostMessage<T>(data: T): ShallowPostMessageSafe<T> {\n  if (data == null) return data as ShallowPostMessageSafe<T>;\n  if (Array.isArray(data)) return data.map((v) => v) as unknown as ShallowPostMessageSafe<T>;\n  if (isObject(data)) {\n    const src = data as Record<string, unknown>;\n    const out: Record<string, unknown> = {};\n    for (const key of Object.keys(src)) {\n      if (key === '_confirmHandle') continue;\n      const value = src[key];\n      if (isFunction(value)) continue;\n      out[key] = value;\n    }\n    return out as ShallowPostMessageSafe<T>;\n  }\n  return data as ShallowPostMessageSafe<T>;\n}\n\n// ===== Shared worker response + UI close helpers =====\nexport const ERROR_MESSAGES = {\n  cancelled: 'User cancelled secure confirm request',\n  collectCredentialsFailed: 'Failed to collect credentials',\n  nearRpcFailed: 'Failed to fetch NEAR data',\n} as const;\n\nexport function sendConfirmResponse(worker: Worker, response: SecureConfirmDecision) {\n  const sanitized = sanitizeForPostMessage(response);\n  worker.postMessage({ type: SecureConfirmMessageType.USER_PASSKEY_CONFIRM_RESPONSE, data: sanitized });\n}\n\nexport function isUserCancelledSecureConfirm(error: unknown): boolean {\n  return (\n    isTouchIdCancellationError(error) ||\n    (() => {\n      const e = toError(error);\n      return e?.name === 'NotAllowedError' || e?.name === 'AbortError';\n    })()\n  );\n}\n\n"],"mappings":";;;;;AAKA,SAAgB,wBAAwB,aAA0C;AAChF,KAAI,CAAC,YAAa,QAAO;AACzB,KAAIA,4BAAS,aACX,KAAI;EACF,MAAM,SAAS,KAAK,MAAM;AAC1B,SAAOC,4BAAS,UAAW,SAAgC;UACpD,YAAY;AACnB,UAAQ,KAAK,0DAA0D;AACvE,SAAO;;AAGX,QAAOA,4BAAS,eAAgB,cAAqC;;AAUvE,SAAgB,uBAA0B,MAAoC;AAC5E,KAAI,QAAQ,KAAM,QAAO;AACzB,KAAI,MAAM,QAAQ,MAAO,QAAO,KAAK,KAAK,MAAM;AAChD,KAAIA,4BAAS,OAAO;EAClB,MAAM,MAAM;EACZ,MAAMC,MAA+B;AACrC,OAAK,MAAM,OAAO,OAAO,KAAK,MAAM;AAClC,OAAI,QAAQ,iBAAkB;GAC9B,MAAM,QAAQ,IAAI;AAClB,OAAIC,8BAAW,OAAQ;AACvB,OAAI,OAAO;;AAEb,SAAO;;AAET,QAAO;;AAIT,MAAa,iBAAiB;CAC5B,WAAW;CACX,0BAA0B;CAC1B,eAAe;;AAGjB,SAAgB,oBAAoB,QAAgB,UAAiC;CACnF,MAAM,YAAY,uBAAuB;AACzC,QAAO,YAAY;EAAE,MAAMC,uCAAyB;EAA+B,MAAM;;;AAG3F,SAAgB,6BAA6B,OAAyB;AACpE,QACEC,0CAA2B,iBACpB;EACL,MAAM,IAAIC,uBAAQ;AAClB,SAAO,GAAG,SAAS,qBAAqB,GAAG,SAAS"}

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/createAdapters.js

@@ -0,0 +1,49 @@
+const require_near = require('./near.js');
+const require_vrf = require('./vrf.js');
+const require_ui = require('./ui.js');
+const require_webauthn = require('./webauthn.js');
+
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/createAdapters.ts
+function getVrfWorkerManager(ctx) {
+	const vrfWorkerManager = ctx.vrfWorkerManager;
+	if (!vrfWorkerManager) throw new Error("VrfWorkerManager not available");
+	return vrfWorkerManager;
+}
+function createConfirmTxFlowAdapters(ctx) {
+	return {
+		near: {
+			fetchNearContext: (opts) => require_near.fetchNearContext(ctx, opts),
+			releaseReservedNonces: (nonces) => require_near.releaseReservedNonces(ctx, nonces)
+		},
+		vrf: {
+			getRpId: () => ctx.touchIdPrompt.getRpId(),
+			maybeRefreshVrfChallenge: (request, nearAccountId) => require_vrf.maybeRefreshVrfChallenge(ctx, request, nearAccountId),
+			generateVrfKeypairBootstrap: (args) => getVrfWorkerManager(ctx).generateVrfKeypairBootstrap(args),
+			generateVrfChallengeForSession: (inputData, sessionId) => getVrfWorkerManager(ctx).generateVrfChallengeForSession(inputData, sessionId),
+			mintSessionKeysAndSendToSigner: (args) => getVrfWorkerManager(ctx).mintSessionKeysAndSendToSigner(args),
+			dispenseSessionKey: (args) => getVrfWorkerManager(ctx).dispenseSessionKey(args),
+			prepareDecryptSession: (args) => getVrfWorkerManager(ctx).prepareDecryptSession(args),
+			requestRegistrationCredentialConfirmation: (args) => getVrfWorkerManager(ctx).requestRegistrationCredentialConfirmation(args),
+			confirmAndDeriveDevice2RegistrationSession: (args) => getVrfWorkerManager(ctx).confirmAndDeriveDevice2RegistrationSession(args),
+			checkVrfStatus: () => getVrfWorkerManager(ctx).checkVrfStatus()
+		},
+		webauthn: {
+			collectAuthenticationCredentialWithPRF: (args) => require_webauthn.collectAuthenticationCredentialWithPRF({
+				ctx,
+				...args
+			}),
+			createRegistrationCredential: (args) => ctx.touchIdPrompt.generateRegistrationCredentialsInternal(args)
+		},
+		ui: {
+			renderConfirmUI: (args) => require_ui.renderConfirmUI({
+				ctx,
+				...args
+			}),
+			closeModalSafely: require_ui.closeModalSafely
+		}
+	};
+}
+
+//#endregion
+exports.createConfirmTxFlowAdapters = createConfirmTxFlowAdapters;
+//# sourceMappingURL=createAdapters.js.map

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/createAdapters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAdapters.js","names":["fetchNearContext","releaseReservedNonces","maybeRefreshVrfChallenge","collectAuthenticationCredentialWithPRF","renderConfirmUI"],"sources":["../../../../../../../../../src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/createAdapters.ts"],"sourcesContent":["import type { VrfWorkerManagerContext } from '../../';\nimport type { ConfirmTxFlowAdapters } from './interfaces';\nimport { fetchNearContext, releaseReservedNonces } from './near';\nimport { maybeRefreshVrfChallenge } from './vrf';\nimport { collectAuthenticationCredentialWithPRF } from './webauthn';\nimport { closeModalSafely, renderConfirmUI } from './ui';\n\nfunction getVrfWorkerManager(ctx: VrfWorkerManagerContext) {\n  const vrfWorkerManager = ctx.vrfWorkerManager;\n  if (!vrfWorkerManager) {\n    throw new Error('VrfWorkerManager not available');\n  }\n  return vrfWorkerManager;\n}\n\nexport function createConfirmTxFlowAdapters(ctx: VrfWorkerManagerContext): ConfirmTxFlowAdapters {\n  return {\n    near: {\n      fetchNearContext: (opts) => fetchNearContext(ctx, opts),\n      releaseReservedNonces: (nonces) => releaseReservedNonces(ctx, nonces),\n    },\n    vrf: {\n      getRpId: () => ctx.touchIdPrompt.getRpId(),\n      maybeRefreshVrfChallenge: (request, nearAccountId) => maybeRefreshVrfChallenge(ctx, request, nearAccountId),\n      generateVrfKeypairBootstrap: (args) => getVrfWorkerManager(ctx).generateVrfKeypairBootstrap(args),\n      generateVrfChallengeForSession: (inputData, sessionId) => getVrfWorkerManager(ctx).generateVrfChallengeForSession(inputData, sessionId),\n      mintSessionKeysAndSendToSigner: (args) => getVrfWorkerManager(ctx).mintSessionKeysAndSendToSigner(args),\n      dispenseSessionKey: (args) => getVrfWorkerManager(ctx).dispenseSessionKey(args),\n      prepareDecryptSession: (args) => getVrfWorkerManager(ctx).prepareDecryptSession(args),\n      requestRegistrationCredentialConfirmation: (args) => getVrfWorkerManager(ctx).requestRegistrationCredentialConfirmation(args),\n      confirmAndDeriveDevice2RegistrationSession: (args) => getVrfWorkerManager(ctx).confirmAndDeriveDevice2RegistrationSession(args),\n      checkVrfStatus: () => getVrfWorkerManager(ctx).checkVrfStatus(),\n    },\n    webauthn: {\n      collectAuthenticationCredentialWithPRF: (args) => collectAuthenticationCredentialWithPRF({ ctx, ...args }),\n      createRegistrationCredential: (args) => ctx.touchIdPrompt.generateRegistrationCredentialsInternal(args),\n    },\n    ui: {\n      renderConfirmUI: (args) => renderConfirmUI({ ctx, ...args }),\n      closeModalSafely,\n    },\n  };\n}\n\n"],"mappings":";;;;;;AAOA,SAAS,oBAAoB,KAA8B;CACzD,MAAM,mBAAmB,IAAI;AAC7B,KAAI,CAAC,iBACH,OAAM,IAAI,MAAM;AAElB,QAAO;;AAGT,SAAgB,4BAA4B,KAAqD;AAC/F,QAAO;EACL,MAAM;GACJ,mBAAmB,SAASA,8BAAiB,KAAK;GAClD,wBAAwB,WAAWC,mCAAsB,KAAK;;EAEhE,KAAK;GACH,eAAe,IAAI,cAAc;GACjC,2BAA2B,SAAS,kBAAkBC,qCAAyB,KAAK,SAAS;GAC7F,8BAA8B,SAAS,oBAAoB,KAAK,4BAA4B;GAC5F,iCAAiC,WAAW,cAAc,oBAAoB,KAAK,+BAA+B,WAAW;GAC7H,iCAAiC,SAAS,oBAAoB,KAAK,+BAA+B;GAClG,qBAAqB,SAAS,oBAAoB,KAAK,mBAAmB;GAC1E,wBAAwB,SAAS,oBAAoB,KAAK,sBAAsB;GAChF,4CAA4C,SAAS,oBAAoB,KAAK,0CAA0C;GACxH,6CAA6C,SAAS,oBAAoB,KAAK,2CAA2C;GAC1H,sBAAsB,oBAAoB,KAAK;;EAEjD,UAAU;GACR,yCAAyC,SAASC,wDAAuC;IAAE;IAAK,GAAG;;GACnG,+BAA+B,SAAS,IAAI,cAAc,wCAAwC;;EAEpG,IAAI;GACF,kBAAkB,SAASC,2BAAgB;IAAE;IAAK,GAAG;;GACrD"}

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/near.js

@@ -0,0 +1,51 @@
+const require_errors = require('../../../../../utils/errors.js');
+
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/near.ts
+async function fetchNearContext(ctx, opts) {
+	try {
+		const transactionContext = await ctx.nonceManager.getNonceBlockHashAndHeight(ctx.nearClient);
+		const txCount = opts.txCount || 1;
+		let reservedNonces;
+		if (opts.reserveNonces) try {
+			reservedNonces = ctx.nonceManager.reserveNonces(txCount);
+			transactionContext.nextNonce = reservedNonces[0];
+		} catch (error) {}
+		return {
+			transactionContext,
+			reservedNonces
+		};
+	} catch (error) {
+		try {
+			const block = await ctx.nearClient.viewBlock({ finality: "final" });
+			const txBlockHeight = String(block?.header?.height ?? "");
+			const txBlockHash = String(block?.header?.hash ?? "");
+			const fallback = {
+				nearPublicKeyStr: "",
+				accessKeyInfo: {
+					nonce: 0,
+					permission: "FullAccess",
+					block_height: 0,
+					block_hash: ""
+				},
+				nextNonce: "0",
+				txBlockHeight,
+				txBlockHash
+			};
+			return { transactionContext: fallback };
+		} catch (e) {
+			return {
+				transactionContext: null,
+				error: "NEAR_RPC_FAILED",
+				details: require_errors.errorMessage(e) || require_errors.errorMessage(error)
+			};
+		}
+	}
+}
+function releaseReservedNonces(ctx, nonces) {
+	nonces?.forEach((n) => ctx.nonceManager.releaseNonce(n));
+}
+
+//#endregion
+exports.fetchNearContext = fetchNearContext;
+exports.releaseReservedNonces = releaseReservedNonces;
+//# sourceMappingURL=near.js.map

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/near.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"near.js","names":["reservedNonces: string[] | undefined","fallback: TransactionContext","errorMessage"],"sources":["../../../../../../../../../src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/near.ts"],"sourcesContent":["import type { VrfWorkerManagerContext } from '../../';\nimport { TransactionContext } from '../../../../types';\nimport type { BlockReference, AccessKeyView } from '@near-js/types';\nimport { errorMessage } from '../../../../../utils/errors';\n\nexport async function fetchNearContext(\n  ctx: VrfWorkerManagerContext,\n  opts: { nearAccountId: string; txCount: number; reserveNonces: boolean },\n): Promise<{\n  transactionContext: TransactionContext | null;\n  error?: string;\n  details?: string;\n  reservedNonces?: string[];\n}> {\n  try {\n    // Prefer NonceManager when initialized (signing flows)\n    // Use cached transaction context if fresh; avoid forcing a refresh here.\n    // JIT refresh later will force a new block height for the VRF challenge.\n    const transactionContext = await ctx.nonceManager.getNonceBlockHashAndHeight(ctx.nearClient);\n\n    const txCount = opts.txCount || 1;\n    let reservedNonces: string[] | undefined;\n    if (opts.reserveNonces) {\n      try {\n        reservedNonces = ctx.nonceManager.reserveNonces(txCount);\n        // Provide the first reserved nonce to the worker context; worker handles per-tx assignment\n        transactionContext.nextNonce = reservedNonces[0];\n      } catch (error) {\n        // Continue with existing nextNonce; worker may auto-increment where appropriate\n      }\n    }\n\n    return { transactionContext, reservedNonces };\n  } catch (error) {\n    // Registration or pre-login flows may not have NonceManager initialized.\n    // Fallback: fetch latest block info directly; nonces are not required for registration/link flows.\n    try {\n      const block = await ctx.nearClient.viewBlock({ finality: 'final' } as BlockReference);\n      const txBlockHeight = String(block?.header?.height ?? '');\n      const txBlockHash = String(block?.header?.hash ?? '');\n      const fallback: TransactionContext = {\n        nearPublicKeyStr: '', // not needed for registration VRF challenge\n        accessKeyInfo: ({\n          nonce: 0,\n          permission: 'FullAccess',\n          block_height: 0,\n          block_hash: ''\n        } as unknown) as AccessKeyView, // minimal shape; not used in registration/link flows\n        nextNonce: '0',\n        txBlockHeight,\n        txBlockHash,\n      } as TransactionContext;\n      return { transactionContext: fallback };\n    } catch (e) {\n      return {\n        transactionContext: null,\n        error: 'NEAR_RPC_FAILED',\n        details: errorMessage(e) || errorMessage(error),\n      };\n    }\n  }\n}\n\nexport function releaseReservedNonces(ctx: VrfWorkerManagerContext, nonces?: string[]) {\n  nonces?.forEach((n) => ctx.nonceManager.releaseNonce(n));\n}\n\n"],"mappings":";;;AAKA,eAAsB,iBACpB,KACA,MAMC;AACD,KAAI;EAIF,MAAM,qBAAqB,MAAM,IAAI,aAAa,2BAA2B,IAAI;EAEjF,MAAM,UAAU,KAAK,WAAW;EAChC,IAAIA;AACJ,MAAI,KAAK,cACP,KAAI;AACF,oBAAiB,IAAI,aAAa,cAAc;AAEhD,sBAAmB,YAAY,eAAe;WACvC,OAAO;AAKlB,SAAO;GAAE;GAAoB;;UACtB,OAAO;AAGd,MAAI;GACF,MAAM,QAAQ,MAAM,IAAI,WAAW,UAAU,EAAE,UAAU;GACzD,MAAM,gBAAgB,OAAO,OAAO,QAAQ,UAAU;GACtD,MAAM,cAAc,OAAO,OAAO,QAAQ,QAAQ;GAClD,MAAMC,WAA+B;IACnC,kBAAkB;IAClB,eAAgB;KACd,OAAO;KACP,YAAY;KACZ,cAAc;KACd,YAAY;;IAEd,WAAW;IACX;IACA;;AAEF,UAAO,EAAE,oBAAoB;WACtB,GAAG;AACV,UAAO;IACL,oBAAoB;IACpB,OAAO;IACP,SAASC,4BAAa,MAAMA,4BAAa;;;;;AAMjD,SAAgB,sBAAsB,KAA8B,QAAmB;AACrF,SAAQ,SAAS,MAAM,IAAI,aAAa,aAAa"}

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/requestAdapter.js

@@ -0,0 +1,31 @@
+const require_validation = require('../../../../../utils/validation.js');
+const require_types = require('../types.js');
+
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/requestAdapter.ts
+/**
+* Validates secure-confirm requests (V2 only).
+* This deliberately does not accept JSON strings or shorthand/legacy shapes.
+*/
+function validateSecureConfirmRequest(input) {
+	if (typeof input === "string") throw new Error("Invalid secure confirm request: expected an object (JSON strings are not supported)");
+	if (!require_validation.isObject(input)) throw new Error("parsed is not an object");
+	const p = input;
+	if (!require_validation.isString(p.requestId) || !p.requestId) throw new Error("missing requestId");
+	if (!require_validation.isString(p.type) || !p.type) throw new Error("missing type");
+	if (p.summary === void 0 || p.summary === null) throw new Error("missing summary");
+	if (p.payload === void 0 || p.payload === null) throw new Error("missing payload");
+	return input;
+}
+function assertNoForbiddenMainThreadSigningSecrets(request) {
+	if (request.type !== require_types.SecureConfirmationType.SIGN_TRANSACTION && request.type !== require_types.SecureConfirmationType.SIGN_NEP413_MESSAGE) return;
+	const payload = request.payload || {};
+	if (payload.prfOutput !== void 0) throw new Error("Invalid secure confirm request: forbidden signing payload field prfOutput");
+	if (payload.wrapKeySeed !== void 0) throw new Error("Invalid secure confirm request: forbidden signing payload field wrapKeySeed");
+	if (payload.wrapKeySalt !== void 0) throw new Error("Invalid secure confirm request: forbidden signing payload field wrapKeySalt");
+	if (payload.vrf_sk !== void 0) throw new Error("Invalid secure confirm request: forbidden signing payload field vrf_sk");
+}
+
+//#endregion
+exports.assertNoForbiddenMainThreadSigningSecrets = assertNoForbiddenMainThreadSigningSecrets;
+exports.validateSecureConfirmRequest = validateSecureConfirmRequest;
+//# sourceMappingURL=requestAdapter.js.map

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/requestAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestAdapter.js","names":["isObject","isString","SecureConfirmationType","payload: any"],"sources":["../../../../../../../../../src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/requestAdapter.ts"],"sourcesContent":["import type { SecureConfirmRequest } from '../types';\nimport { SecureConfirmationType } from '../types';\nimport { isObject, isString } from '@/utils/validation';\n\n/**\n * Validates secure-confirm requests (V2 only).\n * This deliberately does not accept JSON strings or shorthand/legacy shapes.\n */\nexport function validateSecureConfirmRequest(input: unknown): SecureConfirmRequest {\n  if (typeof input === 'string') {\n    throw new Error('Invalid secure confirm request: expected an object (JSON strings are not supported)');\n  }\n  if (!isObject(input)) throw new Error('parsed is not an object');\n  const p = input as {\n    requestId?: unknown;\n    type?: unknown;\n    summary?: unknown;\n    payload?: unknown;\n  };\n  if (!isString(p.requestId) || !p.requestId) throw new Error('missing requestId');\n  if (!isString(p.type) || !p.type) throw new Error('missing type');\n  if (p.summary === undefined || p.summary === null) throw new Error('missing summary');\n  if (p.payload === undefined || p.payload === null) throw new Error('missing payload');\n  return input as unknown as SecureConfirmRequest;\n}\n\nexport function assertNoForbiddenMainThreadSigningSecrets(request: SecureConfirmRequest): void {\n  if (\n    request.type !== SecureConfirmationType.SIGN_TRANSACTION\n    && request.type !== SecureConfirmationType.SIGN_NEP413_MESSAGE\n  ) {\n    return;\n  }\n\n  const payload: any = (request as any).payload || {};\n  if (payload.prfOutput !== undefined) {\n    throw new Error('Invalid secure confirm request: forbidden signing payload field prfOutput');\n  }\n  if (payload.wrapKeySeed !== undefined) {\n    throw new Error('Invalid secure confirm request: forbidden signing payload field wrapKeySeed');\n  }\n  if (payload.wrapKeySalt !== undefined) {\n    throw new Error('Invalid secure confirm request: forbidden signing payload field wrapKeySalt');\n  }\n  if (payload.vrf_sk !== undefined) {\n    throw new Error('Invalid secure confirm request: forbidden signing payload field vrf_sk');\n  }\n}\n"],"mappings":";;;;;;;;AAQA,SAAgB,6BAA6B,OAAsC;AACjF,KAAI,OAAO,UAAU,SACnB,OAAM,IAAI,MAAM;AAElB,KAAI,CAACA,4BAAS,OAAQ,OAAM,IAAI,MAAM;CACtC,MAAM,IAAI;AAMV,KAAI,CAACC,4BAAS,EAAE,cAAc,CAAC,EAAE,UAAW,OAAM,IAAI,MAAM;AAC5D,KAAI,CAACA,4BAAS,EAAE,SAAS,CAAC,EAAE,KAAM,OAAM,IAAI,MAAM;AAClD,KAAI,EAAE,YAAY,UAAa,EAAE,YAAY,KAAM,OAAM,IAAI,MAAM;AACnE,KAAI,EAAE,YAAY,UAAa,EAAE,YAAY,KAAM,OAAM,IAAI,MAAM;AACnE,QAAO;;AAGT,SAAgB,0CAA0C,SAAqC;AAC7F,KACE,QAAQ,SAASC,qCAAuB,oBACrC,QAAQ,SAASA,qCAAuB,oBAE3C;CAGF,MAAMC,UAAgB,QAAgB,WAAW;AACjD,KAAI,QAAQ,cAAc,OACxB,OAAM,IAAI,MAAM;AAElB,KAAI,QAAQ,gBAAgB,OAC1B,OAAM,IAAI,MAAM;AAElB,KAAI,QAAQ,gBAAgB,OAC1B,OAAM,IAAI,MAAM;AAElB,KAAI,QAAQ,WAAW,OACrB,OAAM,IAAI,MAAM"}

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/requestHelpers.js

@@ -0,0 +1,46 @@
+const require_types = require('../types.js');
+
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/requestHelpers.ts
+function getNearAccountId(request) {
+	switch (request.type) {
+		case require_types.SecureConfirmationType.SIGN_TRANSACTION: return getSignTransactionPayload(request).rpcCall.nearAccountId;
+		case require_types.SecureConfirmationType.SIGN_NEP413_MESSAGE: return request.payload.nearAccountId;
+		case require_types.SecureConfirmationType.REGISTER_ACCOUNT:
+		case require_types.SecureConfirmationType.LINK_DEVICE: return getRegisterAccountPayload(request).nearAccountId;
+		case require_types.SecureConfirmationType.DECRYPT_PRIVATE_KEY_WITH_PRF: {
+			const p = request.payload;
+			return p?.nearAccountId || "";
+		}
+		case require_types.SecureConfirmationType.SHOW_SECURE_PRIVATE_KEY_UI: {
+			const p = request.payload;
+			return p?.nearAccountId || "";
+		}
+		default: return "";
+	}
+}
+function getTxCount(request) {
+	return request.type === require_types.SecureConfirmationType.SIGN_TRANSACTION ? getSignTransactionPayload(request).txSigningRequests?.length || 1 : 1;
+}
+function getIntentDigest(request) {
+	if (request.type === require_types.SecureConfirmationType.SIGN_TRANSACTION) {
+		const p = request?.payload;
+		return p?.intentDigest;
+	}
+	return request?.intentDigest;
+}
+function getSignTransactionPayload(request) {
+	if (request.type !== require_types.SecureConfirmationType.SIGN_TRANSACTION) throw new Error(`Expected SIGN_TRANSACTION request, got ${request.type}`);
+	return request.payload;
+}
+function getRegisterAccountPayload(request) {
+	if (request.type !== require_types.SecureConfirmationType.REGISTER_ACCOUNT && request.type !== require_types.SecureConfirmationType.LINK_DEVICE) throw new Error(`Expected REGISTER_ACCOUNT or LINK_DEVICE request, got ${request.type}`);
+	return request.payload;
+}
+
+//#endregion
+exports.getIntentDigest = getIntentDigest;
+exports.getNearAccountId = getNearAccountId;
+exports.getRegisterAccountPayload = getRegisterAccountPayload;
+exports.getSignTransactionPayload = getSignTransactionPayload;
+exports.getTxCount = getTxCount;
+//# sourceMappingURL=requestHelpers.js.map

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/requestHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestHelpers.js","names":["SecureConfirmationType"],"sources":["../../../../../../../../../src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/requestHelpers.ts"],"sourcesContent":["import {\n  SecureConfirmRequest,\n  SecureConfirmationType,\n  SignTransactionPayload,\n  RegisterAccountPayload,\n  SignNep413Payload,\n} from '../types';\n\nexport function getNearAccountId(request: SecureConfirmRequest): string {\n  switch (request.type) {\n    case SecureConfirmationType.SIGN_TRANSACTION:\n      return getSignTransactionPayload(request).rpcCall.nearAccountId;\n    case SecureConfirmationType.SIGN_NEP413_MESSAGE:\n      return (request.payload as SignNep413Payload).nearAccountId;\n    case SecureConfirmationType.REGISTER_ACCOUNT:\n    case SecureConfirmationType.LINK_DEVICE:\n      return getRegisterAccountPayload(request).nearAccountId;\n    case SecureConfirmationType.DECRYPT_PRIVATE_KEY_WITH_PRF: {\n      const p = request.payload as { nearAccountId?: string };\n      return p?.nearAccountId || '';\n    }\n    case SecureConfirmationType.SHOW_SECURE_PRIVATE_KEY_UI: {\n      const p = request.payload as { nearAccountId?: string };\n      return p?.nearAccountId || '';\n    }\n    default:\n      return '';\n  }\n}\n\nexport function getTxCount(request: SecureConfirmRequest): number {\n  return request.type === SecureConfirmationType.SIGN_TRANSACTION\n    ? (getSignTransactionPayload(request).txSigningRequests?.length || 1)\n    : 1;\n}\n\nexport function getIntentDigest(request: SecureConfirmRequest): string | undefined {\n  if (request.type === SecureConfirmationType.SIGN_TRANSACTION) {\n    const p = request?.payload as Partial<SignTransactionPayload> | undefined;\n    return p?.intentDigest;\n  }\n  return request?.intentDigest;\n}\n\nexport function getSignTransactionPayload(request: SecureConfirmRequest): SignTransactionPayload {\n  if (request.type !== SecureConfirmationType.SIGN_TRANSACTION) {\n    throw new Error(`Expected SIGN_TRANSACTION request, got ${request.type}`);\n  }\n  return request.payload as SignTransactionPayload;\n}\n\nexport function getRegisterAccountPayload(request: SecureConfirmRequest): RegisterAccountPayload {\n  if (request.type !== SecureConfirmationType.REGISTER_ACCOUNT && request.type !== SecureConfirmationType.LINK_DEVICE) {\n    throw new Error(`Expected REGISTER_ACCOUNT or LINK_DEVICE request, got ${request.type}`);\n  }\n  return request.payload as RegisterAccountPayload;\n}\n\n"],"mappings":";;;AAQA,SAAgB,iBAAiB,SAAuC;AACtE,SAAQ,QAAQ,MAAhB;EACE,KAAKA,qCAAuB,iBAC1B,QAAO,0BAA0B,SAAS,QAAQ;EACpD,KAAKA,qCAAuB,oBAC1B,QAAQ,QAAQ,QAA8B;EAChD,KAAKA,qCAAuB;EAC5B,KAAKA,qCAAuB,YAC1B,QAAO,0BAA0B,SAAS;EAC5C,KAAKA,qCAAuB,8BAA8B;GACxD,MAAM,IAAI,QAAQ;AAClB,UAAO,GAAG,iBAAiB;;EAE7B,KAAKA,qCAAuB,4BAA4B;GACtD,MAAM,IAAI,QAAQ;AAClB,UAAO,GAAG,iBAAiB;;EAE7B,QACE,QAAO;;;AAIb,SAAgB,WAAW,SAAuC;AAChE,QAAO,QAAQ,SAASA,qCAAuB,mBAC1C,0BAA0B,SAAS,mBAAmB,UAAU,IACjE;;AAGN,SAAgB,gBAAgB,SAAmD;AACjF,KAAI,QAAQ,SAASA,qCAAuB,kBAAkB;EAC5D,MAAM,IAAI,SAAS;AACnB,SAAO,GAAG;;AAEZ,QAAO,SAAS;;AAGlB,SAAgB,0BAA0B,SAAuD;AAC/F,KAAI,QAAQ,SAASA,qCAAuB,iBAC1C,OAAM,IAAI,MAAM,0CAA0C,QAAQ;AAEpE,QAAO,QAAQ;;AAGjB,SAAgB,0BAA0B,SAAuD;AAC/F,KAAI,QAAQ,SAASA,qCAAuB,oBAAoB,QAAQ,SAASA,qCAAuB,YACtG,OAAM,IAAI,MAAM,yDAAyD,QAAQ;AAEnF,QAAO,QAAQ"}

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/session.js

@@ -0,0 +1,53 @@
+const require_common = require('./common.js');
+
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/session.ts
+function createConfirmSession({ adapters, worker, request, confirmationConfig, transactionSummary }) {
+	let reservedNonces;
+	let confirmHandle;
+	const setReservedNonces = (nonces) => {
+		reservedNonces = nonces;
+	};
+	const updateUI = (props) => {
+		confirmHandle?.update?.(props);
+	};
+	const promptUser = async ({ vrfChallenge }) => {
+		const { confirmed, confirmHandle: handle, error } = await adapters.ui.renderConfirmUI({
+			request,
+			confirmationConfig,
+			transactionSummary,
+			vrfChallenge
+		});
+		confirmHandle = handle;
+		return {
+			confirmed,
+			error
+		};
+	};
+	const confirmAndCloseModal = (decision) => {
+		try {
+			require_common.sendConfirmResponse(worker, decision);
+		} finally {
+			if (!decision.confirmed) adapters.near.releaseReservedNonces(reservedNonces);
+			adapters.ui.closeModalSafely(!!decision.confirmed, confirmHandle);
+		}
+	};
+	const cleanupAndRethrow = (err) => {
+		try {
+			adapters.near.releaseReservedNonces(reservedNonces);
+			adapters.ui.closeModalSafely(false, confirmHandle);
+		} finally {
+			throw err;
+		}
+	};
+	return {
+		setReservedNonces,
+		updateUI,
+		promptUser,
+		confirmAndCloseModal,
+		cleanupAndRethrow
+	};
+}
+
+//#endregion
+exports.createConfirmSession = createConfirmSession;
+//# sourceMappingURL=session.js.map

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","names":["reservedNonces: string[] | undefined","confirmHandle: ConfirmUIHandle | undefined"],"sources":["../../../../../../../../../src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/session.ts"],"sourcesContent":["import type { ConfirmationConfig } from '../../../../types/signer-worker';\nimport type { ConfirmUIHandle, ConfirmUIUpdate } from '../../../LitComponents/confirm-ui';\nimport type { KnownSecureConfirmRequest, SecureConfirmDecision, TransactionSummary } from '../types';\nimport type { VRFChallenge } from '../../../../types';\nimport { sendConfirmResponse } from './common';\nimport type { ConfirmTxFlowAdapters } from './interfaces';\n\nexport function createConfirmSession({\n  adapters,\n  worker,\n  request,\n  confirmationConfig,\n  transactionSummary,\n}: {\n  adapters: ConfirmTxFlowAdapters;\n  worker: Worker;\n  request: KnownSecureConfirmRequest;\n  confirmationConfig: ConfirmationConfig;\n  transactionSummary: TransactionSummary;\n}): {\n  setReservedNonces: (nonces?: string[]) => void;\n  updateUI: (props: ConfirmUIUpdate) => void;\n  promptUser: (args: { vrfChallenge?: Partial<VRFChallenge> }) => Promise<{ confirmed: boolean; error?: string }>;\n  /**\n   * Send decision back to worker and perform standard cleanup.\n   * - On `confirmed: false`, releases any reserved nonces.\n   * - Always closes the confirm UI handle when present.\n   */\n  confirmAndCloseModal: (decision: SecureConfirmDecision) => void;\n  /**\n   * Cleanup + rethrow helper for invariant failures (e.g. missing PRF outputs),\n   * where tests/logic expect no worker response envelope.\n   */\n  cleanupAndRethrow: (err: unknown) => never;\n} {\n  let reservedNonces: string[] | undefined;\n  let confirmHandle: ConfirmUIHandle | undefined;\n\n  const setReservedNonces = (nonces?: string[]) => {\n    reservedNonces = nonces;\n  };\n\n  const updateUI = (props: ConfirmUIUpdate) => {\n    confirmHandle?.update?.(props);\n  };\n\n  const promptUser = async ({ vrfChallenge }: { vrfChallenge?: Partial<VRFChallenge> }) => {\n    const { confirmed, confirmHandle: handle, error } = await adapters.ui.renderConfirmUI({\n      request,\n      confirmationConfig,\n      transactionSummary,\n      vrfChallenge,\n    });\n    confirmHandle = handle;\n    return { confirmed, error };\n  };\n\n  const confirmAndCloseModal = (decision: SecureConfirmDecision) => {\n    try {\n      sendConfirmResponse(worker, decision);\n    } finally {\n      if (!decision.confirmed) {\n        adapters.near.releaseReservedNonces(reservedNonces);\n      }\n      adapters.ui.closeModalSafely(!!decision.confirmed, confirmHandle);\n    }\n  };\n\n  const cleanupAndRethrow = (err: unknown): never => {\n    try {\n      adapters.near.releaseReservedNonces(reservedNonces);\n      adapters.ui.closeModalSafely(false, confirmHandle);\n    } finally {\n      throw err;\n    }\n  };\n\n  return {\n    setReservedNonces,\n    updateUI,\n    promptUser,\n    confirmAndCloseModal,\n    cleanupAndRethrow,\n  };\n}\n"],"mappings":";;;AAOA,SAAgB,qBAAqB,EACnC,UACA,QACA,SACA,oBACA,sBAsBA;CACA,IAAIA;CACJ,IAAIC;CAEJ,MAAM,qBAAqB,WAAsB;AAC/C,mBAAiB;;CAGnB,MAAM,YAAY,UAA2B;AAC3C,iBAAe,SAAS;;CAG1B,MAAM,aAAa,OAAO,EAAE,mBAA6D;EACvF,MAAM,EAAE,WAAW,eAAe,QAAQ,UAAU,MAAM,SAAS,GAAG,gBAAgB;GACpF;GACA;GACA;GACA;;AAEF,kBAAgB;AAChB,SAAO;GAAE;GAAW;;;CAGtB,MAAM,wBAAwB,aAAoC;AAChE,MAAI;AACF,sCAAoB,QAAQ;YACpB;AACR,OAAI,CAAC,SAAS,UACZ,UAAS,KAAK,sBAAsB;AAEtC,YAAS,GAAG,iBAAiB,CAAC,CAAC,SAAS,WAAW;;;CAIvD,MAAM,qBAAqB,QAAwB;AACjD,MAAI;AACF,YAAS,KAAK,sBAAsB;AACpC,YAAS,GAAG,iBAAiB,OAAO;YAC5B;AACR,SAAM;;;AAIV,QAAO;EACL;EACA;EACA;EACA;EACA"}

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/ui.js

@@ -0,0 +1,76 @@
+const require_types = require('../types.js');
+const require_requestHelpers = require('./requestHelpers.js');
+const require_confirm_ui = require('../../../LitComponents/confirm-ui.js');
+
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/ui.ts
+function closeModalSafely(confirmed, handle) {
+	handle?.close?.(confirmed);
+}
+async function renderConfirmUI({ ctx, request, confirmationConfig, transactionSummary, vrfChallenge }) {
+	const nearAccountIdForUi = require_requestHelpers.getNearAccountId(request);
+	const uiMode = confirmationConfig.uiMode;
+	const txSigningRequests = request.type === require_types.SecureConfirmationType.SIGN_TRANSACTION ? require_requestHelpers.getSignTransactionPayload(request).txSigningRequests : [];
+	const renderDrawerOrModal = async (mode) => {
+		if (confirmationConfig.behavior === "autoProceed") {
+			const handle$1 = await require_confirm_ui.mountConfirmUI({
+				ctx,
+				summary: transactionSummary,
+				txSigningRequests,
+				vrfChallenge,
+				loading: true,
+				theme: confirmationConfig.theme,
+				uiMode: mode,
+				nearAccountIdOverride: nearAccountIdForUi
+			});
+			const delay = confirmationConfig.autoProceedDelay ?? 0;
+			await new Promise((r) => setTimeout(r, delay));
+			return {
+				confirmed: true,
+				confirmHandle: handle$1
+			};
+		}
+		const { confirmed, handle, error } = await require_confirm_ui.awaitConfirmUIDecision({
+			ctx,
+			summary: transactionSummary,
+			txSigningRequests,
+			vrfChallenge,
+			theme: confirmationConfig.theme,
+			uiMode: mode,
+			nearAccountIdOverride: nearAccountIdForUi
+		});
+		return {
+			confirmed,
+			confirmHandle: handle,
+			error
+		};
+	};
+	switch (uiMode) {
+		case "skip": return {
+			confirmed: true,
+			confirmHandle: void 0
+		};
+		case "drawer": return await renderDrawerOrModal("drawer");
+		case "modal": return await renderDrawerOrModal("modal");
+		default: {
+			const handle = await require_confirm_ui.mountConfirmUI({
+				ctx,
+				summary: transactionSummary,
+				txSigningRequests,
+				vrfChallenge,
+				loading: true,
+				theme: confirmationConfig.theme,
+				uiMode: "modal",
+				nearAccountIdOverride: nearAccountIdForUi
+			});
+			return {
+				confirmed: true,
+				confirmHandle: handle
+			};
+		}
+	}
+}
+
+//#endregion
+exports.closeModalSafely = closeModalSafely;
+exports.renderConfirmUI = renderConfirmUI;
+//# sourceMappingURL=ui.js.map

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/ui.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui.js","names":["getNearAccountId","SecureConfirmationType","getSignTransactionPayload","handle","mountConfirmUI","awaitConfirmUIDecision"],"sources":["../../../../../../../../../src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/ui.ts"],"sourcesContent":["import type { VrfWorkerManagerContext } from '../../';\nimport type { ConfirmationConfig, ConfirmationUIMode } from '../../../../types/signer-worker';\nimport type { SecureConfirmRequest, TransactionSummary } from '../types';\nimport { SecureConfirmationType } from '../types';\nimport type { VRFChallenge } from '../../../../types';\nimport { awaitConfirmUIDecision, mountConfirmUI, type ConfirmUIHandle } from '../../../LitComponents/confirm-ui';\nimport { getNearAccountId, getSignTransactionPayload } from './requestHelpers';\n\nexport function closeModalSafely(confirmed: boolean, handle?: ConfirmUIHandle) {\n  handle?.close?.(confirmed);\n}\n\nexport async function renderConfirmUI({\n  ctx,\n  request,\n  confirmationConfig,\n  transactionSummary,\n  vrfChallenge,\n}: {\n  ctx: VrfWorkerManagerContext,\n  request: SecureConfirmRequest,\n  confirmationConfig: ConfirmationConfig,\n  transactionSummary: TransactionSummary,\n  vrfChallenge?: Partial<VRFChallenge>;\n}): Promise<{ confirmed: boolean; confirmHandle?: ConfirmUIHandle; error?: string }> {\n  const nearAccountIdForUi = getNearAccountId(request);\n\n  const uiMode = confirmationConfig.uiMode as ConfirmationUIMode;\n  const txSigningRequests = request.type === SecureConfirmationType.SIGN_TRANSACTION\n    ? getSignTransactionPayload(request).txSigningRequests\n    : [];\n\n  const renderDrawerOrModal = async (mode: 'drawer' | 'modal') => {\n    if (confirmationConfig.behavior === 'autoProceed') {\n      const handle = await mountConfirmUI({\n        ctx,\n        summary: transactionSummary,\n        txSigningRequests,\n        vrfChallenge,\n        loading: true,\n        theme: confirmationConfig.theme,\n        uiMode: mode,\n        nearAccountIdOverride: nearAccountIdForUi,\n      });\n      const delay = confirmationConfig.autoProceedDelay ?? 0;\n      await new Promise((r) => setTimeout(r, delay));\n      return { confirmed: true, confirmHandle: handle } as const;\n    }\n\n    const { confirmed, handle, error } = await awaitConfirmUIDecision({\n      ctx,\n      summary: transactionSummary,\n      txSigningRequests,\n      vrfChallenge,\n      theme: confirmationConfig.theme,\n      uiMode: mode,\n      nearAccountIdOverride: nearAccountIdForUi,\n    });\n    return { confirmed, confirmHandle: handle, error } as const;\n  };\n\n  switch (uiMode) {\n    case 'skip': {\n      return { confirmed: true, confirmHandle: undefined };\n    }\n    case 'drawer': {\n      return await renderDrawerOrModal('drawer');\n    }\n    case 'modal': {\n      return await renderDrawerOrModal('modal');\n    }\n    default: {\n      const handle = await mountConfirmUI({\n        ctx,\n        summary: transactionSummary,\n        txSigningRequests,\n        vrfChallenge,\n        loading: true,\n        theme: confirmationConfig.theme,\n        uiMode: 'modal',\n        nearAccountIdOverride: nearAccountIdForUi,\n      });\n      return { confirmed: true, confirmHandle: handle };\n    }\n  }\n}\n\n"],"mappings":";;;;;AAQA,SAAgB,iBAAiB,WAAoB,QAA0B;AAC7E,SAAQ,QAAQ;;AAGlB,eAAsB,gBAAgB,EACpC,KACA,SACA,oBACA,oBACA,gBAOmF;CACnF,MAAM,qBAAqBA,wCAAiB;CAE5C,MAAM,SAAS,mBAAmB;CAClC,MAAM,oBAAoB,QAAQ,SAASC,qCAAuB,mBAC9DC,iDAA0B,SAAS,oBACnC;CAEJ,MAAM,sBAAsB,OAAO,SAA6B;AAC9D,MAAI,mBAAmB,aAAa,eAAe;GACjD,MAAMC,WAAS,MAAMC,kCAAe;IAClC;IACA,SAAS;IACT;IACA;IACA,SAAS;IACT,OAAO,mBAAmB;IAC1B,QAAQ;IACR,uBAAuB;;GAEzB,MAAM,QAAQ,mBAAmB,oBAAoB;AACrD,SAAM,IAAI,SAAS,MAAM,WAAW,GAAG;AACvC,UAAO;IAAE,WAAW;IAAM,eAAeD;;;EAG3C,MAAM,EAAE,WAAW,QAAQ,UAAU,MAAME,0CAAuB;GAChE;GACA,SAAS;GACT;GACA;GACA,OAAO,mBAAmB;GAC1B,QAAQ;GACR,uBAAuB;;AAEzB,SAAO;GAAE;GAAW,eAAe;GAAQ;;;AAG7C,SAAQ,QAAR;EACE,KAAK,OACH,QAAO;GAAE,WAAW;GAAM,eAAe;;EAE3C,KAAK,SACH,QAAO,MAAM,oBAAoB;EAEnC,KAAK,QACH,QAAO,MAAM,oBAAoB;EAEnC,SAAS;GACP,MAAM,SAAS,MAAMD,kCAAe;IAClC;IACA,SAAS;IACT;IACA;IACA,SAAS;IACT,OAAO,mBAAmB;IAC1B,QAAQ;IACR,uBAAuB;;AAEzB,UAAO;IAAE,WAAW;IAAM,eAAe"}

package/dist/cjs/react/src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/vrf.js

@@ -0,0 +1,87 @@
+const require_errors = require('../../../../../utils/errors.js');
+const require_intentDigest = require('../../../../digests/intentDigest.js');
+const require_types = require('../types.js');
+
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/vrf.ts
+async function maybeRefreshVrfChallenge(ctx, request, nearAccountId) {
+	const vrfWorkerManager = ctx.vrfWorkerManager;
+	if (!vrfWorkerManager) throw new Error("VrfWorkerManager not available");
+	if (!ctx.nonceManager.nearAccountId || !ctx.nonceManager.nearPublicKeyStr || ctx.nonceManager.nearAccountId !== nearAccountId) throw new Error("NonceManager not initialized with user data");
+	const rpId = ctx.touchIdPrompt.getRpId();
+	let sessionPolicyDigest32;
+	let intentDigestB64u;
+	switch (request.type) {
+		case require_types.SecureConfirmationType.SIGN_TRANSACTION:
+			sessionPolicyDigest32 = request.payload.sessionPolicyDigest32;
+			intentDigestB64u = request.payload.intentDigest;
+			break;
+		case require_types.SecureConfirmationType.SIGN_NEP413_MESSAGE:
+			sessionPolicyDigest32 = request.payload.sessionPolicyDigest32;
+			intentDigestB64u = await require_intentDigest.computeUiIntentDigestFromNep413({
+				nearAccountId,
+				recipient: request.payload.recipient,
+				message: request.payload.message
+			});
+			break;
+		case require_types.SecureConfirmationType.REGISTER_ACCOUNT:
+		case require_types.SecureConfirmationType.LINK_DEVICE:
+			intentDigestB64u = request.intentDigest ? await require_intentDigest.sha256Base64UrlUtf8(request.intentDigest) : void 0;
+			break;
+		default: break;
+	}
+	const attempts = 3;
+	return await retryWithBackoff(async () => {
+		const latestCtx = await ctx.nonceManager.getNonceBlockHashAndHeight(ctx.nearClient, { force: true });
+		const vrfChallenge = request.type === require_types.SecureConfirmationType.REGISTER_ACCOUNT || request.type === require_types.SecureConfirmationType.LINK_DEVICE ? (await vrfWorkerManager.generateVrfKeypairBootstrap({
+			vrfInputData: {
+				userId: nearAccountId,
+				rpId,
+				blockHeight: latestCtx.txBlockHeight,
+				blockHash: latestCtx.txBlockHash,
+				...intentDigestB64u ? { intentDigest: intentDigestB64u } : {}
+			},
+			saveInMemory: true,
+			sessionId: request.requestId
+		})).vrfChallenge : await vrfWorkerManager.generateVrfChallengeForSession({
+			userId: nearAccountId,
+			rpId,
+			blockHeight: latestCtx.txBlockHeight,
+			blockHash: latestCtx.txBlockHash,
+			...intentDigestB64u ? { intentDigest: intentDigestB64u } : {},
+			...sessionPolicyDigest32 ? { sessionPolicyDigest32 } : {}
+		}, request.requestId);
+		return {
+			vrfChallenge,
+			transactionContext: latestCtx
+		};
+	}, {
+		attempts,
+		baseDelayMs: 150,
+		onError: (err, attempt) => {
+			const msg = require_errors.errorMessage(err);
+			const isFinal = attempt >= attempts;
+			if (isFinal) console.warn(`[SecureConfirm] VRF refresh failed: ${msg}`);
+			else console.debug(`[SecureConfirm] VRF refresh attempt ${attempt} failed: ${msg}`);
+		},
+		errorFactory: () => /* @__PURE__ */ new Error("VRF refresh failed")
+	});
+}
+async function retryWithBackoff(fn, options) {
+	const { attempts, baseDelayMs, onError, errorFactory } = options;
+	let lastError;
+	for (let attempt = 1; attempt <= Math.max(1, attempts); attempt++) try {
+		return await fn(attempt);
+	} catch (err) {
+		lastError = err;
+		onError?.(err, attempt);
+		if (attempt < attempts) {
+			const delay = baseDelayMs * attempt;
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+	}
+	throw errorFactory ? errorFactory() : require_errors.toError(lastError ?? /* @__PURE__ */ new Error("Retry exhausted"));
+}
+
+//#endregion
+exports.maybeRefreshVrfChallenge = maybeRefreshVrfChallenge;
+//# sourceMappingURL=vrf.js.map