@tatchi-xyz/sdk 0.21.0 → 0.31.1

package/dist/esm/react/src/core/WalletIframe/client/router.js

@@ -0,0 +1,1096 @@
+import { extractBorshBytesFromPlainSignedTx, isBoolean, isObject, isPlainSignedTransactionLike, stripFunctionsShallow, toBasePath } from "../../../utils/validation.js";
+import { mergeSignerMode } from "../../types/signer-worker.js";
+import { toError } from "../../../utils/errors.js";
+import { PASSKEY_MANAGER_DEFAULT_CONFIGS } from "../../defaultConfigs.js";
+import { SignedTransaction } from "../../NearClient.js";
+import { ActionPhase, DeviceLinkingPhase, EmailRecoveryPhase, LoginPhase, RegistrationPhase, SyncAccountPhase } from "../../types/sdkSentEvents.js";
+import { openOfflineExportWindow } from "../../OfflineExport/overlay.js";
+import { OnEventsProgressBus, defaultPhaseHeuristics } from "./on-events-progress-bus.js";
+import { IframeTransport } from "./IframeTransport.js";
+import overlay_controller_default from "./overlay-controller.js";
+
+//#region src/core/WalletIframe/client/router.ts
+var WalletIframeRouter = class {
+	opts;
+	transport;
+	state = {
+		port: null,
+		ready: false,
+		initInFlight: null,
+		pending: /* @__PURE__ */ new Map(),
+		reqCounter: 0,
+		signerModePreference: null,
+		device2StartPromise: null
+	};
+	listeners = {
+		ready: /* @__PURE__ */ new Set(),
+		vrfStatus: /* @__PURE__ */ new Set(),
+		preferencesChanged: /* @__PURE__ */ new Set(),
+		registerOverlayResult: /* @__PURE__ */ new Set(),
+		registerOverlaySubmit: /* @__PURE__ */ new Set()
+	};
+	progressBus;
+	debug = false;
+	walletOriginUrl;
+	walletOriginOrigin;
+	overlayState;
+	windowMsgHandlerBound;
+	constructor(options) {
+		if (!options?.walletOrigin) throw new Error("[WalletIframeRouter] walletOrigin is required when using the wallet iframe");
+		let parsedOrigin;
+		try {
+			parsedOrigin = new URL(options.walletOrigin);
+		} catch (err) {
+			throw new Error(`[WalletIframeRouter] Invalid walletOrigin: ${options.walletOrigin}`);
+		}
+		if (typeof window !== "undefined") {
+			const parentOrigin = window.location.origin;
+			if (parsedOrigin.origin === parentOrigin) console.warn("[WalletIframeRouter] walletOrigin matches the host origin. Isolation safeguards rely on the parent; consider moving the wallet to a dedicated origin.");
+		}
+		const defaultRouterId = `w3a-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		const testOptions = {
+			routerId: defaultRouterId,
+			ownerTag: void 0,
+			autoMount: true,
+			...options?.testOptions || {}
+		};
+		const normalizedServicePath = (() => {
+			const p = toBasePath(options?.servicePath, "/wallet-service");
+			return p === "/" ? "/wallet-service" : p;
+		})();
+		const normalizedSdkBasePath = (() => {
+			const p = toBasePath(options?.sdkBasePath, "/sdk");
+			return p === "/" ? "/sdk" : p;
+		})();
+		this.opts = {
+			connectTimeoutMs: 8e3,
+			requestTimeoutMs: 2e4,
+			...options,
+			servicePath: normalizedServicePath,
+			sdkBasePath: normalizedSdkBasePath,
+			testOptions,
+			signerMode: options.signerMode ?? PASSKEY_MANAGER_DEFAULT_CONFIGS.signerMode
+		};
+		this.walletOriginUrl = parsedOrigin;
+		this.walletOriginOrigin = parsedOrigin.origin;
+		this.debug = !!this.opts.debug;
+		this.transport = new IframeTransport({
+			walletOrigin: this.opts.walletOrigin,
+			servicePath: this.opts.servicePath,
+			connectTimeoutMs: this.opts.connectTimeoutMs,
+			debug: this.debug,
+			testOptions: {
+				routerId: this.opts.testOptions.routerId,
+				ownerTag: this.opts.testOptions.ownerTag
+			}
+		});
+		this.overlayState = {
+			controller: new overlay_controller_default({ ensureIframe: () => this.transport.ensureIframeMounted() }),
+			forceFullscreen: false
+		};
+		this.progressBus = new OnEventsProgressBus({
+			show: () => this.showFrameForActivation(),
+			hide: () => this.hideFrameForActivation()
+		}, defaultPhaseHeuristics, this.debug ? (msg, data) => {
+			console.debug("[WalletIframeRouter][OnEventsProgressBus]", msg, data || {});
+		} : void 0);
+		this.windowMsgHandlerBound = (ev) => {
+			if (ev.origin !== this.walletOriginOrigin) return;
+			const data = ev.data;
+			if (!data || typeof data !== "object") return;
+			const type = data.type;
+			if (type === "REGISTER_BUTTON_SUBMIT") {
+				this.overlayState.forceFullscreen = true;
+				this.overlayState.controller.setSticky(true);
+				this.overlayState.controller.showFullscreen();
+				for (const cb of Array.from(this.listeners.registerOverlaySubmit)) try {
+					cb();
+				} catch {}
+				return;
+			}
+			if (type === "REGISTER_BUTTON_RESULT") {
+				const payload = data.payload;
+				const ok = !!payload?.ok;
+				for (const cb of Array.from(this.listeners.registerOverlayResult)) cb({
+					ok,
+					result: payload?.result,
+					cancelled: payload?.cancelled,
+					error: payload?.error
+				});
+				this.overlayState.forceFullscreen = false;
+				this.overlayState.controller.setSticky(false);
+				this.hideFrameForActivation();
+				if (ok) {
+					const acct = payload?.result?.nearAccountId;
+					this.getLoginSession(acct).then(({ login: st }) => {
+						this.emitVrfStatusChanged({
+							active: !!st.vrfActive,
+							nearAccountId: st.nearAccountId,
+							sessionDuration: st.vrfSessionDuration
+						});
+					}).catch(() => {});
+				}
+				return;
+			}
+		};
+		globalThis.addEventListener?.("message", this.windowMsgHandlerBound);
+	}
+	attachExportUiClosedListener = (walletOrigin) => {
+		const onUiClosed = (ev) => {
+			if (ev.origin !== walletOrigin) return;
+			const data = ev.data;
+			if (!data || data.type !== "WALLET_UI_CLOSED") return;
+			this.overlayState.controller.setSticky(false);
+			this.hideFrameForActivation();
+			globalThis.removeEventListener?.("message", onUiClosed);
+		};
+		globalThis.addEventListener?.("message", onUiClosed);
+		return () => {
+			globalThis.removeEventListener?.("message", onUiClosed);
+		};
+	};
+	attachExportUiFallbackListener = (walletOrigin, accountId) => {
+		const onFallback = async (ev) => {
+			if (ev.origin !== walletOrigin) return;
+			const data = ev.data;
+			if (!data || data.type !== "OFFLINE_EXPORT_FALLBACK") return;
+			globalThis.removeEventListener?.("message", onFallback);
+			this.overlayState.controller.setSticky(false);
+			this.hideFrameForActivation();
+			await this.openOfflineExport({ accountId });
+		};
+		globalThis.addEventListener?.("message", onFallback);
+		return () => {
+			globalThis.removeEventListener?.("message", onFallback);
+		};
+	};
+	/**
+	* Subscribe to service-ready event. Returns an unsubscribe function.
+	* If already ready, the listener is invoked on next microtask.
+	*/
+	onReady(listener) {
+		if (this.state.ready) {
+			Promise.resolve().then(() => {
+				listener();
+			});
+			return () => {};
+		}
+		this.listeners.ready.add(listener);
+		return () => {
+			this.listeners.ready.delete(listener);
+		};
+	}
+	emitReady() {
+		if (!this.listeners.ready.size) return;
+		for (const cb of Array.from(this.listeners.ready)) cb();
+	}
+	resolveSignerMode(input) {
+		const base = this.state.signerModePreference ?? this.opts.signerMode;
+		return mergeSignerMode(base, input ?? null);
+	}
+	/**
+	* Initialize the transport and configure the wallet host.
+	* Safe to call multiple times; concurrent calls deduplicate via initInFlight.
+	*/
+	async init() {
+		if (this.state.ready) return;
+		if (this.state.initInFlight) return this.state.initInFlight;
+		this.state.initInFlight = (async () => {
+			if (this.opts.testOptions.autoMount !== false) {
+				this.state.port = await this.transport.connect();
+				this.state.port.onmessage = (ev) => this.onPortMessage(ev);
+				this.state.port.start?.();
+				this.state.ready = true;
+			}
+			console.debug("[WalletIframeRouter] init: %s", this.state.ready ? "connected" : "deferred (autoMount=false)");
+			await this.post({
+				type: "PM_SET_CONFIG",
+				payload: {
+					theme: this.opts.theme,
+					signerMode: this.opts.signerMode,
+					nearRpcUrl: this.opts.nearRpcUrl,
+					nearNetwork: this.opts.nearNetwork,
+					contractId: this.opts.contractId,
+					nearExplorerUrl: this.opts.nearExplorerUrl,
+					relayer: this.opts.relayer,
+					vrfWorkerConfigs: this.opts.vrfWorkerConfigs,
+					rpIdOverride: this.opts.rpIdOverride,
+					authenticatorOptions: this.opts.authenticatorOptions,
+					emailRecoveryContracts: this.opts.emailRecoveryContracts,
+					uiRegistry: this.opts.uiRegistry,
+					assetsBaseUrl: (() => {
+						try {
+							const base = new URL(this.opts.sdkBasePath, this.walletOriginUrl).toString();
+							return base.endsWith("/") ? base : `${base}/`;
+						} catch {
+							const fallback = new URL("/sdk/", this.walletOriginUrl).toString();
+							return fallback.endsWith("/") ? fallback : `${fallback}/`;
+						}
+					})()
+				}
+			});
+			this.emitReady();
+		})();
+		try {
+			await this.state.initInFlight;
+		} finally {
+			this.state.initInFlight = null;
+		}
+	}
+	isReady() {
+		return this.state.ready;
+	}
+	registerUiTypes(registry) {
+		const iframe = this.transport.ensureIframeMounted();
+		const w = iframe.contentWindow;
+		if (!w) return;
+		const target = this.walletOriginOrigin;
+		this.postWindowMessage(w, {
+			type: "WALLET_UI_REGISTER_TYPES",
+			payload: registry
+		}, target);
+	}
+	mountUiComponent(params) {
+		const iframe = this.transport.ensureIframeMounted();
+		const w = iframe.contentWindow;
+		if (!w) return;
+		const target = this.walletOriginOrigin;
+		this.postWindowMessage(w, {
+			type: "WALLET_UI_MOUNT",
+			payload: params
+		}, target);
+	}
+	updateUiComponent(params) {
+		const iframe = this.transport.ensureIframeMounted();
+		const w = iframe.contentWindow;
+		if (!w) return;
+		const target = this.walletOriginOrigin;
+		this.postWindowMessage(w, {
+			type: "WALLET_UI_UPDATE",
+			payload: params
+		}, target);
+	}
+	unmountUiComponent(id) {
+		const iframe = this.transport.ensureIframeMounted();
+		const w = iframe.contentWindow;
+		if (!w) return;
+		const target = this.walletOriginOrigin;
+		this.postWindowMessage(w, {
+			type: "WALLET_UI_UNMOUNT",
+			payload: { id }
+		}, target);
+	}
+	onVrfStatusChanged(listener) {
+		this.listeners.vrfStatus.add(listener);
+		return () => {
+			this.listeners.vrfStatus.delete(listener);
+		};
+	}
+	onPreferencesChanged(listener) {
+		this.listeners.preferencesChanged.add(listener);
+		return () => {
+			this.listeners.preferencesChanged.delete(listener);
+		};
+	}
+	emitVrfStatusChanged(status) {
+		for (const cb of Array.from(this.listeners.vrfStatus)) try {
+			cb(status);
+		} catch {}
+	}
+	emitPreferencesChanged(payload) {
+		if (!this.listeners.preferencesChanged.size) return;
+		for (const cb of Array.from(this.listeners.preferencesChanged)) try {
+			cb(payload);
+		} catch {}
+	}
+	onRegisterOverlayResult(listener) {
+		this.listeners.registerOverlayResult.add(listener);
+		return () => {
+			this.listeners.registerOverlayResult.delete(listener);
+		};
+	}
+	onRegisterOverlaySubmit(listener) {
+		this.listeners.registerOverlaySubmit.add(listener);
+		return () => {
+			this.listeners.registerOverlaySubmit.delete(listener);
+		};
+	}
+	async signTransactionsWithActions(payload) {
+		const safeOptions = {
+			signerMode: this.resolveSignerMode(payload.options.signerMode),
+			...payload.options.confirmationConfig ? { confirmationConfig: payload.options.confirmationConfig } : {},
+			...payload.options.confirmerText ? { confirmerText: payload.options.confirmerText } : {}
+		};
+		const res = await this.post({
+			type: "PM_SIGN_TXS_WITH_ACTIONS",
+			payload: {
+				nearAccountId: payload.nearAccountId,
+				transactions: payload.transactions,
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isActionSSEEvent) }
+		});
+		return normalizeSignedTransactionObject(res.result);
+	}
+	async signDelegateAction(payload) {
+		const safeOptions = {
+			signerMode: this.resolveSignerMode(payload.options.signerMode),
+			...payload.options.confirmationConfig ? { confirmationConfig: payload.options.confirmationConfig } : {},
+			...payload.options.confirmerText ? { confirmerText: payload.options.confirmerText } : {}
+		};
+		const res = await this.post({
+			type: "PM_SIGN_DELEGATE_ACTION",
+			payload: {
+				nearAccountId: payload.nearAccountId,
+				delegate: payload.delegate,
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async registerPasskey(payload) {
+		this.overlayState.forceFullscreen = true;
+		this.overlayState.controller.setSticky(true);
+		this.overlayState.controller.showFullscreen();
+		try {
+			if (payload.confirmationConfig) {
+				const base = await this.getConfirmationConfig();
+				await this.setConfirmationConfig({
+					...base,
+					...payload.confirmationConfig
+				});
+			}
+			const safeOptions = removeFunctionsFromOptions(payload.options);
+			const res = await this.post({
+				type: "PM_REGISTER",
+				payload: {
+					nearAccountId: payload.nearAccountId,
+					options: safeOptions,
+					...payload.confirmationConfig ? { confirmationConfig: payload.confirmationConfig } : {}
+				},
+				options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isRegistrationSSEEvent) }
+			});
+			const { login: st } = await this.getLoginSession(payload.nearAccountId);
+			this.emitVrfStatusChanged({
+				active: !!st.vrfActive,
+				nearAccountId: st.nearAccountId,
+				sessionDuration: st.vrfSessionDuration
+			});
+			return res?.result;
+		} finally {
+			this.overlayState.forceFullscreen = false;
+			this.overlayState.controller.setSticky(false);
+			this.hideFrameForActivation();
+		}
+	}
+	async enrollThresholdEd25519Key(payload) {
+		this.showFrameForActivation();
+		try {
+			const safeOptions = removeFunctionsFromOptions(payload.options);
+			const res = await this.post({
+				type: "PM_ENROLL_THRESHOLD_ED25519_KEY",
+				payload: {
+					nearAccountId: payload.nearAccountId,
+					options: safeOptions
+				}
+			});
+			return res.result;
+		} finally {
+			this.hideFrameForActivation();
+		}
+	}
+	async rotateThresholdEd25519Key(payload) {
+		this.showFrameForActivation();
+		try {
+			const safeOptions = removeFunctionsFromOptions(payload.options);
+			const res = await this.post({
+				type: "PM_ROTATE_THRESHOLD_ED25519_KEY",
+				payload: {
+					nearAccountId: payload.nearAccountId,
+					options: safeOptions
+				}
+			});
+			return res.result;
+		} finally {
+			this.hideFrameForActivation();
+		}
+	}
+	async loginAndCreateSession(payload) {
+		this.showFrameForActivation();
+		try {
+			const safeOptions = removeFunctionsFromOptions(payload.options);
+			const res = await this.post({
+				type: "PM_LOGIN",
+				payload: {
+					nearAccountId: payload.nearAccountId,
+					options: safeOptions
+				},
+				options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isLoginSSEEvent) }
+			});
+			const { login: st } = await this.getLoginSession(payload.nearAccountId);
+			this.emitVrfStatusChanged({
+				active: !!st.vrfActive,
+				nearAccountId: st.nearAccountId,
+				sessionDuration: st.vrfSessionDuration
+			});
+			return res?.result;
+		} finally {
+			this.hideFrameForActivation();
+		}
+	}
+	async getLoginSession(nearAccountId) {
+		const res = await this.post({
+			type: "PM_GET_LOGIN_SESSION",
+			payload: nearAccountId ? { nearAccountId } : void 0
+		});
+		return res.result;
+	}
+	async checkVrfStatus() {
+		const { login: st } = await this.getLoginSession();
+		return {
+			ok: true,
+			result: {
+				active: !!st.vrfActive,
+				nearAccountId: st.nearAccountId,
+				sessionDuration: st.vrfSessionDuration
+			}
+		};
+	}
+	async clearVrfSession() {
+		await this.post({ type: "PM_LOGOUT" });
+		this.emitVrfStatusChanged({
+			active: false,
+			nearAccountId: null
+		});
+		return {
+			ok: true,
+			result: void 0
+		};
+	}
+	async signNep413Message(payload) {
+		const safeOptions = {
+			signerMode: this.resolveSignerMode(payload.options.signerMode),
+			...payload.options.confirmerText ? { confirmerText: payload.options.confirmerText } : {},
+			...payload.options.confirmationConfig ? { confirmationConfig: payload.options.confirmationConfig } : {}
+		};
+		const res = await this.post({
+			type: "PM_SIGN_NEP413",
+			payload: {
+				nearAccountId: payload.nearAccountId,
+				params: {
+					message: payload.message,
+					recipient: payload.recipient,
+					state: payload.state
+				},
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async signTransactionWithKeyPair(payload) {
+		const { options } = payload;
+		const res = await this.post({
+			type: "PM_SEND_TRANSACTION",
+			payload: {
+				signedTransaction: payload.signedTransaction,
+				options
+			},
+			options: { onProgress: this.wrapOnEvent(options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async executeAction(payload) {
+		const { options } = payload;
+		const safeOptions = {
+			signerMode: this.resolveSignerMode(options.signerMode),
+			waitUntil: options.waitUntil,
+			confirmationConfig: options.confirmationConfig,
+			...options.confirmerText ? { confirmerText: options.confirmerText } : {}
+		};
+		const res = await this.post({
+			type: "PM_EXECUTE_ACTION",
+			payload: {
+				nearAccountId: payload.nearAccountId,
+				receiverId: payload.receiverId,
+				actionArgs: payload.actionArgs,
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async setConfirmBehavior(behavior) {
+		let { nearAccountId } = (await this.getLoginSession()).login;
+		await this.post({
+			type: "PM_SET_CONFIRM_BEHAVIOR",
+			payload: {
+				behavior,
+				nearAccountId
+			}
+		});
+	}
+	async setConfirmationConfig(config) {
+		let { nearAccountId } = (await this.getLoginSession()).login;
+		await this.post({
+			type: "PM_SET_CONFIRMATION_CONFIG",
+			payload: {
+				config,
+				nearAccountId
+			}
+		});
+	}
+	async getConfirmationConfig() {
+		const res = await this.post({ type: "PM_GET_CONFIRMATION_CONFIG" });
+		return res.result;
+	}
+	async setSignerMode(signerMode) {
+		await this.post({
+			type: "PM_SET_SIGNER_MODE",
+			payload: { signerMode }
+		});
+	}
+	async getSignerMode(opts) {
+		const res = await this.post({ type: "PM_GET_SIGNER_MODE" }, opts);
+		return res.result;
+	}
+	async setTheme(theme) {
+		await this.post({
+			type: "PM_SET_THEME",
+			payload: { theme }
+		});
+	}
+	async prefetchBlockheight() {
+		await this.post({ type: "PM_PREFETCH_BLOCKHEIGHT" });
+	}
+	async getRecentLogins() {
+		const res = await this.post({ type: "PM_GET_RECENT_LOGINS" });
+		return res.result;
+	}
+	async setDerivedAddress(payload) {
+		await this.post({
+			type: "PM_SET_DERIVED_ADDRESS",
+			payload
+		});
+	}
+	async getDerivedAddressRecord(payload) {
+		const res = await this.post({
+			type: "PM_GET_DERIVED_ADDRESS_RECORD",
+			payload
+		});
+		return res.result || null;
+	}
+	async getDerivedAddress(payload) {
+		const res = await this.post({
+			type: "PM_GET_DERIVED_ADDRESS",
+			payload
+		});
+		return res.result || null;
+	}
+	async getRecoveryEmails(nearAccountId) {
+		const res = await this.post({
+			type: "PM_GET_RECOVERY_EMAILS",
+			payload: { nearAccountId }
+		});
+		return res.result || [];
+	}
+	async setRecoveryEmails(payload) {
+		const { options } = payload;
+		const safeOptions = {
+			signerMode: this.resolveSignerMode(options.signerMode),
+			waitUntil: options.waitUntil,
+			confirmationConfig: options.confirmationConfig
+		};
+		const res = await this.post({
+			type: "PM_SET_RECOVERY_EMAILS",
+			payload: {
+				nearAccountId: payload.nearAccountId,
+				recoveryEmails: payload.recoveryEmails,
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	wrapOnEvent(onEvent, isExpectedEvent) {
+		if (!onEvent) return void 0;
+		return (progress) => {
+			try {
+				if (isExpectedEvent(progress)) onEvent(progress);
+			} catch {}
+		};
+	}
+	async signAndSendTransactions(payload) {
+		const { options } = payload;
+		const safeOptions = {
+			signerMode: this.resolveSignerMode(options.signerMode),
+			waitUntil: options.waitUntil,
+			executionWait: options.executionWait,
+			confirmationConfig: options.confirmationConfig,
+			...options.confirmerText ? { confirmerText: options.confirmerText } : {}
+		};
+		const res = await this.post({
+			type: "PM_SIGN_AND_SEND_TXS",
+			payload: {
+				nearAccountId: payload.nearAccountId,
+				transactions: payload.transactions,
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async hasPasskeyCredential(nearAccountId) {
+		const res = await this.post({
+			type: "PM_HAS_PASSKEY",
+			payload: { nearAccountId }
+		});
+		return !!res?.result;
+	}
+	async viewAccessKeyList(accountId) {
+		const res = await this.post({
+			type: "PM_VIEW_ACCESS_KEYS",
+			payload: { accountId }
+		});
+		return res.result;
+	}
+	async deleteDeviceKey(payload) {
+		const res = await this.post({
+			type: "PM_DELETE_DEVICE_KEY",
+			payload: {
+				accountId: payload.accountId,
+				publicKeyToDelete: payload.publicKeyToDelete,
+				options: { signerMode: this.resolveSignerMode(payload.options.signerMode) }
+			},
+			options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async sendTransaction(args) {
+		const { options } = args;
+		const safeOptions = options ? { waitUntil: options.waitUntil } : void 0;
+		const res = await this.post({
+			type: "PM_SEND_TRANSACTION",
+			payload: {
+				signedTransaction: args.signedTransaction,
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async exportNearKeypairWithUI(nearAccountId, options) {
+		try {
+			this.showFrameForActivation();
+			const walletOrigin = this.walletOriginOrigin;
+			this.attachExportUiClosedListener(walletOrigin);
+			this.attachExportUiFallbackListener(walletOrigin, nearAccountId);
+			await this.post({
+				type: "PM_EXPORT_NEAR_KEYPAIR_UI",
+				payload: {
+					nearAccountId,
+					variant: options?.variant,
+					theme: options?.theme
+				},
+				options: { sticky: true }
+			});
+			return;
+		} catch (e) {
+			await this.openOfflineExport({ accountId: nearAccountId });
+		}
+	}
+	/**
+	* Open the offline-export route as a full-screen overlay iframe and instruct it via postMessage
+	* to begin the export flow for the given account. Cleans up when the viewer closes or on error.
+	*/
+	async openOfflineExport({ accountId, timeoutMs = 2e4 }) {
+		const walletOrigin = this.opts.walletOrigin || window.location.origin;
+		openOfflineExportWindow({
+			walletOrigin,
+			target: "_blank",
+			accountId
+		});
+		return Promise.resolve();
+	}
+	async syncAccount(payload) {
+		const res = await this.post({
+			type: "PM_SYNC_ACCOUNT_FLOW",
+			payload: { accountId: payload.accountId },
+			options: { onProgress: this.wrapOnEvent(payload.onEvent, isSyncAccountSSEEvent) }
+		});
+		return res.result;
+	}
+	async startEmailRecovery(payload) {
+		const safeOptions = payload.options ? {
+			...payload.options.confirmerText ? { confirmerText: payload.options.confirmerText } : {},
+			...payload.options.confirmationConfig ? { confirmationConfig: payload.options.confirmationConfig } : {}
+		} : void 0;
+		const res = await this.post({
+			type: "PM_START_EMAIL_RECOVERY",
+			payload: {
+				accountId: payload.accountId,
+				options: safeOptions && Object.keys(safeOptions).length > 0 ? safeOptions : void 0
+			},
+			options: { onProgress: this.wrapOnEvent(payload.onEvent, isEmailRecoverySSEEvent) }
+		});
+		return res.result;
+	}
+	async finalizeEmailRecovery(payload) {
+		await this.post({
+			type: "PM_FINALIZE_EMAIL_RECOVERY",
+			payload: {
+				accountId: payload.accountId,
+				nearPublicKey: payload.nearPublicKey
+			},
+			options: { onProgress: this.wrapOnEvent(payload.onEvent, isEmailRecoverySSEEvent) }
+		});
+	}
+	async stopEmailRecovery(payload) {
+		await this.post({
+			type: "PM_STOP_EMAIL_RECOVERY",
+			payload: {
+				accountId: payload?.accountId,
+				nearPublicKey: payload?.nearPublicKey
+			}
+		});
+	}
+	async linkDeviceWithScannedQRData(payload) {
+		this.showFrameForActivation();
+		try {
+			const safeOptions = payload.options ? {
+				...payload.options.confirmationConfig ? { confirmationConfig: payload.options.confirmationConfig } : {},
+				...payload.options.confirmerText ? { confirmerText: payload.options.confirmerText } : {}
+			} : void 0;
+			const res = await this.post({
+				type: "PM_LINK_DEVICE_WITH_SCANNED_QR_DATA",
+				payload: {
+					qrData: payload.qrData,
+					fundingAmount: payload.fundingAmount,
+					options: safeOptions && Object.keys(safeOptions).length > 0 ? safeOptions : void 0
+				},
+				options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isDeviceLinkingSSEEvent) }
+			});
+			return res.result;
+		} finally {
+			this.hideFrameForActivation();
+		}
+	}
+	async startDevice2LinkingFlow(payload) {
+		if (this.state.device2StartPromise) return this.state.device2StartPromise;
+		const options = payload?.options;
+		const safeOptions = options ? {
+			...options.confirmationConfig ? { confirmationConfig: options.confirmationConfig } : {},
+			...options.confirmerText ? { confirmerText: options.confirmerText } : {}
+		} : void 0;
+		const p = this.post({
+			type: "PM_START_DEVICE2_LINKING_FLOW",
+			payload: {
+				ui: payload?.ui,
+				cameraId: payload?.cameraId,
+				options: safeOptions
+			},
+			options: {
+				onProgress: this.wrapOnEvent(options?.onEvent, isDeviceLinkingSSEEvent),
+				sticky: true
+			}
+		}).then((res) => res.result).finally(() => {
+			this.state.device2StartPromise = null;
+		});
+		this.state.device2StartPromise = p;
+		return p;
+	}
+	async stopDevice2LinkingFlow() {
+		await this.post({ type: "PM_STOP_DEVICE2_LINKING_FLOW" });
+		this.progressBus.clearAll();
+	}
+	async cancelRequest(requestId) {
+		await this.post({
+			type: "PM_CANCEL",
+			payload: { requestId }
+		}).catch(() => {});
+		this.progressBus.unregister(requestId);
+		this.hideFrameForActivation();
+	}
+	async cancelAll() {
+		await this.post({
+			type: "PM_CANCEL",
+			payload: {}
+		}).catch(() => {});
+		this.progressBus.clearAll();
+		this.hideFrameForActivation();
+	}
+	onPortMessage(e) {
+		const msg = e.data;
+		if (msg.type === "PREFERENCES_CHANGED") {
+			const payload = msg.payload;
+			try {
+				this.state.signerModePreference = payload?.signerMode ?? this.state.signerModePreference;
+			} catch {}
+			this.emitPreferencesChanged(payload);
+			return;
+		}
+		const requestId = msg.requestId;
+		if (!requestId) return;
+		if (msg.type === "PROGRESS") {
+			const payload = msg.payload;
+			this.progressBus.dispatch({
+				requestId,
+				payload
+			});
+			const pend = this.state.pending.get(requestId);
+			if (pend) {
+				if (pend.timer) window.clearTimeout(pend.timer);
+				pend.timer = window.setTimeout(() => {
+					const err = pend.onTimeout();
+					pend.reject(err);
+				}, pend.timeoutMs);
+			}
+			return;
+		}
+		const pending = this.state.pending.get(requestId);
+		if (!this.progressBus.isSticky(requestId)) {
+			if (!this.progressBus.wantsVisible()) this.hideFrameForActivation();
+		}
+		if (!pending) {
+			if (this.debug) console.debug("[WalletIframeRouter] Non-PROGRESS without pending → hide + unregister", {
+				requestId,
+				type: msg?.type || "unknown"
+			});
+			this.progressBus.unregister(requestId);
+			return;
+		}
+		this.state.pending.delete(requestId);
+		if (pending.timer) window.clearTimeout(pending.timer);
+		if (msg.type === "ERROR") {
+			const err = new Error(msg.payload?.message || "Wallet error");
+			err.code = msg.payload?.code;
+			err.details = msg.payload?.details;
+			pending.reject(err);
+			this.progressBus.dispatch({
+				requestId,
+				payload: {
+					step: 0,
+					phase: "error",
+					status: "error",
+					message: msg.payload?.message
+				}
+			});
+			this.progressBus.unregister(requestId);
+			return;
+		}
+		pending.resolve(msg.payload);
+		if (!this.progressBus.isSticky(requestId)) this.progressBus.unregister(requestId);
+	}
+	/**
+	* Post a typed envelope over the MessagePort with robust readiness handling.
+	* This is the core method that handles all communication with the iframe.
+	*
+	* Flow:
+	* 1. Ensure iframe is ready (lazy initialization)
+	* 2. Generate unique request ID for correlation
+	* 3. Set up timeout and progress handling
+	* 4. Send message to iframe via MessagePort
+	* 5. Wait for response (PM_RESULT or ERROR)
+	* 6. Clean up on completion or timeout
+	*/
+	async post(envelope, postOpts) {
+		if (!this.state.ready || !this.state.port) await this.init();
+		const requestId = `${Date.now()}-${++this.state.reqCounter}`;
+		const full = {
+			...envelope,
+			requestId
+		};
+		const { options } = full;
+		const timeoutMs = postOpts?.timeoutMs ?? this.opts.requestTimeoutMs;
+		return new Promise((resolve, reject) => {
+			const onTimeout = () => {
+				const pending = this.state.pending.get(requestId);
+				if (pending?.timer !== void 0) window.clearTimeout(pending.timer);
+				this.state.pending.delete(requestId);
+				this.progressBus.unregister(requestId);
+				this.overlayState.controller.setSticky(false);
+				if (!this.progressBus.wantsVisible()) this.hideFrameForActivation();
+				this.sendBestEffortCancel(requestId);
+				return /* @__PURE__ */ new Error(`Wallet request timeout for ${envelope.type}`);
+			};
+			const timer = window.setTimeout(() => {
+				const err = onTimeout();
+				reject(err);
+			}, timeoutMs);
+			this.state.pending.set(requestId, {
+				resolve: (v) => resolve(v),
+				reject,
+				timer,
+				timeoutMs,
+				onProgress: options?.onProgress,
+				onTimeout
+			});
+			this.progressBus.register({
+				requestId,
+				sticky: !!options?.sticky,
+				onProgress: (payload) => {
+					try {
+						options?.onProgress?.(payload);
+					} catch {}
+				}
+			});
+			try {
+				const stickyVal = isObject(options) ? options.sticky : void 0;
+				const wireOptions = isBoolean(stickyVal) ? { sticky: stickyVal } : void 0;
+				const serializableFull = wireOptions ? {
+					...full,
+					options: wireOptions
+				} : {
+					...full,
+					options: void 0
+				};
+				this.overlayState.controller.setSticky(!!(wireOptions && wireOptions.sticky));
+				if (!this.overlayState.controller.getState().visible) {
+					const intent = this.computeOverlayIntent(serializableFull.type);
+					if (intent.mode === "fullscreen") {
+						this.overlayState.controller.setSticky(!!(wireOptions && wireOptions.sticky));
+						this.overlayState.controller.showFullscreen();
+					}
+				}
+				this.state.port.postMessage(serializableFull);
+			} catch (err) {
+				this.state.pending.delete(requestId);
+				window.clearTimeout(timer);
+				this.progressBus.unregister(requestId);
+				reject(toError(err));
+			}
+		});
+	}
+	/**
+	* Preflight overlay decision before sending the request.
+	* - This decides whether to show fullscreen early for user activation.
+	* - ProgressBus handles hide timing; OverlayController just executes the decision.
+	*/
+	computeOverlayIntent(type) {
+		switch (type) {
+			case "PM_EXPORT_NEAR_KEYPAIR_UI":
+			case "PM_REGISTER":
+			case "PM_LOGIN":
+			case "PM_SYNC_ACCOUNT_FLOW":
+			case "PM_LINK_DEVICE_WITH_SCANNED_QR_DATA":
+			case "PM_SIGN_AND_SEND_TXS":
+			case "PM_EXECUTE_ACTION":
+			case "PM_SEND_TRANSACTION":
+			case "PM_SIGN_TXS_WITH_ACTIONS": return { mode: "fullscreen" };
+			default: return { mode: "hidden" };
+		}
+	}
+	showFrameForActivation() {
+		this.transport.ensureIframeMounted();
+		if (this.overlayState.forceFullscreen) this.overlayState.controller.showFullscreen();
+		else this.overlayState.controller.showFullscreen();
+	}
+	hideFrameForActivation() {
+		if (!this.overlayState.controller.getState().visible) return;
+		this.overlayState.controller.hide();
+	}
+	sendBestEffortCancel(targetRequestId) {
+		const port = this.state.port;
+		if (!port) return;
+		const cancelEnvelope = {
+			type: "PM_CANCEL",
+			requestId: `cancel-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+			payload: targetRequestId ? { requestId: targetRequestId } : {}
+		};
+		port.postMessage(cancelEnvelope);
+	}
+	/**
+	* Public toggle to surface the wallet iframe for user activation or hide it.
+	* Useful when mounting inline UI components that require direct user clicks.
+	*/
+	setOverlayVisible(visible) {
+		if (visible) if (this.overlayState.forceFullscreen) this.overlayState.controller.showFullscreen();
+		else this.showFrameForActivation();
+		else this.hideFrameForActivation();
+	}
+	/** Public helper for tests/tools: get the underlying iframe element. */
+	getIframeEl() {
+		return this.transport.getIframeEl();
+	}
+	/** Public helper for tests/tools: inspect current overlay state. */
+	getOverlayState() {
+		return this.overlayState.controller.getState();
+	}
+	/**
+	* Position and show the wallet iframe as an anchored overlay matching a DOMRect.
+	* Accepts viewport-relative coordinates (from getBoundingClientRect()).
+	*
+	* Important: Some apps apply CSS transforms (or filters/perspective) on html/body,
+	* which changes the containing block for position: fixed. In those cases a fixed
+	* iframe will be offset by the page scroll. To avoid that mismatch, anchor the
+	* overlay using absolute positioning in document coordinates.
+	*/
+	setOverlayBounds(rect) {
+		if (this.overlayState.forceFullscreen) return;
+		this.transport.ensureIframeMounted();
+		this.overlayState.controller.showAnchored(rect);
+	}
+	postWindowMessage(w, data, target) {
+		try {
+			w.postMessage(data, target);
+		} catch (err) {
+			if (this.debug) console.error("[WalletIframeRouter] window.postMessage failed", {
+				error: err,
+				data
+			});
+		}
+	}
+};
+const REGISTRATION_PHASES = new Set(Object.values(RegistrationPhase));
+const LOGIN_PHASES = new Set(Object.values(LoginPhase));
+const ACTION_PHASES = new Set(Object.values(ActionPhase));
+const DEVICE_LINKING_PHASES = new Set(Object.values(DeviceLinkingPhase));
+const SYNC_ACCOUNT_PHASES = new Set(Object.values(SyncAccountPhase));
+const EMAIL_RECOVERY_PHASES = new Set(Object.values(EmailRecoveryPhase));
+function phaseOf(progress) {
+	return String(progress?.phase ?? "");
+}
+function isRegistrationSSEEvent(progress) {
+	return REGISTRATION_PHASES.has(phaseOf(progress));
+}
+function isLoginSSEEvent(p) {
+	return LOGIN_PHASES.has(phaseOf(p));
+}
+function isActionSSEEvent(p) {
+	return ACTION_PHASES.has(phaseOf(p));
+}
+function isDeviceLinkingSSEEvent(p) {
+	return DEVICE_LINKING_PHASES.has(phaseOf(p));
+}
+function isSyncAccountSSEEvent(p) {
+	return SYNC_ACCOUNT_PHASES.has(phaseOf(p));
+}
+function isEmailRecoverySSEEvent(p) {
+	return EMAIL_RECOVERY_PHASES.has(phaseOf(p));
+}
+/**
+* Strips out class functions as they cannot be sent over postMessage to iframe
+*/
+function normalizeSignedTransactionObject(result) {
+	const arr = Array.isArray(result) ? result : [];
+	const normalized = arr.map((entry) => {
+		if (entry?.signedTransaction) {
+			const st = entry.signedTransaction;
+			if (isPlainSignedTransactionLike(st)) entry.signedTransaction = SignedTransaction.fromPlain({
+				transaction: st.transaction,
+				signature: st.signature,
+				borsh_bytes: extractBorshBytesFromPlainSignedTx(st)
+			});
+		}
+		return entry;
+	});
+	return normalized;
+}
+function removeFunctionsFromOptions(options) {
+	return stripFunctionsShallow(options);
+}
+
+//#endregion
+export { WalletIframeRouter };
+//# sourceMappingURL=router.js.map