@seams/wallet 0.8.0 → 0.9.1

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

@@ -0,0 +1,206 @@
+import { requireRecord } from "../../shared-ts/src/utils/validation.js";
+import { parseWalletId } from "../../shared-ts/src/utils/domainIds.js";
+import { parseNonNegativeSafeInteger } from "../../shared-ts/src/device-linking/wireFields.js";
+//#region src/SeamsWeb/publicApi/placement.ts
+function parseWalletMoveId(raw) {
+	if (!isWalletMoveId(raw)) throw new Error("Wallet move identity is invalid");
+	return raw;
+}
+function isWalletMoveId(raw) {
+	return typeof raw === "string" && /^wmove_[A-Za-z0-9_-]{43}$/u.test(raw);
+}
+function parseWalletMoveRequest(raw) {
+	const value = requireRecord(raw, "Wallet move request");
+	const wallet = parseWalletId(value.walletId);
+	if (!wallet.ok || Object.keys(value).length !== 4) throw new Error("Wallet move request is invalid");
+	return {
+		walletId: wallet.value,
+		moveId: parseWalletMoveId(value.moveId),
+		destinationRegion: region(value.destinationRegion),
+		expectedGeneration: positivePlacementValue(value.expectedGeneration)
+	};
+}
+function parseWalletPlacement(raw) {
+	const value = requireRecord(raw, "Wallet placement");
+	switch (value.state) {
+		case "settled":
+			if (Object.keys(value).length !== 4) break;
+			return {
+				state: "settled",
+				region: region(value.region),
+				generation: positivePlacementValue(value.generation),
+				nextMoveAtMs: parseNonNegativeSafeInteger(value.nextMoveAtMs, "Next relocation time")
+			};
+		case "unavailable":
+			if (Object.keys(value).length !== 2) break;
+			if (value.code !== "not_found" && value.code !== "wallet_not_established") break;
+			return {
+				state: "unavailable",
+				code: value.code
+			};
+		case "moving": {
+			if (Object.keys(value).length !== 2) break;
+			const move = requireRecord(value.move, "Wallet relocation");
+			if (Object.keys(move).length !== 8) break;
+			const { moveId, sourceRegion, destinationRegion, sourceGeneration, destinationGeneration, admittedAtMs } = relocationIdentity(move);
+			const nextMoveAtMs = parseNonNegativeSafeInteger(move.nextMoveAtMs, "Next relocation time");
+			if (nextMoveAtMs < admittedAtMs) break;
+			return {
+				state: "moving",
+				move: {
+					moveId,
+					sourceRegion,
+					destinationRegion,
+					sourceGeneration,
+					destinationGeneration,
+					admittedAtMs,
+					nextMoveAtMs,
+					progress: progress(move.progress)
+				}
+			};
+		}
+	}
+	throw new Error("Wallet placement response is invalid");
+}
+function parseWalletPlacementResult(raw) {
+	const value = requireRecord(raw, "Wallet placement result");
+	if (Object.keys(value).length !== 2) throw new Error("Wallet placement result fields are invalid");
+	if (value.ok === true) return {
+		ok: true,
+		placement: parseWalletPlacement(value.placement)
+	};
+	if (value.ok === false) switch (value.code) {
+		case "wallet_unlock_required":
+		case "unauthorized":
+		case "transport_unavailable":
+		case "invalid_response": return {
+			ok: false,
+			code: value.code
+		};
+	}
+	throw new Error("Wallet placement result is invalid");
+}
+function region(raw) {
+	switch (raw) {
+		case "US":
+		case "WEUR":
+		case "APAC":
+		case "OC": return raw;
+		default: throw new Error("Wallet region is invalid");
+	}
+}
+function positivePlacementValue(raw) {
+	const value = parseNonNegativeSafeInteger(raw, "Wallet placement generation or time");
+	if (value === 0) throw new Error("Wallet placement generation or time must be positive");
+	return value;
+}
+function progress(raw) {
+	const value = requireRecord(raw, "Wallet relocation progress");
+	if (Object.keys(value).length !== 3) throw new Error("Wallet relocation progress fields are invalid");
+	const current = execution(value.execution);
+	switch (value.state) {
+		case "freezing":
+		case "copying":
+		case "verified":
+		case "activating":
+			if (value.availability === "paused") return {
+				state: value.state,
+				availability: "paused",
+				execution: current
+			};
+			break;
+		case "cleanup":
+			if (value.availability === "active") return {
+				state: "cleanup",
+				availability: "active",
+				execution: current
+			};
+			break;
+	}
+	throw new Error("Wallet relocation availability is invalid");
+}
+function execution(raw) {
+	const value = requireRecord(raw, "Wallet relocation execution");
+	switch (value.state) {
+		case "ready":
+		case "running":
+			if (Object.keys(value).length === 1) return { state: value.state };
+			break;
+		case "retry_wait":
+			if (Object.keys(value).length !== 3) break;
+			if (value.code === "transport_unavailable" || value.code === "authority_unavailable") return {
+				state: "retry_wait",
+				code: value.code,
+				retryAtMs: positivePlacementValue(value.retryAtMs)
+			};
+			break;
+		case "blocked":
+			if (Object.keys(value).length !== 2) break;
+			switch (value.code) {
+				case "transport_unavailable":
+				case "authority_unavailable":
+				case "identity_conflict":
+				case "receipt_conflict":
+				case "content_conflict": return {
+					state: "blocked",
+					code: value.code
+				};
+			}
+	}
+	throw new Error("Wallet relocation execution is invalid");
+}
+function parseWalletMoveStatus(raw, expectedMoveId) {
+	const value = requireRecord(raw, "Wallet move status");
+	if (value.state === "moving") {
+		const placement = parseWalletPlacement(value);
+		if (placement.state !== "moving" || placement.move.moveId !== expectedMoveId) throw new Error("Wallet move identity changed");
+		return placement;
+	}
+	if (value.state !== "completed" || Object.keys(value).length !== 8) throw new Error("Wallet move status is invalid");
+	const { moveId, sourceRegion, destinationRegion, sourceGeneration, destinationGeneration, admittedAtMs } = relocationIdentity(value);
+	const completedAtMs = positivePlacementValue(value.completedAtMs);
+	if (moveId !== expectedMoveId || completedAtMs < admittedAtMs) throw new Error("Wallet move completion is invalid");
+	return {
+		state: "completed",
+		moveId,
+		sourceRegion,
+		destinationRegion,
+		sourceGeneration,
+		destinationGeneration,
+		admittedAtMs,
+		completedAtMs
+	};
+}
+function parseWalletMoveStatusResult(raw, moveId) {
+	const value = requireRecord(raw, "Wallet move result");
+	if (value.ok === false) {
+		const failure = parseWalletPlacementResult(value);
+		if (!failure.ok) return failure;
+	}
+	if (value.ok !== true || Object.keys(value).length !== 2) throw new Error("Wallet move result is invalid");
+	return {
+		ok: true,
+		status: parseWalletMoveStatus(value.status, moveId)
+	};
+}
+function relocationIdentity(value) {
+	const moveId = parseWalletMoveId(value.moveId);
+	const sourceRegion = region(value.sourceRegion);
+	const destinationRegion = region(value.destinationRegion);
+	const sourceGeneration = positivePlacementValue(value.sourceGeneration);
+	const destinationGeneration = positivePlacementValue(value.destinationGeneration);
+	const admittedAtMs = positivePlacementValue(value.admittedAtMs);
+	if (sourceRegion === destinationRegion || destinationGeneration !== sourceGeneration + 1) throw new Error("Wallet move generations or regions are invalid");
+	return {
+		moveId,
+		sourceRegion,
+		destinationRegion,
+		sourceGeneration,
+		destinationGeneration,
+		admittedAtMs
+	};
+}
+//#endregion
+export { parseWalletMoveId, parseWalletMoveRequest, parseWalletMoveStatusResult, parseWalletPlacementResult };
+
+//# sourceMappingURL=placement.js.map

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

@@ -0,0 +1,13 @@
+//#region src/SeamsWeb/publicApi/session.ts
+function buildAnonymousWalletSession() {
+	return {
+		appIdentity: { kind: "anonymous" },
+		authentication: { kind: "signed_out" },
+		capabilityProjection: { kind: "not_requested" },
+		nonceDiagnostics: null
+	};
+}
+//#endregion
+export { buildAnonymousWalletSession };
+
+//# sourceMappingURL=session.js.map

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

@@ -1,202 +1,77 @@
 import { CAPABILITY_KINDS, EVM_ECDSA_MPC_OPERATION_KINDS } from "../../shared-ts/src/authorization/capabilityKinds.js";
-import { toWalletId } from "../../core/signingEngine/interfaces/ecdsaChainTarget.js";
-import { toError } from "../../shared-ts/src/utils/errors.js";
-import { resolveConfiguredChainTarget, resolveTempoChainTarget } from "./chainTargets.js";
 import { requireBrowserCapabilityOperation } from "./capabilitySelection.js";
+import { resolveConfiguredChainTarget, resolveTempoChainTarget } from "./chainTargets.js";
+import { createEvmSignerCapability } from "./evm.js";
 import { executeEvmFamilyTransactionLifecycle, withResolvedChainId } from "../operations/tempo/executeEvmFamilyTransaction.js";
-import { buildTempoBootstrapArgs, toSerializableTempoError } from "../operations/tempo/index.js";
 import { getTempoFeeTokenPreference, setTempoFeeTokenPreference, validateConfiguredTempoFeeToken } from "../operations/tempo/feeTokenPreference.js";
 //#region src/SeamsWeb/publicApi/tempo.ts
-function requireTempoSignedResult(result) {
-	if (result.chain !== "tempo" || result.kind !== "tempoTransaction") throw new Error(`[Tempo capability] expected Tempo result, received ${result.chain}`);
-	return result;
-}
-function toLocalTempoBootstrapRequest(args) {
+function createEvmFamilyCapabilities(deps) {
+	const signer = new EvmFamilySigner(deps);
+	const commands = deps.commands;
+	const advanced = {
+		reportBroadcastAccepted: commands.reportBroadcastAccepted,
+		reportBroadcastRejected: commands.reportBroadcastRejected,
+		reportFinalized: commands.reportFinalized,
+		reportDroppedOrReplaced: commands.reportDroppedOrReplaced,
+		reconcileNonceLane: commands.reconcileNonceLane
+	};
+	const signTempo = signer.signTempo.bind(signer);
+	const executeEvmFamilyTransaction = signer.executeEvmFamilyTransaction.bind(signer);
 	return {
-		kind: "reuse_warm_ecdsa_bootstrap",
-		walletId: toWalletId(args.walletSession.walletId),
-		chainTarget: args.chainTarget,
-		source: args.source,
-		relayerUrl: args.relayerUrl,
-		runtimeScopeBootstrap: args.runtimeScopeBootstrap,
-		ttlMs: args.ttlMs,
-		remainingUses: args.remainingUses
+		tempo: {
+			signTransaction: signTempo,
+			signAndSendTransaction: executeEvmFamilyTransaction,
+			advanced,
+			getFeeToken: getTempoFeeTokenPreference.bind(null, deps.configs.network.chains),
+			validateFeeToken: validateConfiguredTempoFeeToken.bind(null, deps.configs.network.chains),
+			setFeeToken: setTempoFeeTokenPreference.bind(null, {
+				chains: deps.configs.network.chains,
+				execute: executeEvmFamilyTransaction
+			})
+		},
+		evm: createEvmSignerCapability({
+			...deps,
+			advanced,
+			signAndSendTransaction: executeEvmFamilyTransaction
+		})
 	};
 }
-function requireEvmFamilySigningCapability(configs, chainTarget) {
-	requireBrowserCapabilityOperation(configs, {
-		capabilityKind: CAPABILITY_KINDS.evmEcdsaMpcSigning,
-		operationKind: EVM_ECDSA_MPC_OPERATION_KINDS.signTransaction,
-		chainTarget
-	});
-}
-function createTempoSignerCapability(deps, transactionDispatch = { kind: "ordinary" }) {
-	const signEvmFamily = async (args) => {
-		const chainTarget = resolveConfiguredChainTarget(deps.configs.network.chains, args.chainTarget);
-		const walletSession = await deps.currentWallet.walletSession(args.walletSession);
-		requireEvmFamilySigningCapability(deps.configs, chainTarget);
-		const walletIframe = deps.getWalletIframe();
-		const walletId = toWalletId(walletSession.walletId);
-		if (!walletIframe.shouldUseWalletIframe()) return await deps.signingEngine.signEvmFamily({
+var EvmFamilySigner = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async signEvmFamily(args) {
+		const chainTarget = resolveConfiguredChainTarget(this.deps.configs.network.chains, args.chainTarget);
+		const walletSession = await this.deps.currentWallet.walletSession(args.walletSession);
+		requireBrowserCapabilityOperation(this.deps.configs, {
+			capabilityKind: CAPABILITY_KINDS.evmEcdsaMpcSigning,
+			operationKind: EVM_ECDSA_MPC_OPERATION_KINDS.signTransaction,
+			chainTarget
+		});
+		return await this.deps.commands.signEvmFamily({
 			walletSession,
-			request: args.request,
 			chainTarget,
-			confirmationConfigOverride: args.options?.confirmationConfig,
-			shouldAbort: args.options?.shouldAbort,
-			onEvent: args.options?.onEvent
+			request: args.request,
+			options: args.options
 		});
-		try {
-			return await (await walletIframe.requireRouter(walletId)).signTempo({
-				walletSession,
-				request: args.request,
-				chainTarget,
-				options: {
-					confirmationConfig: args.options?.confirmationConfig,
-					onEvent: args.options?.onEvent
-				}
-			}, transactionDispatch);
-		} catch (error) {
-			throw toError(error);
-		}
-	};
-	const signTempo = async (args) => requireTempoSignedResult(await signEvmFamily({
-		...args,
-		chainTarget: resolveTempoChainTarget(deps.configs.network.chains, args.chainTarget)
-	}));
-	const onBroadcastStarted = (args) => {
-		const walletIframe = deps.getWalletIframe();
-		if (!walletIframe.shouldUseWalletIframe()) return;
-		walletIframe.requireRouter(toWalletId(args.walletSession.walletId)).then((router) => router.notifyTransactionBroadcastStarted(args.signedResult)).catch(() => {});
-	};
-	const reportBroadcastAccepted = async (args) => {
-		const walletIframe = deps.getWalletIframe();
-		const walletId = toWalletId(args.walletSession.walletId);
-		if (!walletIframe.shouldUseWalletIframe()) {
-			await deps.signingEngine.reportTempoBroadcastAccepted({
-				walletId,
-				signedResult: args.signedResult,
-				txHash: args.txHash,
-				onEvent: args.options?.onEvent
-			});
-			return;
-		}
-		try {
-			await (await walletIframe.requireRouter(walletId)).reportTempoBroadcastAccepted({
-				walletSession: args.walletSession,
-				signedResult: args.signedResult,
-				txHash: args.txHash,
-				options: { onEvent: args.options?.onEvent }
-			});
-		} catch (error) {
-			throw toError(error);
-		}
-	};
-	const reportBroadcastRejected = async (args) => {
-		const walletIframe = deps.getWalletIframe();
-		const walletId = toWalletId(args.walletSession.walletId);
-		if (!walletIframe.shouldUseWalletIframe()) {
-			await deps.signingEngine.reportTempoBroadcastRejected({
-				walletId,
-				signedResult: args.signedResult,
-				...args.error !== void 0 ? { error: args.error } : {},
-				onEvent: args.options?.onEvent
-			});
-			return;
-		}
-		try {
-			await (await walletIframe.requireRouter(walletId)).reportTempoBroadcastRejected({
-				walletSession: args.walletSession,
-				signedResult: args.signedResult,
-				...args.error != null ? { error: toSerializableTempoError(args.error) } : {},
-				options: { onEvent: args.options?.onEvent }
-			});
-		} catch (error) {
-			throw toError(error);
-		}
-	};
-	const reportFinalized = async (args) => {
-		const walletIframe = deps.getWalletIframe();
-		const walletId = toWalletId(args.walletSession.walletId);
-		if (!walletIframe.shouldUseWalletIframe()) {
-			await deps.signingEngine.reportTempoFinalized({
-				walletId,
-				signedResult: args.signedResult,
-				...args.txHash ? { txHash: args.txHash } : {},
-				...args.receiptStatus ? { receiptStatus: args.receiptStatus } : {},
-				onEvent: args.options?.onEvent
-			});
-			return;
-		}
-		try {
-			await (await walletIframe.requireRouter(walletId)).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);
-		}
-	};
-	const reportDroppedOrReplaced = async (args) => {
-		const walletIframe = deps.getWalletIframe();
-		const walletId = toWalletId(args.walletSession.walletId);
-		if (!walletIframe.shouldUseWalletIframe()) {
-			await deps.signingEngine.reportTempoDroppedOrReplaced({
-				walletId,
-				signedResult: args.signedResult,
-				reason: args.reason,
-				...args.txHash ? { txHash: args.txHash } : {},
-				onEvent: args.options?.onEvent
-			});
-			return;
-		}
-		try {
-			await (await walletIframe.requireRouter(walletId)).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);
-		}
-	};
-	const reconcileNonceLane = async (args) => {
-		const walletIframe = deps.getWalletIframe();
-		const walletId = toWalletId(args.walletSession.walletId);
-		if (!walletIframe.shouldUseWalletIframe()) return await deps.signingEngine.reconcileTempoNonceLane({
-			walletId,
-			signedResult: args.signedResult,
-			onEvent: args.options?.onEvent
+	}
+	async signTempo(args) {
+		const result = await this.signEvmFamily({
+			...args,
+			chainTarget: resolveTempoChainTarget(this.deps.configs.network.chains, args.chainTarget)
 		});
-		try {
-			return await (await walletIframe.requireRouter(walletId)).reconcileTempoNonceLane({
-				walletSession: args.walletSession,
-				signedResult: args.signedResult,
-				options: { onEvent: args.options?.onEvent }
-			});
-		} catch (error) {
-			throw toError(error);
-		}
-	};
-	const lifecycle = {
-		onBroadcastStarted,
-		signEvmFamily,
-		reportBroadcastAccepted,
-		reportBroadcastRejected,
-		reportFinalized,
-		reportDroppedOrReplaced,
-		reconcileNonceLane
-	};
-	const executeEvmFamilyTransaction = async (args) => {
-		const chainTarget = resolveConfiguredChainTarget(deps.configs.network.chains, args.chainTarget);
-		const walletSession = await deps.currentWallet.walletSession(args.walletSession);
+		if (result.chain !== "tempo" || result.kind !== "tempoTransaction") throw new Error(`[Tempo capability] expected Tempo result, received ${result.chain}`);
+		return result;
+	}
+	async executeEvmFamilyTransaction(args) {
+		const chainTarget = resolveConfiguredChainTarget(this.deps.configs.network.chains, args.chainTarget);
+		const walletSession = await this.deps.currentWallet.walletSession(args.walletSession);
 		return await executeEvmFamilyTransactionLifecycle({
-			lifecycle,
-			chains: deps.configs.network.chains,
+			lifecycle: {
+				...this.deps.commands,
+				signEvmFamily: this.signEvmFamily.bind(this)
+			},
+			chains: this.deps.configs.network.chains,
 			input: {
 				...args,
 				chainTarget,
@@ -204,41 +79,9 @@ function createTempoSignerCapability(deps, transactionDispatch = { kind: "ordina
 				request: withResolvedChainId(args.request, chainTarget)
 			}
 		});
-	};
-	const bootstrapEcdsaSession = async (args) => {
-		const walletIframe = deps.getWalletIframe();
-		const bootstrapArgs = buildTempoBootstrapArgs(deps.configs, args);
-		if (!walletIframe.shouldUseWalletIframe()) return await deps.signingEngine.bootstrapEcdsaSession(toLocalTempoBootstrapRequest(bootstrapArgs));
-		return await (await walletIframe.requireRouter(toWalletId(args.walletSession.walletId))).bootstrapEcdsaSession(bootstrapArgs);
-	};
-	return {
-		signTransaction: signTempo,
-		executeTransaction: executeEvmFamilyTransaction,
-		advanced: {
-			reportBroadcastAccepted,
-			reportBroadcastRejected,
-			reportFinalized,
-			reportDroppedOrReplaced,
-			reconcileNonceLane,
-			bootstrapEcdsaSession
-		},
-		signTempo,
-		getFeeTokenPreference: async (args) => await getTempoFeeTokenPreference(deps.configs.network.chains, args),
-		validateFeeToken: async (args) => await validateConfiguredTempoFeeToken(deps.configs.network.chains, args),
-		setFeeTokenPreference: async (args) => await setTempoFeeTokenPreference({
-			chains: deps.configs.network.chains,
-			execute: executeEvmFamilyTransaction
-		}, args),
-		executeEvmFamilyTransaction,
-		reportBroadcastAccepted,
-		reportBroadcastRejected,
-		reportFinalized,
-		reportDroppedOrReplaced,
-		reconcileNonceLane,
-		bootstrapEcdsaSession
-	};
-}
+	}
+};
 //#endregion
-export { createTempoSignerCapability };
+export { createEvmFamilyCapabilities };
 
 //# sourceMappingURL=tempo.js.map

package/dist/esm/SeamsWeb/publicApi/{awaitNearReady.js → waitForNearAccount.js}

@@ -1,5 +1,5 @@
-//#region src/SeamsWeb/publicApi/awaitNearReady.ts
-const DEFAULT_AWAIT_NEAR_READY_TIMEOUT_MS = 12e4;
+//#region src/SeamsWeb/publicApi/waitForNearAccount.ts
+const DEFAULT_NEAR_ACCOUNT_TIMEOUT_MS = 12e4;
 function outcomeFor(state) {
 	if (!state) return null;
 	if (state.status === "near_ready") return {
@@ -15,15 +15,15 @@ function outcomeFor(state) {
 /**
 * Waits for a mixed registration's NEAR account to finish provisioning.
 *
-* `registerPasskey` can return `ecdsa_wallet_registered_near_pending`, which
+* `registerWallet` can return `ecdsa_wallet_registered_near_pending`, which
 * carries no NEAR account id — but signing NEAR needs one. Subscribing first
 * and then reading the current state closes the race where provisioning
 * completes between the two.
 */
-async function awaitNearReady(deps, args) {
+async function waitForNearAccount(deps, args) {
 	const walletId = String(args.walletId || "").trim();
-	if (!walletId) throw new Error("[seams] awaitNearReady requires a walletId");
-	const timeoutMs = Math.max(1, Math.floor(Number(args.timeoutMs) || 0)) || DEFAULT_AWAIT_NEAR_READY_TIMEOUT_MS;
+	if (!walletId) throw new Error("[seams] waitForNearAccount requires a walletId");
+	const timeoutMs = Math.max(1, Math.floor(args.timeoutMs ?? DEFAULT_NEAR_ACCOUNT_TIMEOUT_MS));
 	let unsubscribe = null;
 	let timer = null;
 	let onAbort = null;
@@ -36,24 +36,24 @@ async function awaitNearReady(deps, args) {
 				resolve(result);
 			};
 			if (args.signal?.aborted) {
-				reject(args.signal.reason ?? /* @__PURE__ */ new Error("[seams] awaitNearReady aborted"));
+				reject(args.signal.reason ?? /* @__PURE__ */ new Error("[seams] waitForNearAccount aborted"));
 				return;
 			}
 			if (args.signal) {
 				onAbort = () => {
 					if (settled) return;
 					settled = true;
-					reject(args.signal?.reason ?? /* @__PURE__ */ new Error("[seams] awaitNearReady aborted"));
+					reject(args.signal?.reason ?? /* @__PURE__ */ new Error("[seams] waitForNearAccount aborted"));
 				};
 				args.signal.addEventListener("abort", onAbort, { once: true });
 			}
-			unsubscribe = deps.onNearProvisioningStateChanged((event) => {
+			unsubscribe = deps.onNearAccountChange((event) => {
 				if (String(event.walletId) !== walletId) return;
 				const outcome = outcomeFor(event.state);
 				if (outcome) settle(outcome);
 			});
 			timer = setTimeout(() => settle({ kind: "timed_out" }), timeoutMs);
-			deps.getNearProvisioningState({ walletId }).then((state) => {
+			deps.getNearAccountState({ walletId }).then((state) => {
 				const outcome = outcomeFor(state);
 				if (outcome) settle(outcome);
 			}).catch(() => {});
@@ -67,6 +67,6 @@ async function awaitNearReady(deps, args) {
 	}
 }
 //#endregion
-export { awaitNearReady };
+export { waitForNearAccount };
 
-//# sourceMappingURL=awaitNearReady.js.map
+//# sourceMappingURL=waitForNearAccount.js.map

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

@@ -0,0 +1,50 @@
+//#region src/SeamsWeb/walletIframe/client/deviceCommands.ts
+function createApplicationDeviceCommands(walletIframe) {
+	const commands = new ApplicationDeviceCommands(walletIframe);
+	return {
+		startLinking: commands.startLinking.bind(commands),
+		cancelLinking: commands.cancelLinking.bind(commands),
+		approveLinking: commands.approveLinking.bind(commands),
+		linkedDeviceManagement: {
+			listLinkedDevices: commands.listLinkedDevices.bind(commands),
+			revokeLinkedDevice: commands.revokeLinkedDevice.bind(commands)
+		}
+	};
+}
+var ApplicationDeviceCommands = class {
+	constructor(walletIframe) {
+		this.walletIframe = walletIframe;
+	}
+	async startLinking(args) {
+		return await (await this.walletIframe.requireRouter()).startDevice2LinkingFlow(args);
+	}
+	async cancelLinking() {
+		await (await this.walletIframe.requireRouter()).cancelDeviceLinking();
+	}
+	async approveLinking(...args) {
+		const [qrData, options] = args;
+		return await (await this.walletIframe.requireRouter()).scanAndLinkDevice({
+			qrData,
+			options
+		});
+	}
+	async listLinkedDevices(input) {
+		const { walletId, limit, cursor } = input;
+		return await (await this.walletIframe.requireRouter()).listLinkedDevices({
+			walletId: String(walletId),
+			limit,
+			cursor
+		});
+	}
+	async revokeLinkedDevice(input) {
+		const { walletId, walletAuthMethodId } = input;
+		return await (await this.walletIframe.requireRouter()).revokeLinkedDevice({
+			walletId: String(walletId),
+			walletAuthMethodId: String(walletAuthMethodId)
+		});
+	}
+};
+//#endregion
+export { createApplicationDeviceCommands };
+
+//# sourceMappingURL=deviceCommands.js.map

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

@@ -0,0 +1,25 @@
+import { unlockWithEmailCode } from "../../publicApi/auth.js";
+//#region src/SeamsWeb/walletIframe/client/emailOtpCommands.ts
+function createApplicationEmailOtpCommands(walletIframe) {
+	const commands = new ApplicationEmailOtpCommands(walletIframe);
+	return {
+		requestEmailCode: commands.requestEmailCode.bind(commands),
+		unlockWithEmailCode,
+		startGoogleSignIn: commands.startGoogleSignIn.bind(commands)
+	};
+}
+var ApplicationEmailOtpCommands = class {
+	constructor(walletIframe) {
+		this.walletIframe = walletIframe;
+	}
+	async requestEmailCode(args) {
+		return await (await this.walletIframe.requireRouter()).requestEmailCode(args);
+	}
+	async startGoogleSignIn(args) {
+		return await (await this.walletIframe.requireRouter()).startGoogleSignIn(args);
+	}
+};
+//#endregion
+export { createApplicationEmailOtpCommands };
+
+//# sourceMappingURL=emailOtpCommands.js.map