@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/SeamsWeb/walletIframe/client/evmFamilyCommands.js

@@ -0,0 +1,118 @@
+import { toError } from "../../../shared-ts/src/utils/errors.js";
+import { toSerializableTempoError } from "../../operations/tempo/index.js";
+//#region src/SeamsWeb/walletIframe/client/evmFamilyCommands.ts
+function createApplicationEvmFamilyCommands(walletIframe, beforeSigning, transactionDispatch) {
+	const commands = new ApplicationEvmFamilyCommands(walletIframe, beforeSigning, transactionDispatch);
+	return {
+		signEvmFamily: commands.signEvmFamily.bind(commands),
+		reportBroadcastAccepted: commands.reportBroadcastAccepted.bind(commands),
+		reportBroadcastRejected: commands.reportBroadcastRejected.bind(commands),
+		reportFinalized: commands.reportFinalized.bind(commands),
+		reportDroppedOrReplaced: commands.reportDroppedOrReplaced.bind(commands),
+		reconcileNonceLane: commands.reconcileNonceLane.bind(commands),
+		onBroadcastStarted: commands.onBroadcastStarted.bind(commands)
+	};
+}
+var ApplicationEvmFamilyCommands = class {
+	constructor(walletIframe, beforeSigning, transactionDispatch) {
+		this.walletIframe = walletIframe;
+		this.beforeSigning = beforeSigning;
+		this.transactionDispatch = transactionDispatch;
+	}
+	async signEvmFamily(args) {
+		const { chainTarget, walletSession } = args;
+		const walletIframe = this.walletIframe;
+		try {
+			await this.beforeSigning(args.walletSession.walletId);
+			return await (await walletIframe.requireRouter()).signTempo({
+				walletSession,
+				request: args.request,
+				chainTarget,
+				options: {
+					confirmationConfig: args.options?.confirmationConfig,
+					onEvent: args.options?.onEvent
+				}
+			}, this.transactionDispatch);
+		} catch (error) {
+			throw toError(error);
+		}
+	}
+	async reportBroadcastAccepted(args) {
+		const walletIframe = this.walletIframe;
+		try {
+			await (await walletIframe.requireRouter()).reportTempoBroadcastAccepted({
+				walletSession: args.walletSession,
+				signedResult: args.signedResult,
+				txHash: args.txHash,
+				options: { onEvent: args.options?.onEvent }
+			});
+		} catch (error) {
+			throw toError(error);
+		}
+	}
+	async reportBroadcastRejected(args) {
+		const walletIframe = this.walletIframe;
+		try {
+			await (await walletIframe.requireRouter()).reportTempoBroadcastRejected({
+				walletSession: args.walletSession,
+				signedResult: args.signedResult,
+				...args.error != null ? { error: toSerializableTempoError(args.error) } : {},
+				options: { onEvent: args.options?.onEvent }
+			});
+		} catch (error) {
+			throw toError(error);
+		}
+	}
+	async reportFinalized(args) {
+		const walletIframe = this.walletIframe;
+		try {
+			await (await walletIframe.requireRouter()).reportTempoFinalized({
+				walletSession: args.walletSession,
+				signedResult: args.signedResult,
+				...args.txHash ? { txHash: args.txHash } : {},
+				...args.receiptStatus ? { receiptStatus: args.receiptStatus } : {},
+				options: { onEvent: args.options?.onEvent }
+			});
+		} catch (error) {
+			throw toError(error);
+		}
+	}
+	async reportDroppedOrReplaced(args) {
+		const walletIframe = this.walletIframe;
+		try {
+			await (await walletIframe.requireRouter()).reportTempoDroppedOrReplaced({
+				walletSession: args.walletSession,
+				signedResult: args.signedResult,
+				reason: args.reason,
+				...args.txHash ? { txHash: args.txHash } : {},
+				options: { onEvent: args.options?.onEvent }
+			});
+		} catch (error) {
+			throw toError(error);
+		}
+	}
+	async reconcileNonceLane(args) {
+		const walletIframe = this.walletIframe;
+		try {
+			return await (await walletIframe.requireRouter()).reconcileTempoNonceLane({
+				walletSession: args.walletSession,
+				signedResult: args.signedResult,
+				options: { onEvent: args.options?.onEvent }
+			});
+		} catch (error) {
+			throw toError(error);
+		}
+	}
+	onBroadcastStarted(args) {
+		this.notifyBroadcastStarted(args);
+	}
+	async notifyBroadcastStarted(args) {
+		try {
+			(await this.walletIframe.requireRouter()).notifyTransactionBroadcastStarted(args.signedResult);
+		} catch {}
+	}
+};
+//#endregion
+export { createApplicationEvmFamilyCommands };
+
+//# sourceMappingURL=evmFamilyCommands.js.map

package/dist/esm/SeamsWeb/walletIframe/client/inboundMessages.js

@@ -0,0 +1,223 @@
+import { isObject } from "../../../shared-ts/src/utils/validation.js";
+import { isWalletFlowEvent, parseSdkLifecycleEvent } from "../../../core/types/sdkSentEvents.js";
+import { parseWalletIframeExactSessionSnapshot, parseWalletIframeSessionRevision } from "../shared/exactSessionState.js";
+import { isDeviceLinkEmailOtpBaseFactorSelectionProgressV1, isDeviceLinkTargetFactorActivationProgressV1, isRegistrationTimingSpanV1, parseHostedAuthMenuErrorEvent, parseHostedAuthMenuExternalAuthRequest, parseWalletIframeSurfaceMeasurement } from "../shared/messages.js";
+import { parseTransactionReviewState } from "../shared/transactionReview.js";
+//#region src/SeamsWeb/walletIframe/client/inboundMessages.ts
+function rawClientMessageObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function hasOnlyClientMessageFields(value, allowedFields) {
+	const allowed = new Set(allowedFields);
+	return Object.keys(value).every((field) => allowed.has(field));
+}
+function clientChildRequestId(value) {
+	if (!Object.hasOwn(value, "requestId")) return void 0;
+	const requestId = Reflect.get(value, "requestId");
+	if (requestId === void 0) return void 0;
+	return typeof requestId === "string" ? requestId : null;
+}
+function clientChildRequestIdFields(requestId) {
+	return requestId === void 0 ? {} : { requestId };
+}
+function parseClientPreferencesChangedPayload(value) {
+	const record = rawClientMessageObject(value);
+	if (!record || !hasOnlyClientMessageFields(record, [
+		"walletId",
+		"confirmationConfig",
+		"revision"
+	])) return null;
+	const walletId = Reflect.get(record, "walletId");
+	if (walletId !== null && typeof walletId !== "string") return null;
+	const confirmationConfig = rawClientMessageObject(Reflect.get(record, "confirmationConfig"));
+	if (!confirmationConfig || !hasOnlyClientMessageFields(confirmationConfig, [
+		"uiMode",
+		"behavior",
+		"autoProceedDelay"
+	])) return null;
+	const uiMode = Reflect.get(confirmationConfig, "uiMode");
+	const behavior = Reflect.get(confirmationConfig, "behavior");
+	if (uiMode !== "none" && uiMode !== "modal" && uiMode !== "drawer") return null;
+	if (behavior !== "requireClick" && behavior !== "skipClick") return null;
+	const autoProceedDelay = Reflect.get(confirmationConfig, "autoProceedDelay");
+	if (autoProceedDelay !== void 0 && (typeof autoProceedDelay !== "number" || !Number.isFinite(autoProceedDelay))) return null;
+	const revision = Reflect.get(record, "revision");
+	if (typeof revision !== "number" || !Number.isSafeInteger(revision) || revision < 0) return null;
+	return {
+		walletId,
+		confirmationConfig: autoProceedDelay === void 0 ? {
+			uiMode,
+			behavior
+		} : {
+			uiMode,
+			behavior,
+			autoProceedDelay
+		},
+		revision
+	};
+}
+function isClientDeviceLinkProgressCandidate(value) {
+	const record = rawClientMessageObject(value);
+	if (!record) return false;
+	const event = Reflect.get(record, "event");
+	return event === "wallet_device_link_email_otp_base_factor_selection_required_v1" || event === "wallet_device_link_target_factor_activation_v1";
+}
+function parseClientProgressPayload(value) {
+	if (isWalletFlowEvent(value)) return value;
+	if (isRegistrationTimingSpanV1(value)) return value;
+	if (!isClientDeviceLinkProgressCandidate(value)) return null;
+	if (isDeviceLinkEmailOtpBaseFactorSelectionProgressV1(value)) return value;
+	return isDeviceLinkTargetFactorActivationProgressV1(value) ? value : null;
+}
+function parseClientPmResultPayload(value) {
+	const record = rawClientMessageObject(value);
+	if (!record || !hasOnlyClientMessageFields(record, [
+		"ok",
+		"result",
+		"error"
+	])) return null;
+	const ok = Reflect.get(record, "ok");
+	if (typeof ok !== "boolean") return null;
+	const error = Reflect.get(record, "error");
+	if (error !== void 0 && typeof error !== "string") return null;
+	return {
+		ok,
+		...Object.hasOwn(record, "result") ? { result: Reflect.get(record, "result") } : {},
+		...error !== void 0 ? { error } : {}
+	};
+}
+function parseClientErrorPayload(value) {
+	const record = rawClientMessageObject(value);
+	if (!record || !hasOnlyClientMessageFields(record, [
+		"code",
+		"message",
+		"details"
+	])) return null;
+	const code = Reflect.get(record, "code");
+	const message = Reflect.get(record, "message");
+	if (typeof code !== "string" || typeof message !== "string") return null;
+	return {
+		code,
+		message,
+		...Object.hasOwn(record, "details") ? { details: Reflect.get(record, "details") } : {}
+	};
+}
+function parseClientChildToParentEnvelope(value) {
+	const record = rawClientMessageObject(value);
+	if (!record || !hasOnlyClientMessageFields(record, [
+		"type",
+		"requestId",
+		"payload"
+	])) return null;
+	const requestId = clientChildRequestId(record);
+	if (requestId === null) return null;
+	const requestIdFields = clientChildRequestIdFields(requestId);
+	const type = Reflect.get(record, "type");
+	switch (type) {
+		case "PONG": return Object.hasOwn(record, "payload") ? null : {
+			...requestIdFields,
+			type
+		};
+		case "SESSION_CHANGED": try {
+			return {
+				type,
+				payload: parseWalletIframeExactSessionSnapshot(Reflect.get(record, "payload"))
+			};
+		} catch {
+			return null;
+		}
+		case "PREFERENCES_CHANGED": {
+			const payload = parseClientPreferencesChangedPayload(Reflect.get(record, "payload"));
+			return payload ? {
+				...requestIdFields,
+				type,
+				payload
+			} : null;
+		}
+		case "AUTH_MENU_EXTERNAL_AUTH_REQUEST": {
+			const payload = parseHostedAuthMenuExternalAuthRequest(Reflect.get(record, "payload"));
+			return payload ? {
+				...requestIdFields,
+				type,
+				payload
+			} : null;
+		}
+		case "AUTH_MENU_ERROR": {
+			const payload = parseHostedAuthMenuErrorEvent(Reflect.get(record, "payload"));
+			return payload ? {
+				...requestIdFields,
+				type,
+				payload
+			} : null;
+		}
+		case "TRANSACTION_REVIEW_STATE": {
+			const payload = parseTransactionReviewState(Reflect.get(record, "payload"));
+			return payload ? {
+				...requestIdFields,
+				type,
+				payload
+			} : null;
+		}
+		case "SURFACE_MEASUREMENT": {
+			const payload = parseWalletIframeSurfaceMeasurement(Reflect.get(record, "payload"));
+			return payload ? {
+				...requestIdFields,
+				type,
+				payload
+			} : null;
+		}
+		case "TRANSACTION_ACTIVITY": {
+			const payload = Reflect.get(record, "payload");
+			return typeof requestId === "string" && (payload === "expanded" || payload === "toast" || payload === "closed") ? {
+				type,
+				requestId,
+				payload
+			} : null;
+		}
+		case "PROGRESS": {
+			const payload = parseClientProgressPayload(Reflect.get(record, "payload"));
+			return payload ? {
+				...requestIdFields,
+				type,
+				payload
+			} : null;
+		}
+		case "PM_RESULT": {
+			const payload = parseClientPmResultPayload(Reflect.get(record, "payload"));
+			return payload ? {
+				...requestIdFields,
+				type,
+				payload
+			} : null;
+		}
+		case "ERROR": {
+			const payload = parseClientErrorPayload(Reflect.get(record, "payload"));
+			return payload ? {
+				...requestIdFields,
+				type,
+				payload
+			} : null;
+		}
+		default: return null;
+	}
+}
+function parseSdkLifecycleEnvelope(value) {
+	if (!isObject(value) || value.type !== "SDK_LIFECYCLE_EVENT") return { kind: "not_lifecycle_event" };
+	const payload = rawClientMessageObject(value.payload);
+	if (!payload) return { kind: "invalid_lifecycle_event" };
+	const event = parseSdkLifecycleEvent(Reflect.get(payload, "event"));
+	if (!event) return { kind: "invalid_lifecycle_event" };
+	try {
+		return {
+			kind: "lifecycle_event",
+			revision: parseWalletIframeSessionRevision(Reflect.get(payload, "revision")),
+			event
+		};
+	} catch {
+		return { kind: "invalid_lifecycle_event" };
+	}
+}
+//#endregion
+export { parseClientChildToParentEnvelope, parseClientPreferencesChangedPayload, parseSdkLifecycleEnvelope };
+
+//# sourceMappingURL=inboundMessages.js.map

package/dist/esm/SeamsWeb/walletIframe/client/nearCommands.js

@@ -0,0 +1,153 @@
+import { toError } from "../../../shared-ts/src/utils/errors.js";
+//#region src/SeamsWeb/walletIframe/client/nearCommands.ts
+function createApplicationNearCommands(walletIframe, beforeSigning, transactionDispatch) {
+	const commands = new ApplicationNearCommands(walletIframe, beforeSigning, transactionDispatch);
+	return {
+		signAndSendTransaction: commands.signAndSendTransaction.bind(commands),
+		signTransaction: commands.signTransaction.bind(commands),
+		sendTransaction: commands.sendTransaction.bind(commands),
+		signDelegateAction: commands.signDelegateAction.bind(commands),
+		signMessage: commands.signMessage.bind(commands)
+	};
+}
+var ApplicationNearCommands = class {
+	constructor(walletIframe, beforeSigning, transactionDispatch) {
+		this.walletIframe = walletIframe;
+		this.beforeSigning = beforeSigning;
+		this.transactionDispatch = transactionDispatch;
+	}
+	async signAndSendTransaction(args) {
+		const walletIframe = this.walletIframe;
+		const nearAccountId = args.nearAccount.accountId;
+		const transaction = {
+			receiverId: args.receiverId,
+			actions: args.actions
+		};
+		try {
+			await this.beforeSigning(args.walletSession.walletId);
+			const result = await (await walletIframe.requireRouter()).signAndSendTransaction({
+				walletId: args.walletSession.walletId,
+				nearAccountId,
+				transaction,
+				options: args.options
+			}, this.transactionDispatch);
+			await args.options?.afterCall?.(true, result);
+			return result;
+		} catch (error) {
+			const e = toError(error);
+			await args.options?.onError?.(e);
+			await args.options?.afterCall?.(false, void 0, e);
+			throw e;
+		}
+	}
+	async signTransaction(args) {
+		const walletIframe = this.walletIframe;
+		const nearAccountId = args.nearAccount.accountId;
+		const { transaction, options } = args;
+		try {
+			await this.beforeSigning(args.walletSession.walletId);
+			const result = await (await walletIframe.requireRouter()).signTransaction({
+				walletId: args.walletSession.walletId,
+				nearAccountId,
+				transaction: {
+					receiverId: transaction.receiverId,
+					actions: transaction.actions
+				},
+				options: {
+					signerSlot: options.signerSlot,
+					onEvent: options.onEvent,
+					confirmationConfig: options.confirmationConfig,
+					confirmerText: options.confirmerText
+				}
+			});
+			await options?.afterCall?.(true, result);
+			return result;
+		} catch (error) {
+			const e = toError(error);
+			await options?.onError?.(e);
+			await options?.afterCall?.(false, void 0, e);
+			throw e;
+		}
+	}
+	async sendTransaction(args) {
+		const walletIframe = this.walletIframe;
+		const nearAccountId = args.nearAccount.accountId;
+		try {
+			await this.beforeSigning(args.walletSession.walletId);
+			const result = await (await walletIframe.requireRouter()).sendTransaction({
+				walletId: args.walletSession.walletId,
+				nearAccountId,
+				signedTransaction: args.signedTransaction,
+				options: {
+					onEvent: args.options?.onEvent,
+					...args.options && "waitUntil" in args.options ? { waitUntil: args.options.waitUntil } : {}
+				}
+			});
+			await args.options?.afterCall?.(true, result);
+			return result;
+		} catch (error) {
+			const e = toError(error);
+			await args.options?.onError?.(e);
+			await args.options?.afterCall?.(false, void 0, e);
+			throw e;
+		}
+	}
+	async signDelegateAction(args) {
+		const walletIframe = this.walletIframe;
+		const nearAccountId = args.nearAccount.accountId;
+		const { delegate, options } = args;
+		try {
+			await this.beforeSigning(args.walletSession.walletId);
+			const result = await (await walletIframe.requireRouter()).signDelegateAction({
+				walletId: args.walletSession.walletId,
+				nearAccountId,
+				delegate,
+				options: {
+					signerSlot: options.signerSlot,
+					onEvent: options.onEvent,
+					confirmationConfig: options.confirmationConfig,
+					confirmerText: options.confirmerText
+				}
+			});
+			await options?.afterCall?.(true, result);
+			return result;
+		} catch (error) {
+			const e = toError(error);
+			await options?.onError?.(e);
+			await options?.afterCall?.(false, void 0, e);
+			throw e;
+		}
+	}
+	async signMessage(args) {
+		const walletIframe = this.walletIframe;
+		const nearAccountId = args.nearAccount.accountId;
+		try {
+			await this.beforeSigning(args.walletSession.walletId);
+			const result = await (await walletIframe.requireRouter()).signNep413Message({
+				walletId: args.walletSession.walletId,
+				nearAccountId,
+				message: args.params.message,
+				recipient: args.params.recipient,
+				callbackUrl: args.params.callbackUrl,
+				state: args.params.state,
+				options: {
+					signerSlot: args.options.signerSlot,
+					onEvent: args.options.onEvent,
+					confirmerText: args.options.confirmerText,
+					confirmationConfig: args.options.confirmationConfig
+				}
+			});
+			await args.options?.afterCall?.(true, result);
+			return result;
+		} catch (error) {
+			const e = toError(error);
+			await args.options?.onError?.(e);
+			await args.options?.afterCall?.(false, void 0, e);
+			throw e;
+		}
+	}
+};
+//#endregion
+export { createApplicationNearCommands };
+
+//# sourceMappingURL=nearCommands.js.map

package/dist/esm/SeamsWeb/walletIframe/client/overlay/overlay-styles.js

@@ -1,8 +1,8 @@
 import { resolveAppearanceTheme } from "../../../../core/config/configHelpers.js";
-import { createCspStylesheetManager, getDefaultCspNonce } from "../../../../core/browser/walletIframe/csp-stylesheet.js";
-import { appearanceTokenCssRule } from "../../../../core/signingEngine/uiConfirm/ui/appearance-token-vars.js";
 import "../surface/geometry.js";
 import { DARK_THEME, LIGHT_THEME } from "../../../../base-styles.js";
+import { appearanceTokenCssRule } from "../../../../core/signingEngine/uiConfirm/ui/appearance-token-vars.js";
+import { createCspStylesheetManager, getDefaultCspNonce } from "../../../../core/browser/walletIframe/csp-stylesheet.js";
 //#region src/SeamsWeb/walletIframe/client/overlay/overlay-styles.ts
 /**
 * CSP-safe styles for the host-owned wallet iframe dialog.

package/dist/esm/SeamsWeb/walletIframe/client/placementCommands.js

@@ -0,0 +1,65 @@
+import { parseWalletMoveRequest, parseWalletMoveStatusResult, parseWalletPlacementResult } from "../../publicApi/placement.js";
+//#region src/SeamsWeb/walletIframe/client/placementCommands.ts
+function createIframePlacementCommands(post) {
+	return {
+		getLastMoveRequest: readLastMoveFromHost.bind(null, post),
+		move: moveFromHost.bind(null, post),
+		get: readFromHost.bind(null, post),
+		getMove: readMoveFromHost.bind(null, post)
+	};
+}
+async function readFromHost(post, walletId) {
+	return parseWalletPlacementResult((await post({
+		type: "PM_GET_WALLET_PLACEMENT",
+		payload: { walletId }
+	})).result);
+}
+function createApplicationPlacementCommands(iframe) {
+	return {
+		getLastMoveRequest: readLastMoveFromIframe.bind(null, iframe),
+		move: moveFromIframe.bind(null, iframe),
+		get: readFromIframe.bind(null, iframe),
+		getMove: readMoveFromIframe.bind(null, iframe)
+	};
+}
+async function readFromIframe(iframe, walletId) {
+	return (await iframe.requireRouter()).placement.get(walletId);
+}
+async function readMoveFromHost(post, walletId, moveId) {
+	return parseWalletMoveStatusResult((await post({
+		type: "PM_GET_WALLET_MOVE",
+		payload: {
+			walletId,
+			moveId
+		}
+	})).result, moveId);
+}
+async function readMoveFromIframe(iframe, walletId, moveId) {
+	return (await iframe.requireRouter()).placement.getMove(walletId, moveId);
+}
+async function moveFromHost(post, request) {
+	return parseWalletMoveStatusResult((await post({
+		type: "PM_MOVE_WALLET",
+		payload: request
+	}, { timeout: "interactive" })).result, request.moveId);
+}
+async function moveFromIframe(iframe, request) {
+	return (await iframe.requireRouter()).placement.move(request);
+}
+async function readLastMoveFromHost(post, walletId) {
+	const response = await post({
+		type: "PM_GET_LAST_WALLET_MOVE_REQUEST",
+		payload: { walletId }
+	});
+	if (response.result === null) return null;
+	const request = parseWalletMoveRequest(response.result);
+	if (request.walletId !== walletId) throw new Error("Wallet move locator identity changed");
+	return request;
+}
+async function readLastMoveFromIframe(iframe, walletId) {
+	return (await iframe.requireRouter()).placement.getLastMoveRequest(walletId);
+}
+//#endregion
+export { createApplicationPlacementCommands, createIframePlacementCommands };
+
+//# sourceMappingURL=placementCommands.js.map

package/dist/esm/SeamsWeb/walletIframe/client/preferenceState.js

@@ -0,0 +1,93 @@
+import { DEFAULT_CONFIRMATION_CONFIG } from "../../../core/types/signer-worker.js";
+//#region src/SeamsWeb/walletIframe/client/preferenceState.ts
+/** Application-origin projection. It has no persistence or signing dependencies. */
+var ClientPreferenceState = class {
+	constructor() {
+		this.currentWalletId = null;
+		this.confirmed = /* @__PURE__ */ new Map();
+		this.pending = /* @__PURE__ */ new Map();
+		this.configurationListeners = /* @__PURE__ */ new Set();
+		this.walletListeners = /* @__PURE__ */ new Set();
+		this.disposed = false;
+	}
+	getCurrentWalletId() {
+		return this.currentWalletId;
+	}
+	getConfirmationConfig() {
+		let config = { ...this.confirmed.get(this.currentWalletId) ?? this.confirmed.get(null) ?? DEFAULT_CONFIRMATION_CONFIG };
+		for (const write of this.pending.values()) if (write.walletId === null || write.walletId === this.currentWalletId) config = {
+			...config,
+			...write.patch
+		};
+		return config;
+	}
+	setCurrentWallet(walletId) {
+		if (this.disposed || this.currentWalletId === walletId) return;
+		this.currentWalletId = walletId;
+		for (const listener of this.walletListeners) try {
+			listener(walletId);
+		} catch {}
+		this.notifyConfiguration();
+	}
+	beginWrite(id, walletId, patch) {
+		this.pending.set(id, {
+			walletId,
+			patch
+		});
+		this.notifyConfiguration();
+	}
+	settleWrite(id, succeeded) {
+		const write = this.pending.get(id);
+		if (!write) return;
+		if (succeeded) {
+			const previous = this.confirmed.get(write.walletId) ?? this.confirmed.get(null) ?? DEFAULT_CONFIRMATION_CONFIG;
+			this.confirmed.set(write.walletId, {
+				...previous,
+				...write.patch
+			});
+		}
+		this.pending.delete(id);
+		this.notifyConfiguration();
+	}
+	notifyConfiguration() {
+		if (this.disposed) return;
+		for (const listener of this.configurationListeners) try {
+			listener(this.getConfirmationConfig());
+		} catch {}
+	}
+	applyWalletHostConfirmationConfig(input) {
+		if (this.disposed) return;
+		if (input.walletId && this.currentWalletId === null) this.setCurrentWallet(input.walletId);
+		const config = input.confirmationConfig;
+		this.confirmed.set(input.walletId, {
+			uiMode: config.uiMode ?? DEFAULT_CONFIRMATION_CONFIG.uiMode,
+			behavior: config.behavior ?? DEFAULT_CONFIRMATION_CONFIG.behavior,
+			autoProceedDelay: config.autoProceedDelay ?? DEFAULT_CONFIRMATION_CONFIG.autoProceedDelay
+		});
+		this.notifyConfiguration();
+	}
+	onConfirmationConfigChange(listener) {
+		if (!this.disposed) this.configurationListeners.add(listener);
+		return this.removeConfigurationListener.bind(this, listener);
+	}
+	onCurrentWalletChange(listener) {
+		if (!this.disposed) this.walletListeners.add(listener);
+		return this.removeWalletListener.bind(this, listener);
+	}
+	dispose() {
+		this.disposed = true;
+		this.pending.clear();
+		this.configurationListeners.clear();
+		this.walletListeners.clear();
+	}
+	removeConfigurationListener(listener) {
+		this.configurationListeners.delete(listener);
+	}
+	removeWalletListener(listener) {
+		this.walletListeners.delete(listener);
+	}
+};
+//#endregion
+export { ClientPreferenceState };
+
+//# sourceMappingURL=preferenceState.js.map