@seams/wallet 0.7.3 → 0.8.0

package/dist/esm/react/SeamsWeb/operations/recovery/syncAccount.js

@@ -1,914 +0,0 @@
-import { errorMessage } from "../../../shared-ts/src/utils/errors.js";
-import { base64UrlDecode, base64UrlEncode } from "../../../shared-ts/src/utils/base64.js";
-import { isPlainObject } from "../../../shared-ts/src/utils/validation.js";
-import { buildThresholdEd25519Participants2pV1 } from "../../../shared-ts/src/threshold/participants.js";
-import { normalizeRuntimePolicyScope } from "../../../shared-ts/src/threshold/signingRootScope.js";
-import { getPrfFirstB64uFromCredential, redactCredentialExtensionOutputs } from "../../../core/signingEngine/webauthnAuth/credentials/credentialExtensions.js";
-import { mpcMaterialActivationRefsEqual, parseThresholdEd25519SessionId, parseWalletAuthMethodId, parseWalletAuthorityId, parseWalletId, parseWebAuthnCredentialIdB64u, parseWebAuthnRpId } from "../../../shared-ts/src/utils/domainIds.js";
-import { routerAbMpcMaterialActivationRefFromWire } from "../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import { parseMpcWalletSigningQuotaId, parseWalletSessionAuthorizationId, parseWalletSessionId, parseWalletSessionMintId } from "../../../shared-ts/src/authorization/capabilityKinds.js";
-import { parseRouterAbEcdsaCredentialFreeSessionActivationResponseV1, parseRouterAbEcdsaDerivationPublicCapabilityV1, parseRouterAbEcdsaRegistrationActivationReceiptV1, sameRouterAbEcdsaDerivationPublicCapabilityV1, sameRouterAbEcdsaRegistrationActivationReceiptV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { walletIdFromString } from "../../../shared-ts/src/utils/registrationIds.js";
-import { deriveEvmFamilySigningKeySlotId } from "../../../shared-ts/src/signing-lanes/evmFamilySigningKeySlotId.js";
-import "../../../shared-ts/src/signing-lanes/index.js";
-import { thresholdEcdsaChainTargetKey } from "../../../core/signingEngine/interfaces/ecdsaChainTarget.js";
-import { replaceActiveWalletAuthorityEd25519MaterialActivationV1 } from "../../../shared-ts/src/authorization/walletAuthority.js";
-import { buildRecoveredWalletSessionState, parsePasskeyEd25519YaoSyncResponseV1, passkeyEd25519YaoLaneReferenceFromRecovery } from "../../../core/signingEngine/flows/recovery/passkeyEd25519YaoRecovery.js";
-import { AccountSyncEventPhase, createAccountSyncFlowEvent } from "../../../core/types/sdkSentEvents.js";
-import { WALLET_CUSTODY_ED25519_MATERIAL_KEY_KIND } from "../../../core/indexedDB/walletCustodyEd25519MaterialRecord.js";
-import { walletSessionAuthorizations } from "../../../core/indexedDB/seamsWalletDB/walletSessionAuthorizationStore.js";
-import { IndexedDBManager } from "../../../core/indexedDB/index.js";
-import { nearEd25519YaoMaterialActivationFromMetadata } from "../../../core/signingEngine/session/material/nearEd25519YaoMaterialActivation.js";
-import { persistPasskeyEd25519YaoSignerMaterialV1 } from "../../../core/signingEngine/session/passkey/ed25519YaoLocalMaterial.js";
-import { buildPasskeyEd25519RestoreMetadata, persistPasskeyEd25519YaoSessionForRefresh } from "../../../core/signingEngine/session/passkey/ed25519YaoSealedSession.js";
-import { rememberPasskeyCustodySessionEnvelope } from "../../../core/signingEngine/session/passkey/passkeyCustodySessionCache.js";
-import { openOrRejoinWalletCustodyEd25519V1, openWalletCustodyEd25519ActiveClientV1, walletCustodyActivationFactsFromActiveClientMetadataV1, walletCustodyCacheEnvelopeFromRecordV1 } from "../../../core/signingEngine/walletCustody/openCustodyCache.js";
-import { joinCustodyWireFromEnvelopeRecord } from "../../../core/signingEngine/walletCustody/joinCustodyWire.js";
-import { sameRuntimePolicyScope } from "../registration/registrationStrictEcdsa.js";
-import { assertSameRecoveryWalletIdentity, parseRecoveryResolvedWalletBindingFromResponse } from "./recoveryWalletBinding.js";
-//#region src/SeamsWeb/operations/recovery/syncAccount.ts
-function syncAccountFailure(error) {
-	return {
-		success: false,
-		error
-	};
-}
-function fetchWithGlobalThis(input, init) {
-	return globalThis.fetch(input, init);
-}
-function emitSyncAccountEvent(args) {
-	try {
-		args.onEvent?.(createAccountSyncFlowEvent({
-			flowId: args.flowId,
-			...args.event
-		}));
-	} catch {}
-}
-function requireRelayerUrl(context) {
-	const relayerUrl = String(context.configs.network.relayer?.url || "").trim();
-	if (!relayerUrl) throw new Error("missing_relayer_url");
-	return relayerUrl;
-}
-function requireRpId(context) {
-	const parsed = parseWebAuthnRpId(context.signingEngine.getRpId());
-	if (!parsed.ok) throw new Error("missing_rp_id");
-	return parsed.value;
-}
-function parseCredentialIds(value) {
-	if (!Array.isArray(value)) return [];
-	const ids = [];
-	for (const raw of value) {
-		const id = typeof raw === "string" ? raw.trim() : "";
-		if (id) ids.push(id);
-	}
-	return ids;
-}
-function requireSyncString(record, field) {
-	const value = String(record[field] || "").trim();
-	if (!value) throw new Error(`sync-account ${field} is required`);
-	return value;
-}
-function parseSyncEcdsaChainTarget(value) {
-	if (!isPlainObject(value)) throw new Error("sync-account ECDSA chain target is invalid");
-	const chainId = Number(value.chainId);
-	if (!Number.isSafeInteger(chainId) || chainId <= 0) throw new Error("sync-account ECDSA chain id is invalid");
-	if (value.kind === "evm" && value.namespace === "eip155") return {
-		kind: "evm",
-		namespace: "eip155",
-		chainId,
-		networkSlug: String(value.networkSlug || "").trim() || `evm-${chainId}`
-	};
-	if (value.kind === "tempo") return {
-		kind: "tempo",
-		chainId,
-		networkSlug: String(value.networkSlug || "").trim() || `tempo-${chainId}`
-	};
-	throw new Error("sync-account ECDSA chain family is invalid");
-}
-function parseSyncEcdsaParticipantIds(value) {
-	if (!Array.isArray(value) || value.length !== 2 || value[0] !== 1 || value[1] !== 2) throw new Error("sync-account ECDSA participant ids are invalid");
-	return [1, 2];
-}
-function isEcdsaSignWalletSessionSubject(subject) {
-	return subject.kind === "sign" && subject.keyFamily === "ecdsa_secp256k1";
-}
-function findEcdsaSignWalletSessionSubject(subjects) {
-	for (const subject of subjects) if (isEcdsaSignWalletSessionSubject(subject)) return subject;
-	return null;
-}
-function parseWalletCustodyEcdsaContinuity(raw, expected) {
-	const response = isPlainObject(raw) ? raw : {};
-	const continuity = response.ecdsaCustody;
-	if (!isPlainObject(continuity) || continuity.kind !== "wallet_custody_ecdsa_sync_continuity_v1") throw new Error("sync-account ECDSA custody continuity is invalid");
-	if (!Array.isArray(continuity.signers)) throw new Error("sync-account ECDSA custody signer list is invalid");
-	const signers = [];
-	for (const rawSigner of continuity.signers) {
-		if (!isPlainObject(rawSigner) || !isPlainObject(rawSigner.walletKey)) throw new Error("sync-account ECDSA custody signer is invalid");
-		const walletKey = rawSigner.walletKey;
-		const walletId = requireSyncString(walletKey, "walletId");
-		if (walletId !== String(expected.walletId)) throw new Error("sync-account ECDSA custody signer changed the wallet identity");
-		signers.push({
-			chainTarget: parseSyncEcdsaChainTarget(rawSigner.chainTarget),
-			walletKey: {
-				walletId,
-				keyHandle: requireSyncString(walletKey, "keyHandle"),
-				ecdsaThresholdKeyId: requireSyncString(walletKey, "ecdsaThresholdKeyId"),
-				signingRootId: requireSyncString(walletKey, "signingRootId"),
-				signingRootVersion: requireSyncString(walletKey, "signingRootVersion"),
-				relayerKeyId: requireSyncString(walletKey, "relayerKeyId"),
-				contextBinding32B64u: requireSyncString(walletKey, "contextBinding32B64u"),
-				derivationClientSharePublicKey33B64u: requireSyncString(walletKey, "derivationClientSharePublicKey33B64u"),
-				participantIds: parseSyncEcdsaParticipantIds(walletKey.participantIds),
-				publicCapability: parseRouterAbEcdsaDerivationPublicCapabilityV1(walletKey.publicCapability)
-			},
-			activationReceipt: parseRouterAbEcdsaRegistrationActivationReceiptV1(rawSigner.activationReceipt),
-			runtimePolicyScope: normalizeRuntimePolicyScope(rawSigner.runtimePolicyScope)
-		});
-	}
-	const first = signers[0];
-	if (!first) {
-		if (response.ecdsaSession !== void 0 || response.ecdsaActivationReceipt !== void 0) throw new Error("sync-account returned an ECDSA session without custody continuity");
-		return {
-			kind: "wallet_custody_ecdsa_sync_continuity_v1",
-			state: "absent",
-			signers: []
-		};
-	}
-	const sessionActivation = parseRouterAbEcdsaCredentialFreeSessionActivationResponseV1(response.ecdsaSession);
-	const activationReceipt = parseRouterAbEcdsaRegistrationActivationReceiptV1(response.ecdsaActivationReceipt);
-	const ecdsaSignSubject = findEcdsaSignWalletSessionSubject(expected.walletSession.capabilitySubjects);
-	if (!ecdsaSignSubject || sessionActivation.session.authorization_id !== expected.walletSession.authorizationId || !sameRouterAbEcdsaDerivationPublicCapabilityV1(sessionActivation.public_capability, first.walletKey.publicCapability) || !sameRouterAbEcdsaRegistrationActivationReceiptV1(activationReceipt, first.activationReceipt) || !mpcMaterialActivationRefsEqual(ecdsaSignSubject.materialActivation, routerAbMpcMaterialActivationRefFromWire(sessionActivation.public_capability.material_activation)) || sessionActivation.session.wallet_session_id !== expected.session.walletSessionId || sessionActivation.session.quota_id !== expected.session.quotaId || sessionActivation.session.expires_at_ms !== expected.session.expiresAtMs || sessionActivation.session.remaining_uses !== expected.session.remainingUses) throw new Error("sync-account ECDSA session changed the Wallet Session or custody identity");
-	return {
-		kind: "wallet_custody_ecdsa_sync_continuity_v1",
-		state: "activated",
-		signers: [first, ...signers.slice(1)],
-		sessionActivation
-	};
-}
-async function readJsonOrNull(response) {
-	try {
-		return await response.json();
-	} catch {
-		return null;
-	}
-}
-async function requestSyncOptions(input) {
-	const response = await input.fetch(`${input.relayerUrl}/sync-account/options`, {
-		method: "POST",
-		headers: { "content-type": "application/json" },
-		body: JSON.stringify({
-			rp_id: input.rpId,
-			...input.walletId ? { account_id: input.walletId } : {}
-		})
-	});
-	const raw = await readJsonOrNull(response);
-	if (!response.ok || !isPlainObject(raw) || raw.ok !== true) {
-		const message = isPlainObject(raw) ? String(raw.message || raw.code || "") : "";
-		throw new Error(message || `sync-account/options failed (HTTP ${response.status})`);
-	}
-	const challengeId = String(raw.challengeId || "").trim();
-	const challengeB64u = String(raw.challengeB64u || "").trim();
-	if (!challengeId || !challengeB64u) throw new Error("sync-account/options returned an invalid challenge");
-	const walletBinding = isPlainObject(raw.walletBinding) ? parseRecoveryResolvedWalletBindingFromResponse(raw, "sync-account/options") : null;
-	const credentialIds = parseCredentialIds(raw.credentialIds);
-	if (input.walletId && (!walletBinding || credentialIds.length === 0)) throw new Error(`No passkey recovery capability found for wallet ${input.walletId}`);
-	return {
-		challengeId,
-		challengeB64u,
-		credentialIds,
-		walletBinding
-	};
-}
-function requireSelectedCredentialId(credential) {
-	const id = String(credential.id || "").trim();
-	const rawId = String(credential.rawId || "").trim();
-	if (!id || !rawId || id !== rawId) throw new Error("selected passkey credential identity is invalid");
-	const parsed = parseWebAuthnCredentialIdB64u(rawId);
-	if (!parsed.ok) throw new Error("selected passkey credential identity is invalid");
-	return parsed.value;
-}
-function credentialIdsForSyncAccountRecovery(syncOptions, expectedCredentialIdB64u) {
-	if (expectedCredentialIdB64u === null) return syncOptions.credentialIds;
-	if (!syncOptions.credentialIds.includes(expectedCredentialIdB64u)) throw new Error("replacement account-sync challenge changed the selected passkey");
-	return [expectedCredentialIdB64u];
-}
-function parseCanonicalTerminalIdentity(raw, parser) {
-	if (typeof raw !== "string" || raw.trim() !== raw || !raw) return null;
-	const parsed = parser(raw);
-	return parsed.ok ? parsed.value : null;
-}
-function parseExactSyncAccountAlreadyCommittedResponse(input) {
-	if (input.response.status !== 409 || !isPlainObject(input.raw)) return null;
-	const raw = input.raw;
-	if (raw.ok !== false || raw.code !== "already_committed" || raw.kind !== "already_committed" || raw.next !== "unlock_exact_method") return null;
-	if ([
-		"walletId",
-		"authorityId",
-		"walletAuthMethodId",
-		"mintId",
-		"authorizationId",
-		"walletSessionId",
-		"quotaId"
-	].some((field) => {
-		const value = raw[field];
-		return typeof value !== "string" || !value.trim();
-	})) return null;
-	if ("walletSessionToken" in raw || "walletSessionJwt" in raw || "sessionKind" in raw || "walletSession" in raw || "operationCredential" in raw || "credential" in raw) return null;
-	const walletId = parseCanonicalTerminalIdentity(raw.walletId, parseWalletId);
-	const authorityId = parseCanonicalTerminalIdentity(raw.authorityId, parseWalletAuthorityId);
-	const walletAuthMethodId = parseCanonicalTerminalIdentity(raw.walletAuthMethodId, parseWalletAuthMethodId);
-	const mintId = parseCanonicalTerminalIdentity(raw.mintId, parseWalletSessionMintId);
-	const authorizationId = parseCanonicalTerminalIdentity(raw.authorizationId, parseWalletSessionAuthorizationId);
-	const walletSessionId = parseCanonicalTerminalIdentity(raw.walletSessionId, parseWalletSessionId);
-	const quotaId = parseCanonicalTerminalIdentity(raw.quotaId, parseMpcWalletSigningQuotaId);
-	if (!walletId || !authorityId || !walletAuthMethodId || !mintId || !authorizationId || !walletSessionId || !quotaId) return null;
-	if (input.expectedWalletId !== null && walletId !== input.expectedWalletId) return null;
-	return {
-		walletId,
-		walletAuthMethodId
-	};
-}
-async function verifySyncCredential(input) {
-	const response = await input.fetch(`${input.relayerUrl}/sync-account/verify`, {
-		method: "POST",
-		headers: { "content-type": "application/json" },
-		body: JSON.stringify({
-			challengeId: input.challengeId,
-			webauthn_authentication: redactCredentialExtensionOutputs(input.credential)
-		})
-	});
-	const raw = await readJsonOrNull(response);
-	if (!response.ok || !isPlainObject(raw) || raw.ok !== true || raw.verified !== true) {
-		const committed = parseExactSyncAccountAlreadyCommittedResponse({
-			response,
-			raw,
-			expectedWalletId: input.expectedWalletId
-		});
-		if (committed) return {
-			kind: "already_committed",
-			walletId: committed.walletId,
-			walletAuthMethodId: committed.walletAuthMethodId,
-			credentialIdB64u: input.selectedCredentialId
-		};
-		const message = isPlainObject(raw) ? String(raw.message || raw.code || "") : "";
-		throw new Error(message || `sync-account/verify failed (HTTP ${response.status})`);
-	}
-	const verifiedBinding = parseRecoveryResolvedWalletBindingFromResponse(raw, "sync-account/verify");
-	input.onRelayVerifySucceeded?.(verifiedBinding);
-	const parsedYaoResponse = parsePasskeyEd25519YaoSyncResponseV1(raw);
-	return {
-		kind: "verified",
-		response: {
-			verifiedBinding,
-			parsedYaoResponse,
-			ecdsaContinuity: parseWalletCustodyEcdsaContinuity(raw, parsedYaoResponse)
-		}
-	};
-}
-function assertNeverRecoveredCapabilityOwnership(value) {
-	throw new Error(`Unexpected recovered capability ownership: ${String(value)}`);
-}
-async function disposeRecoveredCapability(input) {
-	const ownership = input.ownership;
-	switch (ownership.kind) {
-		case "caller_owned":
-			ownership.recovery.activeClient.dispose();
-			await input.context.signingEngine.clearVolatileWarmSigningMaterial(ownership.recovery.parsed.walletId);
-			return;
-		case "registry_owned":
-			await input.context.signingEngine.clearVolatileWarmSigningMaterial(ownership.recovery.parsed.walletId);
-			return;
-		case "empty":
-		case "committed": return;
-		default: return assertNeverRecoveredCapabilityOwnership(ownership);
-	}
-}
-function assertRecoveredCapabilityBinding(input) {
-	if (input.optionsBinding) assertSameRecoveryWalletIdentity(input.optionsBinding, input.verifiedBinding, "sync-account/verify");
-	const recovered = input.parsed;
-	if (input.verifiedBinding.rpId !== input.rpId || input.requestedWalletId !== null && input.requestedWalletId !== input.verifiedBinding.walletId || String(recovered.walletId) !== String(input.verifiedBinding.walletId) || String(recovered.nearAccountId) !== String(input.verifiedBinding.nearAccountId) || recovered.nearEd25519SigningKeyId !== String(input.verifiedBinding.nearEd25519SigningKeyId) || recovered.credentialIdB64u !== input.verifiedBinding.credentialIdB64u || recovered.credentialIdB64u !== input.selectedCredentialId || input.expectedWalletAuthMethodId !== null && String(recovered.walletAuthMethodId) !== input.expectedWalletAuthMethodId || recovered.signerSlot !== input.verifiedBinding.signerSlot) throw new Error("recovered Yao capability does not match the verified wallet binding");
-}
-function walletCustodyActivationFacts(parsed) {
-	const continuity = parsed.capability.registrationContinuity;
-	return {
-		materialActivation: parsed.capability.materialActivation,
-		lifecycleId: parsed.capability.lifecycle.lifecycleId,
-		signingRootVersion: parsed.capability.lifecycle.rootShareEpoch,
-		signingRootId: parsed.capability.applicationBinding.signing_root_id,
-		signerSetId: parsed.capability.lifecycle.signerSetId,
-		thresholdSessionId: parsed.capability.lifecycle.thresholdSessionId,
-		activationTranscriptB64u: base64UrlEncode(Uint8Array.from(continuity.activationTranscript)),
-		activationCapabilityBindingB64u: base64UrlEncode(Uint8Array.from(parsed.capability.activeCapabilityBinding))
-	};
-}
-async function loadExpectedWalletCustodyEd25519Material(input) {
-	return await input.load({
-		nearAccountId: String(input.parsed.nearAccountId),
-		signerSlot: input.parsed.signerSlot,
-		expectedRegisteredPublicKeyB64u: base64UrlEncode(Uint8Array.from(input.parsed.capability.registeredPublicKey))
-	});
-}
-function walletCustodyMaterialBinding(input) {
-	return {
-		kind: WALLET_CUSTODY_ED25519_MATERIAL_KEY_KIND,
-		applicationBindingDigestB64u: input.applicationBindingDigestB64u,
-		registeredPublicKeyB64u: base64UrlEncode(input.metadata.registeredPublicKey),
-		participantIds: input.metadata.participantIds,
-		stateEpoch: String(input.metadata.stateEpoch),
-		walletId: String(input.parsed.walletId),
-		nearAccountId: String(input.parsed.nearAccountId),
-		nearEd25519SigningKeyId: input.parsed.nearEd25519SigningKeyId,
-		signerSlot: input.parsed.signerSlot,
-		signingWorkerId: input.parsed.relayerKeyId,
-		signingWorkerVerifyingShareB64u: base64UrlEncode(input.metadata.signingWorkerVerifyingShare)
-	};
-}
-function isSealablePasskeyEd25519YaoClient(activeClient) {
-	return "sealLocalMaterial" in activeClient && typeof activeClient.sealLocalMaterial === "function";
-}
-async function recoverAndCommitPasskeyEd25519Unlock(input) {
-	const custodyWire = joinCustodyWireFromEnvelopeRecord(input.parsed.walletCustody.envelope);
-	if (!custodyWire.ok) throw new Error(custodyWire.reason);
-	const cacheSecret = input.ownedFactorSecret.slice();
-	let rejoinSecret = null;
-	let openSecret = null;
-	let activeClient = null;
-	try {
-		const envelope = walletCustodyCacheEnvelopeFromRecordV1(input.parsed.walletCustody.envelope);
-		const activation = walletCustodyActivationFacts(input.parsed);
-		const cached = await openOrRejoinWalletCustodyEd25519V1({
-			loadCachedMaterial: loadExpectedWalletCustodyEd25519Material.bind(void 0, {
-				load: input.loadWalletCustodyEd25519Material,
-				parsed: input.parsed
-			}),
-			activation,
-			envelope,
-			ownedFactorSecret: cacheSecret
-		});
-		if (cached.kind === "opened") activeClient = cached.activeClient;
-		else {
-			rejoinSecret = input.ownedFactorSecret.slice();
-			openSecret = input.ownedFactorSecret.slice();
-			const rejoined = await input.rejoinWalletCustodyNearEd25519KeySet({
-				walletId: String(input.parsed.walletId),
-				custodyJson: custodyWire.custodyJson,
-				factorSecret: rejoinSecret.buffer,
-				nearEd25519SigningKeyId: input.parsed.nearEd25519SigningKeyId,
-				recoveryBasis: input.parsed.capability,
-				routerOrigin: new URL(input.relayerUrl).origin,
-				walletSessionToken: input.parsed.operationCredential.token
-			});
-			const materialBinding = walletCustodyMaterialBinding({
-				parsed: input.parsed,
-				applicationBindingDigestB64u: rejoined.localMaterial.applicationBindingDigestB64u,
-				metadata: rejoined.metadata
-			});
-			await input.persistWalletCustodyEd25519Material({
-				binding: materialBinding,
-				sealed: {
-					ciphertextB64u: rejoined.localMaterial.b64u,
-					nonceB64u: rejoined.localMaterial.nonceB64u
-				}
-			});
-			activeClient = await openWalletCustodyEd25519ActiveClientV1({
-				material: {
-					binding: materialBinding,
-					sealed: {
-						ciphertextB64u: rejoined.localMaterial.b64u,
-						nonceB64u: rejoined.localMaterial.nonceB64u
-					}
-				},
-				activation: walletCustodyActivationFactsFromActiveClientMetadataV1(rejoined.metadata),
-				envelope,
-				ownedFactorSecret: openSecret
-			});
-		}
-		if (!activeClient) throw new Error("Wallet custody recovery produced no active Ed25519 client");
-		if (!isSealablePasskeyEd25519YaoClient(activeClient)) throw new Error("Wallet custody recovery produced an unsealable Ed25519 client");
-		const recoveredThresholdSessionId = parseThresholdEd25519SessionId(activeClient.metadata().scope.threshold_session_id);
-		if (!recoveredThresholdSessionId.ok) throw new Error("Wallet custody recovery returned an invalid threshold session identity");
-		const envelopeFactor = input.parsed.walletCustody.envelope.factor;
-		if (envelopeFactor.kind !== "passkey") throw new Error("Wallet custody recovery returned a different factor authority");
-		await persistPasskeyEd25519YaoSignerMaterialV1({
-			store: IndexedDBManager,
-			activeClient,
-			identity: {
-				walletId: String(input.parsed.walletId),
-				nearAccountId: String(input.parsed.nearAccountId),
-				nearEd25519SigningKeyId: String(input.parsed.nearEd25519SigningKeyId),
-				thresholdSessionId: recoveredThresholdSessionId.value,
-				signerSlot: input.parsed.signerSlot,
-				rpId: envelopeFactor.rpId,
-				credentialIdB64u: envelopeFactor.credentialIdB64u,
-				signingRootId: input.parsed.capability.applicationBinding.signing_root_id,
-				signingRootVersion: input.parsed.capability.lifecycle.rootShareEpoch,
-				signingWorkerId: input.parsed.relayerKeyId
-			},
-			stableServerScope: {
-				relayerKeyId: input.parsed.relayerKeyId,
-				participantIds: input.parsed.session.participantIds,
-				runtimePolicyScope: input.parsed.capability.runtimePolicyScope,
-				routerAbNormalSigning: input.parsed.session.routerAbNormalSigning
-			},
-			passkeyPrfFirstB64u: base64UrlEncode(input.ownedFactorSecret)
-		});
-		const walletSessionState = buildRecoveredWalletSessionState({
-			parsed: input.parsed,
-			relayerUrl: input.relayerUrl,
-			rpId: input.rpId,
-			thresholdSessionId: recoveredThresholdSessionId.value
-		});
-		const recovery = {
-			activeClient,
-			walletSessionState,
-			parsed: input.parsed
-		};
-		const recoveredActivation = nearEd25519YaoMaterialActivationFromMetadata(recovery.activeClient.metadata());
-		await persistPasskeyEd25519YaoSessionForRefresh({
-			persistence: input.sessionPersistence,
-			session: recovery.walletSessionState,
-			prfFirstB64u: base64UrlEncode(input.ownedFactorSecret),
-			ed25519Restore: buildPasskeyEd25519RestoreMetadata({
-				rpId: envelopeFactor.rpId,
-				nearAccountId: String(input.parsed.nearAccountId),
-				nearEd25519SigningKeyId: String(input.parsed.nearEd25519SigningKeyId),
-				relayerKeyId: input.parsed.relayerKeyId,
-				participantIds: input.parsed.session.participantIds,
-				runtimePolicyScope: input.parsed.session.runtimePolicyScope,
-				signerSlot: input.parsed.signerSlot,
-				routerAbNormalSigning: input.parsed.session.routerAbNormalSigning,
-				credentialIdB64u: envelopeFactor.credentialIdB64u,
-				materialActivation: recoveredActivation
-			}),
-			materialActivation: recoveredActivation
-		});
-		const activated = await input.activateCapability({
-			activeClient: recovery.activeClient,
-			facts: {
-				thresholdSessionId: recovery.walletSessionState.thresholdSessionId,
-				signer: recovery.walletSessionState.signingLane.identity.signer,
-				signingRootId: recovery.walletSessionState.signingRootId,
-				signingRootVersion: recovery.walletSessionState.signingRootVersion,
-				routerAbNormalSigning: recovery.walletSessionState.routerAbNormalSigning,
-				runtimePolicyScope: recovery.walletSessionState.runtimePolicyScope,
-				relayerUrl: recovery.walletSessionState.relayerUrl
-			}
-		});
-		if (!mpcMaterialActivationRefsEqual(activated.materialActivation, recoveredActivation)) throw new Error("Passkey Ed25519 registry activation changed during recovery commit");
-		const recoveredAuthority = await replaceActiveWalletAuthorityEd25519MaterialActivationV1({
-			authority: input.parsed.foundingAuthority,
-			materialActivation: activated.materialActivation,
-			updatedAtMs: Date.now()
-		});
-		await IndexedDBManager.persistFoundingWalletAuthority({
-			authority: recoveredAuthority,
-			authMethod: input.parsed.foundingAuthMethod
-		});
-		await input.sessionPersistence.upsertEd25519YaoPublicCapabilityLaneReference(passkeyEd25519YaoLaneReferenceFromRecovery({
-			walletSessionState: recovery.walletSessionState,
-			materialActivation: activated.materialActivation
-		}));
-		return recovery;
-	} catch (error) {
-		activeClient?.dispose();
-		throw error;
-	} finally {
-		cacheSecret.fill(0);
-		rejoinSecret?.fill(0);
-		openSecret?.fill(0);
-	}
-}
-function ethereumAddressFromAddress20B64u(value) {
-	const bytes = base64UrlDecode(value);
-	if (bytes.length !== 20) throw new Error("ECDSA custody address must contain 20 bytes");
-	let hex = "0x";
-	for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
-	return hex;
-}
-function assertOneEcdsaCustodyIdentity(continuity) {
-	if (continuity.state === "absent") return null;
-	const first = continuity.signers[0];
-	const chainTargets = /* @__PURE__ */ new Set();
-	for (const signer of continuity.signers.slice(1)) if (signer.walletKey.keyHandle !== first.walletKey.keyHandle || !sameRouterAbEcdsaDerivationPublicCapabilityV1(signer.walletKey.publicCapability, first.walletKey.publicCapability) || !sameRouterAbEcdsaRegistrationActivationReceiptV1(signer.activationReceipt, first.activationReceipt) || !sameRuntimePolicyScope(signer.runtimePolicyScope, first.runtimePolicyScope)) throw new Error("sync-account returned conflicting ECDSA custody identities");
-	for (const signer of continuity.signers) {
-		const key = thresholdEcdsaChainTargetKey(signer.chainTarget);
-		if (chainTargets.has(key)) throw new Error("sync-account returned duplicate ECDSA custody chain targets");
-		chainTargets.add(key);
-	}
-	return first;
-}
-async function restoreWalletCustodyEcdsaContinuity(input) {
-	const signer = assertOneEcdsaCustodyIdentity(input.continuity);
-	if (!signer) return;
-	const custodyWire = joinCustodyWireFromEnvelopeRecord(input.parsed.walletCustody.envelope);
-	if (!custodyWire.ok) throw new Error(custodyWire.reason);
-	const walletKey = signer.walletKey;
-	const identity = signer.activationReceipt.ecdsa_activation.public_identity;
-	const factorSecret = input.ownedFactorSecret.slice();
-	const [firstChainTarget, ...remainingChainTargets] = input.continuity.signers.map((entry) => entry.chainTarget);
-	if (!firstChainTarget) return;
-	try {
-		const rejoined = await input.signingSurface.rejoinWalletCustodyEvmFamilyKeySet({
-			walletId: walletKey.walletId,
-			custodyJson: custodyWire.custodyJson,
-			factorSecret: factorSecret.buffer,
-			evmFamilySigningKeySlotId: deriveEvmFamilySigningKeySlotId({
-				walletId: walletKey.walletId,
-				signingRootId: walletKey.signingRootId,
-				signingRootVersion: walletKey.signingRootVersion
-			}),
-			applicationBindingDigestB64u: walletKey.publicCapability.context.application_binding_digest_b64u,
-			registeredClientRootPublicKey33B64u: walletKey.derivationClientSharePublicKey33B64u,
-			relayerPublicIdentityJson: JSON.stringify({
-				relayerKeyId: walletKey.relayerKeyId,
-				relayerPublicKey33B64u: identity.server_public_key33_b64u,
-				groupPublicKey33B64u: identity.threshold_public_key33_b64u,
-				ethereumAddress: ethereumAddressFromAddress20B64u(identity.ethereum_address20_b64u),
-				relayerShareRetryCounter: identity.server_share_retry_counter
-			})
-		});
-		await input.signingSurface.restoreWalletCustodyEcdsaContinuity({
-			authority: input.parsed.authority,
-			chainTargets: [firstChainTarget, ...remainingChainTargets],
-			walletId: walletKey.walletId,
-			keyHandle: walletKey.keyHandle,
-			ecdsaThresholdKeyId: walletKey.ecdsaThresholdKeyId,
-			signingRootId: walletKey.signingRootId,
-			signingRootVersion: walletKey.signingRootVersion,
-			relayerKeyId: walletKey.relayerKeyId,
-			participantIds: walletKey.participantIds,
-			publicCapability: walletKey.publicCapability,
-			activationReceipt: signer.activationReceipt,
-			runtimePolicyScope: signer.runtimePolicyScope,
-			readyStateBlobB64u: rejoined.readyStateBlobB64u,
-			publicFacts: rejoined.publicFacts
-		});
-	} finally {
-		factorSecret.fill(0);
-	}
-}
-async function recoverPasskeyEd25519YaoForUnlockV1(input) {
-	const requestedWalletIdString = input.walletId === null ? null : String(input.walletId).trim();
-	if (input.walletId !== null && !requestedWalletIdString) throw new Error("passkey Yao unlock recovery requires a valid walletId");
-	const requestedWalletId = requestedWalletIdString ? walletIdFromString(requestedWalletIdString) : null;
-	const syncOptions = input.prepared ?? await requestSyncOptions({
-		relayerUrl: input.relayerUrl,
-		rpId: input.rpId,
-		walletId: requestedWalletId ? String(requestedWalletId) : null,
-		fetch: input.fetch
-	});
-	if (input.prepared && !input.credential) throw new Error("prepared account-sync challenge requires a CTA credential");
-	const credentialIds = credentialIdsForSyncAccountRecovery(syncOptions, input.expectedCredentialIdB64u);
-	input.onPromptStarted?.();
-	const credential = input.credential ? input.credential : await input.collectCredential({
-		challengeB64u: syncOptions.challengeB64u,
-		credentialIds
-	});
-	input.onPromptSucceeded?.();
-	const selectedCredentialId = requireSelectedCredentialId(credential);
-	if (input.expectedCredentialIdB64u !== null && selectedCredentialId !== input.expectedCredentialIdB64u) throw new Error("replacement account-sync assertion changed the selected passkey");
-	const prfFirstB64u = getPrfFirstB64uFromCredential(credential);
-	if (!prfFirstB64u) throw new Error("selected passkey did not return PRF.first");
-	input.onRelayVerifyStarted?.();
-	const verification = await verifySyncCredential({
-		relayerUrl: input.relayerUrl,
-		challengeId: syncOptions.challengeId,
-		expectedWalletId: requestedWalletId,
-		selectedCredentialId,
-		credential,
-		fetch: input.fetch,
-		onRelayVerifySucceeded: input.onRelayVerifySucceeded
-	});
-	if (verification.kind === "already_committed") return verification;
-	const { verifiedBinding, parsedYaoResponse, ecdsaContinuity } = verification.response;
-	const ownedFactorSecret = base64UrlDecode(prfFirstB64u);
-	try {
-		assertRecoveredCapabilityBinding({
-			requestedWalletId,
-			expectedWalletAuthMethodId: input.expectedWalletAuthMethodId,
-			rpId: input.rpId,
-			optionsBinding: syncOptions.walletBinding,
-			verifiedBinding,
-			parsed: parsedYaoResponse,
-			selectedCredentialId
-		});
-		await input.prepareLocalProfile(parsedYaoResponse, credential);
-		const recovery = await input.withExactEd25519MaterialOwner({
-			materialActivation: parsedYaoResponse.capability.materialActivation,
-			nearAccountId: parsedYaoResponse.nearAccountId,
-			task: recoverAndCommitPasskeyEd25519Unlock.bind(void 0, {
-				parsed: parsedYaoResponse,
-				ownedFactorSecret,
-				relayerUrl: input.relayerUrl,
-				rpId: input.rpId,
-				sessionPersistence: input.sessionPersistence,
-				activateCapability: input.activateCapability,
-				rejoinWalletCustodyNearEd25519KeySet: input.rejoinWalletCustodyNearEd25519KeySet,
-				loadWalletCustodyEd25519Material: input.loadWalletCustodyEd25519Material,
-				persistWalletCustodyEd25519Material: input.persistWalletCustodyEd25519Material
-			})
-		});
-		await rememberPasskeyCustodySessionEnvelope({
-			walletId: String(parsedYaoResponse.walletId),
-			credentialIdB64u: parsedYaoResponse.credentialIdB64u,
-			envelope: parsedYaoResponse.walletCustody.envelope
-		});
-		await restoreWalletCustodyEcdsaContinuity({
-			signingSurface: {
-				rejoinWalletCustodyEvmFamilyKeySet: input.rejoinWalletCustodyEvmFamilyKeySet,
-				restoreWalletCustodyEcdsaContinuity: input.restoreWalletCustodyEcdsaContinuity
-			},
-			parsed: parsedYaoResponse,
-			continuity: ecdsaContinuity,
-			ownedFactorSecret
-		});
-		return {
-			kind: "recovered",
-			recovery,
-			credential,
-			verifiedBinding,
-			ecdsaContinuity
-		};
-	} finally {
-		ownedFactorSecret.fill(0);
-	}
-}
-async function persistRecoveredPasskey(input) {
-	const parsed = input.parsed;
-	const credentialPublicKey = base64UrlDecode(parsed.credentialPublicKeyB64u);
-	await input.context.signingEngine.storeUserData({
-		walletId: String(parsed.walletId),
-		nearAccountId: parsed.nearAccountId,
-		signerSlot: parsed.signerSlot,
-		operationalPublicKey: parsed.operationalPublicKey,
-		nearEd25519SigningKeyId: parsed.nearEd25519SigningKeyId,
-		lastUpdated: Date.now(),
-		passkeyCredential: {
-			id: String(input.credential.id || ""),
-			rawId: String(input.credential.rawId || "")
-		},
-		version: 2
-	});
-	await input.context.signingEngine.setWalletNearProvisioningState({
-		walletId: parsed.walletId,
-		status: "near_ready",
-		nearAccountId: parsed.nearAccountId
-	});
-	const existingAuthenticator = (await IndexedDBManager.listWalletPasskeyAuthenticators(String(parsed.walletId))).find((authenticator) => authenticator.credentialId === parsed.credentialIdB64u);
-	if (existingAuthenticator) {
-		if (existingAuthenticator.signerSlot !== parsed.signerSlot || base64UrlEncode(existingAuthenticator.credentialPublicKey) !== parsed.credentialPublicKeyB64u) throw new Error("Stored linked passkey authenticator does not match account sync");
-	} else await input.context.signingEngine.storeAuthenticator({
-		nearAccountId: parsed.nearAccountId,
-		credentialId: parsed.credentialIdB64u,
-		credentialPublicKey,
-		transports: [],
-		name: `Passkey for ${String(parsed.walletId)}`,
-		registered: (/* @__PURE__ */ new Date()).toISOString(),
-		syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		signerSlot: parsed.signerSlot
-	});
-	await IndexedDBManager.persistFoundingWalletAuthority({
-		authority: parsed.foundingAuthority,
-		authMethod: parsed.foundingAuthMethod
-	});
-}
-async function persistRecoveredNearThresholdKeyMaterial(signingSurface, parsed) {
-	await signingSurface.storeNearThresholdKeyMaterial({
-		nearAccountId: parsed.nearAccountId,
-		signerSlot: parsed.signerSlot,
-		publicKey: parsed.operationalPublicKey,
-		relayerKeyId: parsed.relayerKeyId,
-		keyVersion: parsed.keyVersion,
-		participants: buildThresholdEd25519Participants2pV1({
-			clientParticipantId: parsed.session.participantIds[0],
-			relayerParticipantId: parsed.session.participantIds[1],
-			relayerKeyId: parsed.relayerKeyId,
-			clientShareDerivation: "prf_first_v1"
-		}),
-		signerId: parsed.operationalPublicKey
-	});
-}
-async function persistRecoveredWalletSessionAuthorization(parsed) {
-	await walletSessionAuthorizations.writeExactWithOperationCredential({
-		record: parsed.walletSession,
-		operationCredential: parsed.operationCredential
-	});
-}
-async function prepareSyncedPasskeyLocalProfile(context, parsed, credential) {
-	await persistRecoveredPasskey({
-		context,
-		parsed,
-		credential
-	});
-}
-function syncAccountAllowCredential(credentialId) {
-	return {
-		id: credentialId,
-		type: "public-key",
-		transports: []
-	};
-}
-async function collectSyncAccountRecoveryCredential(callbacks, input) {
-	return await callbacks.signingSurface.getAuthenticationCredentialsSerialized({
-		subjectId: callbacks.requestedWalletId || "account-sync",
-		challengeB64u: input.challengeB64u,
-		allowCredentials: input.credentialIds.map(syncAccountAllowCredential),
-		includeSecondPrfOutput: false
-	});
-}
-function emitSyncAccountPromptStarted(callbacks) {
-	emitSyncAccountEvent({
-		onEvent: callbacks.onEvent,
-		flowId: callbacks.flowId,
-		event: {
-			phase: AccountSyncEventPhase.STEP_02_PASSKEY_PROMPT_STARTED,
-			status: "waiting_for_user",
-			...callbacks.requestedWalletId ? { accountId: callbacks.requestedWalletId } : {},
-			interaction: {
-				kind: "passkey_assert",
-				overlay: "show"
-			}
-		}
-	});
-}
-function emitSyncAccountPromptSucceeded(callbacks) {
-	emitSyncAccountEvent({
-		onEvent: callbacks.onEvent,
-		flowId: callbacks.flowId,
-		event: {
-			phase: AccountSyncEventPhase.STEP_02_PASSKEY_PROMPT_SUCCEEDED,
-			status: "succeeded",
-			...callbacks.requestedWalletId ? { accountId: callbacks.requestedWalletId } : {},
-			interaction: {
-				kind: "passkey_assert",
-				overlay: "hide"
-			}
-		}
-	});
-}
-function emitSyncAccountRelayVerifyStarted(callbacks) {
-	emitSyncAccountEvent({
-		onEvent: callbacks.onEvent,
-		flowId: callbacks.flowId,
-		event: {
-			phase: AccountSyncEventPhase.STEP_03_RELAY_VERIFY_STARTED,
-			status: "started",
-			...callbacks.requestedWalletId ? { accountId: callbacks.requestedWalletId } : {}
-		}
-	});
-}
-function emitSyncAccountRelayVerifySucceeded(callbacks, binding) {
-	emitSyncAccountEvent({
-		onEvent: callbacks.onEvent,
-		flowId: callbacks.flowId,
-		event: {
-			phase: AccountSyncEventPhase.STEP_03_RELAY_VERIFY_SUCCEEDED,
-			status: "succeeded",
-			accountId: String(binding.walletId)
-		}
-	});
-}
-async function syncAccountInternal(context, walletId, attempt, options, preparedChallenge, preparedCredential) {
-	const requestedWalletId = walletId ? walletIdFromString(String(walletId)) : null;
-	if (attempt.kind === "replacement_after_committed" && requestedWalletId !== attempt.walletId) throw new Error("replacement account-sync attempt changed the committed wallet");
-	if (preparedChallenge && preparedChallenge.walletId !== (requestedWalletId ? String(requestedWalletId) : null)) throw new Error("prepared account-sync challenge wallet binding changed");
-	const flowId = `account-sync:${String(requestedWalletId || "discovery")}`;
-	let recoveryOwnership = { kind: "empty" };
-	try {
-		const relayerUrl = preparedChallenge?.relayerUrl ?? requireRelayerUrl(context);
-		const rpId = preparedChallenge?.rpId ?? requireRpId(context);
-		if (preparedChallenge) {
-			if (requireRelayerUrl(context) !== relayerUrl || requireRpId(context) !== rpId) throw new Error("prepared account-sync challenge runtime binding changed");
-		}
-		emitSyncAccountEvent({
-			onEvent: options?.onEvent,
-			flowId,
-			event: {
-				phase: AccountSyncEventPhase.STEP_01_STARTED,
-				status: "started",
-				...requestedWalletId ? { accountId: String(requestedWalletId) } : {}
-			}
-		});
-		const recoveryCallbacks = {
-			signingSurface: context.signingEngine,
-			requestedWalletId: requestedWalletId ? String(requestedWalletId) : null,
-			onEvent: options?.onEvent,
-			flowId
-		};
-		const recovered = await recoverPasskeyEd25519YaoForUnlockV1({
-			walletId: requestedWalletId ? String(requestedWalletId) : null,
-			relayerUrl,
-			rpId,
-			fetch: fetchWithGlobalThis,
-			expectedCredentialIdB64u: attempt.kind === "replacement_after_committed" ? attempt.credentialIdB64u : null,
-			expectedWalletAuthMethodId: attempt.kind === "replacement_after_committed" ? attempt.walletAuthMethodId : null,
-			...preparedChallenge ? {
-				prepared: preparedChallenge.syncOptions,
-				credential: preparedCredential
-			} : {},
-			collectCredential: collectSyncAccountRecoveryCredential.bind(void 0, recoveryCallbacks),
-			activateCapability: context.signingEngine.activateVerifiedNearEd25519YaoMaterial.bind(context.signingEngine),
-			withExactEd25519MaterialOwner: context.signingEngine.withExactEd25519MaterialOwner.bind(context.signingEngine),
-			sessionPersistence: context.signingEngine,
-			rejoinWalletCustodyNearEd25519KeySet: context.signingEngine.rejoinWalletCustodyNearEd25519KeySet.bind(context.signingEngine),
-			rejoinWalletCustodyEvmFamilyKeySet: context.signingEngine.rejoinWalletCustodyEvmFamilyKeySet.bind(context.signingEngine),
-			restoreWalletCustodyEcdsaContinuity: context.signingEngine.restoreWalletCustodyEcdsaContinuity.bind(context.signingEngine),
-			loadWalletCustodyEd25519Material: context.signingEngine.loadWalletCustodyEd25519Material.bind(context.signingEngine),
-			persistWalletCustodyEd25519Material: context.signingEngine.persistWalletCustodyEd25519Material.bind(context.signingEngine),
-			prepareLocalProfile: prepareSyncedPasskeyLocalProfile.bind(void 0, context),
-			onPromptStarted: emitSyncAccountPromptStarted.bind(void 0, recoveryCallbacks),
-			onPromptSucceeded: emitSyncAccountPromptSucceeded.bind(void 0, recoveryCallbacks),
-			onRelayVerifyStarted: emitSyncAccountRelayVerifyStarted.bind(void 0, recoveryCallbacks),
-			onRelayVerifySucceeded: emitSyncAccountRelayVerifySucceeded.bind(void 0, recoveryCallbacks)
-		});
-		if (recovered.kind === "already_committed") {
-			if (attempt.kind === "initial") return await syncAccountInternal(context, recovered.walletId, {
-				kind: "replacement_after_committed",
-				walletId: recovered.walletId,
-				walletAuthMethodId: recovered.walletAuthMethodId,
-				credentialIdB64u: recovered.credentialIdB64u
-			}, options);
-			throw new Error("sync-account/verify remained already committed after one replacement attempt");
-		}
-		const { recovery, verifiedBinding } = recovered;
-		recoveryOwnership = {
-			kind: "registry_owned",
-			recovery
-		};
-		await persistRecoveredWalletSessionAuthorization(recovery.parsed);
-		await persistRecoveredNearThresholdKeyMaterial(context.signingEngine, recovery.parsed);
-		emitSyncAccountEvent({
-			onEvent: options?.onEvent,
-			flowId,
-			event: {
-				phase: AccountSyncEventPhase.STEP_04_AUTHENTICATOR_SAVED,
-				status: "succeeded",
-				accountId: String(verifiedBinding.walletId)
-			}
-		});
-		emitSyncAccountEvent({
-			onEvent: options?.onEvent,
-			flowId,
-			event: {
-				phase: AccountSyncEventPhase.STEP_05_THRESHOLD_SESSION_READY,
-				status: "succeeded",
-				accountId: String(verifiedBinding.walletId)
-			}
-		});
-		await context.signingEngine.activateAuthenticatedWalletState({
-			walletId: verifiedBinding.walletId,
-			nearAccountId: verifiedBinding.nearAccountId,
-			signerSlot: verifiedBinding.signerSlot,
-			nearClient: context.nearClient
-		});
-		recoveryOwnership = { kind: "committed" };
-		emitSyncAccountEvent({
-			onEvent: options?.onEvent,
-			flowId,
-			event: {
-				phase: AccountSyncEventPhase.STEP_06_COMPLETED,
-				status: "succeeded",
-				accountId: String(verifiedBinding.walletId)
-			}
-		});
-		return {
-			success: true,
-			accountId: String(verifiedBinding.walletId),
-			walletId: String(verifiedBinding.walletId),
-			nearAccountId: String(verifiedBinding.nearAccountId),
-			nearEd25519SigningKeyId: String(verifiedBinding.nearEd25519SigningKeyId),
-			publicKey: recovery.parsed.operationalPublicKey,
-			message: "Account synced successfully",
-			loginState: { isLoggedIn: true }
-		};
-	} catch (error) {
-		let message = errorMessage(error) || "syncAccount failed";
-		try {
-			await disposeRecoveredCapability({
-				context,
-				ownership: recoveryOwnership
-			});
-		} catch (cleanupError) {
-			const cleanupMessage = errorMessage(cleanupError) || "recovered capability cleanup failed";
-			message = `${message}; ${cleanupMessage}`;
-		}
-		emitSyncAccountEvent({
-			onEvent: options?.onEvent,
-			flowId,
-			event: {
-				phase: AccountSyncEventPhase.FAILED,
-				status: "failed",
-				...requestedWalletId ? { accountId: String(requestedWalletId) } : {},
-				error: { message }
-			}
-		});
-		return syncAccountFailure(message);
-	}
-}
-async function syncAccount(context, walletId, options) {
-	return await syncAccountInternal(context, walletId, { kind: "initial" }, options);
-}
-//#endregion
-export { syncAccount };
-
-//# sourceMappingURL=syncAccount.js.map