@seams/wallet 0.8.0 → 0.9.0

package/dist/types/wallet/src/SeamsWeb/signingSurface/BrowserSigningSurface.d.ts

@@ -1,10 +1,10 @@
+import type { WalletSessionHome } from '../../../../shared-ts/src/device-linking/contracts';
 import type { NearClient } from '../../core/rpcClients/near/NearClient';
 import type { NonceCoordinator } from '../../core/signingEngine/nonce/NonceCoordinator';
 import { type AccountId } from '../../core/types/accountIds';
 import type { SdkLifecycleEvent, SdkLifecycleEventListener, SigningFlowEvent } from '../../core/types/sdkSentEvents';
 import type { AppearanceConfig, SigningSessionStatus, SeamsConfigsReadonly, WalletAuthenticationState } from '../../core/types/seams';
 import type { WebAuthnAuthenticationCredential } from '../../core/types';
-import { type WalletEmailOtpChannel } from '../../../../shared-ts/src/utils/emailOtpDomain';
 import type { UserPreferencesManager } from '../../core/signingEngine/session/userPreferences';
 import type { NearEd25519YaoOperationMaterial } from '../../core/signingEngine/interfaces/near';
 import type { Ed25519YaoActiveClientIdentityV1 } from '../../core/signingEngine/threshold/ed25519/yaoActiveClientRegistry';
@@ -19,7 +19,6 @@ import { type RouterAbEd25519YaoRegistrationAdmissionRequestV1 } from '../../../
 import type { RouterAbTraceContextV1 } from '../../../../shared-ts/src/utils/routerAbTraceContext';
 import type { SignerWorkerKind, SignerWorkerOperationRequest, SignerWorkerOperationResult, SignerWorkerOperationType, EmailOtpYaoPrewarmRequest, EmailOtpYaoPrewarmOutcome } from '../../core/signingEngine/workerManager/workerTypes';
 import type { WorkerOperationContext } from '../../core/signingEngine/workerManager/executeWorkerOperation';
-import type { EcdsaClientPresignCleanupTarget } from '../../core/signingEngine/workerManager/ecdsaPresignLifecycle';
 import { type ImportWalletCustodyEcdsaContinuityInput } from '../../core/indexedDB/seamsWalletDB/walletCustodyEcdsaContinuity';
 import type { EcdsaRoleLocalPersistedMaterialRef } from '../../core/signingEngine/session/keyMaterialBrands';
 import type { PasskeyMpcSessionPort, UiConfirmSurfaceMeasurementBinding } from '../../core/signingEngine/uiConfirm/uiConfirm.types';
@@ -41,10 +40,9 @@ import { type ReconcileTempoNonceLaneArgs, type ReportTempoBroadcastAcceptedArgs
 import type { SigningEngineResolveExactKeyExportLaneInput, SigningEngineResolveExactKeyExportLaneResult, SigningEngineExportKeypairWithUIInput } from '../../core/signingEngine/flows/recovery/public';
 import type { RegistrationCredentialConfirmationPayload } from '../../core/signingEngine/workerManager/validation';
 import type { ConfirmationConfig } from '../../core/types/signer-worker';
-import * as registrationPublic from '../../core/signingEngine/flows/registration/public';
+import * as registrationAccount from '../../core/signingEngine/flows/registration/accountLifecycle';
 import { type LoginWithEmailOtpEcdsaCapabilityInternalArgs, type LoginWithEmailOtpEcdsaCapabilityInternalResult, type PrepareEmailOtpRegistrationEnrollmentMaterialInternalArgs, type PrepareEmailOtpRegistrationEnrollmentMaterialInternalResult } from '../../core/signingEngine/flows/signEvmFamily/emailOtpPublic';
 import type { ExactWalletSessionAuthorization } from '../../core/signingEngine/session/persistence/walletSessionAuthorizationProjection';
-import * as emailOtpPublic from '../../core/signingEngine/flows/signEvmFamily/emailOtpPublic';
 import type { ProvisionWarmEd25519CapabilityResult } from '../../core/signingEngine/session/warmCapabilities/types';
 import type { LoginWithEmailOtpWalletCustodyEd25519Args } from '../../core/signingEngine/walletCustody/ed25519Login';
 import { type EmailOtpAuthorityUnlockEd25519Request } from '../../core/signingEngine/session/emailOtp/walletUnlock';
@@ -54,7 +52,6 @@ import type { NearEd25519SignerBinding } from '../../../../shared-ts/src/utils/w
 import type { OwnerLaneScope } from '../../core/signingEngine/session/identity/signingLaneAuthBinding';
 import type { EmailOtpEd25519YaoRecoveryBootstrapV1 } from '../../core/signingEngine/workerManager/workerTypes';
 import type { RouterAbEd25519YaoActiveClientMetadataV1 } from '../../core/signingEngine/threshold/ed25519/yaoClient';
-import type { EmailOtpBootstrapRecovery } from '../../core/signingEngine/stepUpConfirmation/otpPrompt/bootstrapRecovery';
 import type { DiscoverPersistedSessionsForWalletInput, DiscoverPersistedSessionsForWalletResult, ReadAvailableSigningLanesInput, AvailableSigningLanes } from '../../core/signingEngine/session/public';
 import * as warmCapabilitiesPublic from '../../core/signingEngine/session/warmCapabilities/public';
 import type { ConnectEd25519SessionArgs } from '../../core/signingEngine/session/passkey/public';
@@ -103,7 +100,6 @@ export declare class BrowserSigningSurface {
     private readonly sessionPublicDeps;
     private readonly emailOtpPublicDeps;
     private readonly recoveryPublicDeps;
-    private readonly registrationPublicDeps;
     private readonly sealedRefreshStartupParityPromise;
     private hostWarmCriticalResourcesTask;
     private sealedRefreshStartupParityError;
@@ -117,9 +113,9 @@ export declare class BrowserSigningSurface {
     private readonly signingSessionLifecycleSubscription;
     private readonly nearProvisioningUnsubscribe;
     private walletAuthenticationState;
-    private walletAuthenticationRestoreGeneration;
     private volatileWarmSigningMaterialCleanupInFlight;
     readonly seamsWebConfigs: SeamsConfigsReadonly;
+    private readNearEd25519SigningCandidate;
     private readExactNearEd25519WalletSessionAuthorization;
     private resolveActiveNearEd25519WalletSessionAuthorization;
     private readonly listPreprocessingCapabilities;
@@ -138,6 +134,7 @@ export declare class BrowserSigningSurface {
      * with the same trace context — only the root behind it changed.
      */
     establishWalletCustodyNearEd25519KeySet(args: {
+        readonly home: WalletSessionHome;
         walletId: string;
         factorJson: string;
         factorSecret: ArrayBuffer;
@@ -160,6 +157,9 @@ export declare class BrowserSigningSurface {
         }>;
     }): Promise<WalletRecoveryReplacementCredential>;
     joinWalletCustodyNearEd25519KeySet(args: {
+        readonly routing: WalletSessionHome | {
+            readonly kind: 'discovery';
+        };
         preparation: {
             readonly kind: 'fresh';
         } | {
@@ -234,7 +234,7 @@ export declare class BrowserSigningSurface {
     assertSealedRefreshStartupParity(): Promise<void>;
     discoverPersistedSessionsForWallet(args: DiscoverPersistedSessionsForWalletInput): Promise<DiscoverPersistedSessionsForWalletResult>;
     private isEd25519YaoPublicCapabilityActive;
-    readPersistedAvailableSigningLanes(args: Omit<ReadAvailableSigningLanesInput, 'ecdsaChainTargets'>): Promise<AvailableSigningLanes>;
+    readPersistedAvailableSigningLanes(args: Omit<ReadAvailableSigningLanesInput, 'ecdsaChainTargets'>, statusReads: WalletSessionStatusReadScope): Promise<AvailableSigningLanes>;
     readOwnerScopedSigningLanes(args: {
         readonly walletId: WalletId | string;
         readonly ownerScope: OwnerLaneScope;
@@ -256,18 +256,6 @@ export declare class BrowserSigningSurface {
         readonly walletId: WalletId;
         readonly walletAuthMethodId: WalletAuthMethodId;
     }): Promise<void>;
-    /**
-     * Every route that lands a wallet in the authenticated state goes through
-     * here — passkey unlock, email OTP login, the hosted auth menu, and session
-     * restore. Binding the preferences manager at this choke point is what makes
-     * per-wallet preferences real: without it the manager stays on "no last
-     * user", so reads answer the built-in defaults while the wallet's persisted
-     * choices sit unread, and writes stay memory-only and evaporate on reload —
-     * the Confirmer UI toggle looked applied but silently reverted every page
-     * load. setCurrentWallet also notifies, which pushes PREFERENCES_CHANGED to
-     * the app origin so its mirrored uiMode follows the wallet too.
-     */
-    private applyAuthenticatedWalletState;
     setWalletAuthenticated(state: Extract<WalletAuthenticationState, {
         kind: 'authenticated';
     }>): void;
@@ -359,45 +347,45 @@ export declare class BrowserSigningSurface {
     reportTempoFinalized(args: ReportTempoFinalizedArgs): Promise<void>;
     reportTempoDroppedOrReplaced(args: ReportTempoDroppedOrReplacedArgs): Promise<void>;
     reconcileTempoNonceLane(args: ReconcileTempoNonceLaneArgs): Promise<TempoNonceLaneStatus>;
-    storeUserData(userData: Parameters<typeof registrationPublic.storeUserData>[1]): ReturnType<typeof registrationPublic.storeUserData>;
+    storeUserData(userData: Parameters<typeof registrationAccount.storeUserData>[1]): ReturnType<typeof registrationAccount.storeUserData>;
     storeNearThresholdKeyMaterial(input: StoreNearThresholdKeyMaterialInput): Promise<void>;
-    getAllUsers(): ReturnType<typeof registrationPublic.getAllUsers>;
-    getUserBySignerSlot(nearAccountId: Parameters<typeof registrationPublic.getUserBySignerSlot>[1], signerSlot: Parameters<typeof registrationPublic.getUserBySignerSlot>[2]): ReturnType<typeof registrationPublic.getUserBySignerSlot>;
-    getLastUser(): ReturnType<typeof registrationPublic.getLastUser>;
-    nearAuthenticatorsByAccount(nearAccountId: Parameters<typeof registrationPublic.nearAuthenticatorsByAccount>[1]): ReturnType<typeof registrationPublic.nearAuthenticatorsByAccount>;
-    setLastUser(walletId: Parameters<typeof registrationPublic.setLastUser>[1], signerSlot: Parameters<typeof registrationPublic.setLastUser>[2]): ReturnType<typeof registrationPublic.setLastUser>;
-    activateAuthenticatedWalletState(args: Parameters<typeof registrationPublic.activateAuthenticatedWalletState>[1]): ReturnType<typeof registrationPublic.activateAuthenticatedWalletState>;
+    getAllUsers(): ReturnType<typeof registrationAccount.getAllUsers>;
+    getUserBySignerSlot(nearAccountId: Parameters<typeof registrationAccount.getUserBySignerSlot>[1], signerSlot: Parameters<typeof registrationAccount.getUserBySignerSlot>[2]): ReturnType<typeof registrationAccount.getUserBySignerSlot>;
+    getLastUser(): ReturnType<typeof registrationAccount.getLastUser>;
+    nearAuthenticatorsByAccount(nearAccountId: Parameters<typeof registrationAccount.nearAuthenticatorsByAccount>[1]): ReturnType<typeof registrationAccount.nearAuthenticatorsByAccount>;
+    setLastUser(walletId: Parameters<typeof registrationAccount.setLastUser>[1], signerSlot: Parameters<typeof registrationAccount.setLastUser>[2]): ReturnType<typeof registrationAccount.setLastUser>;
+    activateAuthenticatedWalletState(args: Parameters<typeof registrationAccount.activateAuthenticatedWalletState>[1]): ReturnType<typeof registrationAccount.activateAuthenticatedWalletState>;
     upsertEd25519YaoPublicCapabilityReference(identity: Ed25519YaoPublicCapabilityReferenceV1): Promise<void>;
     upsertEd25519YaoPublicCapabilityLaneReference(reference: Ed25519YaoPublicCapabilityLaneReferenceV1): Promise<void>;
-    setWalletNearProvisioningState(write: Parameters<typeof registrationPublic.setWalletNearProvisioningState>[1]): ReturnType<typeof registrationPublic.setWalletNearProvisioningState>;
-    getWalletNearProvisioningState(walletId: Parameters<typeof registrationPublic.getWalletNearProvisioningState>[1]): ReturnType<typeof registrationPublic.getWalletNearProvisioningState>;
-    storeAuthenticator(authenticatorData: Parameters<typeof registrationPublic.storeAuthenticator>[1]): ReturnType<typeof registrationPublic.storeAuthenticator>;
-    rollbackUserRegistration(nearAccountId: Parameters<typeof registrationPublic.rollbackUserRegistration>[1]): ReturnType<typeof registrationPublic.rollbackUserRegistration>;
-    hasPasskeyCredential(nearAccountId: Parameters<typeof registrationPublic.hasPasskeyCredential>[1]): ReturnType<typeof registrationPublic.hasPasskeyCredential>;
-    storeWalletEd25519RegistrationData(input: Parameters<typeof registrationPublic.storeWalletEd25519RegistrationData>[1]): ReturnType<typeof registrationPublic.storeWalletEd25519RegistrationData>;
-    storeWalletMixedRegistrationData(input: Parameters<typeof registrationPublic.storeWalletMixedRegistrationData>[1]): ReturnType<typeof registrationPublic.storeWalletMixedRegistrationData>;
-    storeWalletEd25519RecoveryRegistrationData(input: Parameters<typeof registrationPublic.storeWalletEd25519RecoveryRegistrationData>[1]): ReturnType<typeof registrationPublic.storeWalletEd25519RecoveryRegistrationData>;
-    storeWalletEmailOtpEd25519RegistrationData(input: Parameters<typeof registrationPublic.storeWalletEmailOtpEd25519RegistrationData>[1]): ReturnType<typeof registrationPublic.storeWalletEmailOtpEd25519RegistrationData>;
-    storeWalletEmailOtpMixedRegistrationData(input: Parameters<typeof registrationPublic.storeWalletEmailOtpMixedRegistrationData>[1]): ReturnType<typeof registrationPublic.storeWalletEmailOtpMixedRegistrationData>;
-    finalizeWalletEd25519SignerRegistration(input: Parameters<typeof registrationPublic.finalizeWalletEd25519SignerRegistration>[1]): ReturnType<typeof registrationPublic.finalizeWalletEd25519SignerRegistration>;
-    rollbackWalletEd25519SignerRegistration(receipt: Parameters<typeof registrationPublic.rollbackWalletEd25519SignerRegistration>[1]): ReturnType<typeof registrationPublic.rollbackWalletEd25519SignerRegistration>;
+    setWalletNearProvisioningState(write: Parameters<typeof registrationAccount.setWalletNearProvisioningState>[1]): ReturnType<typeof registrationAccount.setWalletNearProvisioningState>;
+    getWalletNearProvisioningState(walletId: Parameters<typeof registrationAccount.getWalletNearProvisioningState>[1]): ReturnType<typeof registrationAccount.getWalletNearProvisioningState>;
+    storeAuthenticator(authenticatorData: Parameters<typeof registrationAccount.storeAuthenticator>[1]): ReturnType<typeof registrationAccount.storeAuthenticator>;
+    rollbackUserRegistration(nearAccountId: Parameters<typeof registrationAccount.rollbackUserRegistration>[1]): ReturnType<typeof registrationAccount.rollbackUserRegistration>;
+    hasPasskeyCredential(nearAccountId: Parameters<typeof registrationAccount.hasPasskeyCredential>[1]): ReturnType<typeof registrationAccount.hasPasskeyCredential>;
+    storeWalletEd25519RegistrationData(input: Parameters<typeof registrationAccount.storeWalletEd25519RegistrationData>[1]): ReturnType<typeof registrationAccount.storeWalletEd25519RegistrationData>;
+    storeWalletMixedRegistrationData(input: Parameters<typeof registrationAccount.storeWalletMixedRegistrationData>[1]): ReturnType<typeof registrationAccount.storeWalletMixedRegistrationData>;
+    storeWalletEd25519RecoveryRegistrationData(input: Parameters<typeof registrationAccount.storeWalletEd25519RecoveryRegistrationData>[1]): ReturnType<typeof registrationAccount.storeWalletEd25519RecoveryRegistrationData>;
+    storeWalletEmailOtpEd25519RegistrationData(input: Parameters<typeof registrationAccount.storeWalletEmailOtpEd25519RegistrationData>[1]): ReturnType<typeof registrationAccount.storeWalletEmailOtpEd25519RegistrationData>;
+    storeWalletEmailOtpMixedRegistrationData(input: Parameters<typeof registrationAccount.storeWalletEmailOtpMixedRegistrationData>[1]): ReturnType<typeof registrationAccount.storeWalletEmailOtpMixedRegistrationData>;
+    finalizeWalletEd25519SignerRegistration(input: Parameters<typeof registrationAccount.finalizeWalletEd25519SignerRegistration>[1]): ReturnType<typeof registrationAccount.finalizeWalletEd25519SignerRegistration>;
+    rollbackWalletEd25519SignerRegistration(receipt: Parameters<typeof registrationAccount.rollbackWalletEd25519SignerRegistration>[1]): ReturnType<typeof registrationAccount.rollbackWalletEd25519SignerRegistration>;
     createRouterAbEcdsaRegistrationCeremony(input: Parameters<typeof this.runtimePorts.signerCrypto.createRouterAbEcdsaRegistrationCeremony>[0]): ReturnType<typeof this.runtimePorts.signerCrypto.createRouterAbEcdsaRegistrationCeremony>;
     verifyRouterAbEcdsaRegistrationClientProofs(input: Parameters<typeof this.runtimePorts.signerCrypto.verifyRouterAbEcdsaRegistrationClientProofs>[0]): ReturnType<typeof this.runtimePorts.signerCrypto.verifyRouterAbEcdsaRegistrationClientProofs>;
     persistInitialCanonicalEcdsaActivation(input: Parameters<typeof this.runtimePorts.signerCrypto.persistInitialCanonicalEcdsaActivation>[0]): ReturnType<typeof this.runtimePorts.signerCrypto.persistInitialCanonicalEcdsaActivation>;
     finalizeRouterAbEcdsaRegistrationActivation(input: Parameters<typeof this.runtimePorts.signerCrypto.finalizeRouterAbEcdsaRegistrationActivation>[0]): ReturnType<typeof this.runtimePorts.signerCrypto.finalizeRouterAbEcdsaRegistrationActivation>;
     closeRouterAbEcdsaRegistrationCeremony(input: Parameters<typeof this.runtimePorts.signerCrypto.closeRouterAbEcdsaRegistrationCeremony>[0]): ReturnType<typeof this.runtimePorts.signerCrypto.closeRouterAbEcdsaRegistrationCeremony>;
     finalizeWalletRegistrationEcdsaSessions(input: Parameters<typeof finalizeWalletRegistrationEcdsaSessionsOperation>[0]): ReturnType<typeof finalizeWalletRegistrationEcdsaSessionsOperation>;
-    storeWalletEcdsaSignerRecords(input: Parameters<typeof registrationPublic.storeWalletEcdsaSignerRecords>[1]): ReturnType<typeof registrationPublic.storeWalletEcdsaSignerRecords>;
-    storeWalletEcdsaRecoverySignerRecords(input: Parameters<typeof registrationPublic.storeWalletEcdsaRecoverySignerRecords>[1]): ReturnType<typeof registrationPublic.storeWalletEcdsaRecoverySignerRecords>;
-    storeWalletEmailOtpEcdsaSignerRecords(input: Parameters<typeof registrationPublic.storeWalletEmailOtpEcdsaSignerRecords>[1]): ReturnType<typeof registrationPublic.storeWalletEmailOtpEcdsaSignerRecords>;
-    finalizeWalletEcdsaRegistration(input: Parameters<typeof registrationPublic.finalizeWalletEcdsaRegistration>[1]): ReturnType<typeof registrationPublic.finalizeWalletEcdsaRegistration>;
+    storeWalletEcdsaSignerRecords(input: Parameters<typeof registrationAccount.storeWalletEcdsaSignerRecords>[1]): ReturnType<typeof registrationAccount.storeWalletEcdsaSignerRecords>;
+    storeWalletEcdsaRecoverySignerRecords(input: Parameters<typeof registrationAccount.storeWalletEcdsaRecoverySignerRecords>[1]): ReturnType<typeof registrationAccount.storeWalletEcdsaRecoverySignerRecords>;
+    storeWalletEmailOtpEcdsaSignerRecords(input: Parameters<typeof registrationAccount.storeWalletEmailOtpEcdsaSignerRecords>[1]): ReturnType<typeof registrationAccount.storeWalletEmailOtpEcdsaSignerRecords>;
+    finalizeWalletEcdsaRegistration(input: Parameters<typeof registrationAccount.finalizeWalletEcdsaRegistration>[1]): ReturnType<typeof registrationAccount.finalizeWalletEcdsaRegistration>;
     activateVerifiedNearEd25519YaoMaterial(material: NearEd25519YaoOperationMaterial): Promise<Ed25519YaoActiveClientIdentityV1>;
     withExactEd25519MaterialOwner<T>(args: {
         materialActivation: MpcMaterialActivationRef;
         nearAccountId: AccountId;
         task: () => Promise<T>;
     }): Promise<T>;
-    storeWalletEmailOtpEcdsaRegistrationData(input: Parameters<typeof registrationPublic.storeWalletEmailOtpEcdsaRegistrationData>[1]): ReturnType<typeof registrationPublic.storeWalletEmailOtpEcdsaRegistrationData>;
+    storeWalletEmailOtpEcdsaRegistrationData(input: Parameters<typeof registrationAccount.storeWalletEmailOtpEcdsaRegistrationData>[1]): ReturnType<typeof registrationAccount.storeWalletEmailOtpEcdsaRegistrationData>;
     requestWorkerOperation: <K extends SignerWorkerKind, T extends SignerWorkerOperationType<K>>(args: {
         kind: K;
         request: SignerWorkerOperationRequest<K, T>;
@@ -424,7 +412,7 @@ export declare class BrowserSigningSurface {
      *
      * Built on the same confirmation channel key export uses, so the code is
      * typed into the wallet's own surface and never passes through the host
-     * application — the reason `addEmailOtp` takes an address and not a code.
+     * application — the reason `addEmail` takes an address and not a code.
      */
     requestEmailOtpEnrollmentConfirmation(params: {
         walletId: string;
@@ -553,38 +541,6 @@ export declare class BrowserSigningSurface {
     activateEmailOtpEd25519CustodyCapabilityInternal(args: EmailOtpEd25519CustodyCapabilityActivationArgs): Promise<NearEd25519SignerBinding>;
     private activateEmailOtpEd25519CustodyCapabilityWithExactCredential;
     loginWithEmailOtpWalletCustodyEd25519Internal(args: LoginWithEmailOtpWalletCustodyEd25519Args): Promise<NearEd25519SignerBinding>;
-    requestEmailOtpSigningSessionChallenge(args: {
-        walletSession: WalletSessionRef;
-        chainTarget: ThresholdEcdsaChainTarget;
-    }): Promise<{
-        challengeId: string;
-        emailHint?: string;
-    }>;
-    refreshEmailOtpSigningSession(args: {
-        walletSession: WalletSessionRef;
-        chainTarget: ThresholdEcdsaChainTarget;
-        challengeId: string;
-        otpCode: string;
-        ttlMs?: number;
-        remainingUses?: number;
-    }): Promise<{
-        recovery: EmailOtpBootstrapRecovery;
-        bootstrap: ThresholdEcdsaSessionBootstrapResult;
-        authorization: ExactWalletSessionAuthorization;
-        authorizations: readonly [
-            ExactWalletSessionAuthorization,
-            ...ExactWalletSessionAuthorization[]
-        ];
-    }>;
-    enrollEmailOtpInternal(args: {
-        walletId: WalletId;
-        otpCode: string;
-        relayUrl?: string;
-        challengeId?: string;
-        groupId?: string;
-        clientSecret32?: Uint8Array;
-        otpChannel?: WalletEmailOtpChannel;
-    }): Promise<Awaited<ReturnType<typeof emailOtpPublic.enrollEmailOtpInternal>>>;
     prepareEmailOtpRegistrationEnrollmentMaterialInternal(args: PrepareEmailOtpRegistrationEnrollmentMaterialInternalArgs): Promise<PrepareEmailOtpRegistrationEnrollmentMaterialInternalResult>;
     getWarmThresholdEd25519SessionStatus(args: {
         walletId: WalletId | string;
@@ -597,7 +553,6 @@ export declare class BrowserSigningSurface {
         waitForPoolReady?: boolean;
     }, statusReads: WalletSessionStatusReadScope): Promise<RouterAbEcdsaDerivationLoginPresignaturePrefillResult>;
     clearVolatileWarmSigningMaterial(walletId?: WalletId): Promise<void>;
-    deleteDurableEcdsaPresignatures(target: EcdsaClientPresignCleanupTarget): Promise<number>;
     private clearVolatileWarmSigningMaterialInternal;
     onSdkLifecycleEvent(listener: SdkLifecycleEventListener): () => void;
     publishSdkLifecycleEvent(event: SdkLifecycleEvent): void;

package/dist/types/wallet/src/SeamsWeb/signingSurface/ports.d.ts

@@ -1,3 +1,4 @@
+import type { WalletSessionHome } from '../../../../shared-ts/src/device-linking/contracts';
 import type { WalletSessionStatusReadScope } from '../../core/rpcClients/relayer/walletSessionAuthorizationStatus';
 import type { NonceCoordinator } from '../../core/signingEngine/nonce/NonceCoordinator';
 import type { EmailOtpAuthorityUnlockEd25519Request } from '../../core/signingEngine/session/emailOtp/walletUnlock';
@@ -9,7 +10,6 @@ import type { NearProvisioningState, NearProvisioningWriteV1, WalletAuthenticati
 import type { WalletId } from '../../../../shared-ts/src/utils/registrationIntent';
 import type { ThresholdEcdsaChainTarget, WalletId as EcdsaWalletId, WalletSessionRef } from '../../core/signingEngine/interfaces/ecdsaChainTarget';
 import type { ProvisionWarmEd25519CapabilityResult } from '../../core/signingEngine/session/warmCapabilities/types';
-import type { ExactWalletSessionAuthorization } from '../../core/signingEngine/session/persistence/walletSessionAuthorizationProjection';
 import type { RouterAbEcdsaDerivationLoginPresignaturePrefillResult } from '../../core/signingEngine/session/warmCapabilities/ecdsaLoginPrefill';
 import type { AvailableSigningLanes, ReadAvailableSigningLanesInput, DiscoverPersistedSessionsForWalletInput, DiscoverPersistedSessionsForWalletResult } from '../../core/signingEngine/session/public';
 import type { OwnerLaneScope } from '../../core/signingEngine/session/identity/signingLaneAuthBinding';
@@ -43,7 +43,6 @@ import type { ThresholdEcdsaSessionBootstrapResult } from '../../core/signingEng
 import type { EcdsaBootstrapRequest } from '../../core/signingEngine/session/passkey/ecdsaBootstrap';
 import type { ConnectEd25519SessionArgs } from '../../core/signingEngine/session/passkey/public';
 import type { HydrateWarmSigningSessionInput } from '../../core/signingEngine/session/passkey/warmSessionHydration';
-import type { EmailOtpBootstrapRecovery } from '../../core/signingEngine/stepUpConfirmation/otpPrompt/bootstrapRecovery';
 import type { LoginWithEmailOtpWalletCustodyEd25519Args } from '../../core/signingEngine/walletCustody/ed25519Login';
 import type { EmailOtpEd25519YaoRecoveryBootstrapV1 } from '../../core/signingEngine/workerManager/workerTypes';
 import type { RouterAbEd25519YaoActiveClientMetadataV1 } from '../../core/signingEngine/threshold/ed25519/yaoClient';
@@ -58,12 +57,11 @@ import type { RecoveredWalletCustodyManifestV1, WalletRecoveryReplacementFactorI
 import type { LoadedWalletCustodyEd25519MaterialV1, LoadWalletCustodyEd25519MaterialResultV1, WalletCustodyEd25519MaterialBindingV1, WalletCustodySealedEd25519MaterialV1 } from '../../core/signingEngine/walletCustody/ed25519SeedMaterial';
 import type { WalletCustodyCacheEnvelopeV1 } from '../../core/signingEngine/walletCustody/openCustodyCache';
 import type { WalletCustodyEd25519Projection } from '../../core/signingEngine/walletCustody/ed25519Projection';
-import type { EnrollEmailOtpInternalArgs, EnrollEmailOtpInternalResult, LoginWithEmailOtpEcdsaCapabilityInternalArgs, LoginWithEmailOtpEcdsaCapabilityInternalResult, PrepareEmailOtpRegistrationEnrollmentMaterialInternalArgs, PrepareEmailOtpRegistrationEnrollmentMaterialInternalResult } from '../../core/signingEngine/flows/signEvmFamily/emailOtpPublic';
+import type { LoginWithEmailOtpEcdsaCapabilityInternalArgs, LoginWithEmailOtpEcdsaCapabilityInternalResult, PrepareEmailOtpRegistrationEnrollmentMaterialInternalArgs, PrepareEmailOtpRegistrationEnrollmentMaterialInternalResult } from '../../core/signingEngine/flows/signEvmFamily/emailOtpPublic';
 import type { WebAuthnAllowCredential } from '../../core/signingEngine/webauthnAuth/credentials/collectAuthenticationCredentialForChallengeB64u';
 import type { RegistrationCredentialConfirmationPayload } from '../../core/signingEngine/workerManager/validation';
 import type { WebAuthnAuthenticationCredential } from '../../core/types';
 import type { WorkerOperationContext } from '../../core/signingEngine/workerManager/executeWorkerOperation';
-import type { EcdsaClientPresignCleanupTarget } from '../../core/signingEngine/workerManager/ecdsaPresignLifecycle';
 import type { WarmSessionSealAndPersistResult, WarmSessionSealTransportInput } from '../../core/types/secure-confirm-worker';
 import type { SdkLifecycleEventListener, SigningFlowEvent } from '../../core/types/sdkSentEvents';
 import type { WorkerResourceWarmupAccountContext, WorkerResourceWarmupDiagnostics } from '../../core/signingEngine/assembly/warmup';
@@ -197,7 +195,7 @@ export interface Ed25519YaoCapabilityActivationSurface {
  * Establish runs during successful owner registration and ordinary unlock,
  * where the passkey factor is already being presented, and only after the
  * owner Wallet Session named in the input is active. Destroy runs at lock,
- * logout, wallet switch, session retirement, and expiry. The linking flow only
+ * lock, wallet switch, session retirement, and expiry. The linking flow only
  * ever reads; it never establishes and never prompts.
  */
 export interface UnlockedEd25519ExportRootCapabilitySurface {
@@ -229,6 +227,7 @@ export interface WalletCustodyCeremonySurface {
         relayUrl: string;
     }): Promise<RecoveredWalletCustodyManifestV1>;
     establishWalletCustodyNearEd25519KeySet(args: {
+        readonly home: WalletSessionHome;
         walletId: string;
         factorJson: string;
         factorSecret: ArrayBuffer;
@@ -243,6 +242,9 @@ export interface WalletCustodyCeremonySurface {
         traceContext?: RouterAbTraceContextV1;
     }): Promise<EstablishedWalletCustodyNearEd25519KeySetV1>;
     joinWalletCustodyNearEd25519KeySet(args: {
+        readonly routing: WalletSessionHome | {
+            readonly kind: 'discovery';
+        };
         preparation: {
             readonly kind: 'fresh';
         } | {
@@ -416,7 +418,7 @@ export interface SigningSessionSurface {
         }>;
     }): Promise<WarmSessionSealAndPersistResult>;
     discoverPersistedSessionsForWallet(args: DiscoverPersistedSessionsForWalletInput): Promise<DiscoverPersistedSessionsForWalletResult>;
-    readPersistedAvailableSigningLanes(args: Omit<ReadAvailableSigningLanesInput, 'ecdsaChainTargets'>): Promise<AvailableSigningLanes>;
+    readPersistedAvailableSigningLanes(args: Omit<ReadAvailableSigningLanesInput, 'ecdsaChainTargets'>, statusReads: WalletSessionStatusReadScope): Promise<AvailableSigningLanes>;
     readOwnerScopedSigningLanes(args: {
         readonly walletId: WalletId | string;
         readonly ownerScope: OwnerLaneScope;
@@ -455,7 +457,6 @@ export type LoginUnlockSigningSurface = WalletSessionReadSurface & NearRegistrat
 export type RecentUnlocksSigningSurface = Pick<UserProfileStoreSurface, 'getAllUsers' | 'getLastUser'>;
 export interface EcdsaSessionControlSurface {
     clearVolatileWarmSigningMaterial(walletId?: EcdsaWalletId): Promise<void>;
-    deleteDurableEcdsaPresignatures(target: EcdsaClientPresignCleanupTarget): Promise<number>;
     clearThresholdEcdsaSigningQueue(): void;
 }
 export type LockSigningSurface = NonceCoordinatorSurface & EcdsaSessionControlSurface & WalletLockGenerationSurface & Pick<UnlockedEd25519ExportRootCapabilitySurface, 'destroyUnlockedWalletEd25519ExportRootCapabilitiesV1'> & Pick<WalletAuthenticationSurface, 'readWalletAuthenticationState' | 'retireActiveWalletSessionAuthorizationForLock' | 'clearWalletAuthenticationIfCurrent'>;
@@ -579,30 +580,6 @@ export interface EmailOtpSigningSessionSurface {
     }): Promise<NearEd25519SignerBinding>;
     loginWithEmailOtpWalletCustodyEd25519Internal(args: LoginWithEmailOtpWalletCustodyEd25519Args): Promise<NearEd25519SignerBinding>;
     loginWithEmailOtpEcdsaCapabilityInternal(args: LoginWithEmailOtpEcdsaCapabilityInternalArgs): Promise<LoginWithEmailOtpEcdsaCapabilityInternalResult>;
-    requestEmailOtpSigningSessionChallenge(args: {
-        walletSession: WalletSessionRef;
-        chainTarget: ThresholdEcdsaChainTarget;
-    }): Promise<{
-        challengeId: string;
-        emailHint?: string;
-    }>;
-    refreshEmailOtpSigningSession(args: {
-        walletSession: WalletSessionRef;
-        chainTarget: ThresholdEcdsaChainTarget;
-        challengeId: string;
-        otpCode: string;
-        ttlMs?: number;
-        remainingUses?: number;
-    }): Promise<{
-        recovery: EmailOtpBootstrapRecovery;
-        bootstrap: ThresholdEcdsaSessionBootstrapResult;
-        authorization: ExactWalletSessionAuthorization;
-        authorizations: readonly [
-            ExactWalletSessionAuthorization,
-            ...ExactWalletSessionAuthorization[]
-        ];
-    }>;
-    enrollEmailOtpInternal(args: EnrollEmailOtpInternalArgs): Promise<EnrollEmailOtpInternalResult>;
 }
 export interface KeyExportSigningSurface {
     resolveExactKeyExportLane(input: SigningEngineResolveExactKeyExportLaneInput): Promise<SigningEngineResolveExactKeyExportLaneResult>;

package/dist/types/wallet/src/SeamsWeb/walletIframe/client/deviceCommands.d.ts

@@ -0,0 +1,4 @@
+import type { DeviceCommands } from '../../publicApi/devices';
+import type { WalletIframeCoordinator } from '../coordinator';
+export declare function createApplicationDeviceCommands(walletIframe: Pick<WalletIframeCoordinator, 'requireRouter'>): DeviceCommands;
+//# sourceMappingURL=deviceCommands.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/client/emailOtpCommands.d.ts

@@ -0,0 +1,4 @@
+import { type EmailOtpAuthCommands } from '../../publicApi/auth';
+import type { WalletIframeCoordinator } from '../coordinator';
+export declare function createApplicationEmailOtpCommands(walletIframe: Pick<WalletIframeCoordinator, 'requireRouter'>): EmailOtpAuthCommands;
+//# sourceMappingURL=emailOtpCommands.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/client/evmFamilyCommands.d.ts

@@ -0,0 +1,6 @@
+import type { WalletId } from '../../../core/signingEngine/interfaces/ecdsaChainTarget';
+import type { EvmFamilyCommands } from '../../publicApi/evmFamilyCommands';
+import type { TransactionDispatch } from './transactionReviewReservation';
+import type { WalletIframeCoordinator } from '../coordinator';
+export declare function createApplicationEvmFamilyCommands(walletIframe: Pick<WalletIframeCoordinator, 'requireRouter'>, beforeSigning: (walletId: WalletId) => Promise<void>, transactionDispatch: TransactionDispatch): EvmFamilyCommands;
+//# sourceMappingURL=evmFamilyCommands.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/client/inboundMessages.d.ts

@@ -0,0 +1,62 @@
+import { parseTransactionReviewState } from '../shared/transactionReview';
+import { type ProgressPayload, type PreferencesChangedPayload, type ErrorPayload, type PMResultPayload, parseWalletIframeSurfaceMeasurement, parseHostedAuthMenuErrorEvent } from '../shared/messages';
+import type { SdkLifecycleEvent } from '../../../core/types/sdkSentEvents';
+import { parseHostedAuthMenuExternalAuthRequest } from '../shared/messages';
+import { type WalletIframeExactSessionSnapshot } from '../shared/exactSessionState';
+type ParsedSdkLifecycleEnvelope = {
+    readonly kind: 'not_lifecycle_event';
+} | {
+    readonly kind: 'invalid_lifecycle_event';
+} | {
+    readonly kind: 'lifecycle_event';
+    readonly revision: number;
+    readonly event: SdkLifecycleEvent;
+};
+type ParsedChildToParentEnvelope = {
+    readonly type: 'SESSION_CHANGED';
+    readonly payload: WalletIframeExactSessionSnapshot;
+} | {
+    readonly type: 'TRANSACTION_REVIEW_STATE';
+    readonly requestId?: string;
+    readonly payload: NonNullable<ReturnType<typeof parseTransactionReviewState>>;
+} | {
+    readonly type: 'PONG';
+    readonly requestId?: string;
+} | {
+    readonly type: 'PREFERENCES_CHANGED';
+    readonly requestId?: string;
+    readonly payload: PreferencesChangedPayload;
+} | {
+    readonly type: 'AUTH_MENU_EXTERNAL_AUTH_REQUEST';
+    readonly requestId?: string;
+    readonly payload: NonNullable<ReturnType<typeof parseHostedAuthMenuExternalAuthRequest>>;
+} | {
+    readonly type: 'AUTH_MENU_ERROR';
+    readonly requestId?: string;
+    readonly payload: NonNullable<ReturnType<typeof parseHostedAuthMenuErrorEvent>>;
+} | {
+    readonly type: 'SURFACE_MEASUREMENT';
+    readonly requestId?: string;
+    readonly payload: NonNullable<ReturnType<typeof parseWalletIframeSurfaceMeasurement>>;
+} | {
+    readonly type: 'TRANSACTION_ACTIVITY';
+    readonly requestId: string;
+    readonly payload: 'expanded' | 'toast' | 'closed';
+} | {
+    readonly type: 'PROGRESS';
+    readonly requestId?: string;
+    readonly payload: ProgressPayload;
+} | {
+    readonly type: 'PM_RESULT';
+    readonly requestId?: string;
+    readonly payload: PMResultPayload;
+} | {
+    readonly type: 'ERROR';
+    readonly requestId?: string;
+    readonly payload: ErrorPayload;
+};
+export declare function parseClientPreferencesChangedPayload(value: unknown): PreferencesChangedPayload | null;
+export declare function parseClientChildToParentEnvelope(value: unknown): ParsedChildToParentEnvelope | null;
+export declare function parseSdkLifecycleEnvelope(value: unknown): ParsedSdkLifecycleEnvelope;
+export {};
+//# sourceMappingURL=inboundMessages.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/client/nearCommands.d.ts

@@ -0,0 +1,6 @@
+import type { WalletId } from '../../../core/signingEngine/interfaces/ecdsaChainTarget';
+import type { NearCommands } from '../../publicApi/nearCommands';
+import type { TransactionDispatch } from './transactionReviewReservation';
+import type { WalletIframeCoordinator } from '../coordinator';
+export declare function createApplicationNearCommands(walletIframe: Pick<WalletIframeCoordinator, 'requireRouter'>, beforeSigning: (walletId: WalletId) => Promise<void>, transactionDispatch: TransactionDispatch): NearCommands;
+//# sourceMappingURL=nearCommands.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/client/placementCommands.d.ts

@@ -0,0 +1,31 @@
+import { type WalletMoveId, type WalletMoveRequest, type WalletPlacementCapability } from '../../publicApi/placement';
+import type { WalletIframeCoordinator } from '../coordinator';
+import type { WalletId } from '../../../../../shared-ts/src/utils/domainIds';
+type PlacementPost = (request: {
+    readonly type: 'PM_GET_LAST_WALLET_MOVE_REQUEST';
+    readonly payload: {
+        readonly walletId: WalletId;
+    };
+} | {
+    readonly type: 'PM_MOVE_WALLET';
+    readonly payload: WalletMoveRequest;
+} | {
+    readonly type: 'PM_GET_WALLET_PLACEMENT';
+    readonly payload: {
+        readonly walletId: WalletId;
+    };
+} | {
+    readonly type: 'PM_GET_WALLET_MOVE';
+    readonly payload: {
+        readonly walletId: WalletId;
+        readonly moveId: WalletMoveId;
+    };
+}, options?: {
+    readonly timeout: 'interactive';
+}) => Promise<{
+    readonly result: unknown;
+}>;
+export declare function createIframePlacementCommands(post: PlacementPost): WalletPlacementCapability;
+export declare function createApplicationPlacementCommands(iframe: Pick<WalletIframeCoordinator, 'requireRouter'>): WalletPlacementCapability;
+export {};
+//# sourceMappingURL=placementCommands.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/client/preferenceState.d.ts

@@ -0,0 +1,35 @@
+import type { WalletId } from '../../../core/signingEngine/interfaces/ecdsaChainTarget';
+import { type ConfirmationConfig } from '../../../core/types/signer-worker';
+import type { PreferencesCapability } from '../../signingSurface/types';
+/** The display state shared by preference controls and the iframe coordinator. */
+export type PreferenceState = Pick<PreferencesCapability, 'setCurrentWallet' | 'getCurrentWalletId' | 'getConfirmationConfig' | 'onConfirmationConfigChange' | 'onCurrentWalletChange'> & {
+    applyWalletHostConfirmationConfig(input: {
+        walletId: WalletId | null;
+        confirmationConfig: ConfirmationConfig;
+    }): void;
+};
+/** Application-origin projection. It has no persistence or signing dependencies. */
+export declare class ClientPreferenceState implements PreferenceState {
+    private currentWalletId;
+    private readonly confirmed;
+    private readonly pending;
+    private readonly configurationListeners;
+    private readonly walletListeners;
+    private disposed;
+    getCurrentWalletId(): WalletId | null;
+    getConfirmationConfig(): ConfirmationConfig;
+    setCurrentWallet(walletId: WalletId): void;
+    beginWrite(id: number, walletId: WalletId | null, patch: Partial<ConfirmationConfig>): void;
+    settleWrite(id: number, succeeded: boolean): void;
+    private notifyConfiguration;
+    applyWalletHostConfirmationConfig(input: {
+        walletId: WalletId | null;
+        confirmationConfig: ConfirmationConfig;
+    }): void;
+    onConfirmationConfigChange(listener: (config: ConfirmationConfig) => void): () => void;
+    onCurrentWalletChange(listener: (walletId: WalletId | null) => void): () => void;
+    dispose(): void;
+    private removeConfigurationListener;
+    private removeWalletListener;
+}
+//# sourceMappingURL=preferenceState.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/client/preferences.d.ts

@@ -0,0 +1,10 @@
+import type { WalletId } from '../../../core/signingEngine/interfaces/ecdsaChainTarget';
+import type { PreferencesCapability } from '../../signingSurface/types';
+import type { WalletIframeCoordinator } from '../coordinator';
+import type { ClientPreferenceState } from './preferenceState';
+export declare function createApplicationPreferences(state: ClientPreferenceState, walletIframe: Pick<WalletIframeCoordinator, 'requireRouter'>): {
+    capability: PreferencesCapability;
+    beforeSigning: (walletId: WalletId) => Promise<void>;
+    dispose: () => void;
+};
+//# sourceMappingURL=preferences.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/client/registrationCommands.d.ts

@@ -0,0 +1,6 @@
+import type { WalletRegistrationCommands } from '../../publicApi/createPublicApi';
+import type { WalletIframeCoordinator } from '../coordinator';
+type RegistrationIframe = Pick<WalletIframeCoordinator, 'requireRouter' | 'getTransportDiagnosticsSnapshot'>;
+export declare function createApplicationRegistrationCommands(walletIframe: RegistrationIframe): WalletRegistrationCommands;
+export {};
+//# sourceMappingURL=registrationCommands.d.ts.map