@seams/wallet 0.7.1 → 0.8.0

package/dist/esm/react/SeamsWeb/operations/tempo/index.js

@@ -1,39 +0,0 @@
-//#region src/SeamsWeb/operations/tempo/index.ts
-function toSerializableTempoError(error) {
-	if (error == null) return void 0;
-	if (typeof error === "string") return { message: error };
-	if (error instanceof Error) {
-		const code = "code" in error ? String(error.code || "").trim() : "";
-		return {
-			...code ? { code } : {},
-			message: String(error.message || "")
-		};
-	}
-	if (typeof error === "object") {
-		const value = error;
-		const code = String(value.code || "").trim();
-		const message = String(value.message || "").trim();
-		return {
-			...code ? { code } : {},
-			...message ? { message } : {},
-			...value.details !== void 0 ? { details: value.details } : {}
-		};
-	}
-	return { message: String(error) };
-}
-function buildTempoBootstrapArgs(configs, args) {
-	const managedRegistration = configs.registration.mode === "managed" ? configs.registration : null;
-	const runtimeScopeBootstrap = args.runtimeScopeBootstrap || (managedRegistration ? {
-		projectEnvironmentId: managedRegistration.projectEnvironmentId,
-		publishableKey: managedRegistration.publishableKey
-	} : void 0);
-	if (args.chainTarget.kind !== "tempo") throw new Error("[SeamsWeb][tempo] bootstrapEcdsaSession requires a Tempo chainTarget");
-	return {
-		...args,
-		...runtimeScopeBootstrap ? { runtimeScopeBootstrap } : {}
-	};
-}
-//#endregion
-export { buildTempoBootstrapArgs, toSerializableTempoError };
-
-//# sourceMappingURL=index.js.map

package/dist/esm/react/SeamsWeb/publicApi/auth.js

@@ -1,23 +0,0 @@
-import { getRecentUnlocksDomain, getWalletSessionDomain, hasPasskeyCredentialDomain, lockDomain, logoutDomain, prefillRouterAbEcdsaDerivationPresignaturePoolDomain, unlockDomain } from "../operations/auth/walletAuth.js";
-//#region src/SeamsWeb/publicApi/auth.ts
-function createAuthCapability(deps) {
-	return {
-		unlock: async (walletId, options) => await unlockDomain(deps.getWalletAuthDeps(), walletId, options),
-		lock: async () => await lockDomain(deps.getWalletAuthDeps()),
-		logout: async () => await logoutDomain(deps.getWalletAuthDeps()),
-		getWalletSession: async (walletId) => await getWalletSessionDomain(deps.getWalletAuthDeps(), walletId),
-		getRecentUnlocks: async () => await getRecentUnlocksDomain(deps.getWalletAuthDeps()),
-		hasPasskeyCredential: async (walletId) => await hasPasskeyCredentialDomain(deps.getWalletAuthDeps(), walletId),
-		prefillRouterAbEcdsaDerivationPresignaturePool: async (args) => await prefillRouterAbEcdsaDerivationPresignaturePoolDomain(deps.getWalletAuthDeps(), args),
-		requestEmailOtpChallenge: deps.domain.requestEmailOtpChallenge,
-		requestEmailOtpSigningSessionChallenge: deps.domain.requestEmailOtpSigningSessionChallenge,
-		refreshEmailOtpSigningSession: deps.domain.refreshEmailOtpSigningSession,
-		loginWithEmailOtpEcdsaCapability: deps.domain.loginWithEmailOtpEcdsaCapability,
-		unlockAddedEmailOtpWallet: deps.domain.unlockAddedEmailOtpWallet,
-		beginGoogleEmailOtpWalletAuth: deps.domain.beginGoogleEmailOtpWalletAuth
-	};
-}
-//#endregion
-export { createAuthCapability };
-
-//# sourceMappingURL=auth.js.map

package/dist/esm/react/SeamsWeb/publicApi/awaitNearReady.js

@@ -1,72 +0,0 @@
-//#region src/SeamsWeb/publicApi/awaitNearReady.ts
-const DEFAULT_AWAIT_NEAR_READY_TIMEOUT_MS = 12e4;
-function outcomeFor(state) {
-	if (!state) return null;
-	if (state.status === "near_ready") return {
-		kind: "near_ready",
-		nearAccountId: state.nearAccountId
-	};
-	if (state.status === "near_failed_retryable") return {
-		kind: "near_failed_retryable",
-		reason: state.error
-	};
-	return null;
-}
-/**
-* Waits for a mixed registration's NEAR account to finish provisioning.
-*
-* `registerPasskey` 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) {
-	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;
-	let unsubscribe = null;
-	let timer = null;
-	let onAbort = null;
-	try {
-		return await new Promise((resolve, reject) => {
-			let settled = false;
-			const settle = (result) => {
-				if (settled) return;
-				settled = true;
-				resolve(result);
-			};
-			if (args.signal?.aborted) {
-				reject(args.signal.reason ?? /* @__PURE__ */ new Error("[seams] awaitNearReady aborted"));
-				return;
-			}
-			if (args.signal) {
-				onAbort = () => {
-					if (settled) return;
-					settled = true;
-					reject(args.signal?.reason ?? /* @__PURE__ */ new Error("[seams] awaitNearReady aborted"));
-				};
-				args.signal.addEventListener("abort", onAbort, { once: true });
-			}
-			unsubscribe = deps.onNearProvisioningStateChanged((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) => {
-				const outcome = outcomeFor(state);
-				if (outcome) settle(outcome);
-			}).catch(() => {});
-		});
-	} finally {
-		if (timer) clearTimeout(timer);
-		if (onAbort && args.signal) args.signal.removeEventListener("abort", onAbort);
-		try {
-			unsubscribe?.();
-		} catch {}
-	}
-}
-//#endregion
-export { awaitNearReady };
-
-//# sourceMappingURL=awaitNearReady.js.map

package/dist/esm/react/SeamsWeb/publicApi/capabilitySelection.js

@@ -1,63 +0,0 @@
-import { CAPABILITY_KINDS, EVM_ECDSA_MPC_OPERATION_KINDS, NEAR_ED25519_MPC_OPERATION_KINDS, buildEvmEcdsaMpcOperationRef, buildNearEd25519MpcOperationRef, buildVaultOperationRef } from "../../shared-ts/src/authorization/capabilityKinds.js";
-import { configuredThresholdEcdsaChainTargets, thresholdEcdsaChainTargetsEqual } from "../../core/signingEngine/interfaces/ecdsaChainTarget.js";
-//#region src/SeamsWeb/publicApi/capabilitySelection.ts
-var BrowserCapabilityUnavailableError = class extends Error {
-	constructor(selection) {
-		super(`Browser capability ${selection.operation.capabilityKind} is unavailable for ${selection.operation.operationKind}: ${selection.reason}`);
-		this.code = "browser_capability_unavailable";
-		this.name = "BrowserCapabilityUnavailableError";
-		this.selection = selection;
-	}
-};
-function selected(operation) {
-	return {
-		kind: "selected",
-		operation
-	};
-}
-function disabled(operation, reason) {
-	return {
-		kind: "disabled",
-		operation,
-		reason
-	};
-}
-function selectNearBrowserCapabilityOperation(configs, request) {
-	switch (request.operationKind) {
-		case NEAR_ED25519_MPC_OPERATION_KINDS.signTransaction:
-		case NEAR_ED25519_MPC_OPERATION_KINDS.signDelegateAction:
-		case NEAR_ED25519_MPC_OPERATION_KINDS.signNep413Message: {
-			const operation = buildNearEd25519MpcOperationRef(request.operationKind);
-			return configs.signing.routerAb.normalSigning.mode === "enabled" ? selected(operation) : disabled(operation, "router_ab_normal_signing_disabled");
-		}
-		case NEAR_ED25519_MPC_OPERATION_KINDS.exportKey: return selected(buildNearEd25519MpcOperationRef(request.operationKind));
-	}
-}
-function selectEvmBrowserCapabilityOperation(configs, request) {
-	const targetIsConfigured = configuredThresholdEcdsaChainTargets(configs.network.chains).some((configuredTarget) => thresholdEcdsaChainTargetsEqual(configuredTarget, request.chainTarget));
-	switch (request.operationKind) {
-		case EVM_ECDSA_MPC_OPERATION_KINDS.signTransaction:
-		case EVM_ECDSA_MPC_OPERATION_KINDS.exportKey: {
-			const operation = buildEvmEcdsaMpcOperationRef(request.operationKind);
-			return targetIsConfigured ? selected(operation) : disabled(operation, "ecdsa_target_not_configured");
-		}
-	}
-}
-function selectBrowserCapabilityOperation(configs, request) {
-	switch (request.capabilityKind) {
-		case CAPABILITY_KINDS.vaultAccess: return disabled(buildVaultOperationRef(request.operationKind), "capability_not_deployed");
-		case CAPABILITY_KINDS.nearEd25519MpcSigning: return selectNearBrowserCapabilityOperation(configs, request);
-		case CAPABILITY_KINDS.evmEcdsaMpcSigning: return selectEvmBrowserCapabilityOperation(configs, request);
-	}
-}
-function requireBrowserCapabilityOperation(configs, request) {
-	const selection = selectBrowserCapabilityOperation(configs, request);
-	switch (selection.kind) {
-		case "selected": return selection.operation;
-		case "disabled": throw new BrowserCapabilityUnavailableError(selection);
-	}
-}
-//#endregion
-export { requireBrowserCapabilityOperation };
-
-//# sourceMappingURL=capabilitySelection.js.map

package/dist/esm/react/SeamsWeb/publicApi/chainTargets.js

@@ -1,48 +0,0 @@
-import { configuredThresholdEcdsaChainTargets, thresholdEcdsaChainTargetFromRequest, thresholdEcdsaChainTargetKey } from "../../core/signingEngine/interfaces/ecdsaChainTarget.js";
-//#region src/SeamsWeb/publicApi/chainTargets.ts
-function isBuiltTarget(selector) {
-	return typeof selector === "object" && selector !== null && "kind" in selector;
-}
-function matchesSelector(target, selector) {
-	if (typeof selector === "string") return target.networkSlug === selector;
-	if ("chainId" in selector) return target.chainId === selector.chainId;
-	return target.kind === selector.family;
-}
-function describeSelector(selector) {
-	if (typeof selector === "string") return selector;
-	if (isBuiltTarget(selector)) return thresholdEcdsaChainTargetKey(selector);
-	if ("chainId" in selector) return `chainId ${selector.chainId}`;
-	return `family ${selector.family}`;
-}
-/**
-* Resolves a selector against the chains this client was configured with.
-*
-* Throws when the selector matches no configured chain, or more than one — the
-* error names every configured target so the caller can pick an exact one.
-*/
-function resolveConfiguredChainTarget(chains, selector) {
-	if (isBuiltTarget(selector)) return thresholdEcdsaChainTargetFromRequest(selector);
-	const configured = configuredThresholdEcdsaChainTargets(chains);
-	const matches = configured.filter((target) => matchesSelector(target, selector));
-	const only = matches[0];
-	if (matches.length === 1 && only) return only;
-	if (matches.length > 1) throw new Error(`[threshold-ecdsa] ambiguous chain selector "${describeSelector(selector)}": matched ${matches.map(thresholdEcdsaChainTargetKey).join(", ")}. Name one exact network slug instead.`);
-	const configuredSlugs = configured.map((target) => target.networkSlug).join(", ");
-	throw new Error(`[threshold-ecdsa] no configured ECDSA chain matches "${describeSelector(selector)}". Configured chains: ${configuredSlugs || "(none)"}.`);
-}
-/** Resolve a Tempo call site's selector, asserting the resolved family. */
-function resolveTempoChainTarget(chains, selector) {
-	const target = resolveConfiguredChainTarget(chains, selector);
-	if (target.kind !== "tempo") throw new Error(`[threshold-ecdsa] expected a Tempo chain target, resolved ${thresholdEcdsaChainTargetKey(target)}`);
-	return target;
-}
-/** Resolve an EVM-eip155 call site's selector, asserting the resolved family. */
-function resolveEvmChainTarget(chains, selector) {
-	const target = resolveConfiguredChainTarget(chains, selector);
-	if (target.kind !== "evm") throw new Error(`[threshold-ecdsa] expected an EVM chain target, resolved ${thresholdEcdsaChainTargetKey(target)}`);
-	return target;
-}
-//#endregion
-export { resolveConfiguredChainTarget, resolveEvmChainTarget, resolveTempoChainTarget };
-
-//# sourceMappingURL=chainTargets.js.map

package/dist/esm/react/SeamsWeb/publicApi/createPublicApi.js

@@ -1,133 +0,0 @@
-import { registerTransactionReviewBridge } from "./transactionReview.js";
-import { createAuthCapability } from "./auth.js";
-import { createDevicesCapability } from "./devices.js";
-import { createEvmSignerCapability } from "./evm.js";
-import { createNearSignerCapability } from "./near.js";
-import { createPreferencesCapability } from "./preferences.js";
-import { createRecoveryCapability } from "./recovery.js";
-import { createTempoSignerCapability } from "./tempo.js";
-import { createCurrentWalletResolver } from "./currentWallet.js";
-import { awaitNearReady } from "./awaitNearReady.js";
-import { createKeyExportCapability } from "./keyExport.js";
-//#region src/SeamsWeb/publicApi/createPublicApi.ts
-function createWalletIframeRoutingSurface(getWalletIframe) {
-	return {
-		shouldUseWalletIframe: () => getWalletIframe().shouldUseWalletIframe(),
-		requireRouter: async (walletId) => await getWalletIframe().requireRouter(walletId)
-	};
-}
-function createPublicApi(deps) {
-	const getAccountSyncContext = () => ({
-		signingEngine: deps.signingEngine,
-		nearClient: deps.nearClient,
-		configs: deps.configs,
-		theme: deps.getTheme()
-	});
-	const getDeviceLinkingContext = () => ({
-		signingEngine: deps.signingEngine,
-		nearClient: deps.nearClient,
-		configs: deps.configs,
-		theme: deps.getTheme()
-	});
-	const walletIframeRoutingSurface = createWalletIframeRoutingSurface(deps.getWalletIframe);
-	const auth = createAuthCapability({
-		getWalletAuthDeps: deps.getWalletAuthDeps,
-		domain: deps.auth
-	});
-	const devices = createDevicesCapability({
-		getContext: getDeviceLinkingContext,
-		walletIframe: walletIframeRoutingSurface,
-		domain: deps.devices
-	});
-	const currentWallet = createCurrentWalletResolver({ getWalletSession: auth.getWalletSession });
-	const signingDeps = {
-		signingEngine: deps.signingEngine,
-		nearClient: deps.nearClient,
-		configs: deps.configs,
-		getTheme: deps.getTheme,
-		getWalletIframe: deps.getWalletIframe,
-		currentWallet
-	};
-	const near = createNearSignerCapability(signingDeps);
-	const evmFamily = createTempoSignerCapability(signingDeps);
-	registerTransactionReviewBridge(near, {
-		getWalletIframe: deps.getWalletIframe,
-		createCapabilities: createReviewedCapabilities.bind(null, signingDeps)
-	});
-	return {
-		walletIframeControls: {
-			initWalletIframe: async (walletId) => await deps.getWalletIframe().init(walletId),
-			isWalletIframeReady: () => deps.getWalletIframe().isReady(),
-			onWalletIframeReady: (listener) => deps.getWalletIframe().onReady(listener),
-			onWalletIframeLoginStatusChanged: (listener) => deps.getWalletIframe().onLoginStatusChanged(listener),
-			onWalletIframePreferencesChanged: (listener) => deps.getWalletIframe().onPreferencesChanged(listener)
-		},
-		preferences: createPreferencesCapability({
-			userPreferences: deps.userPreferences,
-			getWalletIframe: deps.getWalletIframe
-		}),
-		auth,
-		registration: {
-			resumePendingEcdsaRegistration: deps.registration.resumePendingEcdsaRegistration,
-			getNearProvisioningState: deps.registration.getNearProvisioningState,
-			onNearProvisioningStateChanged: deps.registration.onNearProvisioningStateChanged,
-			awaitNearReady: async (args) => await awaitNearReady({
-				getNearProvisioningState: deps.registration.getNearProvisioningState,
-				onNearProvisioningStateChanged: deps.registration.onNearProvisioningStateChanged
-			}, {
-				...args,
-				walletId: String(args.walletId)
-			}),
-			addWalletSigner: deps.registration.addWalletSigner,
-			addPasskey: deps.registration.addPasskey,
-			addEmailOtp: deps.registration.addEmailOtp,
-			revokeAuthMethod: deps.registration.revokeAuthMethod,
-			registerWallet: deps.registration.registerWallet,
-			registerWithEmailOtp: deps.registration.registerWallet,
-			registerPasskey: deps.registration.registerPasskey,
-			requestEmailOtpEnrollmentChallenge: deps.registration.requestEmailOtpEnrollmentChallenge,
-			enrollEmailOtp: deps.registration.enrollEmailOtp
-		},
-		recovery: createRecoveryCapability({
-			getContext: getAccountSyncContext,
-			walletIframe: walletIframeRoutingSurface,
-			domain: deps.recovery
-		}),
-		devices,
-		keys: createKeyExportCapability({
-			configs: deps.configs,
-			currentWallet,
-			domain: deps.keys
-		}),
-		near,
-		tempo: evmFamily,
-		evm: createEvmSignerCapability({
-			signingEngine: deps.signingEngine,
-			nearClient: deps.nearClient,
-			configs: deps.configs,
-			getTheme: deps.getTheme,
-			getWalletIframe: deps.getWalletIframe,
-			currentWallet,
-			evmFamily
-		})
-	};
-}
-function createReviewedCapabilities(deps, reservation) {
-	const dispatch = {
-		kind: "reviewed",
-		reservation
-	};
-	const tempo = createTempoSignerCapability(deps, dispatch);
-	return {
-		near: createNearSignerCapability(deps, dispatch),
-		tempo,
-		evm: createEvmSignerCapability({
-			...deps,
-			evmFamily: tempo
-		}, dispatch)
-	};
-}
-//#endregion
-export { createPublicApi };
-
-//# sourceMappingURL=createPublicApi.js.map

package/dist/esm/react/SeamsWeb/publicApi/currentWallet.js

@@ -1,46 +0,0 @@
-import { nearAccountRefFromAccountId, walletSessionRefFromSession } from "../../core/signingEngine/interfaces/ecdsaChainTarget.js";
-//#region src/SeamsWeb/publicApi/currentWallet.ts
-function toWalletSessionRef(input) {
-	return typeof input === "string" ? walletSessionRefFromSession({ walletId: input }) : input;
-}
-function toNearAccountRef(input) {
-	return typeof input === "string" ? nearAccountRefFromAccountId(input) : input;
-}
-function createCurrentWalletResolver(deps) {
-	const readAuthenticatedSession = async () => {
-		const session = await deps.getWalletSession();
-		if (session.authentication.kind !== "authenticated") throw new Error("[seams] no authenticated wallet: unlock a wallet first, or pass an explicit `walletSession`.");
-		return session;
-	};
-	const walletSession = async (explicit) => {
-		if (explicit) return toWalletSessionRef(explicit);
-		return walletSessionRefFromSession({ walletId: (await readAuthenticatedSession()).authentication.walletId });
-	};
-	return {
-		walletSession,
-		nearSubject: async (explicit) => {
-			if (explicit.walletSession && explicit.nearAccount) return {
-				walletSession: toWalletSessionRef(explicit.walletSession),
-				nearAccount: toNearAccountRef(explicit.nearAccount)
-			};
-			const session = await readAuthenticatedSession();
-			const authenticatedWalletId = session.authentication.walletId;
-			const resolvedSession = explicit.walletSession ? toWalletSessionRef(explicit.walletSession) : walletSessionRefFromSession({ walletId: authenticatedWalletId });
-			if (explicit.nearAccount) return {
-				walletSession: resolvedSession,
-				nearAccount: toNearAccountRef(explicit.nearAccount)
-			};
-			const identity = session.appIdentity;
-			if (identity.kind !== "resolved" || String(identity.walletId) !== String(authenticatedWalletId)) throw new Error("[seams] the authenticated wallet has no resolved NEAR account: pass an explicit `nearAccount`.");
-			if (!identity.nearAccountId) throw new Error("[seams] this wallet has no NEAR account yet (NEAR provisioning may still be pending): pass an explicit `nearAccount`, or await `seams.registration.awaitNearReady`.");
-			return {
-				walletSession: resolvedSession,
-				nearAccount: nearAccountRefFromAccountId(identity.nearAccountId)
-			};
-		}
-	};
-}
-//#endregion
-export { createCurrentWalletResolver };
-
-//# sourceMappingURL=currentWallet.js.map

package/dist/esm/react/SeamsWeb/publicApi/devices.js

@@ -1,83 +0,0 @@
-import { parseWalletAuthMethodId, parseWalletId } from "../../shared-ts/src/utils/domainIds.js";
-import { parseLinkedDeviceListRequestV1, parseLinkedDeviceListResultV1, parseLinkedDeviceRevokeRequestV1, parseLinkedDeviceRevokeResultV1 } from "../../shared-ts/src/device-linking/deviceManagement.js";
-import "../../shared-ts/src/device-linking/index.js";
-import { DeviceLinkingDomain } from "../operations/devices/linkDevice.js";
-//#region src/SeamsWeb/publicApi/devices.ts
-function createWalletIframeLinkedDeviceManagementPortV1(deps) {
-	return {
-		listLinkedDevices: async ({ walletId, limit, cursor }) => {
-			return await (await deps.walletIframe.requireRouter(walletId)).listLinkedDevices({
-				walletId: String(walletId),
-				limit,
-				cursor
-			});
-		},
-		revokeLinkedDevice: async ({ walletId, walletAuthMethodId, requestedAtMs, sourceProof }) => {
-			return await (await deps.walletIframe.requireRouter(walletId)).revokeLinkedDevice({
-				walletId: String(walletId),
-				walletAuthMethodId: String(walletAuthMethodId),
-				requestedAtMs,
-				sourceProof
-			});
-		}
-	};
-}
-function createDevicesCapability(deps) {
-	const deviceLinking = deps.domain.kind === "direct" ? new DeviceLinkingDomain({
-		kind: "direct",
-		getContext: deps.getContext,
-		walletIframe: deps.walletIframe,
-		ports: deps.domain.deviceLinkingPorts
-	}) : new DeviceLinkingDomain({
-		kind: "iframe",
-		getContext: deps.getContext,
-		walletIframe: deps.walletIframe
-	});
-	return {
-		startDevice2LinkingFlow: async (args) => await deviceLinking.startDevice2LinkingFlow(args),
-		cancelDeviceLinking: async () => await deviceLinking.cancelDeviceLinking(),
-		scanAndLinkDevice: async (qrData, options) => await deviceLinking.scanAndLinkDevice(qrData, options),
-		listLinkedDevices: async (args) => {
-			const request = parseLinkedDeviceListRequestV1({
-				kind: "linked_device_list_request_v1",
-				walletId: parseWalletIdForPublicCall(args.walletId),
-				limit: args.limit,
-				cursor: args.cursor
-			});
-			const managementRequest = {
-				walletId: request.walletId,
-				limit: request.limit,
-				cursor: request.cursor
-			};
-			return parseLinkedDeviceListResultV1(await deps.domain.linkedDeviceManagement.listLinkedDevices(managementRequest));
-		},
-		revokeLinkedDevice: async (args) => {
-			const request = parseLinkedDeviceRevokeRequestV1({
-				kind: "linked_device_revoke_request_v1",
-				walletId: parseWalletIdForPublicCall(args.walletId),
-				walletAuthMethodId: parseWalletAuthMethodIdForPublicCall(args.walletAuthMethodId),
-				requestedAtMs: args.requestedAtMs
-			});
-			return parseLinkedDeviceRevokeResultV1(await deps.domain.linkedDeviceManagement.revokeLinkedDevice({
-				walletId: request.walletId,
-				walletAuthMethodId: request.walletAuthMethodId,
-				requestedAtMs: request.requestedAtMs,
-				sourceProof: args.sourceProof
-			}));
-		}
-	};
-}
-function parseWalletIdForPublicCall(raw) {
-	const result = parseWalletId(raw);
-	if (!result.ok) throw new Error(result.error.message);
-	return result.value;
-}
-function parseWalletAuthMethodIdForPublicCall(raw) {
-	const result = parseWalletAuthMethodId(raw);
-	if (!result.ok) throw new Error(result.error.message);
-	return result.value;
-}
-//#endregion
-export { createDevicesCapability, createWalletIframeLinkedDeviceManagementPortV1 };
-
-//# sourceMappingURL=devices.js.map

package/dist/esm/react/SeamsWeb/publicApi/evm.js

@@ -1,103 +0,0 @@
-import { toError } from "../../shared-ts/src/utils/errors.js";
-import { cloneAuthenticatorOptions } from "../../shared-ts/src/utils/authenticatorOptions.js";
-import { CAPABILITY_KINDS, EVM_ECDSA_MPC_OPERATION_KINDS } from "../../shared-ts/src/authorization/capabilityKinds.js";
-import { toWalletId } from "../../core/signingEngine/interfaces/ecdsaChainTarget.js";
-import { registerWallet } from "../operations/registration/registration.js";
-import { resolveEvmChainTarget } from "./chainTargets.js";
-import { buildEvmBootstrapArgs, buildEvmWalletRegistrationArgs } from "../operations/evm/index.js";
-import { requireBrowserCapabilityOperation } from "./capabilitySelection.js";
-//#region src/SeamsWeb/publicApi/evm.ts
-function requireEvmSignedResult(result) {
-	if (result.chain !== "evm" || result.kind !== "eip1559") throw new Error(`[EVM capability] expected EVM result, received ${result.chain}`);
-	return result;
-}
-function toLocalEvmBootstrapRequest(args) {
-	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
-	};
-}
-function createEvmSignerCapability(deps, transactionDispatch = { kind: "ordinary" }) {
-	return {
-		executeTransaction: async (args) => await deps.evmFamily.executeEvmFamilyTransaction(args),
-		advanced: {
-			reportBroadcastAccepted: async (args) => await deps.evmFamily.reportBroadcastAccepted(args),
-			reportBroadcastRejected: async (args) => await deps.evmFamily.reportBroadcastRejected(args),
-			reportFinalized: async (args) => await deps.evmFamily.reportFinalized(args),
-			reportDroppedOrReplaced: async (args) => await deps.evmFamily.reportDroppedOrReplaced(args),
-			reconcileNonceLane: async (args) => await deps.evmFamily.reconcileNonceLane(args),
-			bootstrapEcdsaSession: async (args) => await deps.evmFamily.bootstrapEcdsaSession(args)
-		},
-		signTransaction: async (args) => {
-			const chainTarget = resolveEvmChainTarget(deps.configs.network.chains, args.chainTarget);
-			const walletSession = await deps.currentWallet.walletSession(args.walletSession);
-			requireBrowserCapabilityOperation(deps.configs, {
-				capabilityKind: CAPABILITY_KINDS.evmEcdsaMpcSigning,
-				operationKind: EVM_ECDSA_MPC_OPERATION_KINDS.signTransaction,
-				chainTarget
-			});
-			const walletIframe = deps.getWalletIframe();
-			if (!walletIframe.shouldUseWalletIframe()) return requireEvmSignedResult(await deps.signingEngine.signEvmFamily({
-				walletSession,
-				request: args.request,
-				chainTarget,
-				confirmationConfigOverride: args.options?.confirmationConfig,
-				shouldAbort: args.options?.shouldAbort,
-				onEvent: args.options?.onEvent
-			}));
-			try {
-				return requireEvmSignedResult(await (await walletIframe.requireRouter(toWalletId(walletSession.walletId))).signTempo({
-					walletSession,
-					request: args.request,
-					chainTarget,
-					options: {
-						confirmationConfig: args.options?.confirmationConfig,
-						onEvent: args.options?.onEvent
-					}
-				}, transactionDispatch));
-			} catch (error) {
-				throw toError(error);
-			}
-		},
-		registerEvmWallet: async (args) => {
-			const walletIframe = deps.getWalletIframe();
-			const registerWalletArgs = buildEvmWalletRegistrationArgs(args);
-			if (!walletIframe.shouldUseWalletIframe()) return await registerWallet({
-				context: {
-					signingEngine: deps.signingEngine,
-					nearClient: deps.nearClient,
-					configs: deps.configs,
-					theme: deps.getTheme()
-				},
-				...registerWalletArgs,
-				authenticatorOptions: cloneAuthenticatorOptions(deps.configs.webauthn.authenticatorOptions)
-			});
-			try {
-				const result = await (await walletIframe.requireRouter()).registerWallet(registerWalletArgs);
-				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;
-			}
-		},
-		bootstrapEcdsaSession: async (args) => {
-			const walletIframe = deps.getWalletIframe();
-			const bootstrapArgs = buildEvmBootstrapArgs(deps.configs, args);
-			if (!walletIframe.shouldUseWalletIframe()) return await deps.signingEngine.bootstrapEcdsaSession(toLocalEvmBootstrapRequest(bootstrapArgs));
-			return await (await walletIframe.requireRouter(toWalletId(args.walletSession.walletId))).bootstrapEcdsaSession(bootstrapArgs);
-		}
-	};
-}
-//#endregion
-export { createEvmSignerCapability };
-
-//# sourceMappingURL=evm.js.map