@seams/wallet 0.26.0 → 0.28.0

package/dist/.build-inputs.sha256

@@ -1 +1 @@
-5e18387096278925c5c1f4c69f379b59f0eab2e662d419fe575bee269eb216df
+ea177740b9a568b4deea722dc18528d4cbfd4098970381660360b3bd1003291b

package/dist/esm/SeamsWeb/publicApi/near.js

@@ -1,5 +1,6 @@
 import { CAPABILITY_KINDS, NEAR_ED25519_MPC_OPERATION_KINDS } from "../../shared-ts/src/authorization/capabilityKinds.js";
 import { toError } from "../../shared-ts/src/utils/errors.js";
+import { nearTransactionFailure } from "../../core/signingEngine/nearTransactionSubmission.js";
 import { requireBrowserCapabilityOperation } from "./capabilitySelection.js";
 import { accountExists } from "../../core/rpcClients/near/accountExists.js";
 import { delegateRelayerAuthFromConfigs, sendDelegateAction } from "../operations/near/delegateAction.js";
@@ -23,16 +24,21 @@ var NearSigner = class {
 		this.deps = deps;
 	}
 	async signAndSendTransaction(rawArgs) {
-		const args = {
+		let subject;
+		try {
+			subject = await this.deps.currentWallet.nearSubject(rawArgs);
+			requireBrowserCapabilityOperation(this.deps.configs, {
+				capabilityKind: CAPABILITY_KINDS.nearEd25519MpcSigning,
+				operationKind: NEAR_ED25519_MPC_OPERATION_KINDS.signTransaction
+			});
+		} catch (error) {
+			return nearTransactionFailure(error, "not_submitted");
+		}
+		return this.deps.commands.signAndSendTransaction({
 			...rawArgs,
-			...await this.deps.currentWallet.nearSubject(rawArgs),
+			...subject,
 			options: rawArgs.options ?? {}
-		};
-		requireBrowserCapabilityOperation(this.deps.configs, {
-			capabilityKind: CAPABILITY_KINDS.nearEd25519MpcSigning,
-			operationKind: NEAR_ED25519_MPC_OPERATION_KINDS.signTransaction
 		});
-		return await this.deps.commands.signAndSendTransaction(args);
 	}
 	async signTransaction(rawArgs) {
 		const args = {
@@ -47,12 +53,17 @@ var NearSigner = class {
 		return await this.deps.commands.signTransaction(args);
 	}
 	async sendTransaction(rawArgs) {
-		const args = {
+		let subject;
+		try {
+			subject = await this.deps.currentWallet.nearSubject(rawArgs);
+		} catch (error) {
+			return nearTransactionFailure(error, "not_submitted");
+		}
+		return this.deps.commands.sendTransaction({
 			...rawArgs,
-			...await this.deps.currentWallet.nearSubject(rawArgs),
+			...subject,
 			options: rawArgs.options ?? {}
-		};
-		return await this.deps.commands.sendTransaction(args);
+		});
 	}
 	async signDelegateAction(rawArgs) {
 		const args = {

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

@@ -1,4 +1,5 @@
 import { toError } from "../../../shared-ts/src/utils/errors.js";
+import { nearTransactionFailure, notifyNearTransactionResult } from "../../../core/signingEngine/nearTransactionSubmission.js";
 //#region src/SeamsWeb/walletIframe/client/nearCommands.ts
 function createApplicationNearCommands(walletIframe, beforeSigning, transactionDispatch) {
 	const commands = new ApplicationNearCommands(walletIframe, beforeSigning, transactionDispatch);
@@ -31,13 +32,12 @@ var ApplicationNearCommands = class {
 				transaction,
 				options: args.options
 			}, this.transactionDispatch);
-			await args.options?.afterCall?.(true, result);
+			await notifyNearTransactionResult(args.options, result);
 			return result;
 		} catch (error) {
-			const e = toError(error);
-			await args.options?.onError?.(e);
-			await args.options?.afterCall?.(false, void 0, e);
-			throw e;
+			const result = nearTransactionFailure(error, "not_submitted");
+			await notifyNearTransactionResult(args.options, result);
+			return result;
 		}
 	}
 	async signTransaction(args) {
@@ -83,13 +83,12 @@ var ApplicationNearCommands = class {
 					...args.options && "waitUntil" in args.options ? { waitUntil: args.options.waitUntil } : {}
 				}
 			});
-			await args.options?.afterCall?.(true, result);
+			await notifyNearTransactionResult(args.options, result);
 			return result;
 		} catch (error) {
-			const e = toError(error);
-			await args.options?.onError?.(e);
-			await args.options?.afterCall?.(false, void 0, e);
-			throw e;
+			const result = nearTransactionFailure(error, "not_submitted");
+			await notifyNearTransactionResult(args.options, result);
+			return result;
 		}
 	}
 	async signDelegateAction(args) {

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

@@ -3,6 +3,7 @@ import { extractBorshBytesFromPlainSignedTx, isBoolean, isObject, isPlainSignedT
 import { parseMpcMaterialActivationRef } from "../../../shared-ts/src/utils/domainIds.js";
 import { createIframePlacementCommands } from "./placementCommands.js";
 import { toError } from "../../../shared-ts/src/utils/errors.js";
+import { NearTransactionRequest, parseNearTransactionResult } from "../../../core/signingEngine/nearTransactionSubmission.js";
 import { secureRandomBase36 } from "../../../shared-ts/src/utils/secureRandomId.js";
 import { SignedTransaction } from "../../../core/rpcClients/near/NearClient.js";
 import { thresholdEcdsaChainTargetsEqual, toWalletId } from "../../../core/signingEngine/interfaces/ecdsaChainTarget.js";
@@ -1902,6 +1903,44 @@ var WalletIframeRouter = class {
 			}
 		}, { timeout: "interactive" })).result;
 	}
+	async authenticate(input) {
+		return (await this.post({
+			type: "PM_EXTERNAL_AUTH",
+			payload: {
+				action: "authenticate",
+				input
+			}
+		})).result;
+	}
+	async prepareExternalAuth(walletId) {
+		return (await this.post({
+			type: "PM_EXTERNAL_AUTH",
+			payload: {
+				action: "prepare",
+				walletId
+			}
+		})).result;
+	}
+	async removeExternalAuth(input) {
+		return (await this.post({
+			type: "PM_EXTERNAL_AUTH",
+			payload: {
+				action: "unlink",
+				walletId: input.walletId,
+				associationId: input.associationId
+			}
+		})).result;
+	}
+	async associateExternalAuth(input) {
+		return (await this.post({
+			type: "PM_EXTERNAL_AUTH",
+			payload: {
+				action: "associate",
+				walletId: input.walletId,
+				idToken: input.idToken
+			}
+		})).result;
+	}
 	async getWalletSession(walletId) {
 		const expectedWalletId = walletId === void 0 ? void 0 : parseRequestedWalletId(walletId);
 		if (!this.state.ready || !this.state.port) await this.init();
@@ -2463,31 +2502,39 @@ var WalletIframeRouter = class {
 		};
 	}
 	async signAndSendTransaction(payload, transactionDispatch = { kind: "ordinary" }) {
-		if (transactionDispatch.kind === "reviewed") payload = {
-			...payload,
-			options: {
-				...payload.options,
-				confirmationConfig: transactionDispatch.reservation.confirmationConfig
-			}
-		};
-		const { options } = payload;
-		const safeOptions = {
-			waitUntil: options.waitUntil,
-			...options.voiceId !== void 0 ? { voiceId: options.voiceId } : {},
-			confirmationConfig: options.confirmationConfig,
-			...typeof options.signerSlot === "number" ? { signerSlot: options.signerSlot } : {},
-			...options.confirmerText ? { confirmerText: options.confirmerText } : {}
-		};
-		return (await this.post({
-			type: "PM_SIGN_AND_SEND_TX",
-			payload: {
-				walletId: payload.walletId,
-				nearAccountId: payload.nearAccountId,
-				transaction: payload.transaction,
-				options: safeOptions
-			},
-			options: { onProgress: this.wrapOnEvent(options?.onEvent, isSigningFlowEvent) }
-		}, { transactionDispatch })).result;
+		const request = new NearTransactionRequest({ kind: "sign_and_send" });
+		try {
+			if (transactionDispatch.kind === "reviewed") payload = {
+				...payload,
+				options: {
+					...payload.options,
+					confirmationConfig: transactionDispatch.reservation.confirmationConfig
+				}
+			};
+			const { options } = payload;
+			const safeOptions = {
+				waitUntil: options.waitUntil,
+				...options.voiceId !== void 0 ? { voiceId: options.voiceId } : {},
+				confirmationConfig: options.confirmationConfig,
+				...typeof options.signerSlot === "number" ? { signerSlot: options.signerSlot } : {},
+				...options.confirmerText ? { confirmerText: options.confirmerText } : {}
+			};
+			return parseNearTransactionResult((await this.post({
+				type: "PM_SIGN_AND_SEND_TX",
+				payload: {
+					walletId: payload.walletId,
+					nearAccountId: payload.nearAccountId,
+					transaction: payload.transaction,
+					options: safeOptions
+				},
+				options: { onProgress: this.wrapOnEvent(options?.onEvent, isSigningFlowEvent) }
+			}, {
+				transactionDispatch,
+				onDispatched: request.dispatched
+			})).result);
+		} catch (error) {
+			return request.failed(error);
+		}
 	}
 	async hasPasskeyCredential(walletId) {
 		return !!(await this.post({
@@ -2518,18 +2565,26 @@ var WalletIframeRouter = class {
 		})).result);
 	}
 	async sendTransaction(args) {
-		const { options } = args;
-		const safeOptions = options ? { waitUntil: options.waitUntil } : void 0;
-		return (await this.post({
-			type: "PM_SEND_TRANSACTION",
-			payload: {
-				walletId: args.walletId,
-				nearAccountId: args.nearAccountId,
-				signedTransaction: args.signedTransaction,
-				options: safeOptions
-			},
-			options: { onProgress: this.wrapOnEvent(options?.onEvent, isSigningFlowEvent) }
-		})).result;
+		const request = new NearTransactionRequest({
+			kind: "send",
+			transactionId: args.signedTransaction.transactionHash
+		});
+		try {
+			const { options } = args;
+			const safeOptions = options ? { waitUntil: options.waitUntil } : void 0;
+			return parseNearTransactionResult((await this.post({
+				type: "PM_SEND_TRANSACTION",
+				payload: {
+					walletId: args.walletId,
+					nearAccountId: args.nearAccountId,
+					signedTransaction: args.signedTransaction,
+					options: safeOptions
+				},
+				options: { onProgress: this.wrapOnEvent(options?.onEvent, isSigningFlowEvent) }
+			}, { onDispatched: request.dispatched })).result);
+		} catch (error) {
+			return request.failed(error);
+		}
 	}
 	async resolveExactKeyExportLane(input) {
 		return parseResolveExactKeyExportLaneResult((await this.post({
@@ -2711,7 +2766,7 @@ var WalletIframeRouter = class {
 				requestId,
 				payload
 			});
-			if (!this.reviews.has(requestId) && isWalletFlowEvent(payload) && payload.status === "cancelled") {
+			if (!this.reviews.has(requestId) && this.state.pending.get(requestId)?.requestType !== "PM_SIGN_AND_SEND_TX" && this.state.pending.get(requestId)?.requestType !== "PM_SEND_TRANSACTION" && isWalletFlowEvent(payload) && payload.status === "cancelled") {
 				this.settlePendingRequestCancellation(requestId, false);
 				this.sendBestEffortCancel(requestId);
 				return;
@@ -2902,6 +2957,7 @@ var WalletIframeRouter = class {
 						options: void 0
 					};
 					this.state.port.postMessage(serializableFull);
+					postOpts?.onDispatched?.();
 				} catch (err) {
 					this.state.pending.delete(requestId);
 					window.clearTimeout(timer);
@@ -3055,6 +3111,7 @@ function normalizeSignedTransactionResult(result) {
 			transaction: signedTransaction.transaction,
 			signature: signedTransaction.signature,
 			borsh_bytes: extractBorshBytesFromPlainSignedTx(signedTransaction),
+			transactionHash: signedTransaction.transactionHash,
 			...nonceLease ? { nonceLease } : {},
 			...serverDispatch ? { serverDispatch } : {}
 		})

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

@@ -3,6 +3,10 @@ import { walletIframeUnlockRequestFromLoginHooks } from "../shared/unlockOptions
 //#region src/SeamsWeb/walletIframe/client/sessionCommands.ts
 function createApplicationSessionCommands(walletIframe) {
 	return {
+		authenticate: authenticate.bind(null, walletIframe),
+		prepareExternalAuth: prepareExternalAuth.bind(null, walletIframe),
+		associateExternalAuth: associateExternalAuth.bind(null, walletIframe),
+		removeExternalAuth: removeExternalAuth.bind(null, walletIframe),
 		unlock: unlock.bind(null, walletIframe),
 		unlockWithAuthMethod: unlockWithAuthMethod.bind(null, walletIframe),
 		lock: lock.bind(null, walletIframe),
@@ -11,6 +15,18 @@ function createApplicationSessionCommands(walletIframe) {
 		hasPasskey: hasPasskey.bind(null, walletIframe)
 	};
 }
+async function authenticate(walletIframe, input) {
+	return (await walletIframe.requireRouter()).authenticate(input);
+}
+async function prepareExternalAuth(walletIframe, walletId) {
+	return (await walletIframe.requireRouter()).prepareExternalAuth(walletId);
+}
+async function associateExternalAuth(walletIframe, input) {
+	return (await walletIframe.requireRouter()).associateExternalAuth(input);
+}
+async function removeExternalAuth(walletIframe, input) {
+	return (await walletIframe.requireRouter()).removeExternalAuth(input);
+}
 async function unlock(walletIframe, walletId, options) {
 	const resolvedWalletId = String(walletId || "").trim();
 	if (!resolvedWalletId) throw new Error("unlock requires walletId");

package/dist/esm/SeamsWeb/walletIframe/host/surface-measurement-reporter.js

@@ -23,6 +23,7 @@ function sizeFromEntryOrElement(element, entry) {
 function sizeForReporter(options, entry) {
 	if (options.kind === "request_scroll_surface") {
 		const rect = options.element.getBoundingClientRect();
+		if (options.element.classList.contains("seams-confirm-surface-pinned")) return sizeFromRect(rect);
 		return sizeFromRect({
 			width: Math.max(options.element.scrollWidth, rect.width),
 			height: Math.max(options.element.scrollHeight, rect.height)

package/dist/esm/SeamsWeb/walletIframe/host/ui/auth-menu/AuthMenuSurface.js

@@ -753,7 +753,7 @@ var AuthMenuSurface = class extends Component {
 					"data-auth-menu-provider": "google",
 					disabled: !isAuthMenuGoogleActionReady(viewModel),
 					onClick: this.onGoogleClick,
-					children: [googleIcon(), /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(WalletText, { copy: viewModel.mode === "login" ? "Email code (Google)" : "Continue with Google" }) })]
+					children: [googleIcon(), /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(WalletText, { copy: viewModel.mode === "login" ? "Unlock with email code" : "Continue with Google" }) })]
 				}) : null,
 				viewModel.mode === "login" && viewModel.accountOptions.some(voiceAvailableForWallet.bind(null, selectedLoginAccount(viewModel)?.walletId)) ? /* @__PURE__ */ jsxs("button", {
 					type: "button",

package/dist/esm/SeamsWeb/walletIframe/host/ui/auth-menu/mountAuthMenuSurface.js

@@ -24,6 +24,7 @@ function authMenuStyles(document) {
 var MountedAuthMenuSurface = class {
 	element;
 	styles;
+	entrance = [];
 	state;
 	constructor(input) {
 		const document = input.parent.ownerDocument;
@@ -39,11 +40,36 @@ var MountedAuthMenuSurface = class {
 		input.parent.appendChild(this.element);
 		try {
 			this.update(input.viewModel);
+			this.animateEntrance(input.initialHeightCssPx);
 		} catch (error) {
 			this.dispose();
 			throw error;
 		}
 	}
+	animateEntrance(initialHeightCssPx) {
+		if (initialHeightCssPx === void 0 || window.matchMedia("(prefers-reduced-motion: reduce)").matches) return;
+		const card = this.element.querySelector(".auth-menu-root");
+		if (!card) return;
+		const height = card.getBoundingClientRect().height;
+		this.entrance.push(card.animate([{
+			height: `${initialHeightCssPx}px`,
+			minHeight: "0px",
+			overflow: "hidden"
+		}, {
+			height: `${height}px`,
+			minHeight: "0px",
+			overflow: "hidden"
+		}], {
+			duration: 200,
+			easing: "cubic-bezier(0.32, 0.72, 0, 1)"
+		}));
+		for (const child of card.children) this.entrance.push(child.animate([{ opacity: 0 }, { opacity: 1 }], {
+			duration: 140,
+			delay: 60,
+			fill: "backwards",
+			easing: "cubic-bezier(0.25, 1, 0.5, 1)"
+		}));
+	}
 	update(viewModel) {
 		if (this.state.kind === "disposed") return;
 		this.element.lang = viewModel.appearance.locale ?? "en";
@@ -59,6 +85,8 @@ var MountedAuthMenuSurface = class {
 	dispose() {
 		if (this.state.kind === "disposed") return;
 		this.state = { kind: "disposed" };
+		for (const animation of this.entrance) animation.cancel();
+		this.entrance = [];
 		this.element.removeEventListener("cancel", this.cancel);
 		render(null, this.element);
 		this.styles.deleteDynamicRule(this.element.id + "-appearance");

package/dist/esm/SeamsWeb/walletIframe/host/walletMutationGuard.js

@@ -44,6 +44,7 @@ function walletForHostRequest(request, currentWalletId) {
 		case "PM_REGISTER_WALLET":
 		case "PM_UNLOCK":
 		case "PM_UNLOCK_AUTH_METHOD":
+		case "PM_EXTERNAL_AUTH":
 		case "PM_LOCK":
 		case "PM_LOCK_EXACT_WALLET_SESSION":
 		case "PM_GET_LAST_WALLET_MOVE_REQUEST":

package/dist/esm/SeamsWeb/walletIframe/shared/exactSessionState.js

@@ -6,6 +6,7 @@ import "../../../shared-ts/src/device-linking/activeWalletSession.js";
 import { parseWalletAuthAuthorityRef } from "../../../shared-ts/src/utils/walletAuthAuthority.js";
 import { toAccountId } from "../../../core/types/accountIds.js";
 import { isWalletAuthMethod } from "../../../shared-ts/src/utils/signerDomain.js";
+import { parseExternalWalletAuthentication, parseExternalWalletSettings } from "../../../shared-ts/src/auth/externalAuth.js";
 import { NonceCoordinatorDegradationReason, NonceCoordinatorFallback, NonceLeaseState } from "../../../core/signingEngine/nonce/nonceTypes.js";
 import { parseEcdsaThresholdKeyId } from "../../../core/signingEngine/session/keyMaterialBrands.js";
 import { parseNearEd25519SigningKeyId } from "../../../shared-ts/src/utils/registrationIds.js";
@@ -89,12 +90,33 @@ function parseWalletIframeExactSessionState(value) {
 function parseWalletSessionFromBoundary(value, expectedWalletId) {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("Wallet Session must be an object");
 	if (Reflect.get(value, "reusableWalletSession") !== void 0) throw new Error("Wallet Session contains removed reusable-session fields");
-	const parsed = {
-		appIdentity: parseWalletSessionAppIdentity(Reflect.get(value, "appIdentity")),
-		authentication: parseWalletAuthenticationState(Reflect.get(value, "authentication")),
-		capabilityProjection: parseWalletSessionCapabilityProjection(Reflect.get(value, "capabilityProjection")),
+	const appIdentity = parseWalletSessionAppIdentity(Reflect.get(value, "appIdentity"));
+	const authentication = parseWalletAuthenticationState(Reflect.get(value, "authentication"));
+	const capabilityProjection = parseWalletSessionCapabilityProjection(Reflect.get(value, "capabilityProjection"));
+	const common = {
+		appIdentity,
 		nonceDiagnostics: parseNullableNonceDiagnostics(Reflect.get(value, "nonceDiagnostics"))
 	};
+	let parsed;
+	if (authentication.kind === "external_authenticated") {
+		if (appIdentity.kind !== "resolved") throw new Error("External authentication requires a resolved wallet");
+		if (common.nonceDiagnostics !== null) throw new Error("External authentication has no signing runtime");
+		if (capabilityProjection.kind !== "not_requested") throw new Error("External authentication cannot grant signing capabilities");
+		const externalSettings = parseExternalWalletSettings(Reflect.get(value, "externalSettings"));
+		if (externalSettings.authentication.sessionId !== authentication.sessionId || externalSettings.authentication.walletId !== authentication.walletId || externalSettings.authentication.associationId !== authentication.associationId || externalSettings.authentication.environmentId !== authentication.environmentId || externalSettings.authentication.expiresAtMs !== authentication.expiresAtMs) throw new Error("External settings identity mismatch");
+		parsed = {
+			appIdentity,
+			nonceDiagnostics: common.nonceDiagnostics,
+			authentication,
+			capabilityProjection,
+			externalSettings
+		};
+	} else parsed = {
+		appIdentity: common.appIdentity,
+		nonceDiagnostics: common.nonceDiagnostics,
+		authentication,
+		capabilityProjection
+	};
 	const expected = expectedWalletId === void 0 ? null : requireWalletId(expectedWalletId);
 	const canonicalWalletId = walletSessionCanonicalWalletId(parsed);
 	if (expected !== null && canonicalWalletId === null) throw new Error("Wallet iframe Wallet Session omitted the requested wallet identity");
@@ -106,6 +128,7 @@ function parseWalletAuthenticationState(value) {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("Wallet Session authentication must be an object");
 	switch (Reflect.get(value, "kind")) {
 		case "signed_out": return { kind: "signed_out" };
+		case "external_authenticated": return parseExternalWalletAuthentication(value);
 		case "authenticated": {
 			const authMethod = Reflect.get(value, "authMethod");
 			if (!isWalletAuthMethod(authMethod)) throw new Error("Wallet Session authentication method is invalid");

package/dist/esm/SeamsWeb/walletIframe/shared/messages.js

@@ -203,6 +203,7 @@ function parseHostedAuthMenuOpenRequest(value) {
 		"kind",
 		"authMenuSessionId",
 		"initialMode",
+		"initialHeightCssPx",
 		"loginTarget",
 		"registrationAccountInput",
 		"showRegistrationInput",
@@ -212,6 +213,8 @@ function parseHostedAuthMenuOpenRequest(value) {
 	]) || !hasOnlyHostedAuthMenuCopyKeys(record.copy)) return null;
 	const authMenuSessionId = hostedAuthMenuSessionIdFromBoundary(record.authMenuSessionId);
 	const initialMode = parseAuthMenuMode(record.initialMode);
+	const initialHeightCssPx = record.initialHeightCssPx;
+	if (initialHeightCssPx !== void 0 && (typeof initialHeightCssPx !== "number" || !Number.isFinite(initialHeightCssPx) || initialHeightCssPx <= 0)) return null;
 	const loginTargetRecord = recordFromBoundary(record.loginTarget);
 	const loginWalletId = loginTargetRecord?.kind === "wallet" || loginTargetRecord?.kind === "wallet_sync" ? parseWalletId(loginTargetRecord.walletId) : null;
 	const loginTarget = loginTargetRecord?.kind === "discoverable" && hasOnlyKeys(loginTargetRecord, ["kind"]) ? { kind: "discoverable" } : loginTargetRecord?.kind === "wallet" && hasOnlyKeys(loginTargetRecord, ["kind", "walletId"]) && loginWalletId?.ok ? {
@@ -228,6 +231,7 @@ function parseHostedAuthMenuOpenRequest(value) {
 		kind: "hosted_auth_menu_open_v1",
 		authMenuSessionId,
 		initialMode,
+		initialHeightCssPx,
 		loginTarget,
 		registrationAccountInput,
 		showRegistrationInput: record.showRegistrationInput,
@@ -242,6 +246,7 @@ function buildHostedAuthMenuOpenRequest(args) {
 	if (!argsRecord || !hasOnlyKeys(argsRecord, [
 		"authMenuSessionId",
 		"initialMode",
+		"initialHeightCssPx",
 		"loginTarget",
 		"registrationAccountInput",
 		"showRegistrationInput",
@@ -255,6 +260,7 @@ function buildHostedAuthMenuOpenRequest(args) {
 		kind: "hosted_auth_menu_open_v1",
 		authMenuSessionId: parsedSessionId,
 		initialMode: args.initialMode ?? "login",
+		initialHeightCssPx: args.initialHeightCssPx,
 		loginTarget: args.loginTarget ?? { kind: "discoverable" },
 		registrationAccountInput: args.registrationAccountInput ?? "implicit_wallet",
 		showRegistrationInput: args.showRegistrationInput ?? false,
@@ -464,7 +470,7 @@ function parseHostedAuthMenuOutcome(value) {
 		default: return null;
 	}
 }
-const WALLET_PROTOCOL_VERSION = "17.0.0";
+const WALLET_PROTOCOL_VERSION = "18.0.0";
 const WALLET_IFRAME_PROTOCOL_VERSION_MISMATCH = "WALLET_IFRAME_PROTOCOL_VERSION_MISMATCH";
 const HOSTED_WALLET_REDEMPTION_PAYLOAD_FIELDS = [
 	"home",

package/dist/esm/core/authMethods/plugins.js

@@ -5,12 +5,18 @@ function parseWalletAuthMethodPlugins(value) {
 	const plugins = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const candidate of value) {
-		if (!isPlainObject(candidate) || Object.keys(candidate).length !== 1 || candidate.kind !== "voiceid" || seen.has(candidate.kind)) throw new Error("Unsupported or duplicate wallet auth method plugin.");
+		if (!isPlainObject(candidate) || Object.keys(candidate).some(unknownVoiceIdOption) || candidate.kind !== "voiceid" || candidate.transcriptionModel !== void 0 && candidate.transcriptionModel !== "aurora" && candidate.transcriptionModel !== "citrinet" || seen.has(candidate.kind)) throw new Error("Unsupported or duplicate wallet auth method plugin.");
 		seen.add(candidate.kind);
-		plugins.push({ kind: "voiceid" });
+		plugins.push({
+			kind: "voiceid",
+			transcriptionModel: candidate.transcriptionModel ?? "citrinet"
+		});
 	}
 	return plugins;
 }
+function unknownVoiceIdOption(key) {
+	return key !== "kind" && key !== "transcriptionModel";
+}
 //#endregion
 export { parseWalletAuthMethodPlugins };
 

package/dist/esm/core/rpcClients/near/NearClient.js

@@ -1,13 +1,20 @@
+import { requireCanonicalString } from "../../../shared-ts/src/utils/validation.js";
 import { errorMessage } from "../../../shared-ts/src/utils/errors.js";
 import { NearJsonRpcClient, SignedTransaction as SignedTransaction$1 } from "../../../shared-ts/src/near/nearClient.js";
 import { NearRpcError } from "./NearRpcError.js";
 //#region src/core/rpcClients/near/NearClient.ts
 var SignedTransaction = class SignedTransaction extends SignedTransaction$1 {
+	transactionHash;
+	constructor(input) {
+		super(input);
+		this.transactionHash = input.transactionHash;
+	}
 	static fromPlain(input) {
 		return new SignedTransaction({
 			transaction: input.transaction,
 			signature: input.signature,
 			borsh_bytes: input.borsh_bytes,
+			transactionHash: requireCanonicalString(input.transactionHash, "signed transaction hash"),
 			...input.nonceLease ? { nonceLease: input.nonceLease } : {},
 			...input.serverDispatch ? { serverDispatch: input.serverDispatch } : {}
 		});

package/dist/esm/core/signingEngine/flows/signNear/signTransactions.js

@@ -908,12 +908,15 @@ function toSignedTransactionResult(args) {
 	const signedTx = signedTransactions[0];
 	if (!signedTx || !signedTx.transaction || !signedTx.signature) throw new Error("Incomplete signed transaction data received");
 	const nonceLease = args.nonceLeases?.[0];
+	const transactionHash = args.okResponse.payload.transactionHashes?.[0];
+	if (!transactionHash) throw new Error("Signed transaction is missing its hash");
 	const serverDispatch = signedTx.serverDispatch;
 	return {
 		signedTransaction: new SignedTransaction({
 			transaction: signedTx.transaction,
 			signature: signedTx.signature,
 			borsh_bytes: Array.from(signedTx.borshBytes || []),
+			transactionHash,
 			...nonceLease ? { nonceLease } : {},
 			...serverDispatch ? { serverDispatch } : {}
 		}),

package/dist/esm/core/signingEngine/nearTransactionSubmission.js

@@ -0,0 +1,89 @@
+import { requireCanonicalString, requireNonEmptyString, requireRecord } from "../../shared-ts/src/utils/validation.js";
+import { safeErrorMessage } from "../../shared-ts/src/utils/errors.js";
+import { decodeNearFinalExecutionOutcome } from "../../shared-ts/src/utils/nearRpcResults.js";
+//#region src/core/signingEngine/nearTransactionSubmission.ts
+var NearTransactionRequest = class {
+	state = "not_dispatched";
+	constructor(transaction) {
+		this.transaction = transaction;
+	}
+	dispatched = () => {
+		this.state = "dispatched";
+	};
+	failed(error) {
+		if (this.state === "not_dispatched") return nearTransactionFailure(error, "not_submitted");
+		switch (this.transaction.kind) {
+			case "sign_and_send": return nearTransactionFailure(error, "submission_unknown");
+			case "send": return unresolvedNearTransaction(this.transaction.transactionId, error);
+			default: return assertNeverNearTransactionState(this.transaction);
+		}
+	}
+};
+function assertNeverNearTransactionState(value) {
+	throw new Error(`Unsupported NEAR transaction state: ${String(value)}`);
+}
+function parseNearTransactionResult(raw) {
+	const result = requireRecord(raw, "NEAR transaction result");
+	if (result.success === true) {
+		const transactionId = requireCanonicalString(result.transactionId, "transactionId");
+		const outcome = decodeNearFinalExecutionOutcome(result.result);
+		if (transactionId !== outcome.transaction.hash) throw new Error("NEAR transaction result contains different transaction hashes");
+		if (typeof outcome.status === "object" && "Failure" in outcome.status) return unresolvedNearTransaction(transactionId, /* @__PURE__ */ new Error("NEAR transaction execution failed"));
+		return {
+			success: true,
+			transactionId,
+			result: outcome
+		};
+	}
+	if (result.success !== false) throw new Error("Invalid NEAR transaction result");
+	const error = requireNonEmptyString(result.error, "NEAR transaction error");
+	switch (result.kind) {
+		case "not_submitted": return {
+			success: false,
+			kind: "not_submitted",
+			error
+		};
+		case "submission_unknown": return {
+			success: false,
+			kind: "submission_unknown",
+			error
+		};
+		case "unresolved": return {
+			success: false,
+			kind: "unresolved",
+			transactionId: requireCanonicalString(result.transactionId, "transactionId"),
+			error
+		};
+		default: throw new Error("Invalid NEAR transaction failure");
+	}
+}
+function nearTransactionFailure(error, fallback) {
+	return {
+		success: false,
+		kind: fallback,
+		error: safeErrorMessage(error) || "NEAR transaction failed"
+	};
+}
+function unresolvedNearTransaction(transactionId, error) {
+	return {
+		success: false,
+		kind: "unresolved",
+		transactionId,
+		error: safeErrorMessage(error)
+	};
+}
+/** Application hooks cannot replace a settled transaction outcome with their own error. */
+async function notifyNearTransactionResult(options, result) {
+	const error = result.success ? void 0 : new Error(result.error);
+	if (error) try {
+		await options?.onError?.(error);
+	} catch {}
+	try {
+		if (result.success) await options?.afterCall?.(true, result);
+		else await options?.afterCall?.(false, void 0, error);
+	} catch {}
+}
+//#endregion
+export { NearTransactionRequest, nearTransactionFailure, notifyNearTransactionResult, parseNearTransactionResult };
+
+//# sourceMappingURL=nearTransactionSubmission.js.map