@seams/wallet 0.6.2 → 0.7.1

package/dist/types/wallet/src/SeamsWeb/operations/devices/linkDeviceFlowSupport.d.ts

@@ -0,0 +1,53 @@
+import type { DeviceLinkingWebContext } from '../../signingSurface/types';
+import type { StartDevice2LinkingFlowArgs } from '../../../core/types/linkDevice';
+import { DeviceLinkingError } from '../../../core/types/linkDevice';
+import type { LinkedDeviceTargetCredentialRegistrationResultV1, LinkSessionStateV1, ActiveWalletSessionV1, QrLinkedDeviceSessionPayloadV5 } from '../../../../../shared-ts/src/device-linking';
+import { LinkDeviceEventPhase } from '../../../core/types/sdkSentEvents';
+import type { CreateLinkDeviceFlowEventInput } from '../../../core/types/sdkSentEvents';
+import type { WalletAuthenticationState } from '../../../core/types/seams';
+export type EmitLinkDeviceEventInput = Omit<CreateLinkDeviceFlowEventInput, 'flowId' | 'accountId'> & {
+    readonly accountId?: string;
+};
+export type GetLinkedDeviceAuthenticationContext = () => DeviceLinkingWebContext;
+export declare function linkedDeviceWalletAuthenticationState(walletSession: ActiveWalletSessionV1, registration: LinkedDeviceTargetCredentialRegistrationResultV1): Extract<WalletAuthenticationState, {
+    readonly kind: 'authenticated';
+}>;
+export declare function createLinkSessionId(): import('../../../../../shared-ts/src/signing-lanes/ids').LinkDeviceSessionId;
+export declare function createFlowId(): string;
+export declare function notifyError(callback: ((error: Error) => void) | undefined, error: Error): void;
+export declare function logDevice2LinkingStageV1(input: {
+    readonly flowId: string;
+    readonly linkSessionId: string;
+    readonly stage: string;
+    readonly details?: Readonly<Record<string, unknown>>;
+}): void;
+export declare function logDevice2LinkingFailureV1(input: {
+    readonly flowId: string;
+    readonly linkSessionId: string;
+    readonly state: LinkSessionStateV1['state'];
+    readonly error: unknown;
+}): void;
+export declare function waitForSessionStateRetry(attempt: number): Promise<void>;
+export declare function phaseForState(state: LinkSessionStateV1): LinkDeviceEventPhase;
+export declare function errorForFailure(error: unknown, phase: DeviceLinkingError['phase']): DeviceLinkingError;
+export type LinkedDeviceDeliveryRecoveryReasonV1 = 'recipient_private_handle_lost' | 'sealed_delivery_expired';
+/**
+ * These failures happen after the server has committed the linked authority.
+ * The original delivery is intentionally abandoned; exact-method unlock uses
+ * the durable local installation to obtain a successor Wallet Session.
+ */
+export declare function classifyLinkedDeviceDeliveryFailureV1(error: unknown): LinkedDeviceDeliveryRecoveryReasonV1 | null;
+export declare function linkedDeviceDeliveryRecoveryMessageV1(reason: LinkedDeviceDeliveryRecoveryReasonV1): string;
+export declare class LinkDeviceFlowSupersededError extends Error {
+    constructor();
+}
+export declare function generateQrCodeDataUrlV1(payload: string): Promise<string>;
+export declare function buildDevice2QrSessionPayloadV1(input: {
+    readonly linkSessionId: import('../../../../../shared-ts/src/signing-lanes/ids').LinkDeviceSessionId;
+    readonly linkPublicKeyB64u: import('../../../../../shared-ts/src/device-linking').LinkDevicePublicKeyB64u;
+    readonly devicePublicKeyB64u: import('../../../../../shared-ts/src/device-linking').LinkDevicePublicKeyB64u;
+    readonly target: StartDevice2LinkingFlowArgs;
+    readonly issuedAtMs: number;
+    readonly expiresAtMs: number;
+}): QrLinkedDeviceSessionPayloadV5;
+//# sourceMappingURL=linkDeviceFlowSupport.d.ts.map

package/dist/types/wallet/src/SeamsWeb/operations/devices/linkDeviceTargetActivation.d.ts

@@ -0,0 +1,149 @@
+import type { DeviceLinkingWebContext } from '../../signingSurface/types';
+import type { LinkedDeviceTargetCredentialRegistrationResultV1, LinkSessionStateV1, LinkSessionTransportEventV1, LinkedDeviceTargetPreparationV1, LinkedDevicePasskeyCreationOptionsV1, LinkedDeviceEmailOtpChallengeResultV1, ActiveWalletSessionV1, OrdinarySignerMaterialRecipientRequestV1 } from '../../../../../shared-ts/src/device-linking';
+import type { WalletEmailOtpEnrollmentMaterialV1 } from '../../../../../shared-ts/src/utils/registrationAuthMethodInput';
+import type { DeviceLinkingEd25519ExportRootRecipientHandleV1 } from './deviceLinkingEd25519ExportRoot';
+import type { WebAuthnRpId } from '../../../../../shared-ts/src/utils/domainIds';
+import { type PasskeyEnvelopeId } from '../../../../../shared-ts/src/utils/domainIds';
+export type AwaitingTargetFactorStateV1 = Extract<LinkSessionStateV1, {
+    readonly state: 'awaiting_target_factor';
+}>;
+export type AwaitingTargetPasskeyStateV1 = Extract<AwaitingTargetFactorStateV1, {
+    readonly state: 'awaiting_target_factor';
+}>;
+export type AwaitingTargetEmailOtpStateV1 = Extract<AwaitingTargetFactorStateV1, {
+    readonly state: 'awaiting_target_factor';
+}>;
+export type PasskeyTargetPreparationV1 = Extract<LinkedDeviceTargetPreparationV1, {
+    readonly targetFactor: {
+        readonly kind: 'passkey_prf';
+    };
+    readonly passkeyCreationOptions: LinkedDevicePasskeyCreationOptionsV1;
+}>;
+type EmailOtpTargetPreparationV1 = Extract<LinkedDeviceTargetPreparationV1, {
+    readonly targetFactor: {
+        readonly kind: 'email_otp';
+    };
+}>;
+export declare function isPasskeyTargetPreparation(preparation: LinkedDeviceTargetPreparationV1): preparation is PasskeyTargetPreparationV1;
+export declare function isEmailOtpTargetPreparation(preparation: LinkedDeviceTargetPreparationV1): preparation is EmailOtpTargetPreparationV1;
+export type TargetCredentialActivationState = {
+    readonly kind: 'idle';
+} | {
+    readonly kind: 'in_progress';
+    readonly runEpoch: number;
+    readonly promise: Promise<void>;
+} | {
+    readonly kind: 'factor_ready';
+    readonly runEpoch: number;
+    readonly factorSecret: Uint8Array;
+};
+export type EmailOtpTargetActivationBaseContextV1 = {
+    readonly event: LinkSessionTransportEventV1;
+    readonly state: AwaitingTargetEmailOtpStateV1;
+    readonly runEpoch: number;
+    readonly deviceId: import('../../../../../shared-ts/src/signing-lanes/ids').LinkedDeviceId;
+    readonly preparation: EmailOtpTargetPreparationV1;
+    readonly ordinarySignerMaterialRecipientRequests: readonly [
+        OrdinarySignerMaterialRecipientRequestV1,
+        ...OrdinarySignerMaterialRecipientRequestV1[]
+    ];
+    readonly exportRoot: {
+        readonly kind: 'required';
+        readonly recipient: DeviceLinkingEd25519ExportRootRecipientHandleV1;
+    } | {
+        readonly kind: 'not_required';
+        readonly recipient?: never;
+    };
+};
+export type EmailOtpTargetActivationContextV1 = EmailOtpTargetActivationBaseContextV1 & {
+    readonly challenge: LinkedDeviceEmailOtpChallengeResultV1;
+};
+export declare function emailOtpTargetActivationBaseContextV1(context: EmailOtpTargetActivationBaseContextV1): EmailOtpTargetActivationBaseContextV1;
+export type EmailOtpTargetActivationStateV1 = {
+    readonly kind: 'idle';
+} | {
+    readonly kind: 'available';
+    readonly context: EmailOtpTargetActivationBaseContextV1;
+} | {
+    readonly kind: 'starting';
+    readonly context: EmailOtpTargetActivationBaseContextV1;
+    readonly promise: Promise<void>;
+} | {
+    readonly kind: 'awaiting_code';
+    readonly context: EmailOtpTargetActivationContextV1;
+} | {
+    readonly kind: 'resending';
+    readonly context: EmailOtpTargetActivationContextV1;
+    readonly promise: Promise<void>;
+} | {
+    readonly kind: 'submitting';
+    readonly context: EmailOtpTargetActivationContextV1;
+    readonly promise: Promise<void>;
+} | {
+    readonly kind: 'failed';
+    readonly runEpoch: number;
+    readonly message: string;
+} | {
+    readonly kind: 'completed';
+    readonly runEpoch: number;
+    readonly enrollment: {
+        readonly kind: 'existing_enrollment';
+    } | {
+        readonly kind: 'new_enrollment';
+    };
+    readonly factorSecret: Uint8Array;
+    readonly providerUserId: string;
+    readonly exportRootRequirement?: never;
+    readonly verificationGrant?: never;
+    readonly factorRelease?: never;
+};
+type CompletedEmailOtpTargetActivationStateV1 = Extract<EmailOtpTargetActivationStateV1, {
+    readonly kind: 'completed';
+}>;
+export declare function requireCompletedEmailOtpTargetActivationStateV1(state: EmailOtpTargetActivationStateV1): CompletedEmailOtpTargetActivationStateV1;
+export declare function assertNeverEmailOtpTargetActivationState(value: never): never;
+export declare function assertNeverTargetCredentialActivationState(value: never): never;
+type PostLinkActivationV1 = {
+    readonly factor: {
+        readonly kind: 'passkey';
+        readonly walletId: ActiveWalletSessionV1['walletId'];
+    };
+    readonly factorSecret32: Uint8Array;
+} | {
+    readonly factor: {
+        readonly kind: 'email_otp';
+        readonly walletId: ActiveWalletSessionV1['walletId'];
+        readonly walletAuthMethodId: LinkedDeviceTargetCredentialRegistrationResultV1['walletAuthMethodId'];
+        readonly emailHashHex: string;
+        readonly providerIdentity: {
+            readonly provider: 'google' | 'email';
+            readonly providerSubjectId: string;
+        };
+    };
+    readonly factorSecret32: Uint8Array;
+};
+export declare function resolvePostLinkActivationV1(input: {
+    readonly targetFactor: LinkedDeviceTargetCredentialRegistrationResultV1['targetFactor'];
+    readonly walletAuthMethodId: LinkedDeviceTargetCredentialRegistrationResultV1['walletAuthMethodId'];
+    readonly targetCredentialActivationState: TargetCredentialActivationState;
+    readonly emailOtpTargetActivationState: EmailOtpTargetActivationStateV1;
+    readonly walletId: ActiveWalletSessionV1['walletId'];
+    readonly runEpoch: number;
+}): PostLinkActivationV1;
+export declare function zeroizeLiveBytes(value: Uint8Array): void;
+export declare function requireTargetRpIdV1(preparation: PasskeyTargetPreparationV1): WebAuthnRpId;
+export declare function requireEmailOtpTargetPreparationV1(preparation: LinkedDeviceTargetPreparationV1): EmailOtpTargetPreparationV1;
+export declare function createExportRootEnvelopeIdV1(): PasskeyEnvelopeId;
+export declare function createEmailOtpFactorSecretV1(): Uint8Array;
+export declare function prepareNewEmailOtpEnrollmentMaterialV1(input: {
+    readonly context: DeviceLinkingWebContext;
+    readonly walletId: EmailOtpTargetPreparationV1['walletId'];
+    readonly targetEmail: EmailOtpTargetPreparationV1['targetEmail'];
+    readonly factorSecret: Uint8Array;
+}): Promise<{
+    readonly enrollmentId: string;
+    readonly enrollment: WalletEmailOtpEnrollmentMaterialV1;
+}>;
+export declare function requireNewEmailOtpEnrollmentMaterialV1(value: WalletEmailOtpEnrollmentMaterialV1 | null): WalletEmailOtpEnrollmentMaterialV1;
+export {};
+//# sourceMappingURL=linkDeviceTargetActivation.d.ts.map

package/dist/types/wallet/src/SeamsWeb/operations/devices/scanDevice.d.ts

@@ -7,8 +7,9 @@ export type Device1OwnerLinkCancellationV1 = {
     readonly expectedRevision: number;
     readonly authentication: LinkSessionAuthenticationV1;
 };
-export type RegisterDevice1OwnerLinkCancellationV1 = (cancellation: Device1OwnerLinkCancellationV1 | null) => void;
+type RegisterDevice1OwnerLinkCancellationV1 = (cancellation: Device1OwnerLinkCancellationV1 | null) => void;
 /** Strictly parse the only QR payload accepted by this browser. */
 export declare function validateQrLinkedDeviceSessionPayloadV5(raw: unknown): QrLinkedDeviceSessionPayloadV5;
 export declare function scanAndLinkDevice(_context: unknown, qrData: QrLinkedDeviceSessionPayloadV5, options: ScanAndLinkDeviceOptionsDevice1, ports: Device1LinkingFlowPortsV1, registerCancellation?: RegisterDevice1OwnerLinkCancellationV1): Promise<LinkDeviceResult>;
+export {};
 //# sourceMappingURL=scanDevice.d.ts.map

package/dist/types/wallet/src/SeamsWeb/operations/devices/walletHostComposition.d.ts

@@ -6,19 +6,13 @@ import type { DeviceLinkingFlowPortsAssemblyV1 } from './deviceLinkingCompositio
 import type { LinkSessionOwnerApprovalUpdatesPortV1, LinkSessionOwnerAuthenticatedRequestPortV1 } from './deviceLinkingOwnerTransport';
 import type { DeviceLinkingOwnerAuthorizationPortV1, DeviceLinkingSourceContributionPortV1 } from './deviceLinkingPorts';
 import type { LinkedDeviceManagementPortV1 } from '../../publicApi/devices';
-import type { WalletHostManagementRequestV1 } from './walletHostOwnerAuthority';
-export declare const LINKED_DEVICE_MANAGEMENT_HTTP_BASE_PATH_V1: "/wallet/device-linking/v1/devices";
-export declare const OWNER_WALLET_SESSION_REAUTH_REQUIRED: "owner_wallet_session_reauth_required";
-export declare class OwnerWalletSessionReauthRequiredError extends Error {
-    readonly code: "owner_wallet_session_reauth_required";
-    constructor();
-}
+import { type WalletHostManagementRequestV1 } from './walletHostOwnerAuthority';
 /**
  * The owner request closures are created by the wallet-host signing surface.
  * They retain the active Wallet Session credential and expose only parsed HTTP
  * boundaries to this assembly layer.
  */
-export type WalletHostCompositionDependenciesV1 = {
+type WalletHostCompositionDependenciesV1 = {
     readonly authenticator: AuthenticatorPort;
     readonly http: HttpTransport;
     readonly relayerUrl: string;
@@ -36,10 +30,11 @@ export type WalletHostCompositionDependenciesV1 = {
     readonly nowMs: () => number;
     readonly pollIntervalMs: number;
 };
-export type WalletHostCompositionV1 = {
+type WalletHostCompositionV1 = {
     readonly linkedDeviceManagement: LinkedDeviceManagementPortV1;
     readonly deviceLinkingPorts: DeviceLinkingFlowPortsAssemblyV1;
     readonly dispose: () => void;
 };
 export declare function createWalletHostCompositionV1(args: WalletHostCompositionDependenciesV1): WalletHostCompositionV1;
+export {};
 //# sourceMappingURL=walletHostComposition.d.ts.map

package/dist/types/wallet/src/SeamsWeb/operations/devices/walletHostOwnerAuthority.d.ts

@@ -1,11 +1,16 @@
 import type { HttpTransport } from '../../../core/platform/http';
-import type { UnlockedWalletEd25519ExportRootCapabilityV1 } from '../../../core/signingEngine/workerManager/workerTypes';
+import type { UnlockedEd25519ExportRootLinkingCapabilityV1 } from '../../../core/signingEngine/workerManager/workerTypes';
 import { type WalletSessionAuthorizationRepository } from '../../../core/indexedDB/seamsWalletDB/walletSessionAuthorizationStore';
 import type { ResolveSelectedWalletAuthorityResultV1 } from '../../../core/indexedDB/seamsWalletDB/repositories';
 import type { WalletAuthenticationState } from '../../../core/types/seams';
 import type { DeviceLinkingOwnerAuthorizationPortV1 } from './deviceLinkingPorts';
 import type { LinkSessionOwnerAuthenticatedRequestPortV1 } from './deviceLinkingOwnerTransport';
 import { type WalletId } from '../../../../../shared-ts/src/utils/domainIds';
+/** An owner request that received no answer: the network failed, or it timed out. */
+export declare class WalletHostOwnerRequestTransportError extends Error {
+    readonly code: 'network_error' | 'timeout';
+    constructor(code: 'network_error' | 'timeout', message: string);
+}
 export type WalletHostManagementRequestV1 = {
     request(input: {
         readonly walletId: WalletId;
@@ -29,10 +34,9 @@ export declare function createWalletHostOwnerAuthoritiesV1(input: {
     readonly resolveSelectedWalletAuthority: (walletId: WalletId) => Promise<ResolveSelectedWalletAuthorityResultV1>;
     readonly readWalletAuthenticationState: () => WalletAuthenticationState;
     /**
-     * R103 zero-prompt handoff: reads the worker-held unlocked Ed25519 export-root
-     * capability for a wallet, or undefined when none exists. Reading never
-     * prompts.
+     * Reads the worker-held unlocked Ed25519 export-root capability for a wallet,
+     * or undefined when none exists. Reading never prompts.
      */
-    readonly readUnlockedEd25519ExportRootCapabilityV1: (walletId: WalletId) => UnlockedWalletEd25519ExportRootCapabilityV1 | undefined;
+    readonly readUnlockedEd25519ExportRootCapabilityV1: (walletId: WalletId) => UnlockedEd25519ExportRootLinkingCapabilityV1 | undefined;
 }): WalletHostOwnerAuthoritiesV1;
 //# sourceMappingURL=walletHostOwnerAuthority.d.ts.map

package/dist/types/wallet/src/SeamsWeb/operations/near/actions.d.ts

@@ -1,7 +1,6 @@
 import type { ActionHooksOptions, SendTransactionHooksOptions, SignAndSendTransactionHooksOptions, SignTransactionHooksOptions } from '../../../core/types/sdkSentEvents';
 import type { ActionResult, SignTransactionResult } from '../../../core/types/seams';
 import type { ActionArgs, TransactionInput } from '../../../core/types/actions';
-import { type ConfirmationConfig } from '../../../core/types/signer-worker';
 import type { NearSigningWebContext } from '../../signingSurface/types';
 import type { SignedTransaction } from '../../../core/rpcClients/near/NearClient';
 import type { AccountId } from '../../../core/types/accountIds';
@@ -97,49 +96,4 @@ export declare function sendTransaction({ context, nearAccountId, walletSession,
     signedTransaction: SignedTransaction;
     options?: SendTransactionHooksOptions;
 }): Promise<ActionResult>;
-/**
- * Internal API for executing actions with optional confirmation override
- * @internal - Only used by internal SDK components like SecureTxConfirmButton
- *
- * @param context - SeamsWeb context
- * @param nearAccountId - NEAR account ID to sign transactions with
- * @param actionArgs - Action arguments to sign transactions with
- * @param options - Options for the action
- * @returns Promise resolving to the action result
- */
-export declare function executeActionInternal({ context, nearAccountId, walletSession, receiverId, actionArgs, options, confirmationConfigOverride, }: {
-    context: NearSigningWebContext;
-    nearAccountId: AccountId;
-    walletSession: WalletSessionRef;
-    receiverId: AccountId;
-    actionArgs: ActionArgs | ActionArgs[];
-    options?: ActionHooksOptions;
-    confirmationConfigOverride?: Partial<ConfirmationConfig> | undefined;
-}): Promise<ActionResult>;
-export declare function signAndSendTransactionInternal({ context, nearAccountId, walletSession, transactionInput, options, confirmationConfigOverride, }: {
-    context: NearSigningWebContext;
-    nearAccountId: AccountId;
-    walletSession: WalletSessionRef;
-    transactionInput: TransactionInput;
-    options?: SignAndSendTransactionHooksOptions;
-    confirmationConfigOverride?: Partial<ConfirmationConfig> | undefined;
-}): Promise<ActionResult>;
-/**
- * Internal API for signing transactions with actions
- * @internal - Only used by internal SDK components with confirmationConfigOverride
- *
- * @param context - SeamsWeb context
- * @param nearAccountId - NEAR account ID to sign transactions with
- * @param actionArgs - Action arguments to sign transactions with
- * @param options - Options for the action
- * @returns Promise resolving to the action result
- */
-export declare function signTransactionWithActionsInternal({ context, nearAccountId, walletSession, transactionInput, options, confirmationConfigOverride, }: {
-    context: NearSigningWebContext;
-    nearAccountId: AccountId;
-    walletSession: WalletSessionRef;
-    transactionInput: TransactionInput;
-    options?: Omit<ActionHooksOptions, 'afterCall'>;
-    confirmationConfigOverride?: Partial<ConfirmationConfig> | undefined;
-}): Promise<SignTransactionResult>;
 //# sourceMappingURL=actions.d.ts.map

package/dist/types/wallet/src/SeamsWeb/operations/near/delegateAction.d.ts

@@ -5,7 +5,7 @@ import type { DelegateRouterApiResult, SignDelegateActionResult } from '../../..
 import type { AccountId } from '../../../core/types/accountIds';
 import type { WasmSignedDelegate } from '../../../core/types/signer-worker';
 import type { WalletSessionRef } from '../../../core/signingEngine/interfaces/ecdsaChainTarget';
-export interface RouterApiDelegateRequest {
+interface RouterApiDelegateRequest {
     hash: string;
     signedDelegate: SignedDelegate | WasmSignedDelegate;
 }
@@ -39,4 +39,5 @@ export declare function sendDelegateActionViaRelayer(args: {
     signal?: AbortSignal;
     options?: DelegateRelayHooksOptions;
 }): Promise<DelegateRouterApiResult>;
+export {};
 //# sourceMappingURL=delegateAction.d.ts.map

package/dist/types/wallet/src/SeamsWeb/operations/near/signingEventHelpers.d.ts

@@ -1,5 +1,6 @@
 import type { AccountId } from '../../../core/types/accountIds';
 import { type CreateSigningFlowEventInput, type SigningFlowEvent } from '../../../core/types/sdkSentEvents';
-export type NearSigningEventInput = Omit<CreateSigningFlowEventInput, 'flowId' | 'accountId'>;
+type NearSigningEventInput = Omit<CreateSigningFlowEventInput, 'flowId' | 'accountId'>;
 export declare function emitNearSigningEvent(onEvent: ((event: SigningFlowEvent) => void) | undefined, accountId: AccountId | string, event: NearSigningEventInput): void;
+export {};
 //# sourceMappingURL=signingEventHelpers.d.ts.map

package/dist/types/wallet/src/SeamsWeb/operations/recovery/accountSync.d.ts

@@ -2,7 +2,7 @@ import type { SyncAccountHooksOptions } from '../../../core/types/sdkSentEvents'
 import { type SyncAccountResult } from './syncAccount';
 import type { AccountSyncWebContext } from '../../signingSurface/types';
 import type { WalletIframeCoordinator } from '../../walletIframe/coordinator';
-export type AccountSyncDomainDeps = {
+type AccountSyncDomainDeps = {
     getContext: () => AccountSyncWebContext;
     walletIframe: Pick<WalletIframeCoordinator, 'shouldUseWalletIframe' | 'requireRouter'>;
 };
@@ -15,4 +15,5 @@ export declare class AccountSyncDomain {
         options?: SyncAccountHooksOptions;
     }): Promise<SyncAccountResult>;
 }
+export {};
 //# sourceMappingURL=accountSync.d.ts.map

package/dist/types/wallet/src/SeamsWeb/operations/recovery/recoveryWalletBinding.d.ts

@@ -1,6 +1,6 @@
 import type { AccountId } from '../../../core/types/accountIds';
 import { type WalletId, type WebAuthnCredentialIdB64u } from '../../../../../shared-ts/src/utils/domainIds';
-import { type NearEd25519SigningKeyId } from '../../../../../shared-ts/src/utils/registrationIntent';
+import { type NearEd25519SigningKeyId } from '../../../../../shared-ts/src/utils/registrationIds';
 export type RecoveryResolvedWalletBinding = {
     walletId: WalletId;
     nearAccountId: AccountId;
@@ -9,7 +9,6 @@ export type RecoveryResolvedWalletBinding = {
     credentialIdB64u: WebAuthnCredentialIdB64u;
     signerSlot: number;
 };
-export declare function parseRecoveryResolvedWalletBinding(raw: unknown, context: string): RecoveryResolvedWalletBinding;
 export declare function parseRecoveryResolvedWalletBindingFromResponse(raw: Record<string, unknown>, context: string): RecoveryResolvedWalletBinding;
 export declare function assertSameRecoveryWalletIdentity(left: RecoveryResolvedWalletBinding, right: RecoveryResolvedWalletBinding, context: string): void;
 //# sourceMappingURL=recoveryWalletBinding.d.ts.map

package/dist/types/wallet/src/SeamsWeb/operations/recovery/syncAccount.d.ts

@@ -1,13 +1,8 @@
 import { type SyncAccountHooksOptions } from '../../../core/types/sdkSentEvents';
 import type { SyncAccountResult } from '../../../core/types/sdkPublicResults';
-import type { AccountSyncSigningSurface, AccountSyncWebContext } from '../../signingSurface/types';
+import type { AccountSyncWebContext } from '../../signingSurface/types';
 import type { WebAuthnAuthenticationCredential } from '../../../core/types';
-import { type PasskeyEd25519YaoRecoveryResultV1, type ParsedPasskeyEd25519YaoSyncResponseV1 } from '../../../core/signingEngine/flows/recovery/passkeyEd25519YaoRecovery';
-import { type WalletAuthMethodId, type WalletId, type WebAuthnCredentialIdB64u } from '../../../../../shared-ts/src/utils/domainIds';
 import { type RecoveryResolvedWalletBinding } from './recoveryWalletBinding';
-import { type RouterAbEcdsaDerivationPublicCapabilityV1, type RouterAbEcdsaCredentialFreeSessionActivationResponseV1, type RouterAbEcdsaRegistrationActivationReceiptV1 } from '../../../../../shared-ts/src/utils/routerAbEcdsaDerivation';
-import { normalizeRuntimePolicyScope } from '../../../../../shared-ts/src/threshold/signingRootScope';
-import type { ThresholdEcdsaChainTarget } from '../../../core/platform/types';
 export type { SyncAccountResult };
 type SyncOptionsV1 = {
     readonly challengeId: string;
@@ -21,78 +16,7 @@ export type PreparedSyncAccountChallenge = Readonly<{
     readonly rpId: string;
     readonly syncOptions: SyncOptionsV1;
 }>;
-export type PasskeyEd25519YaoUnlockRecoveryV1 = {
-    readonly kind: 'recovered';
-    readonly recovery: PasskeyEd25519YaoRecoveryResultV1;
-    readonly credential: WebAuthnAuthenticationCredential;
-    readonly verifiedBinding: RecoveryResolvedWalletBinding;
-    readonly ecdsaContinuity: ParsedWalletCustodyEcdsaContinuityV1;
-} | {
-    readonly kind: 'already_committed';
-    readonly walletId: WalletId;
-    readonly walletAuthMethodId: WalletAuthMethodId;
-    readonly credentialIdB64u: WebAuthnCredentialIdB64u;
-};
-type ParsedWalletCustodyEcdsaSignerV1 = {
-    readonly chainTarget: ThresholdEcdsaChainTarget;
-    readonly walletKey: {
-        readonly walletId: string;
-        readonly keyHandle: string;
-        readonly ecdsaThresholdKeyId: string;
-        readonly signingRootId: string;
-        readonly signingRootVersion: string;
-        readonly relayerKeyId: string;
-        readonly contextBinding32B64u: string;
-        readonly derivationClientSharePublicKey33B64u: string;
-        readonly participantIds: readonly [number, number];
-        readonly publicCapability: RouterAbEcdsaDerivationPublicCapabilityV1;
-    };
-    readonly activationReceipt: RouterAbEcdsaRegistrationActivationReceiptV1;
-    readonly runtimePolicyScope: ReturnType<typeof normalizeRuntimePolicyScope>;
-};
-type ParsedWalletCustodyEcdsaContinuityV1 = {
-    readonly kind: 'wallet_custody_ecdsa_sync_continuity_v1';
-    readonly state: 'absent';
-    readonly signers: readonly [];
-    readonly sessionActivation?: never;
-} | {
-    readonly kind: 'wallet_custody_ecdsa_sync_continuity_v1';
-    readonly state: 'activated';
-    readonly signers: readonly [
-        ParsedWalletCustodyEcdsaSignerV1,
-        ...ParsedWalletCustodyEcdsaSignerV1[]
-    ];
-    readonly sessionActivation: RouterAbEcdsaCredentialFreeSessionActivationResponseV1;
-};
-export type RecoverPasskeyEd25519YaoForUnlockInputV1 = {
-    readonly walletId: string | null;
-    readonly relayerUrl: string;
-    readonly rpId: string;
-    readonly fetch: typeof fetch;
-    readonly expectedCredentialIdB64u: WebAuthnCredentialIdB64u | null;
-    readonly expectedWalletAuthMethodId: WalletAuthMethodId | null;
-    readonly collectCredential: (input: {
-        readonly challengeB64u: string;
-        readonly credentialIds: readonly string[];
-    }) => Promise<WebAuthnAuthenticationCredential>;
-    readonly prepared?: SyncOptionsV1;
-    readonly credential?: WebAuthnAuthenticationCredential;
-    readonly activateCapability: AccountSyncSigningSurface['activateVerifiedNearEd25519YaoMaterial'];
-    readonly withExactEd25519MaterialOwner: AccountSyncSigningSurface['withExactEd25519MaterialOwner'];
-    readonly sessionPersistence: Pick<AccountSyncSigningSurface, 'hydrateSigningSession' | 'upsertEd25519YaoPublicCapabilityLaneReference'>;
-    readonly rejoinWalletCustodyNearEd25519KeySet: AccountSyncSigningSurface['rejoinWalletCustodyNearEd25519KeySet'];
-    readonly rejoinWalletCustodyEvmFamilyKeySet: AccountSyncSigningSurface['rejoinWalletCustodyEvmFamilyKeySet'];
-    readonly restoreWalletCustodyEcdsaContinuity: AccountSyncSigningSurface['restoreWalletCustodyEcdsaContinuity'];
-    readonly loadWalletCustodyEd25519Material: AccountSyncSigningSurface['loadWalletCustodyEd25519Material'];
-    readonly persistWalletCustodyEd25519Material: AccountSyncSigningSurface['persistWalletCustodyEd25519Material'];
-    readonly prepareLocalProfile: (parsed: ParsedPasskeyEd25519YaoSyncResponseV1, credential: WebAuthnAuthenticationCredential) => Promise<void>;
-    readonly onPromptStarted?: () => void;
-    readonly onPromptSucceeded?: () => void;
-    readonly onRelayVerifyStarted?: () => void;
-    readonly onRelayVerifySucceeded?: (binding: RecoveryResolvedWalletBinding) => void;
-};
 export declare function prepareSyncAccountChallenge(context: AccountSyncWebContext, walletId: string | null): Promise<PreparedSyncAccountChallenge>;
-export declare function recoverPasskeyEd25519YaoForUnlockV1(input: RecoverPasskeyEd25519YaoForUnlockInputV1): Promise<PasskeyEd25519YaoUnlockRecoveryV1>;
 export declare function syncAccount(context: AccountSyncWebContext, walletId: string | null, options?: SyncAccountHooksOptions): Promise<SyncAccountResult>;
 export declare function syncAccountWithPreparedCredential(context: AccountSyncWebContext, preparedChallenge: PreparedSyncAccountChallenge, credential: WebAuthnAuthenticationCredential, options?: SyncAccountHooksOptions): Promise<SyncAccountResult>;
 //# sourceMappingURL=syncAccount.d.ts.map

package/dist/types/wallet/src/SeamsWeb/operations/recovery/walletRecovery.d.ts

@@ -18,7 +18,7 @@ export type WalletRecoveryCredentialCreatedHandle = {
         readonly kind: 'passkey';
     }>;
 };
-export type WalletRecoveryGoogleVerifiedHandle = {
+type WalletRecoveryGoogleVerifiedHandle = {
     readonly kind: 'google_verified';
     readonly recoveryOperationId: string;
     readonly walletId: WalletId;
@@ -29,7 +29,7 @@ export type WalletRecoveryGoogleVerifiedHandle = {
     readonly delivery: EmailOtpChallengeDelivery;
     readonly expiresAtMs: number;
 };
-export type WalletRecoveryEmailOtpVerifiedHandle = {
+type WalletRecoveryEmailOtpVerifiedHandle = {
     readonly kind: 'email_otp_verified';
     readonly recoveryOperationId: string;
     readonly walletId: WalletId;
@@ -38,23 +38,23 @@ export type WalletRecoveryEmailOtpVerifiedHandle = {
     }>;
     readonly challengeId: string;
 };
-export type WalletRecoveryCoordinatorRpc = {
+type WalletRecoveryCoordinatorRpc = {
     readonly verifyGoogle: typeof verifyWalletRecoveryGoogle;
     readonly verifyEmailOtp: typeof verifyWalletRecoveryEmailOtp;
     readonly finalizeEmailOtp: typeof finalizeWalletRecoveryGoogleEmailOtp;
 };
-export type WalletRecoveryCoordinatorResult<T> = T | WalletRecoveryAttemptFailure;
-export type WalletRecoveryPrepareCoordinatorResult = WalletRecoveryPreparedHandle | WalletRecoveryAttemptFailure | {
+type WalletRecoveryCoordinatorResult<T> = T | WalletRecoveryAttemptFailure;
+type WalletRecoveryPrepareCoordinatorResult = WalletRecoveryPreparedHandle | WalletRecoveryAttemptFailure | {
     readonly kind: 'consumed';
 };
-export type WalletRecoveryCredentialCreationResult = WalletRecoveryCredentialCreatedHandle | {
+type WalletRecoveryCredentialCreationResult = WalletRecoveryCredentialCreatedHandle | {
     readonly kind: 'dismissed';
 } | {
     readonly kind: 'refused';
 } | {
     readonly kind: 'transport_uncertain';
 };
-export type WalletRecoveryFinalizeCoordinatorResult = {
+type WalletRecoveryFinalizeCoordinatorResult = {
     readonly kind: 'ready_for_sign_in';
     readonly walletId: WalletId;
 } | WalletRecoveryAttemptFailure;
@@ -90,4 +90,5 @@ export declare class WalletRecoveryCoordinator {
     }): Promise<WalletRecoveryFinalizeCoordinatorResult>;
     cancel(recoveryOperationId: string): void;
 }
+export {};
 //# sourceMappingURL=walletRecovery.d.ts.map

package/dist/types/wallet/src/SeamsWeb/operations/recovery/walletRecoveryCodeBackup.d.ts

@@ -5,7 +5,7 @@ import type { RecoveryCodeBackupExperience } from '../../../core/signingEngine/u
 type AccountMenuRecoveryCodeExperience = Extract<RecoveryCodeBackupExperience, {
     readonly kind: 'account_menu';
 }>;
-export type WalletRecoveryCodesUiRequest = Omit<AccountMenuRecoveryCodeExperience, 'kind'>;
+type WalletRecoveryCodesUiRequest = Omit<AccountMenuRecoveryCodeExperience, 'kind'>;
 type RecoveryCodeBackupUiOptions = {
     readonly appearance?: AppearanceConfig;
     readonly shouldCancel?: () => boolean;

package/dist/types/wallet/src/SeamsWeb/operations/recovery/walletRecoveryCommit.d.ts

@@ -2,7 +2,6 @@ import { type WalletRecoveryFinalizeResult } from '../../../core/rpcClients/rela
 import { type WalletRecoveryGoogleEmailOtpFinalizeResult } from '../../../core/rpcClients/relayer/walletRecoveryGoogleEmailOtp';
 import type { WalletRecoveryAttemptFailure } from '../../../core/rpcClients/relayer/walletRecoveryPrepare';
 import { type WalletRecoveryDurableEmailOtpPayload, type WalletRecoveryDurableOperationInput, type WalletRecoveryDurablePasskeyPayload, type WalletRecoveryDurablePayloadV1 } from './walletRecoveryJournal';
-import { type WalletRecoveryCommittedProjectionV1 } from '../../../../../shared-ts/src/wallet-recovery/walletRecoveryCommittedProjection';
 import type { PendingWalletRecoveryCommitV1 } from '../../../core/indexedDB/pendingWalletRecoveryCommit';
 type PasskeyRecoveryPromotion = Extract<WalletRecoveryFinalizeResult, {
     readonly kind: 'promoted';
@@ -19,7 +18,6 @@ export type WalletRecoveryCommitPromotion = {
     readonly payload: WalletRecoveryDurableEmailOtpPayload;
     readonly promotion: EmailOtpRecoveryPromotion;
 };
-export declare function committedProjectionFromPromotion(input: WalletRecoveryCommitPromotion): WalletRecoveryCommittedProjectionV1;
 export declare function restoreAndPublishWalletRecoveryCommit(input: {
     readonly pending: Extract<PendingWalletRecoveryCommitV1, {
         readonly stage: 'server_promoted';

package/dist/types/wallet/src/SeamsWeb/operations/recovery/walletRecoveryRotation.d.ts

@@ -1,7 +1,5 @@
 import type { RegistrationWebContext } from '../../signingSurface/types';
 import { type WalletRecoveryRotationOutcome } from '../../../core/signingEngine/walletCustody/walletRecoveryRotation';
-import { type WalletCustodyFactorProof } from '../../../core/rpcClients/relayer/walletRecoveryRotate';
-import type { WalletCustodyAdminOperation } from '../../../../../shared-ts/src/authorization/walletCustodyOperation';
 export type WalletRecoveryRotationAuthorization = {
     readonly kind: 'existing_passkey';
 } | {
@@ -11,12 +9,6 @@ export type WalletRecoveryRotationAuthorization = {
     readonly challenge_digest: string;
     readonly otpCode: string;
 };
-export declare function buildWalletCustodyPasskeyFactorProof(args: {
-    readonly context: RegistrationWebContext;
-    readonly walletId: string;
-    readonly operation: WalletCustodyAdminOperation;
-    readonly payload: Record<string, unknown>;
-}): Promise<WalletCustodyFactorProof>;
 export declare function rotateWalletRecoveryCodes(args: {
     readonly context: RegistrationWebContext;
     readonly relayUrl: string;

package/dist/types/wallet/src/SeamsWeb/operations/registration/pendingEcdsaRegistrationRecovery.d.ts

@@ -5,7 +5,7 @@ type PendingEcdsaRecoveryCommon = {
     readonly signingSurface: PendingRegistrationRecoverySigningSurface;
     readonly ports: PendingEcdsaRegistrationRecoveryPorts;
 };
-export type ResumePendingEcdsaRegistrationInput = (PendingEcdsaRecoveryCommon & {
+type ResumePendingEcdsaRegistrationInput = (PendingEcdsaRecoveryCommon & {
     readonly exactMethod: Extract<PendingRegistrationExactMethod, {
         readonly kind: 'passkey';
     }>;

package/dist/types/wallet/src/SeamsWeb/operations/registration/pendingEcdsaRegistrationRecoveryValidation.d.ts

@@ -9,13 +9,13 @@ export type PendingEcdsaRegistrationKeyFamilies = readonly ['ecdsa_secp256k1'];
 type PendingEcdsaOnlyLocalMaterial = Extract<PendingWalletRegistrationLocalMaterialV1, {
     readonly keyFamilies: readonly ['ecdsa_secp256k1'];
 }>;
-export type PendingEcdsaOnlyRegistrationCommit = Extract<PendingWalletRegistrationCommitV1, {
+type PendingEcdsaOnlyRegistrationCommit = Extract<PendingWalletRegistrationCommitV1, {
     readonly operation: 'registration_activate';
 }> & {
     readonly signerPlanKind: 'evm_family_ecdsa';
     readonly localMaterial: PendingEcdsaOnlyLocalMaterial;
 };
-export type PendingMixedEcdsaRegistrationCommit = Extract<PendingWalletRegistrationCommitV1, {
+type PendingMixedEcdsaRegistrationCommit = Extract<PendingWalletRegistrationCommitV1, {
     readonly operation: 'registration_activate';
 }> & {
     readonly signerPlanKind: 'near_ed25519_and_evm_family_ecdsa';