@seams/wallet 0.8.0 → 0.9.0

package/dist/esm/SeamsWeb/assembly/createWalletIframeRouter.js

@@ -1,4 +1,4 @@
-import { cloneAuthenticatorOptions } from "../../shared-ts/src/utils/authenticatorOptions.js";
+import { createWalletHostConfig } from "../walletIframe/shared/configuration.js";
 import { createWalletIframeOverlayState } from "./createWalletIframeOverlayState.js";
 //#region src/SeamsWeb/assembly/createWalletIframeRouter.ts
 let warnedAboutSameOriginWallet = false;
@@ -15,26 +15,15 @@ function warnIfSameOriginWallet(walletOrigin) {
 async function createWalletIframeRouter(args) {
 	warnIfSameOriginWallet(args.walletOrigin);
 	const { WalletIframeRouter } = await import("../walletIframe/client/router.js");
-	const signingSessionPersistenceMode = args.configs.signing.sessionPersistenceMode;
 	return new WalletIframeRouter({
 		walletOrigin: args.walletOrigin,
-		servicePath: args.configs.wallet.iframe?.servicePath || "/wallet-service",
+		servicePath: args.configs.wallet.iframe.servicePath,
 		connectTimeoutMs: 2e4,
 		requestTimeoutMs: 6e4,
-		chains: args.configs.network.chains,
-		relayerAccount: args.configs.network.relayer.accountId,
-		relayer: args.configs.network.relayer,
-		registration: args.configs.registration,
-		signingSessionDefaults: args.configs.signing.sessionDefaults,
-		signingSessionPersistenceMode,
-		routerAb: args.configs.signing.routerAb,
-		routerAbEcdsaDerivationPresignaturePool: args.configs.signing.routerAbEcdsaDerivation.presignaturePool,
-		provisioningDefaults: args.configs.signing.thresholdEcdsa.provisioningDefaults,
-		rpIdOverride: args.configs.wallet.iframe?.rpIdOverride,
-		authenticatorOptions: cloneAuthenticatorOptions(args.configs.webauthn.authenticatorOptions),
+		hostConfig: createWalletHostConfig(args.configs),
 		appearance: args.getAppearance(),
 		getAppearance: args.getAppearance,
-		sdkBasePath: args.configs.wallet.iframe?.sdkBasePath,
+		sdkBasePath: args.configs.wallet.iframe.sdkBasePath,
 		createOverlayState: createWalletIframeOverlayState
 	});
 }

package/dist/esm/SeamsWeb/index.js

@@ -1,6 +1,6 @@
-import { LinkDeviceEventPhase } from "../core/types/sdkSentEvents.js";
-import { DeviceLinkingError, DeviceLinkingErrorCode } from "../core/types/linkDevice.js";
 import { BrowserCapabilityUnavailableError } from "./publicApi/capabilitySelection.js";
+import { LinkDeviceEventPhase } from "../core/types/sdkSentEvents.js";
 import { SeamsWeb } from "./SeamsWeb.js";
 import { buildHostedAuthMenuOpenRequest, hostedAuthMenuExternalAuthRequestIdFromBoundary, hostedAuthMenuSessionIdFromBoundary } from "./walletIframe/shared/messages.js";
+import { DeviceLinkingError, DeviceLinkingErrorCode } from "../core/types/linkDevice.js";
 export { BrowserCapabilityUnavailableError, DeviceLinkingError, DeviceLinkingErrorCode, LinkDeviceEventPhase, SeamsWeb, buildHostedAuthMenuOpenRequest, hostedAuthMenuExternalAuthRequestIdFromBoundary, hostedAuthMenuSessionIdFromBoundary };

package/dist/esm/SeamsWeb/operations/devices/scanDevice.js

@@ -1,41 +1,12 @@
-import { LinkDeviceEventPhase, createLinkDeviceFlowEvent } from "../../../core/types/sdkSentEvents.js";
-import { buildLinkedDeviceApprovalV1, buildLinkedDeviceSessionClaimRequestV1, parseQrLinkedDeviceSessionPayloadV5 } from "../../../shared-ts/src/device-linking/parsers.js";
+import { errorMessage } from "../../../shared-ts/src/utils/errors.js";
+import { parseQrLinkedDeviceSessionPayloadV5 } from "../../../shared-ts/src/device-linking/parsers.js";
 import "../../../shared-ts/src/device-linking/requestProof.js";
 import "../../../shared-ts/src/device-linking/index.js";
-import { errorMessage } from "../../../shared-ts/src/utils/errors.js";
 import { DeviceLinkingError, DeviceLinkingErrorCode } from "../../../core/types/linkDevice.js";
-import { nextLinkedDevicePollingDelayMsV1 } from "./deviceLinkingHttpTransport.js";
 //#region src/SeamsWeb/operations/devices/scanDevice.ts
-function createFlowId(qrData) {
-	return qrData ? String(qrData.linkSessionId) : "link-device-scan";
-}
 function createInvalidQrError(message) {
 	return new DeviceLinkingError(message, DeviceLinkingErrorCode.INVALID_QR_DATA, "authorization");
 }
-function notifyError(callback, error) {
-	try {
-		callback?.(error);
-	} catch {}
-}
-function emitScannerEvent(onEvent, qrData, event) {
-	onEvent?.(createLinkDeviceFlowEvent({
-		flowId: createFlowId(qrData),
-		...event,
-		data: {
-			role: "scanner",
-			...event.data ?? {}
-		}
-	}));
-}
-function assertAuthorizationSourcesMatch(left, right) {
-	if (left.walletSessionId !== right.walletSessionId || left.authorizationId !== right.authorizationId) throw new Error("wallet-session authorization source changed during linking");
-}
-function classifyFailure(error) {
-	if (error instanceof DeviceLinkingError) return error;
-	const message = errorMessage(error) || "Device linking failed";
-	if (/expired|expiry/i.test(message)) return new DeviceLinkingError(message, DeviceLinkingErrorCode.SESSION_EXPIRED, "authorization");
-	return new DeviceLinkingError(message, DeviceLinkingErrorCode.REGISTRATION_FAILED, "registration");
-}
 /** Strictly parse the only QR payload accepted by this browser. */
 function validateQrLinkedDeviceSessionPayloadV5(raw) {
 	let parsed;
@@ -49,336 +20,7 @@ function validateQrLinkedDeviceSessionPayloadV5(raw) {
 	if (parsed.expiresAtMs <= now) throw new DeviceLinkingError("QR code expired", DeviceLinkingErrorCode.SESSION_EXPIRED, "authorization");
 	return parsed;
 }
-async function scanAndLinkDevice(_context, qrData, options, ports, registerCancellation) {
-	let parsedQrData = null;
-	let claimedSessionCancellation = null;
-	emitScannerEvent(options.onEvent, parsedQrData, {
-		phase: LinkDeviceEventPhase.STEP_02_QR_SCAN_STARTED,
-		status: "started",
-		message: "Scanning QR code",
-		interaction: {
-			kind: "qr_scan",
-			overlay: "hide"
-		}
-	});
-	try {
-		parsedQrData = validateQrLinkedDeviceSessionPayloadV5(qrData);
-		const owner = await ports.ownerAuthorization.authenticateOwnerForLinkingV1({
-			payload: parsedQrData,
-			requestedAtMs: Date.now()
-		});
-		assertAuthorizationSourcesMatch(owner.ownerAuthorization, owner.authentication.source);
-		const claim = await ports.transport.claimSessionV1({
-			request: buildLinkedDeviceSessionClaimRequestV1(parsedQrData),
-			authentication: owner.authentication
-		});
-		if (claim.linkSessionId !== parsedQrData.linkSessionId || claim.devicePublicKeyB64u !== parsedQrData.devicePublicKeyB64u || claim.walletId !== owner.walletId) throw new Error("linked-device claim does not match the scanned QR payload");
-		claimedSessionCancellation = {
-			linkSessionId: claim.linkSessionId,
-			expectedRevision: claim.sessionRevision,
-			authentication: owner.authentication
-		};
-		registerCancellation?.(claimedSessionCancellation);
-		const targetFactor = await resolveApprovedTargetFactorV1({
-			targetFactor: parsedQrData.targetFactor,
-			targetEmail: parsedQrData.targetFactor.kind === "email_otp" ? parsedQrData.targetEmail : void 0,
-			linkSessionId: claim.linkSessionId,
-			sessionRevision: claim.sessionRevision,
-			transport: ports.transport,
-			authentication: owner.authentication,
-			onEmailOtpBaseFactorRequired: options.onEmailOtpBaseFactorRequired
-		});
-		const approval = buildLinkedDeviceApprovalV1({
-			linkSessionId: claim.linkSessionId,
-			walletId: claim.walletId,
-			enrollmentId: claim.enrollmentId,
-			deviceId: claim.deviceId,
-			linkPublicKeyB64u: parsedQrData.linkPublicKeyB64u,
-			devicePublicKeyB64u: claim.devicePublicKeyB64u,
-			targetFactor,
-			permission: parsedQrData.requestedPermission,
-			ownerAuthorization: owner.ownerAuthorization,
-			approvedAtMs: Date.now(),
-			expiresAtMs: Math.min(owner.expiresAtMs, claim.claimExpiresAtMs)
-		});
-		assertApprovalRecordedV1(await ports.transport.recordOwnerApprovalV1({
-			approval,
-			authentication: owner.authentication
-		}));
-		claimedSessionCancellation = null;
-		await submitEd25519ExportRootIfRequiredV1({
-			transport: ports.transport,
-			linkSessionId: claim.linkSessionId,
-			walletId: claim.walletId,
-			enrollmentId: claim.enrollmentId,
-			deviceId: claim.deviceId,
-			expiresAtMs: Math.min(owner.expiresAtMs, claim.claimExpiresAtMs),
-			exportRootRequirement: owner.exportRootRequirement,
-			ed25519ExportRootCapability: owner.exportRootRequirement === "required" ? owner.ed25519ExportRootCapability : void 0,
-			ed25519ExportRoot: ports.ed25519ExportRoot,
-			authentication: owner.authentication
-		});
-		await submitSourceContributionsV1({
-			transport: ports.transport,
-			sourceContribution: ports.sourceContribution,
-			ed25519ExportRootCapability: owner.exportRootRequirement === "required" ? owner.ed25519ExportRootCapability : void 0,
-			initialApproval: approval,
-			authentication: owner.authentication,
-			expiresAtMs: Math.min(owner.expiresAtMs, claim.claimExpiresAtMs)
-		});
-		const result = {
-			success: true,
-			kind: "approval_recorded",
-			walletId: claim.walletId,
-			enrollmentId: claim.enrollmentId,
-			deviceId: claim.deviceId
-		};
-		emitScannerEvent(options.onEvent, parsedQrData, {
-			phase: LinkDeviceEventPhase.STEP_02_QR_SCAN_STARTED,
-			status: "succeeded",
-			message: "Device-link approval recorded",
-			walletId: String(claim.walletId),
-			data: { enrollmentId: String(claim.enrollmentId) },
-			interaction: {
-				kind: "qr_scan",
-				overlay: "hide"
-			}
-		});
-		await options.afterCall?.(true, result);
-		return result;
-	} catch (error) {
-		if (claimedSessionCancellation) {
-			await cancelClaimedSessionAfterOwnerAbortV1(ports.transport, claimedSessionCancellation);
-			registerCancellation?.(null);
-		}
-		const failure = classifyFailure(error);
-		emitScannerEvent(options.onEvent, parsedQrData, {
-			phase: LinkDeviceEventPhase.FAILED,
-			status: "failed",
-			message: failure.message,
-			interaction: {
-				kind: "qr_scan",
-				overlay: "hide"
-			},
-			error: {
-				code: failure.code,
-				message: failure.message,
-				retryable: failure.code !== DeviceLinkingErrorCode.SESSION_EXPIRED
-			}
-		});
-		notifyError(options.onError, failure);
-		await options.afterCall?.(false, void 0, failure);
-		throw failure;
-	}
-}
-async function cancelClaimedSessionAfterOwnerAbortV1(transport, cancellation) {
-	if (!cancellation) return;
-	await transport.cancelClaimedSessionV1(cancellation).catch(() => void 0);
-}
-async function resolveApprovedTargetFactorV1(input) {
-	if (input.targetFactor.kind === "passkey_prf") return { kind: "passkey_prf" };
-	const targetEmail = requireTargetEmailAddressV1(input.targetEmail);
-	const result = await input.transport.resolveEmailOtpBaseFactorV1({
-		linkSessionId: input.linkSessionId,
-		request: {
-			kind: "resolve",
-			expectedRevision: input.sessionRevision
-		},
-		authentication: input.authentication
-	});
-	assertEmailOtpBaseFactorResolutionIsCurrentV1(result, input.sessionRevision);
-	switch (result.resolution.kind) {
-		case "selected": return {
-			kind: "email_otp",
-			targetEmail,
-			enrollment: { kind: "existing_enrollment" },
-			baseWalletAuthMethodId: result.resolution.choice.baseWalletAuthMethodId
-		};
-		case "selection_required": return await selectRequiredEmailOtpBaseFactorV1(input, result.resolution.choices);
-		case "unavailable": return {
-			kind: "email_otp",
-			targetEmail,
-			enrollment: { kind: "new_enrollment" }
-		};
-	}
-}
-async function selectRequiredEmailOtpBaseFactorV1(input, choices) {
-	if (!input.onEmailOtpBaseFactorRequired) throw new Error("Choose the Email OTP method to use for the linked device");
-	const selected = await input.onEmailOtpBaseFactorRequired(choices);
-	if (!emailOtpBaseFactorChoicesIncludeV1(choices, selected)) throw new Error("The selected Email OTP method is unavailable for this linked device");
-	const result = await input.transport.resolveEmailOtpBaseFactorV1({
-		linkSessionId: input.linkSessionId,
-		request: {
-			kind: "select",
-			expectedRevision: input.sessionRevision,
-			baseWalletAuthMethodId: selected
-		},
-		authentication: input.authentication
-	});
-	assertEmailOtpBaseFactorResolutionIsCurrentV1(result, input.sessionRevision);
-	if (result.resolution.kind !== "selected" || result.resolution.choice.baseWalletAuthMethodId !== selected) throw new Error("The selected Email OTP method is unavailable for this linked device");
-	return {
-		kind: "email_otp",
-		targetEmail: requireTargetEmailAddressV1(input.targetEmail),
-		enrollment: { kind: "existing_enrollment" },
-		baseWalletAuthMethodId: selected
-	};
-}
-function assertEmailOtpBaseFactorResolutionIsCurrentV1(result, expectedRevision) {
-	if (result.revision === expectedRevision) return;
-	if (result.resolution.kind === "unavailable") throw new Error(`linked-device Email OTP target-factor resolution failed: ${result.resolution.reason}`);
-	throw new Error("linked-device Email OTP target-factor resolution changed the session");
-}
-function requireTargetEmailAddressV1(targetEmail) {
-	if (!targetEmail) throw new Error("Email OTP linked-device QR omitted its target email");
-	return targetEmail;
-}
-function emailOtpBaseFactorChoicesIncludeV1(choices, selected) {
-	for (const choice of choices) if (choice.baseWalletAuthMethodId === selected) return true;
-	return false;
-}
-function assertApprovalRecordedV1(result) {
-	switch (result.outcome) {
-		case "pending": return;
-		case "replayed":
-			if (result.replay.state === "pending") return;
-			throw new Error("linked-device approval replay returned an unsupported session state");
-		default: {
-			const exhaustive = result;
-			throw new Error(`unsupported linked-device approval result: ${String(exhaustive)}`);
-		}
-	}
-}
-async function submitSourceContributionsV1(input) {
-	let preparation = null;
-	let attempt = 0;
-	while (Date.now() < input.expiresAtMs) {
-		preparation = await input.transport.getSourceContributionPreparationV1({
-			linkSessionId: input.initialApproval.linkSessionId,
-			authentication: input.authentication
-		});
-		if (preparation) break;
-		await waitForApprovalPollV1(attempt);
-		attempt += 1;
-	}
-	if (!preparation) throw new DeviceLinkingError("Device-link approval expired before target source preparation was published", DeviceLinkingErrorCode.SESSION_EXPIRED, "registration");
-	const sourceContribution = await produceSourceContributionTupleV1({
-		preparation,
-		ports: input.sourceContribution,
-		ed25519ExportRootCapability: input.ed25519ExportRootCapability,
-		authentication: input.authentication
-	});
-	const finalApproval = buildFinalLinkedDeviceApprovalV1(input.initialApproval, sourceContribution);
-	assertSourceContributionRecordedV1(await input.transport.recordSourceContributionV1({
-		approval: finalApproval,
-		authentication: input.authentication
-	}));
-}
-function buildFinalLinkedDeviceApprovalV1(initialApproval, sourceContribution) {
-	if (initialApproval.targetFactor.kind === "passkey_prf") return buildLinkedDeviceApprovalV1({
-		linkSessionId: initialApproval.linkSessionId,
-		walletId: initialApproval.walletId,
-		enrollmentId: initialApproval.enrollmentId,
-		deviceId: initialApproval.deviceId,
-		linkPublicKeyB64u: initialApproval.linkPublicKeyB64u,
-		devicePublicKeyB64u: initialApproval.devicePublicKeyB64u,
-		targetFactor: initialApproval.targetFactor,
-		permission: initialApproval.permission,
-		ownerAuthorization: initialApproval.ownerAuthorization,
-		approvedAtMs: initialApproval.approvedAtMs,
-		expiresAtMs: initialApproval.expiresAtMs,
-		sourceContribution
-	});
-	return buildLinkedDeviceApprovalV1({
-		linkSessionId: initialApproval.linkSessionId,
-		walletId: initialApproval.walletId,
-		enrollmentId: initialApproval.enrollmentId,
-		deviceId: initialApproval.deviceId,
-		linkPublicKeyB64u: initialApproval.linkPublicKeyB64u,
-		devicePublicKeyB64u: initialApproval.devicePublicKeyB64u,
-		targetFactor: initialApproval.targetFactor,
-		permission: initialApproval.permission,
-		ownerAuthorization: initialApproval.ownerAuthorization,
-		approvedAtMs: initialApproval.approvedAtMs,
-		expiresAtMs: initialApproval.expiresAtMs,
-		sourceContribution
-	});
-}
-async function produceSourceContributionTupleV1(input) {
-	const first = input.preparation[0];
-	if (!first) throw new Error("source contribution preparation is empty");
-	if (isEd25519SourceContributionPreparationV1(first)) {
-		if (!input.ed25519ExportRootCapability) throw new Error("Ed25519 export-root capability is required for source contribution");
-		const ed25519 = await input.ports.ed25519.produceSourceContributionV1({
-			preparation: first,
-			capability: input.ed25519ExportRootCapability,
-			authentication: input.authentication
-		});
-		const second = input.preparation[1];
-		if (!second) return [ed25519];
-		if (isEd25519SourceContributionPreparationV1(second)) throw new Error("source contribution preparation repeats Ed25519");
-		return [ed25519, await input.ports.ecdsa.produceSourceContributionV1({ preparation: second })];
-	}
-	if (input.preparation.length !== 1) throw new Error("ECDSA source contribution preparation is out of order");
-	return [await input.ports.ecdsa.produceSourceContributionV1({ preparation: first })];
-}
-function isEd25519SourceContributionPreparationV1(preparation) {
-	return "kind" in preparation;
-}
-function assertSourceContributionRecordedV1(result) {
-	if (result.state.state !== "authority_pending_local_install" && result.state.state !== "active") throw new Error("source contribution acknowledgement did not commit the linked device");
-}
-async function submitEd25519ExportRootIfRequiredV1(input) {
-	if (input.exportRootRequirement === "not_required") return;
-	if (!input.ed25519ExportRootCapability) throw new Error("Ed25519 export-root capability is required for this authority");
-	let sealedPackage = null;
-	let attempt = 0;
-	while (Date.now() < input.expiresAtMs) {
-		if (!sealedPackage) {
-			const recipient = await input.transport.getEd25519ExportRootRecipientV1({
-				linkSessionId: input.linkSessionId,
-				authentication: input.authentication
-			});
-			if (recipient) {
-				if (String(recipient.linkSessionId) !== String(input.linkSessionId) || String(recipient.walletId) !== String(input.walletId) || String(recipient.enrollmentId) !== String(input.enrollmentId) || String(recipient.deviceId) !== String(input.deviceId)) throw new Error("Ed25519 export-root recipient differs from the approved linked-device session");
-				sealedPackage = await input.ed25519ExportRoot.sealForLinkedDeviceV1({
-					recipient,
-					capability: input.ed25519ExportRootCapability,
-					sealedAtMs: Date.now()
-				});
-			}
-		}
-		if (sealedPackage) try {
-			await input.transport.submitEd25519ExportRootPackageV1({
-				submission: {
-					kind: "linked_device_ed25519_export_root_submission_v1",
-					linkSessionId: input.linkSessionId,
-					package: sealedPackage
-				},
-				authentication: input.authentication
-			});
-			return;
-		} catch (error) {
-			const status = readErrorStatusV1(error);
-			if (status !== null && status !== 408 && status !== 429 && status < 500) throw error;
-		}
-		await waitForApprovalPollV1(attempt);
-		attempt += 1;
-	}
-	throw new DeviceLinkingError("Device-link approval expired before the export root recipient was published", DeviceLinkingErrorCode.SESSION_EXPIRED, "registration");
-}
-function readErrorStatusV1(error) {
-	if (typeof error !== "object" || error === null || Array.isArray(error)) return null;
-	const status = Reflect.get(error, "status");
-	return typeof status === "number" && Number.isSafeInteger(status) ? status : null;
-}
-function resolveApprovalPollV1(resolve, attempt) {
-	setTimeout(resolve, nextLinkedDevicePollingDelayMsV1(250, attempt));
-}
-async function waitForApprovalPollV1(attempt) {
-	await new Promise((resolve) => resolveApprovalPollV1(resolve, attempt));
-}
 //#endregion
-export { scanAndLinkDevice, validateQrLinkedDeviceSessionPayloadV5 };
+export { validateQrLinkedDeviceSessionPayloadV5 };
 
 //# sourceMappingURL=scanDevice.js.map

package/dist/esm/SeamsWeb/operations/near/delegateAction.js

@@ -1,20 +1,7 @@
 import { isObject } from "../../../shared-ts/src/utils/validation.js";
-import { toAccountId } from "../../../core/types/accountIds.js";
 import { SigningEventPhase } from "../../../core/types/sdkSentEvents.js";
-import { resolvePrimaryNearRpcUrl } from "../../../core/config/chains.js";
-import { toError } from "../../../shared-ts/src/utils/errors.js";
 import { emitNearSigningEvent } from "./signingEventHelpers.js";
-import { resolveNearCommandSubject } from "./commandSubject.js";
 //#region src/SeamsWeb/operations/near/delegateAction.ts
-async function yieldForUiPaint() {
-	if (typeof window !== "undefined" && typeof window.requestAnimationFrame === "function") {
-		await new Promise((resolve) => {
-			window.requestAnimationFrame(() => resolve());
-		});
-		return;
-	}
-	await Promise.resolve();
-}
 /** HTTP header carrying the managed environment id for Router API auth. */
 const ROUTER_API_ENVIRONMENT_ID_HEADER = "X-Seams-Environment-Id";
 const DELEGATE_RELAYER_TIMEOUT_MS = 3e4;
@@ -54,81 +41,6 @@ function delegateRelayerAuthFromConfigs(configs) {
 		...environmentId ? { environmentId } : {}
 	};
 }
-async function signDelegateAction(args) {
-	const { context, delegate, options } = args;
-	const nearAccountId = toAccountId(String(args.nearAccountId));
-	const title = options?.confirmerText?.title;
-	const body = options?.confirmerText?.body;
-	const resolvedDelegate = {
-		...delegate,
-		senderId: delegate.senderId || String(nearAccountId)
-	};
-	emitNearSigningEvent(options?.onEvent, nearAccountId, {
-		phase: SigningEventPhase.STEP_01_STARTED,
-		status: "started",
-		message: "Preparing delegate action inputs",
-		interaction: {
-			kind: "none",
-			overlay: "none"
-		}
-	});
-	await yieldForUiPaint();
-	try {
-		const coreResult = await context.signingEngine.signNear({
-			chain: "near",
-			kind: "delegateAction",
-			args: {
-				commandSubject: resolveNearCommandSubject({
-					nearAccountId,
-					walletSession: args.walletSession
-				}),
-				delegate: resolvedDelegate,
-				rpcCall: {
-					nearRpcUrl: resolvePrimaryNearRpcUrl(context.configs.network.chains),
-					nearAccountId: String(nearAccountId)
-				},
-				signerSlot: options?.signerSlot,
-				confirmationConfigOverride: options?.confirmationConfig,
-				title,
-				body,
-				onEvent: options?.onEvent
-			}
-		});
-		const result = {
-			hash: coreResult.hash,
-			signedDelegate: coreResult.signedDelegate,
-			nearAccountId: String(nearAccountId),
-			logs: coreResult.logs
-		};
-		emitNearSigningEvent(options?.onEvent, nearAccountId, {
-			phase: SigningEventPhase.STEP_15_COMPLETED,
-			status: "succeeded",
-			message: "Delegate action signed",
-			interaction: {
-				kind: "none",
-				overlay: "none"
-			},
-			data: { hash: result.hash }
-		});
-		await options?.afterCall?.(true, result);
-		return result;
-	} catch (error) {
-		const e = toError(error);
-		options?.onError?.(e);
-		await options?.afterCall?.(false);
-		emitNearSigningEvent(options?.onEvent, nearAccountId, {
-			phase: SigningEventPhase.FAILED,
-			status: "failed",
-			message: e.message,
-			interaction: {
-				kind: "none",
-				overlay: "hide"
-			},
-			error: { message: e.message }
-		});
-		throw e;
-	}
-}
 const toNumberArray = (value) => Array.isArray(value) ? value : Array.from(value);
 const normalizeSignedDelegateForRelay = (signedDelegate) => {
 	const delegateAction = signedDelegate.delegateAction;
@@ -147,24 +59,12 @@ const normalizeSignedDelegateForRelay = (signedDelegate) => {
 		}
 	};
 };
-async function sendDelegateActionViaRelayer(args) {
+async function sendDelegateAction(args) {
 	const { url, payload, auth, signal, options } = args;
 	const normalizedPayload = {
 		...payload,
 		signedDelegate: normalizeSignedDelegateForRelay(payload.signedDelegate)
 	};
-	const emitError = (message) => {
-		emitNearSigningEvent(options?.onEvent, "delegate", {
-			phase: SigningEventPhase.FAILED,
-			status: "failed",
-			message,
-			interaction: {
-				kind: "none",
-				overlay: "hide"
-			},
-			error: { message }
-		});
-	};
 	emitNearSigningEvent(options?.onEvent, "delegate", {
 		phase: SigningEventPhase.STEP_12_BROADCAST_STARTED,
 		status: "running",
@@ -185,7 +85,7 @@ async function sendDelegateActionViaRelayer(args) {
 	} catch (err) {
 		const error = err instanceof DOMException && err.name === "TimeoutError" ? /* @__PURE__ */ new Error("Relayer request timed out after 30 seconds") : err instanceof Error ? err : new Error(String(err));
 		options?.onError?.(error);
-		emitError(error.message);
+		emitDelegateRelayError(options, error.message);
 		await options?.afterCall?.(false);
 		throw error;
 	}
@@ -196,7 +96,7 @@ async function sendDelegateActionViaRelayer(args) {
 		} catch {}
 		const response = parseDelegateRelayerFailure(body, res.status);
 		options?.onError?.(new Error(response.error));
-		emitError(response.error);
+		emitDelegateRelayError(options, response.error);
 		await options?.afterCall?.(false);
 		return response;
 	}
@@ -211,7 +111,7 @@ async function sendDelegateActionViaRelayer(args) {
 		};
 		const error = err instanceof Error ? err : new Error(String(err));
 		options?.onError?.(error);
-		emitError(response.error);
+		emitDelegateRelayError(options, response.error);
 		await options?.afterCall?.(false);
 		return response;
 	}
@@ -236,12 +136,24 @@ async function sendDelegateActionViaRelayer(args) {
 	} else {
 		const message = response.error || "Relayer execution failed";
 		options?.onError?.(new Error(message));
-		emitError(message);
+		emitDelegateRelayError(options, message);
 		await options?.afterCall?.(false);
 	}
 	return response;
 }
+function emitDelegateRelayError(options, message) {
+	emitNearSigningEvent(options?.onEvent, "delegate", {
+		phase: SigningEventPhase.FAILED,
+		status: "failed",
+		message,
+		interaction: {
+			kind: "none",
+			overlay: "hide"
+		},
+		error: { message }
+	});
+}
 //#endregion
-export { delegateRelayerAuthFromConfigs, sendDelegateActionViaRelayer, signDelegateAction };
+export { delegateRelayerAuthFromConfigs, sendDelegateAction };
 
 //# sourceMappingURL=delegateAction.js.map

package/dist/esm/SeamsWeb/operations/recovery/walletRecovery.js

@@ -2,14 +2,14 @@ import { parseEmailOtpChallengeId, parseWebAuthnRpId } from "../../../shared-ts/
 import { base64UrlEncode } from "../../../shared-ts/src/utils/base64.js";
 import { sha256Bytes, sha256HexUtf8 } from "../../../shared-ts/src/utils/digests.js";
 import { secureRandomId } from "../../../shared-ts/src/utils/secureRandomId.js";
-import { decodeEmailOtpRecoveryKey } from "../../../shared-ts/src/utils/emailOtpRecoveryKey.js";
-import "../../../shared-ts/src/wallet-recovery/recoveryCodes.js";
 import { buildEmailOtpEnvelopeFactor, buildPasskeyEnvelopeFactor } from "../../../shared-ts/src/passkey-custody/custodyEnvelope.js";
 import "../../../shared-ts/src/passkey-custody/index.js";
+import { decodeEmailOtpRecoveryKey } from "../../../shared-ts/src/utils/emailOtpRecoveryKey.js";
 import { parseRecoveryCodeReservationId } from "../../../shared-ts/src/wallet-recovery/recoveryCodeReservation.js";
 import { IndexedDBManager } from "../../../core/indexedDB/index.js";
-import { finalizeWalletRecovery } from "../../../core/rpcClients/relayer/walletRecoveryFinalize.js";
+import "../../../shared-ts/src/wallet-recovery/recoveryCodes.js";
 import { buildWalletRecoveryCeremonyCustodyJson, prepareWalletRecoveryWithCode } from "../../../core/rpcClients/relayer/walletRecoveryPrepare.js";
+import { finalizeWalletRecovery } from "../../../core/rpcClients/relayer/walletRecoveryFinalize.js";
 import { isDurablePasskeyPayload } from "./walletRecoveryDurablePayload.js";
 import { createAwaitingWalletRecoveryCommit, promoteWalletRecoveryCommit, restoreAndPublishWalletRecoveryCommit } from "./walletRecoveryCommit.js";
 //#region src/SeamsWeb/operations/recovery/walletRecovery.ts