@seams/wallet 0.28.0 → 0.30.0

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

@@ -0,0 +1,72 @@
+import type { ResolveSelectedWalletAuthorityResultV1 } from '../../core/indexedDB/seamsWalletDB/repositories';
+import { type WalletId } from '../../core/signingEngine/interfaces/ecdsaChainTarget';
+import type { NearEd25519YaoOperationMaterial, NearEd25519YaoOperationMaterialFacts } from '../../core/signingEngine/interfaces/near';
+import type { NearEd25519MaterialIdentity, NearSigningApiDeps } from '../../core/signingEngine/interfaces/operationDeps';
+import { preparePasskeyEd25519YaoLocalMaterialRehydrationV1, type Ed25519YaoLocalMaterialIdentity, type PasskeyEd25519YaoPublicLocatorObservationV1 } from '../../core/signingEngine/session/passkey/ed25519YaoLocalMaterial';
+import type { WebAuthnAuthenticationCredential } from '../../core/types';
+import { type MpcMaterialActivationRef } from '../../../../shared-ts/src/utils/domainIds';
+import { type WalletAuthAuthorityRef } from '../../../../shared-ts/src/utils/walletAuthAuthority';
+import { type ActivePasskeyWalletAuthMethodRecordV2 } from '../../../../shared-ts/src/utils/walletAuthMethodRecord';
+import type { NearEd25519SignerBinding } from '../../../../shared-ts/src/utils/walletCapabilityBindings';
+export declare function resolveBrowserExactPasskeyWalletAuthAuthorityRef(args: {
+    readonly walletId: WalletId;
+    readonly rpId: string;
+    readonly credentialIdB64u: string;
+}): Promise<WalletAuthAuthorityRef | null>;
+export type PasskeyEd25519MaterialAccess = {
+    readonly kind: 'wallet_session';
+} | {
+    readonly kind: 'owner_operation';
+    readonly authMethod: ActivePasskeyWalletAuthMethodRecordV2;
+    readonly authority: import('../../../../shared-ts/src/authorization/walletAuthority').ActiveWalletAuthorityV1;
+    readonly assertCurrent: () => void;
+};
+export declare function preparePasskeyEd25519OperationMaterial(args: {
+    walletId: WalletId;
+    identity: NearEd25519MaterialIdentity;
+    relayerUrl: string;
+    access: PasskeyEd25519MaterialAccess;
+}): Promise<{
+    prepared: {
+        kind: 'prepared';
+        plan: Extract<import("../../core/signingEngine/session/material/mpcCapabilityHydration").MpcCapabilityHydrationPlan, {
+            kind: 'rehydrate_material_activation';
+        }>;
+    };
+    localIdentity: Ed25519YaoLocalMaterialIdentity;
+    authority: WalletAuthAuthorityRef;
+    publicLocator: Omit<{
+        readonly kind: 'available';
+        readonly walletId: string;
+        readonly nearAccountId: string;
+        readonly signerSlot: number;
+        readonly materialActivation: MpcMaterialActivationRef;
+        readonly authority: WalletAuthAuthorityRef;
+    }, "authority">;
+    facts: NearEd25519YaoOperationMaterialFacts;
+    participantIds: readonly [number, number];
+}>;
+export declare function assertPasskeyEd25519MaterialAccess(access: PasskeyEd25519MaterialAccess, selected: Extract<ResolveSelectedWalletAuthorityResultV1, {
+    kind: 'resolved';
+}>): void;
+export declare function prepareExactPasskeyEd25519YaoLocalMaterialRehydration(input: Parameters<typeof preparePasskeyEd25519YaoLocalMaterialRehydrationV1>[0]): Promise<Awaited<ReturnType<typeof preparePasskeyEd25519YaoLocalMaterialRehydrationV1>>>;
+export type PrepareNearEd25519YaoMaterialBoundaryInput = Parameters<NearSigningApiDeps['prepareNearEd25519YaoMaterialBoundary']>[0];
+export declare function nearEd25519MaterialIdentityFromBoundaryInput(input: PrepareNearEd25519YaoMaterialBoundaryInput): NearEd25519MaterialIdentity;
+export declare function nearEd25519SignerFromBoundaryInput(input: PrepareNearEd25519YaoMaterialBoundaryInput): NearEd25519SignerBinding;
+export declare function validateExactNearEd25519YaoOperationMaterial(args: {
+    material: NearEd25519YaoOperationMaterial;
+    input: PrepareNearEd25519YaoMaterialBoundaryInput;
+    expectedActivation: MpcMaterialActivationRef;
+}): NearEd25519YaoOperationMaterial;
+export declare function rehydratePreparedPasskeyEd25519YaoOperationStepUp(prepared: {
+    input: PrepareNearEd25519YaoMaterialBoundaryInput;
+    access: PasskeyEd25519MaterialAccess;
+    identity: Ed25519YaoLocalMaterialIdentity;
+    facts: NearEd25519YaoOperationMaterialFacts;
+    authority: WalletAuthAuthorityRef;
+    rpId: string;
+    credentialIdB64u: string;
+    publicLocator: PasskeyEd25519YaoPublicLocatorObservationV1;
+    materialActivation: MpcMaterialActivationRef;
+}, credential: WebAuthnAuthenticationCredential): Promise<NearEd25519YaoOperationMaterial>;
+//# sourceMappingURL=nearPasskeyOperationMaterial.d.ts.map

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

@@ -6,6 +6,9 @@ import type { WorkerOperationContext } from '../../core/signingEngine/workerMana
 export type { AccountSyncSigningSurface, AccountSyncWebContext, WalletAuthWebContext, DeviceLinkingSigningSurface, DeviceLinkingWebContext, EcdsaLoginSessionSurface, EcdsaRegistrationSurface, Ed25519YaoCapabilityActivationSurface, EcdsaSessionBootstrapSurface, EcdsaSessionControlSurface, Ed25519SessionConnectionSurface, EmailOtpRegistrationEnrollmentSurface, EmailOtpSigningSessionSurface, WalletRecoverySigningSurface, WalletRecoveryWebContext, EvmFamilySigningSurface, LocalLoginStateSurface, LockSigningSurface, LoginUnlockSigningSurface, LoginWarmSigningSurface, LoginWebContext, NearSigningSurface, NearSigningWebContext, NonceCoordinatorSurface, PasskeyLoginAssertionSurface, RecentUnlocksSigningSurface, RecentUnlocksWebContext, RegistrationAccountSurface, RegistrationResourceWarmupSurface, RegistrationSigningSurface, RegistrationWebContext, RpIdSurface, RuntimeStartupSurface, SeamsWebBaseContext, SigningEngineLifecycleEventSurface, SignerWorkerContextSurface, SigningSessionSurface, TempoNonceLifecycleSurface, TempoSigningSurface, UnlockedEd25519ExportRootCapabilitySurface, UserAccountLookupSurface, UserProfileStoreSurface, WalletIframeWarmupSurface, WalletAuthenticationSurface, WalletSessionReadSurface, WalletSessionWebContext, WarmSessionStatusSurface, WebAuthnRegistrationConfirmationSurface, } from './ports';
 export type * from '../publicApi/types';
 export interface SeamsWebSigningSurface extends RpIdSurface, NonceCoordinatorSurface, WalletIframeWarmupSurface, WalletIframeSurfaceMeasurementSurface, WalletAuthenticationSurface, WalletLockGenerationSurface, RuntimeStartupSurface, SigningEngineLifecycleEventSurface, WorkerOperationContext, SigningSessionSurface, Ed25519SessionConnectionSurface, EcdsaSessionBootstrapSurface, EmailOtpSigningSessionSurface, EmailOtpRegistrationEnrollmentSurface, EcdsaLoginSessionSurface, EcdsaSessionControlSurface, SignerWorkerContextSurface, WarmSessionStatusSurface, NearSigningSurface, EvmFamilySigningSurface, TempoNonceLifecycleSurface, UserProfileStoreSurface, RegistrationResourceWarmupSurface, RegistrationAccountSurface, EcdsaRegistrationSurface, Ed25519YaoCapabilityActivationSurface, UnlockedEd25519ExportRootCapabilitySurface, WalletCustodyCeremonySurface, Ed25519MaterialOwnerQueueSurface, Pick<AccountSyncSigningSurface, 'storeNearThresholdKeyMaterial'>, WebAuthnRegistrationConfirmationSurface, EmailOtpOwnerConfirmationSurface, PasskeyLoginAssertionSurface, KeyExportSigningSurface {
+    signNearOwnerTransaction(command: Extract<import('../walletIframe/shared/ownerNearOperation').OwnerNearCommand, {
+        action: 'approve';
+    }>, assertCurrent: () => void, onEvent: (event: import('../../core/types/sdkSentEvents').SigningFlowEvent) => void): Promise<import('../../core/types/seams').SignTransactionResult>;
     readonly seamsWebConfigs: SeamsConfigsReadonly;
     dispose(): void;
     setAppearance(appearance: AppearanceConfig): void;

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

@@ -1,3 +1,4 @@
+import { parseWalletConnectionRequest } from '../shared/walletAlternatives';
 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';
@@ -13,6 +14,10 @@ type ParsedSdkLifecycleEnvelope = {
     readonly event: SdkLifecycleEvent;
 };
 type ParsedChildToParentEnvelope = {
+    readonly type: 'WALLET_CONNECTION_REQUEST';
+    readonly requestId?: string;
+    readonly payload: NonNullable<ReturnType<typeof parseWalletConnectionRequest>>;
+} | {
     readonly type: 'SESSION_CHANGED';
     readonly payload: WalletIframeExactSessionSnapshot;
 } | {

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

@@ -0,0 +1,25 @@
+import type { ExecuteOwnerNearOperation } from '../../publicApi/ownerNearOperation';
+import type { WalletIframeRequestId } from '../../../core/types/walletIframeIdentity';
+import type { ProgressPayload } from '../shared/messages';
+import { type OwnerNearCommand } from '../shared/ownerNearOperation';
+type OwnerNearRequestPorts = {
+    allocateRequestId(): WalletIframeRequestId;
+    cancelRequest(requestId: string): Promise<void>;
+    post(request: {
+        type: 'PM_OWNER_NEAR_TRANSACTION';
+        payload: OwnerNearCommand;
+        options: {
+            onProgress: (payload: ProgressPayload) => void;
+        };
+    }, options: {
+        requestId: WalletIframeRequestId;
+        timeout: 'interactive';
+        shouldContinue: () => boolean;
+        onDispatched: () => void;
+    }): Promise<{
+        result?: unknown;
+    }>;
+};
+export declare function executeOwnerNearRequest(ports: OwnerNearRequestPorts, ...args: Parameters<ExecuteOwnerNearOperation>): ReturnType<ExecuteOwnerNearOperation>;
+export {};
+//# sourceMappingURL=ownerNearOperation.d.ts.map

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

@@ -1,3 +1,5 @@
+import { type WalletConnectionRequest, type WalletConnectionResolutionInput } from '../shared/walletAlternatives';
+import type { ExecuteOwnerNearOperation } from '../../publicApi/ownerNearOperation';
 import type { VoiceIdConfirmationOptions } from '../../../core/authMethods/plugins';
 import type { WalletRegistrationCommand } from '../../publicApi/createPublicApi';
 import type { AuthCapability } from '../../publicApi/types';
@@ -167,6 +169,8 @@ export declare class WalletIframeRouter {
     private hideRequestSurface;
     private finishDeviceLinkQrSurface;
     onConnectionClosed(listener: () => void): () => void;
+    onWalletConnectionRequest(listener: (request: WalletConnectionRequest) => void): () => void;
+    resolveWalletConnection(resolution: WalletConnectionResolutionInput): Promise<void>;
     onHostedAuthMenuExternalAuthRequest(listener: (payload: HostedAuthMenuExternalAuthRequest) => void): () => void;
     resolveHostedAuthMenuExternalAuth(resolution: HostedAuthMenuExternalAuthResolutionInput): Promise<void>;
     /**
@@ -247,6 +251,7 @@ export declare class WalletIframeRouter {
     authenticate(input: Parameters<AuthCapability['authenticate']>[0]): ReturnType<AuthCapability['authenticate']>;
     prepareExternalAuth(walletId: string): ReturnType<AuthCapability['prepareExternalAuth']>;
     removeExternalAuth(input: Parameters<AuthCapability['removeExternalAuth']>[0]): ReturnType<AuthCapability['removeExternalAuth']>;
+    prepareExternalAssociation(walletId: string): ReturnType<AuthCapability['prepareExternalAssociation']>;
     associateExternalAuth(input: Parameters<AuthCapability['associateExternalAuth']>[0]): ReturnType<AuthCapability['associateExternalAuth']>;
     getWalletSession(walletId?: string): Promise<WalletSession>;
     private finishWalletSessionRead;
@@ -259,7 +264,7 @@ export declare class WalletIframeRouter {
     requestWalletCustodyEmailOtpChallenge(payload: {
         walletId: string;
         providerSubjectId: string;
-        operation: import('../../../../../shared-ts/src/authorization/walletCustodyOperation').WalletCustodyAdminOperation;
+        operation: import('../../../../../shared-ts/src/authorization/walletOwnerOperation').WalletOwnerAdminOperation;
         payload: Record<string, unknown>;
         requestOrigin?: string;
     }): Promise<WalletCustodyEmailOtpChallengeResult>;
@@ -376,6 +381,7 @@ export declare class WalletIframeRouter {
     private submitLinkedDeviceTargetEmailOtpV1;
     cancelDeviceLinking(): Promise<void>;
     private wrapOnEvent;
+    ownerNearOperation(...args: Parameters<ExecuteOwnerNearOperation>): ReturnType<ExecuteOwnerNearOperation>;
     signAndSendTransaction(payload: {
         walletId: string;
         nearAccountId: string;

package/dist/types/wallet/src/SeamsWeb/walletIframe/coordinator.d.ts

@@ -1,3 +1,4 @@
+import type { WalletConnectionRequest, WalletConnectionResolutionInput } from './shared/walletAlternatives';
 import type { ClientConnectionState } from '../publicApi/types';
 import type { PreferenceState } from './client/preferenceState';
 import type { AppearanceConfig, SeamsClientConfig, WalletSession } from '../../core/types/seams';
@@ -29,6 +30,8 @@ export declare class WalletIframeCoordinator {
     private walletIframeSessionUnsubscribe;
     private readonly sessionListeners;
     private walletIframeLifecycleUnsubscribe;
+    private walletConnectionUnsubscribe;
+    private readonly walletConnectionListeners;
     private walletIframeAuthMenuUnsubscribe;
     private readonly sdkLifecycleEventListeners;
     private readonly hostedAuthMenuExternalAuthRequestListeners;
@@ -60,6 +63,9 @@ export declare class WalletIframeCoordinator {
     cancelHostedAuthMenu(args: {
         authMenuSessionId: HostedAuthMenuSessionId;
     }): Promise<void>;
+    onWalletConnectionRequest(listener: (request: WalletConnectionRequest) => void): () => void;
+    resolveWalletConnection(resolution: WalletConnectionResolutionInput): Promise<void>;
+    private forwardWalletConnection;
     onHostedAuthMenuExternalAuthRequest(listener: (request: HostedAuthMenuExternalAuthRequest) => void): () => void;
     resolveHostedAuthMenuExternalAuth(resolution: HostedAuthMenuExternalAuthResolutionInput): Promise<void>;
     lockExactSession(identity: WalletIframeExactSessionIdentity): Promise<WalletIframeExactSessionLockResult>;

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/WalletHostRuntime.d.ts

@@ -1,3 +1,4 @@
+import type { OwnerNearCommand, OwnerNearOutcome } from '../shared/ownerNearOperation';
 import type { WalletPlacementCapability } from '../../publicApi/placement';
 import { type KeyExportDomainMethods } from '../../publicApi/keyExport';
 import type { WalletAuthCommands } from '../../publicApi/auth';
@@ -26,6 +27,7 @@ export declare class WalletHostRuntime {
     private readonly nearClient;
     readonly configs: WalletHostConfig;
     readonly readExternalSession: WalletHostSessionCommands['readExternalSession'];
+    private readonly captureExternalOwnerOperation;
     private appearance;
     theme: ThemeMode;
     private readonly prefillRestoredSession;
@@ -33,9 +35,10 @@ export declare class WalletHostRuntime {
     readonly devices: DevicesCapability;
     readonly keys: KeyExportDomainMethods;
     readonly preferences: Omit<PreferencesCapability, 'setConfirmationConfig' | 'setConfirmationBehavior' | 'onCurrentWalletChange'> & Pick<UserPreferencesManager, 'setConfirmationConfig' | 'setConfirmationBehavior' | 'onCurrentWalletChange'>;
-    readonly auth: WalletAuthCommands & Pick<WalletHostSessionCommands, 'unlockWithAuthMethod' | 'authenticate'>;
+    readonly auth: WalletAuthCommands & Pick<WalletHostSessionCommands, 'unlockWithAuthMethod' | 'authenticate' | 'associateExternalAuth' | 'removeExternalAuth'>;
     readonly placement: WalletPlacementCapability;
     readonly registration: RegistrationCapability;
+    readonly registerWalletCommand: import('../../publicApi/createPublicApi').WalletRegistrationCommands['registerWallet'];
     readonly near: NearSignerCapability;
     readonly tempo: TempoSignerCapability;
     readonly evm: EvmSignerCapability;
@@ -47,6 +50,7 @@ export declare class WalletHostRuntime {
     private lockAfterWalletMove;
     /** Subscribe to typed lifecycle events emitted by the wallet boundary. */
     onSdkLifecycleEvent(listener: SdkLifecycleEventListener): () => void;
+    runOwnerNearOperation(command: OwnerNearCommand, assertActive: () => void, onEvent: (event: import('../../../core/types/sdkSentEvents').SigningFlowEvent) => void, onSubmission: () => void): Promise<OwnerNearOutcome>;
     getContext(): SeamsWebContextWithDeviceLinkingResumeV1;
     private resumePendingAcknowledgementsAfterExactUnlockV1;
     private resumePendingRegistrationOnStartup;

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/auth-menu/controller.d.ts

@@ -1,3 +1,4 @@
+import type { WalletConnectionResolution } from '../../shared/walletAlternatives';
 import type { AppearanceConfig } from '../../../../core/types/seams';
 import type { WalletHostRuntime } from '../WalletHostRuntime';
 import type { ChildToParentEnvelope, HostedAuthMenuCancelPayload, HostedAuthMenuExternalAuthResolution, HostedAuthMenuOpenRequest } from '../../shared/messages';
@@ -24,6 +25,7 @@ export declare class AuthMenuController {
     private cancelDeviceLinking;
     private prepareRegistration;
     cancel(payload: HostedAuthMenuCancelPayload): boolean;
+    resolveWalletConnection(resolution: WalletConnectionResolution): boolean;
     resolveExternalAuth(resolution: HostedAuthMenuExternalAuthResolution): boolean;
 }
 export {};

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/auth-menu/domain.d.ts

@@ -303,6 +303,9 @@ export type AuthMenuRecoveryViewModel = AuthMenuViewModelCommon & {
 export type AuthMenuViewModel = AuthMenuLoginViewModel | AuthMenuRegisterViewModel | AuthMenuGoogleLoginViewModel | AuthMenuGoogleRegistrationViewModel | AuthMenuLinkDeviceViewModel | AuthMenuRecoveryViewModel;
 type AuthMenuCloseReason = 'close_button' | 'escape';
 export type AuthMenuIntent = {
+    readonly kind: 'wallet_connection';
+    readonly alternativeId: string;
+} | {
     readonly kind: 'close';
     readonly reason: AuthMenuCloseReason;
 } | {

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/auth-menu/session.d.ts

@@ -1,3 +1,4 @@
+import { type WalletConnectionResolution } from '../../shared/walletAlternatives';
 import type { WalletHostSessionCommands } from '../createSessionCommands';
 import type { AppearanceConfig } from '../../../../core/types/seams';
 import { type AuthMenuAccountOption, type AuthMenuGoogleLoginViewModel, type AuthMenuGoogleRegistrationViewModel, type AuthMenuLinkDeviceViewModel, type AuthMenuRecoveryViewModel, type AuthMenuViewModel } from './domain';
@@ -164,6 +165,7 @@ export declare class AuthMenuSession {
     readonly request: HostedAuthMenuOpenRequest;
     private stateValue;
     private surface;
+    private walletConnection;
     private outcomeResolver;
     private outcomePromise;
     private successTimers;
@@ -246,6 +248,8 @@ export declare class AuthMenuSession {
     private currentViewModel;
     private updateElement;
     private reportPresentedError;
+    private requestWalletConnection;
+    acceptWalletConnection(resolution: WalletConnectionResolution): boolean;
     private onIntent;
     private selectMode;
     private showPasskeyMode;

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/createNearCommands.d.ts

@@ -1,4 +1,5 @@
+import type { WalletHostRuntime } from './WalletHostRuntime';
 import type { NearCommands } from '../../publicApi/nearCommands';
 import type { NearSigningWebContext } from '../../signingSurface/types';
-export declare function createWalletHostNearCommands(getContext: () => NearSigningWebContext): NearCommands;
+export declare function createWalletHostNearCommands(getContext: () => NearSigningWebContext, runOwnerOperation: WalletHostRuntime['runOwnerNearOperation']): NearCommands;
 //# sourceMappingURL=createNearCommands.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/createSessionCommands.d.ts

@@ -1,3 +1,4 @@
+import { HostedExternalAuth } from './externalAuth';
 import { type PendingRegistrationRecoverySigningSurface } from '../../operations/registration/pendingRegistrationRecovery';
 import { WalletSessionStatusReadScope } from '../../../core/rpcClients/relayer/walletSessionAuthorizationStatus';
 import type { RouterAbEcdsaDerivationLoginPresignaturePrefillResult } from '../../../core/signingEngine/session/warmCapabilities/ecdsaLoginPrefill';
@@ -10,12 +11,15 @@ import type { WalletSessionCommands } from '../../publicApi/auth';
 type WalletHostAuthContext = WalletAuthWebContext & {
     signingEngine: Pick<WalletIframeWarmupSurface, 'warmCriticalResources'> & PendingRegistrationRecoverySigningSurface & WalletIframeSurfaceMeasurementSurface & Pick<WalletAuthenticationSurface, 'installAuthMethodSession'>;
 };
-export type WalletHostSessionCommands = Omit<WalletSessionCommands, 'unlockWithAuthMethod' | 'authenticate'> & {
+export type WalletHostSessionCommands = Omit<WalletSessionCommands, 'unlockWithAuthMethod' | 'authenticate' | 'associateExternalAuth' | 'removeExternalAuth'> & {
     authenticate(input: Parameters<WalletSessionCommands['authenticate']>[0], assertActive?: () => void): ReturnType<WalletSessionCommands['authenticate']>;
+    associateExternalAuth(input: Parameters<WalletSessionCommands['associateExternalAuth']>[0], assertActive?: () => void): ReturnType<WalletSessionCommands['associateExternalAuth']>;
+    removeExternalAuth(input: Parameters<WalletSessionCommands['removeExternalAuth']>[0], assertActive?: () => void): ReturnType<WalletSessionCommands['removeExternalAuth']>;
     readExternalSession(walletId?: string): Promise<WalletSession | null>;
+    captureExternalOwnerOperation: HostedExternalAuth['captureOwnerOperation'];
     unlockWithAuthMethod(args: Parameters<WalletSessionCommands['unlockWithAuthMethod']>[0], assertActive?: () => void, mountCapture?: AuthMethodCaptureMount): ReturnType<WalletSessionCommands['unlockWithAuthMethod']>;
 };
-export declare function createWalletHostSessionCommands(getContext: () => WalletHostAuthContext, readOwnerCredential: import('../../operations/devices/walletHostOwnerAuthority').WalletHostOwnerAuthoritiesV1['readOwnerCredential'], parentOrigin: string): WalletHostSessionCommands;
+export declare function createWalletHostSessionCommands(getContext: () => WalletHostAuthContext, parentOrigin: string): WalletHostSessionCommands;
 export declare function prefillWalletHostPresignatures(getContext: () => WalletHostAuthContext, args: {
     walletSession: WalletSessionRef;
     chainTarget: ThresholdEcdsaChainTarget;

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/externalAuth.d.ts

@@ -1,14 +1,14 @@
 import type { SeamsConfigsReadonly, WalletSession } from '../../../core/types/seams';
 import { type ExternalAuthenticateInput, type ExternalAuthAttempt, type ExternalAuthResult, type ExternalWalletAuthentication } from '../../../../../shared-ts/src/auth/externalAuth';
-import type { WalletHostOwnerAuthoritiesV1 } from '../../operations/devices/walletHostOwnerAuthority';
+import { type ExternalOwnerApproval } from './externalOwnerApproval';
 export declare class HostedExternalAuth {
     private readonly configs;
     private readonly lockOwner;
-    private readonly readOwnerCredential;
+    private readonly approveOwner;
     private readonly parentOrigin;
     private state;
     private generation;
-    constructor(configs: SeamsConfigsReadonly, lockOwner: () => Promise<void>, readOwnerCredential: WalletHostOwnerAuthoritiesV1['readOwnerCredential'], parentOrigin: string);
+    constructor(configs: SeamsConfigsReadonly, lockOwner: () => Promise<void>, approveOwner: ExternalOwnerApproval, parentOrigin: string);
     private storageKey;
     private restore;
     private request;
@@ -16,14 +16,16 @@ export declare class HostedExternalAuth {
     releaseForOwner(): Promise<void>;
     prepare(walletId: string): Promise<ExternalAuthResult<ExternalAuthAttempt>>;
     authenticate(input: ExternalAuthenticateInput, assertActive?: () => void): Promise<ExternalAuthResult<ExternalWalletAuthentication>>;
-    associate(input: {
-        walletId: string;
-        idToken: string;
-    }): Promise<ExternalAuthResult<null>>;
+    prepareAssociation(walletId: string): Promise<ExternalAuthResult<ExternalAuthAttempt<'associate'>>>;
+    associate(input: ExternalAuthenticateInput, assertActive?: () => void): Promise<ExternalAuthResult<null>>;
+    private assertOwnerOperation;
+    private completeOwnerOperation;
+    captureOwnerOperation(authentication: ExternalWalletAuthentication): Promise<() => void>;
+    private assertOwnerOperationCurrent;
     getSession(walletId?: string): Promise<WalletSession | null>;
     remove(input: {
         walletId: string;
         associationId: string;
-    }): Promise<ExternalAuthResult<null>>;
+    }, assertActive?: () => void): Promise<ExternalAuthResult<null>>;
 }
 //# sourceMappingURL=externalAuth.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/externalOwnerApproval.d.ts

@@ -0,0 +1,24 @@
+import type { SeamsConfigsReadonly } from '../../../core/types/seams';
+import type { UiConfirmSurfaceMeasurementBinding } from '../../../core/signingEngine/uiConfirm/uiConfirm.types';
+import type { WalletCustodyFactorProof } from '../../../core/rpcClients/relayer/walletRecoveryRotate';
+import type { ExternalOwnerChallenge } from '../../../../../shared-ts/src/auth/externalAuth';
+type OwnerApprovalContext = {
+    readonly configs: Pick<SeamsConfigsReadonly, 'ui'>;
+    readonly signingEngine: {
+        getRpId(): string;
+        getWalletIframeSurfaceMeasurementBinding(): UiConfirmSurfaceMeasurementBinding;
+    };
+};
+export type ExternalOwnerApprovalRequest = Readonly<{
+    challenge: ExternalOwnerChallenge;
+    signal: AbortSignal;
+    assertCurrent: () => void;
+}>;
+export type ExternalOwnerApproval = (input: ExternalOwnerApprovalRequest) => Promise<WalletCustodyFactorProof>;
+export declare class ExternalOwnerApprovalError extends Error {
+    readonly code: 'cancelled' | 'expired';
+    constructor(code: 'cancelled' | 'expired');
+}
+export declare function approveExternalOwnerOperation(getContext: () => OwnerApprovalContext, input: ExternalOwnerApprovalRequest): Promise<WalletCustodyFactorProof>;
+export {};
+//# sourceMappingURL=externalOwnerApproval.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/ownerNearOperation.d.ts

@@ -0,0 +1,12 @@
+import { type SigningFlowEvent } from '../../../core/types/sdkSentEvents';
+import type { SeamsWebContext } from '../../signingSurface/types';
+import { type OwnerNearCommand, type OwnerNearOutcome } from '../shared/ownerNearOperation';
+import type { HostedExternalAuth } from './externalAuth';
+type OwnerNearPorts = {
+    readonly getContext: () => SeamsWebContext;
+    readonly captureConnection: HostedExternalAuth['captureOwnerOperation'];
+    readonly parentOrigin: string;
+};
+export declare function runOwnerNearOperation(ports: OwnerNearPorts, command: OwnerNearCommand, assertActive: () => void, onEvent: (event: SigningFlowEvent) => void, onSubmission: () => void): Promise<OwnerNearOutcome>;
+export {};
+//# sourceMappingURL=ownerNearOperation.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/requestRouter.d.ts

@@ -3,8 +3,8 @@ type WalletHostRequest<T extends ParentToChildType> = ParentToChildEnvelope & {
     type: T;
 };
 type BootWalletRequestType = 'PM_ACTIVATE_TRANSACTION_REVIEW' | 'PING' | 'PM_PREPARE_WALLET_RUNTIME' | 'PM_SET_CONFIG' | 'PM_CANCEL' | 'PM_SET_TRANSACTION_VIEW' | 'PM_TRANSACTION_BROADCAST_STARTED';
-type NearWalletRequestType = 'PM_REGISTER_WALLET' | 'PM_ADD_WALLET_SIGNER' | 'PM_ADD_PASSKEY' | 'PM_ACTIVATE_AUTH_METHOD' | 'PM_GET_AUTH_METHOD_AVAILABILITY' | 'PM_SET_AUTH_METHOD_ENABLED' | 'PM_ADD_EMAIL_OTP' | 'PM_REVOKE_AUTH_METHOD' | 'PM_GET_NEAR_PROVISIONING_STATE' | 'PM_SIGN_TX_WITH_ACTIONS' | 'PM_SIGN_AND_SEND_TX' | 'PM_SEND_TRANSACTION' | 'PM_SIGN_DELEGATE_ACTION' | 'PM_SIGN_NEP413';
-type AuthWalletRequestType = 'PM_OPEN_AUTH_MENU' | 'PM_CANCEL_AUTH_MENU' | 'PM_RESOLVE_AUTH_MENU_EXTERNAL_AUTH' | 'PM_UNLOCK' | 'PM_UNLOCK_AUTH_METHOD' | 'PM_EXTERNAL_AUTH' | 'PM_LOCK' | 'PM_LOCK_EXACT_WALLET_SESSION' | 'PM_GET_LAST_WALLET_MOVE_REQUEST' | 'PM_MOVE_WALLET' | 'PM_GET_WALLET_MOVE' | 'PM_GET_WALLET_PLACEMENT' | 'PM_GET_WALLET_SESSION' | 'PM_GET_EXACT_WALLET_SESSION_STATE' | 'PM_GET_RECENT_UNLOCKS';
+type NearWalletRequestType = 'PM_OWNER_NEAR_TRANSACTION' | 'PM_REGISTER_WALLET' | 'PM_ADD_WALLET_SIGNER' | 'PM_ADD_PASSKEY' | 'PM_ACTIVATE_AUTH_METHOD' | 'PM_GET_AUTH_METHOD_AVAILABILITY' | 'PM_SET_AUTH_METHOD_ENABLED' | 'PM_ADD_EMAIL_OTP' | 'PM_REVOKE_AUTH_METHOD' | 'PM_GET_NEAR_PROVISIONING_STATE' | 'PM_SIGN_TX_WITH_ACTIONS' | 'PM_SIGN_AND_SEND_TX' | 'PM_SEND_TRANSACTION' | 'PM_SIGN_DELEGATE_ACTION' | 'PM_SIGN_NEP413';
+type AuthWalletRequestType = 'PM_OPEN_AUTH_MENU' | 'PM_CANCEL_AUTH_MENU' | 'PM_RESOLVE_AUTH_MENU_EXTERNAL_AUTH' | 'PM_RESOLVE_WALLET_CONNECTION' | 'PM_UNLOCK' | 'PM_UNLOCK_AUTH_METHOD' | 'PM_EXTERNAL_AUTH' | 'PM_EXTERNAL_OWNER_AUTH' | 'PM_LOCK' | 'PM_LOCK_EXACT_WALLET_SESSION' | 'PM_GET_LAST_WALLET_MOVE_REQUEST' | 'PM_MOVE_WALLET' | 'PM_GET_WALLET_MOVE' | 'PM_GET_WALLET_PLACEMENT' | 'PM_GET_WALLET_SESSION' | 'PM_GET_EXACT_WALLET_SESSION_STATE' | 'PM_GET_RECENT_UNLOCKS';
 type EcdsaWalletRequestType = 'PM_SIGN_TEMPO' | 'PM_REPORT_TEMPO_BROADCAST_ACCEPTED' | 'PM_REPORT_TEMPO_BROADCAST_REJECTED' | 'PM_REPORT_TEMPO_FINALIZED' | 'PM_REPORT_TEMPO_DROPPED_OR_REPLACED' | 'PM_RECONCILE_TEMPO_NONCE_LANE';
 type EmailOtpWalletRequestType = 'PM_REDEEM_HOSTED_WALLET_SEAMS_SESSION' | 'PM_REQUEST_EMAIL_OTP_CHALLENGE' | 'PM_BEGIN_GOOGLE_EMAIL_OTP_WALLET_AUTH' | 'PM_GOOGLE_EMAIL_OTP_WALLET_AUTH_RESEND' | 'PM_GOOGLE_EMAIL_OTP_WALLET_AUTH_REROLL_WALLET_ID' | 'PM_GOOGLE_EMAIL_OTP_WALLET_AUTH_SUBMIT' | 'PM_GOOGLE_EMAIL_OTP_WALLET_AUTH_COMPLETE_REGISTRATION' | 'PM_GOOGLE_EMAIL_OTP_WALLET_AUTH_CANCEL' | 'PM_GET_WALLET_RECOVERY_CODE_STATUS' | 'PM_ACKNOWLEDGE_WALLET_RECOVERY_CODE_BACKUP' | 'PM_ROTATE_WALLET_RECOVERY_CODES' | 'PM_REQUEST_WALLET_CUSTODY_EMAIL_OTP_CHALLENGE';
 type RecoveryWalletRequestType = 'PM_SYNC_ACCOUNT_FLOW';

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/ui/auth-menu/AuthMenuSurface.d.ts

@@ -1,9 +1,13 @@
+/** @jsxImportSource preact */
+import type { WalletAlternatives, WalletConnectionState } from '../../../shared/walletAlternatives';
 import type { WalletLocale } from '../../../../../core/ui/locale';
 import { type RecoveryCodeSelection } from './recovery-code-input';
 import { Component, type ComponentChildren } from 'preact';
 import type { CspStylesheetManager } from '../../../../../core/browser/walletIframe/csp-stylesheet';
 import { type AuthMenuIntent, type AuthMenuViewModel } from '../../auth-menu/domain';
 type AuthMenuSurfaceProps = {
+    readonly walletAlternatives: WalletAlternatives;
+    readonly walletConnection: WalletConnectionState;
     readonly viewModel: AuthMenuViewModel;
     readonly element: HTMLElement;
     readonly onIntent: (intent: AuthMenuIntent) => void;
@@ -54,6 +58,7 @@ export declare class AuthMenuSurface extends Component<AuthMenuSurfaceProps, Aut
     private restoreFocus;
     private onKeydown;
     private focusableElements;
+    private onDismiss;
     private onBackClick;
     /**
      * Escape backs out of the in-progress views the back arrow already serves.

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/ui/auth-menu/WalletAlternativesSection.d.ts

@@ -0,0 +1,13 @@
+/** @jsxImportSource preact */
+import { Component, type ComponentChildren } from 'preact';
+import type { WalletAlternatives } from '../../../shared/walletAlternatives';
+import type { AuthMenuIntent } from '../../auth-menu/domain';
+export declare class WalletAlternativesSection extends Component<{
+    alternatives: WalletAlternatives;
+    onIntent: (intent: AuthMenuIntent) => void;
+}> {
+    private connect;
+    private renderWalletRows;
+    render(): ComponentChildren;
+}
+//# sourceMappingURL=WalletAlternativesSection.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/ui/auth-menu/mountAuthMenuSurface.d.ts

@@ -1,13 +1,16 @@
+import { type WalletAlternatives, type WalletConnectionState } from '../../../shared/walletAlternatives';
 import type { AuthMenuIntent, AuthMenuViewModel } from '../../auth-menu/domain';
 export type AuthMenuSurfaceHandle = {
     readonly element: HTMLElement;
     update(viewModel: AuthMenuViewModel): void;
+    updateWalletConnection(state: WalletConnectionState): void;
     dispose(): void;
 };
 type MountAuthMenuSurfaceInput = {
     readonly parent: HTMLElement;
     readonly viewModel: AuthMenuViewModel;
     readonly initialHeightCssPx?: number;
+    readonly walletAlternatives?: WalletAlternatives;
     readonly onIntent: (intent: AuthMenuIntent) => void;
 };
 export declare function mountAuthMenuSurface(input: MountAuthMenuSurfaceInput): AuthMenuSurfaceHandle;

package/dist/types/wallet/src/SeamsWeb/walletIframe/shared/exactSessionState.d.ts

@@ -25,6 +25,14 @@ export type WalletIframeExactSessionIdentityInput = {
 type WalletIframeSessionUnavailableReason = 'exhausted' | 'absent' | 'not_found' | 'unavailable' | 'upgrade_required' | 'superseded' | 'invalid';
 export type WalletIframeExactSessionState = {
     readonly kind: 'wallet_locked';
+} | {
+    readonly kind: 'external_read';
+    readonly walletId: WalletId;
+    readonly externalSessionId: string;
+    readonly expiresAtMs: number;
+    readonly walletSessionId?: never;
+    readonly authorizationId?: never;
+    readonly authMethod?: never;
 } | {
     readonly kind: 'wallet_authenticated_identity_unresolvable';
     readonly walletId: WalletId;