@seams/wallet 0.8.0 → 0.9.0

package/dist/types/wallet/src/core/config/configBuilder.d.ts

@@ -1,11 +1,21 @@
-import type { SeamsConfigsInput, SeamsConfigsReadonly, RouterAbEcdsaDerivationPresignaturePoolPolicy } from '../types/seams';
-export type BuildConfigsOptions = {
-    allowDirectWalletMode?: 'wallet_host';
+import type { SeamsConfigsInput, SeamsClientConfig, RouterAbEcdsaDerivationPresignaturePoolPolicy } from '../types/seams';
+export declare const THRESHOLD_ECDSA_PRESIGN_POOL_LIMITS: {
+    targetDepth: {
+        min: number;
+        max: number;
+    };
+    maxRefillInFlight: {
+        min: number;
+        max: number;
+    };
+    refillAttemptTimeoutMs: {
+        min: number;
+        max: number;
+    };
 };
 export declare function buildConfigsFromDefaults(args: {
-    defaults: SeamsConfigsReadonly;
+    defaults: SeamsClientConfig;
     overrides?: SeamsConfigsInput;
     fallbackRouterAbEcdsaDerivationPresignaturePoolPolicy: RouterAbEcdsaDerivationPresignaturePoolPolicy;
-    options?: BuildConfigsOptions;
-}): SeamsConfigsReadonly;
+}): SeamsClientConfig;
 //# sourceMappingURL=configBuilder.d.ts.map

package/dist/types/wallet/src/core/config/defaultConfigs.d.ts

@@ -1,7 +1,6 @@
-import type { SeamsConfigsInput, SeamsConfigsReadonly, RouterAbEcdsaDerivationPresignaturePoolPolicy } from '../types/seams';
-import type { BuildConfigsOptions } from './configBuilder';
+import type { SeamsConfigsInput, SeamsClientConfig, RouterAbEcdsaDerivationPresignaturePoolPolicy } from '../types/seams';
 export { THRESHOLD_ED25519_CLIENT_PARTICIPANT_ID, THRESHOLD_ED25519_RELAYER_PARTICIPANT_ID, THRESHOLD_ED25519_2P_PARTICIPANT_IDS, } from '../../../../shared-ts/src/threshold/participants';
 export declare const DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY: RouterAbEcdsaDerivationPresignaturePoolPolicy;
-export declare const PASSKEY_MANAGER_DEFAULT_CONFIGS: SeamsConfigsReadonly;
-export declare function buildConfigsFromEnv(overrides?: SeamsConfigsInput, options?: BuildConfigsOptions): SeamsConfigsReadonly;
+export declare const PASSKEY_MANAGER_DEFAULT_CONFIGS: SeamsClientConfig;
+export declare function buildConfigsFromEnv(overrides?: SeamsConfigsInput): SeamsClientConfig;
 //# sourceMappingURL=defaultConfigs.d.ts.map

package/dist/types/wallet/src/core/config/defineConfig.d.ts

@@ -1,11 +1,8 @@
 import type { SeamsChainConfigInput, SeamsConfigsInput } from '../types/seams';
 /**
- * The four values a browser wallet cannot start without.
- *
- * Every field of `SeamsConfigsInput` is optional, because the wallet-host
- * runtime builds partial configs — which means `{} satisfies SeamsConfigsInput`
- * compiles and then throws at runtime. `defineSeamsConfig` is the application's
- * entry point, so it makes the real contract compile-time enforced.
+ * Required application values for managed wallet registration.
+ * The lower-level input permits omitted registration credentials for signing-only
+ * applications. This helper makes the standard registration setup explicit.
  */
 export type SeamsRequiredConfigInput = {
     /** Origin serving the wallet iframe, e.g. `https://wallet.example.com`. */

package/dist/types/wallet/src/core/config/presignatures.d.ts

@@ -0,0 +1,3 @@
+export declare const ECDSA_CLIENT_PRESIGNATURE_CAPACITY: 5;
+export declare const MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS: number;
+//# sourceMappingURL=presignatures.d.ts.map

package/dist/types/wallet/src/core/diagnostics/registration.d.ts

@@ -0,0 +1,2 @@
+export declare function isRegistrationBenchmarkDiagnosticsEnabled(): boolean;
+//# sourceMappingURL=registration.d.ts.map

package/dist/types/wallet/src/core/indexedDB/normalization.d.ts

@@ -4,4 +4,9 @@ export declare function normalizeIndexedDbChainIdKey(chainIdKey: unknown): strin
 export declare function normalizeIndexedDbAccountAddress(address: unknown): string;
 export declare function normalizeIndexedDbAccountModel<T extends string = string>(model: unknown): T;
 export declare function toIndexedDbChainTargetKey(chainTarget: ThresholdEcdsaChainTarget): string;
+export declare function parseStoredNonEmptyString(value: unknown): string | null;
+export declare function signerChainTargetKey(args: {
+    chainIdKey: string;
+    accountAddress: string;
+}): string;
 //# sourceMappingURL=normalization.d.ts.map

package/dist/types/wallet/src/core/indexedDB/passkeyClientDB.types.d.ts

@@ -18,8 +18,8 @@ export interface PasskeyCredentialRecord {
     rawId: string;
 }
 export interface UserPreferences {
-    useRelayer: boolean;
-    useNetwork: 'testnet' | 'mainnet';
+    useRelayer?: boolean;
+    useNetwork?: 'testnet' | 'mainnet';
     confirmationConfig: ConfirmationConfig;
 }
 export interface LastProfileState {

package/dist/types/wallet/src/core/indexedDB/pendingWalletRegistrationCommit.d.ts

@@ -95,16 +95,6 @@ type PendingWalletRegistrationEd25519LocalMaterialBranchV1 = Extract<PendingWall
     readonly keyFamilies: readonly ['ed25519'];
 }>;
 export type PendingWalletRegistrationCommitV1 = (PendingWalletRegistrationCommitCommonV1 & {
-    readonly operation: 'registration_activate';
-    readonly phase?: never;
-    readonly completion?: never;
-    readonly admissionRequest?: never;
-    readonly admissionReceipt?: never;
-    readonly baseCustodyCommit?: never;
-    readonly checkpointJson?: never;
-    readonly signerPlanKind: 'near_ed25519';
-    readonly localMaterial: PendingWalletRegistrationEd25519LocalMaterialBranchV1;
-}) | (PendingWalletRegistrationCommitCommonV1 & {
     readonly operation: 'registration_activate';
     readonly phase?: never;
     readonly completion?: never;

package/dist/types/wallet/src/core/indexedDB/seamsWalletDB/accountSignerRows.d.ts

@@ -0,0 +1,44 @@
+import type { AccountSignerRecord, AccountSignerStatus, ChainAccountRecord, UpsertChainAccountInput } from '../passkeyClientDB.types';
+type ChainAccountProjectionRow = {
+    wallet_id: string;
+    near_account_id: string;
+    signer_slot: number;
+    profile_id: string;
+    chain_id_key: string;
+    account_address: string;
+    account_model: string;
+    is_primary: boolean;
+    updated_at: number;
+    record: ChainAccountRecord;
+};
+export type WalletSignerRow = {
+    wallet_signer_id: string;
+    wallet_id: string;
+    kind: string;
+    chain_target_key: string;
+    near_signer_slot?: number;
+    near_ed25519_signing_key_id?: string;
+    key_handle?: string;
+    ecdsa_threshold_key_id?: string;
+    threshold_owner_address?: string;
+    status: AccountSignerStatus;
+    updated_at: number;
+    record: AccountSignerRecord;
+};
+export declare const CHAIN_ACCOUNT_PROJECTION_SIGNER_SLOT = 0;
+export declare function chainAccountProjectionId(args: {
+    chainIdKey: string;
+    accountAddress: string;
+}): string;
+export declare function walletSignerId(args: {
+    chainIdKey: string;
+    accountAddress: string;
+    signerId: string;
+}): string;
+export declare function normalizeEcdsaChainTargetKey(value: unknown): string;
+export declare function chainAccountProjectionRow(input: UpsertChainAccountInput, existing?: ChainAccountRecord): ChainAccountProjectionRow;
+export declare function parseChainAccountProjectionRow(value: unknown): ChainAccountRecord | null;
+export declare function accountSignerRow(record: AccountSignerRecord): WalletSignerRow;
+export declare function parseAccountSignerRow(value: unknown): AccountSignerRecord | null;
+export {};
+//# sourceMappingURL=accountSignerRows.d.ts.map

package/dist/types/wallet/src/core/indexedDB/seamsWalletDB/ecdsaCapabilityManifestStore.d.ts

@@ -9,7 +9,6 @@ import { type ActiveEcdsaCapabilityManifest, type EcdsaActivationBinding, type S
 import type { VerifiedEcdsaPublicFacts } from '../../signingEngine/session/identity/evmFamilyEcdsaIdentity';
 import type { SeamsWalletDBManager, SeamsWalletTransactionContext } from './manager';
 import { type EcdsaClientPresignPoolIdentity } from '../../signingEngine/workerManager/ecdsaPresignPoolIdentity';
-import { type EcdsaClientPresignCleanupTarget } from '../../signingEngine/workerManager/ecdsaPresignLifecycle';
 import { type EcdsaCapabilitySelector, type PrepareEcdsaCapabilityActivationInput } from './ecdsaCapabilityManifestRecords';
 import { type DurableClientPresignatureMetadata, type DurableClientPresignatureAdmissionResult, type DurableClientPresignatureAdmissionInput, type DurableClientPresignatureTakeResult } from './ecdsaClientPresignatures';
 import { type ActiveEcdsaWalletCapabilitySubjectListResult, type EcdsaWalletActivationSelectorListResult, type EcdsaCapabilityManifestLookup, type EcdsaActivationJournalWriteResult, type EcdsaActivationJournalReadResult, type EcdsaPreparedActivationOpenResult, type EcdsaActiveMaterialOpenResult, type EcdsaActiveMaterialRefOpenResult, type EcdsaCapabilityMaterialRefLookup, type EcdsaCapabilityActivationLookup, type EcdsaCapabilityActivationFinalizationResult } from './ecdsaCapabilityManifestLookups';
@@ -73,7 +72,6 @@ export declare class IndexedDbEcdsaCapabilityManifestStore {
         readonly recordId: string;
         readonly poolIdentity: EcdsaClientPresignPoolIdentity;
     }): Promise<void>;
-    deleteClientPresignatures(target: EcdsaClientPresignCleanupTarget): Promise<number>;
     listActiveWalletCapabilitySubjects(walletIdInput: WalletId): Promise<ActiveEcdsaWalletCapabilitySubjectListResult>;
     listWalletActivationJournalSelectors(walletIdInput: WalletId): Promise<EcdsaWalletActivationSelectorListResult>;
     prepareActivation(input: PrepareEcdsaCapabilityActivationInput): Promise<EcdsaActivationJournalWriteResult<PreparedEcdsaActivationJournal>>;

package/dist/types/wallet/src/core/indexedDB/seamsWalletDB/ecdsaClientPresignatures.d.ts

@@ -74,11 +74,6 @@ export declare function parseDurableClientPresignatureRecordId(value: unknown):
 export declare function parsePresignatureTimestamp(value: unknown, label: string): number;
 export declare function rawRecordId(value: unknown): string | null;
 export declare function supportsStrictIndexedDbDurability(): boolean;
-type DeletableCursor = {
-    delete(): Promise<void>;
-    continue(): Promise<DeletableCursor | null>;
-};
-export declare function deleteCursorRows(cursor: DeletableCursor | null, limit?: number): Promise<number>;
 export declare function readAvailableClientPresignatureRows(context: SeamsWalletTransactionContext, poolIdentity: EcdsaClientPresignPoolIdentity, nowMs: number): Promise<SealedAvailableClientPresignatureRow[]>;
 export declare function parseSealedAvailableClientPresignatureRow(value: unknown): SealedAvailableClientPresignatureRow;
 export declare function metadataFromPresignatureRow(row: SealedAvailableClientPresignatureRow): DurableClientPresignatureMetadata;

package/dist/types/wallet/src/core/indexedDB/seamsWalletDB/manager.d.ts

@@ -11,6 +11,17 @@ export declare class SeamsWalletDBManager {
     private config;
     private dbPromise;
     private disabled;
+    private walletAuthorityRevision;
+    private walletAuthorityChannel;
+    private readonly walletAuthorityListeners;
+    onWalletAuthorityChange(listener: () => void): () => void;
+    private removeWalletAuthorityListener;
+    getWalletAuthorityRevision(): number;
+    private publishWalletAuthorityCommit;
+    private connectWalletAuthorityChannel;
+    private closeWalletAuthorityChannel;
+    private receiveWalletAuthorityCommit;
+    private invalidateWalletAuthority;
     constructor(config?: SeamsWalletDBConfig);
     getDbName(): string;
     setDbName(dbName: typeof SEAMS_WALLET_DB_NAME | `seams_test_wallet_${string}`): void;

package/dist/types/wallet/src/core/indexedDB/seamsWalletDB/nonceLeaseRows.d.ts

@@ -0,0 +1,23 @@
+import type { NonceLaneLeaseStoreRecord, NonceLaneLeaseStoreRecordState } from '../passkeyClientDB.types';
+type NonceLaneLeaseRow = {
+    lease_id: string;
+    lane_key: string;
+    wallet_id: string;
+    near_account_id?: string;
+    state: NonceLaneLeaseStoreRecordState;
+    expires_at_ms: number;
+    record: NonceLaneLeaseStoreRecord;
+};
+export type NonceLaneLockRow = {
+    lock_key: string;
+    owner_id: string;
+    fencing_token: string;
+    acquired_at_ms: number;
+    expires_at_ms: number;
+    updated_at_ms: number;
+};
+export declare function nonceLeaseRow(record: NonceLaneLeaseStoreRecord): NonceLaneLeaseRow;
+export declare function parseNonceLaneLockRow(value: unknown): NonceLaneLockRow | null;
+export declare function parseNonceLeaseRow(value: unknown): NonceLaneLeaseStoreRecord | null;
+export {};
+//# sourceMappingURL=nonceLeaseRows.d.ts.map

package/dist/types/wallet/src/core/indexedDB/seamsWalletDB/repositories.d.ts

@@ -141,6 +141,7 @@ type WalletRegistrationSessionPublicationV1 = {
 } | {
     readonly kind: 'credential_free_projection';
     readonly walletSession: ActiveWalletSessionV1;
+    readonly operationCredential?: never;
 };
 export type PublishPendingWalletRegistrationCommitInputV1 = {
     readonly pending: PendingWalletRegistrationCommitV1;

package/dist/types/wallet/src/core/indexedDB/seamsWalletDB/signerOutboxRows.d.ts

@@ -0,0 +1,15 @@
+import type { SignerOperationStatus, SignerOpOutboxRecord } from '../passkeyClientDB.types';
+type SignerOpsOutboxRow = {
+    op_id: string;
+    idempotency_key: string;
+    status: SignerOperationStatus;
+    next_attempt_at: number;
+    wallet_id: string;
+    chain_target_key: string;
+    updated_at: number;
+    record: SignerOpOutboxRecord;
+};
+export declare function signerOutboxRow(record: SignerOpOutboxRecord): SignerOpsOutboxRow;
+export declare function parseSignerOutboxRow(value: unknown): SignerOpOutboxRecord | null;
+export {};
+//# sourceMappingURL=signerOutboxRows.d.ts.map

package/dist/types/wallet/src/core/indexedDB/seamsWalletDB/walletOwnershipGeneration.d.ts

@@ -0,0 +1,6 @@
+import type { SeamsWalletTransactionContext } from './manager';
+export declare function assertWalletOwnershipGeneration(context: SeamsWalletTransactionContext, walletId: string, generation: number): Promise<void>;
+export declare function acceptWalletOwnershipGeneration(context: SeamsWalletTransactionContext, walletId: string, generation: number): Promise<void>;
+export declare function assertCurrentWalletOwnershipGeneration(walletId: string, generation: number): Promise<void>;
+export declare function observeWalletOwnershipGeneration(walletId: string, generation: number): Promise<void>;
+//# sourceMappingURL=walletOwnershipGeneration.d.ts.map

package/dist/types/wallet/src/core/indexedDB/unifiedIndexedDBManager.d.ts

@@ -226,7 +226,7 @@ export declare class UnifiedIndexedDBManager {
     updateWalletPreferences(args: {
         walletId: string;
         preferences: Partial<UserPreferences>;
-    }): Promise<void>;
+    }): Promise<UserPreferences | null>;
     deleteProfileData(profileId: string, args?: {
         eventAccountId?: AccountId | null;
     }): Promise<void>;

package/dist/types/wallet/src/core/rpcClients/near/accountExists.d.ts

@@ -0,0 +1,3 @@
+import type { NearClient } from './NearClient';
+export declare function accountExists(nearClient: NearClient, input: string): Promise<boolean>;
+//# sourceMappingURL=accountExists.d.ts.map

package/dist/types/wallet/src/core/rpcClients/near/rpcCalls.d.ts

@@ -1,12 +1,10 @@
 /**
  * NEAR RPC helpers
  *
- * This file centralizes helper calls made to the NEAR RPC (account existence checks,
- * access key polling, tx context fetch, etc).
+ * This file centralizes NEAR RPC access-key polling and transaction context calls.
  *
  * Wallet unlock verification and NEAR RPC helpers share this transport module.
  */
-import type { NearClient } from './NearClient';
 import type { WebAuthnAuthenticationCredential } from '../../types/webauthn';
 import type { ThresholdEcdsaChainTarget } from '../../platform';
 import { type RouterAbEcdsaCredentialFreeSessionActivationResponseV1, type RouterAbEcdsaPostRegistrationSessionActivationPolicyV1, type RouterAbEcdsaPostRegistrationSessionActivationResponseV1, type RouterAbEcdsaRegistrationActivationReceiptV1, type RouterAbEcdsaDerivationPublicCapabilityV1 } from '../../../../../shared-ts/src/utils/routerAbEcdsaDerivation';
@@ -20,17 +18,6 @@ import type { ExactWalletSessionAuthorization } from '../../signingEngine/sessio
 import { type WalletSessionCommittedIdentityV1 } from '../../../../../shared-ts/src/authorization';
 import { type ThresholdEd25519SessionId } from '../../../../../shared-ts/src/utils/domainIds';
 import { type RouterAbEd25519NormalSigningState } from '../../../../../shared-ts/src/utils/signingSessionSeal';
-/**
- * Best-effort on-chain account existence check.
- *
- * Used to short-circuit UX flows (e.g. registration) before prompting the user.
- * Returns `false` on unknown/non-deterministic failures so that downstream flows
- * can rely on the Router API/contract for final enforcement.
- */
-export declare function checkNearAccountExistsBestEffort(nearClient: NearClient, nearAccountId: string, opts?: {
-    attempts?: number;
-    delayMs?: number;
-}): Promise<boolean>;
 type PasskeyWalletUnlockInputCore = {
     type: 'passkey_assertion';
     challengeId: string;

package/dist/types/wallet/src/core/rpcClients/relayer/ecdsaPrepareSession.d.ts

@@ -0,0 +1,13 @@
+import { type RouterAbEcdsaDerivationEvmDigestSigningRequestV1Wire, type RouterAbEcdsaDerivationEvmDigestSigningPrepareResponseV1Wire } from '../../../../../shared-ts/src/utils/routerAbEcdsaDerivation';
+import { type PreparedWalletSessionStatus } from './walletSessionAuthorizationStatus';
+export type EcdsaPrepareSessionResult = {
+    readonly kind: 'reusable_wallet_session';
+    readonly signing: RouterAbEcdsaDerivationEvmDigestSigningPrepareResponseV1Wire;
+    readonly sessionStatus: PreparedWalletSessionStatus;
+} | {
+    readonly kind: 'operation_step_up';
+    readonly signing: RouterAbEcdsaDerivationEvmDigestSigningPrepareResponseV1Wire;
+    readonly sessionStatus?: never;
+};
+export declare function parseEcdsaPrepareSessionResponse(request: RouterAbEcdsaDerivationEvmDigestSigningRequestV1Wire, value: unknown): Promise<EcdsaPrepareSessionResult>;
+//# sourceMappingURL=ecdsaPrepareSession.d.ts.map

package/dist/types/wallet/src/core/rpcClients/relayer/ownerWalletExecutionLanePreflight.d.ts

@@ -1,11 +1,11 @@
+import type { WalletSessionOperationCredentialV1 } from '../../../../../shared-ts/src/device-linking/contracts';
 import type { OwnerWalletExecutionLaneProjectionV1 } from '../../../../../shared-ts/src/signing-lanes';
 import { type MpcMaterialActivationRef } from '../../../../../shared-ts/src/utils/domainIds';
 export declare const OWNER_WALLET_EXECUTION_LANE_PREFLIGHT_PATH = "/wallet/execution-lane/owner";
-export type { OwnerWalletExecutionLaneProjectionV1 };
 export declare function readOwnerWalletExecutionLaneProjectionV1(input: {
     readonly relayerUrl: string;
-    readonly walletSessionToken: string;
-    readonly curve: 'ed25519' | 'ecdsa_secp256k1';
+    readonly operationCredential: WalletSessionOperationCredentialV1;
+    readonly curve: 'ecdsa_secp256k1';
     readonly expectedMaterialActivation: MpcMaterialActivationRef;
 }): Promise<OwnerWalletExecutionLaneProjectionV1>;
 //# sourceMappingURL=ownerWalletExecutionLanePreflight.d.ts.map

package/dist/types/wallet/src/core/rpcClients/relayer/relayerHttp.d.ts

@@ -1,3 +1,5 @@
+import type { WalletSessionHome } from '../../../../../shared-ts/src/device-linking/contracts';
+import type { WalletSessionOperationCredentialV1 } from '../../../../../shared-ts/src/device-linking/contracts';
 type RelayerHttpHeaders = Readonly<Record<string, string>>;
 export declare function normalizeRelayerBaseUrl(value: unknown, options?: {
     trim: boolean;
@@ -11,5 +13,20 @@ export declare function buildRelayerJsonPostRequestInit(args: {
     headers?: RelayerHttpHeaders;
     bodyJson?: string;
 }): RequestInit;
+/**
+ * Runs the CORS preflight of relayer routes ahead of their first request.
+ *
+ * A cross-origin JSON request costs one preflight exchange for each new URL.
+ * The browser caches the answer for that URL, so an early preflight takes the
+ * exchange out of the later request's path. An `OPTIONS` fetch is the smallest
+ * request that makes the browser run one.
+ *
+ * Best effort: a failed preflight changes nothing, because the later request
+ * runs its own. A same-origin relayer needs no preflight and gets no request.
+ */
+export declare function prewarmRelayerPreflights(relayerUrl: string, paths: readonly string[]): void;
+export declare function buildWalletSessionAuthorizationHeaders(credential: Pick<WalletSessionOperationCredentialV1, 'token' | 'home'>): Record<string, string>;
+export declare function buildWalletHomeRoutingHeaders(home: WalletSessionHome): Record<string, string>;
+export declare function fetchWithWalletHomeDiscovery(request: Request): Promise<Response>;
 export {};
 //# sourceMappingURL=relayerHttp.d.ts.map

package/dist/types/wallet/src/core/rpcClients/relayer/routerAbNormalSigning.d.ts

@@ -1,4 +1,7 @@
-import { type RouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1Wire, type RouterAbEcdsaDerivationEvmDigestSigningPrepareResponseV1Wire, type RouterAbEcdsaDerivationEvmDigestSigningRequestV1Wire, type RouterAbEcdsaDerivationEvmDigestSigningResponseV1Wire } from '../../../../../shared-ts/src/utils/routerAbEcdsaDerivation';
+import type { PreparedWalletSessionStatus } from './walletSessionAuthorizationStatus';
+import type { WalletSessionHome } from '../../../../../shared-ts/src/device-linking/contracts';
+import { type EcdsaPrepareSessionResult } from './ecdsaPrepareSession';
+import { type RouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1Wire, type RouterAbEcdsaDerivationEvmDigestSigningRequestV1Wire, type RouterAbEcdsaDerivationEvmDigestSigningResponseV1Wire } from '../../../../../shared-ts/src/utils/routerAbEcdsaDerivation';
 import { type RouterAbMpcMaterialActivationRefWire, type RouterAbNormalSigningAuthorizationWire } from '../../../../../shared-ts/src/utils/routerAbNormalSigningIdentity';
 export declare class RouterAbSigningRequestError extends Error {
     readonly code: string;
@@ -13,6 +16,7 @@ export declare class RouterAbSigningRequestError extends Error {
 }
 type RouterAbOpaqueWalletSessionCredential = {
     kind: 'wallet_session_opaque';
+    home: WalletSessionHome;
     walletSessionToken: string;
 };
 export type RouterAbWalletSessionCredential = RouterAbOpaqueWalletSessionCredential;
@@ -22,6 +26,9 @@ export type RouterAbEd25519NormalSigningCredential = RouterAbWalletSessionCreden
 export type RouterAbOwnerNormalSigningCredential = RouterAbOpaqueWalletSessionCredential | {
     kind: 'operation_step_up';
 };
+export type RouterAbEcdsaPresignCredential = RouterAbOwnerNormalSigningCredential & {
+    readonly ownershipGeneration: number;
+};
 export type RouterAbPublicDigest32Wire = {
     bytes: readonly number[];
 };
@@ -266,17 +273,26 @@ export declare function buildRouterAbEd25519NormalSigningFinalizeRequestV2(args:
     clientVerifyingShareB64u: string;
     clientSignatureShareB64u: string;
 }): RouterAbNormalSigningFinalizeRequestV2Wire;
+type Ed25519PrepareSessionResult = {
+    readonly kind: 'reusable_wallet_session';
+    readonly signing: RouterAbNormalSigningPrepareResponseV1Wire;
+    readonly sessionStatus: PreparedWalletSessionStatus;
+} | {
+    readonly kind: 'operation_step_up';
+    readonly signing: RouterAbNormalSigningPrepareResponseV1Wire;
+    readonly sessionStatus?: never;
+};
 export declare function prepareRouterAbNormalSigningV2(args: {
     relayServerUrl: string;
     credential: RouterAbEd25519NormalSigningCredential;
     request: RouterAbNormalSigningPrepareRequestV2Wire;
-}): Promise<RouterAbNormalSigningPrepareResponseV1Wire>;
+}): Promise<Ed25519PrepareSessionResult>;
 export declare function prepareRouterAbEcdsaDerivationEvmDigestSigningV1(args: {
     relayServerUrl: string;
     credential: RouterAbEd25519NormalSigningCredential;
     request: RouterAbEcdsaDerivationEvmDigestSigningRequestV1Wire;
     onServerTiming?: (header: string | null) => void;
-}): Promise<RouterAbEcdsaDerivationEvmDigestSigningPrepareResponseV1Wire>;
+}): Promise<EcdsaPrepareSessionResult>;
 export declare function finalizeRouterAbNormalSigningV2(args: {
     relayServerUrl: string;
     credential: RouterAbEd25519NormalSigningCredential;

package/dist/types/wallet/src/core/rpcClients/relayer/walletRegistration.d.ts

@@ -1,3 +1,4 @@
+import type { WalletSessionHome } from '../../../../../shared-ts/src/device-linking/contracts';
 import type { AddAuthMethodIntentGrant, AddAuthMethodIntentCallerV1, AddAuthMethodIntentV1, AddSignerIntentV1, AddSignerIntentGrant, RegistrationIntentGrant, RegistrationIntentV1, WalletId, WebAuthnRpId } from '../../../../../shared-ts/src/utils/registrationIntent';
 import type { ActiveWalletAuthMethodRecordV2 } from '../../../../../shared-ts/src/utils/walletAuthMethodRecord';
 import type { RegistrationNearAccountProvisioning, ResolvedRegistrationNearAccount } from '../../../../../shared-ts/src/utils/registrationSignerPlan';
@@ -10,7 +11,7 @@ import type { RegistrationEstablishedSessionResultV2 } from '../../../../../shar
 import { type RootShareEpoch, type ThresholdEd25519SessionId, type WalletAuthMethodId } from '../../../../../shared-ts/src/utils/domainIds';
 import { type WebAuthnAuthenticatorDeviceInfo } from '../../../../../shared-ts/src/utils/webauthnDeviceInfo';
 import type { EcdsaKeyFactsInventoryWalletSessionCredential } from '../../types/sdkSentEvents';
-import { type RouterAbEd25519YaoRegistrationAdmissionRequestV1 } from '../../../../../shared-ts/src/utils/routerAbEd25519Yao';
+import { type RouterAbEd25519YaoActivationAdmissionReceiptV1, type RouterAbEd25519YaoRegistrationAdmissionRequestV1 } from '../../../../../shared-ts/src/utils/routerAbEd25519Yao';
 import type { CreateRegistrationIntentRequest, WalletEd25519YaoSignerPublicResult, WalletRegistrationEd25519YaoActivationReference, WalletRegistrationEd25519YaoStart, WalletRegistrationFinalizeAuthMethod } from '../../../../../shared-ts/src/utils/registrationContracts';
 import { type WalletAuthAuthority } from '../../../../../shared-ts/src/utils/walletAuthAuthority';
 import { type RouterAbEd25519NormalSigningState } from '../../../../../shared-ts/src/utils/signingSessionSeal';
@@ -22,6 +23,16 @@ import { type Ed25519AuthorityScope, type ThresholdRuntimePolicyScope } from '..
 import type { EcdsaDerivationRoleLocalPublicIdentity, ThresholdEcdsaDerivationRoleLocalBootstrapValue } from './thresholdEcdsa';
 import { parseWalletRegistrationFinalizeResponse } from './walletRegistrationTerminalResponse';
 export { parseWalletRegistrationFinalizeResponse };
+/**
+ * Preflights the routes that a registration calls after setup, and the routes
+ * of a NEAR wallet's first signature. Setup and the authenticator prompt run
+ * meanwhile, so each later request starts without that exchange.
+ */
+export declare function prewarmWalletRegistrationRoutes(input: {
+    relayerUrl: string;
+    nearEd25519: boolean;
+    evmFamilyEcdsa: boolean;
+}): void;
 export type CreateRegistrationIntentResponse = {
     ok: true;
     intent: RegistrationIntentV1;
@@ -112,6 +123,7 @@ export type WalletRegistrationStartResponse = WalletRegistrationStartResponseBas
  * challenge the WebAuthn create must sign.
  */
 type WalletRegistrationSetupSuccessBase = {
+    readonly home: WalletSessionHome;
     ok: true;
     registrationCeremonyId: string;
     walletId: WalletId;
@@ -537,11 +549,9 @@ export declare function createWalletAddAuthMethodIntent(args: {
  * setup's challenge travels with the ECDSA registration request, so one round
  * trip both establishes the verified authority and runs the Router leg.
  *
- * The result is a discriminated signer plan, not a bundle with an optional
- * Ed25519 member. A mixed plan always carries deferred NEAR work; an
- * ECDSA-only plan has no arm to omit. The NEAR work is `deferred` by
- * construction — the caller starts it and must never await it to decide the
- * wallet is usable.
+ * The result follows the signer plan. Mixed wallets carry deferred NEAR work
+ * while ECDSA is usable. NEAR-only wallets receive their admitted Yao session
+ * here and complete it before finalization.
  */
 export type WalletRegistrationRespondEd25519DeferredWork = {
     status: 'deferred';
@@ -568,7 +578,11 @@ export type WalletRegistrationRespondResponseV2 = {
     registrationCeremonyId: string;
     kind: 'near_ed25519';
     ecdsa?: never;
-    ed25519: WalletRegistrationRespondEd25519DeferredWork;
+    ed25519: {
+        readonly status: 'admitted';
+        readonly admissionRequest: WalletRegistrationEd25519YaoStart['admissionRequest'];
+        readonly admissionReceipt: RouterAbEd25519YaoActivationAdmissionReceiptV1<'registration'>;
+    };
 };
 export type WalletRegistrationNearAdmissionResponseV2 = {
     ok: true;
@@ -630,36 +644,16 @@ type ActivateTerminalEcdsaPayload = Extract<WalletRegistrationFinalizeResponse,
     activation: RouterAbEcdsaRegistrationPublicActivationReceiptV1;
     bootstrap: ThresholdEcdsaDerivationRoleLocalBootstrapValue;
 };
-/**
- * Ed25519-only activate returns a wallet that cannot sign yet: its sole signer
- * arrives with the deferred Yao computation. `nearProvisioning` is required on
- * this arm — a pending wallet with no provisioning state would be
- * indistinguishable from one that never needed NEAR.
- */
-type DistributiveOmit<T, K extends keyof any> = T extends unknown ? Omit<T, K> : never;
-export type WalletRegistrationActivateEd25519PendingV2 = DistributiveOmit<Extract<WalletRegistrationFinalizeResponse, {
-    ok: true;
-    kind: 'near_ed25519';
-}>, 'ed25519' | 'resolvedAccount' | 'accountProvisioning' | 'authorityScope' | 'foundingAuthority' | 'foundingAuthMethod' | 'custodyKeyManifestDigestB64u'> & {
-    nearProvisioning: {
-        status: 'near_pending';
-    };
-    ed25519?: never;
-    resolvedAccount?: never;
-    accountProvisioning?: never;
-    authorityScope?: never;
-    ecdsa?: never;
-};
-export type WalletRegistrationActivateResponseV2 = (Omit<Extract<WalletRegistrationFinalizeResponse, {
+export type WalletRegistrationActivateResponseV2 = Extract<WalletRegistrationFinalizeResponse, {
     ok: true;
     kind: 'evm_family_ecdsa';
-}>, never> & {
+}> & {
     ecdsa: ActivateTerminalEcdsaPayload;
     registrationEstablishedSession: RegistrationEstablishedSessionResultV2;
     nearProvisioning?: {
         status: 'near_pending';
     };
-}) | WalletRegistrationActivateEd25519PendingV2;
+};
 type ActivateWalletRegistrationArgsBase = {
     relayerUrl: string;
     headers?: Record<string, string>;
@@ -677,26 +671,21 @@ type WalletRegistrationActivateEcdsaRequest = {
     clientActivation: RouterAbEcdsaVerifiedClientActivationFactsV1;
     expectedKeyHandles?: string[];
 };
-type ActivateWalletRegistrationArgs = (ActivateWalletRegistrationArgsBase & {
-    signerPlanKind: 'near_ed25519';
-    ecdsa?: never;
-}) | (ActivateWalletRegistrationArgsBase & {
+type ActivateWalletRegistrationArgs = ActivateWalletRegistrationArgsBase & {
     signerPlanKind: Exclude<WalletRegistrationSignerPlanKind, 'near_ed25519'>;
     ecdsa: WalletRegistrationActivateEcdsaRequest;
-});
+};
 export declare function activateWalletRegistration(args: ActivateWalletRegistrationArgs): Promise<WalletRegistrationActivateResponseV2>;
 /**
- * Route 4. The deferred NEAR completion, called once the Yao computation the
- * client started after respond has finished.
+ * Finalizes the NEAR signer after Yao and the recovery backup complete.
  *
  * One completion path serves both plans: an Ed25519-only wallet installs its
  * sole signer here, and a mixed wallet's NEAR arm lands here too. It carries
  * its own idempotency key because it is a separate effect from activate's —
  * sharing one would let a retry of this call replay activate's commit.
  *
- * A retryable failure leaves the pending wallet intact and the call
- * repeatable, so the caller reports provisioning state rather than unwinding
- * a wallet that already exists.
+ * A retryable failure retains the client checkpoint. Repeating the same
+ * request replays its committed result without issuing another credential.
  */
 type WalletRegistrationNearProvisioningFinalizeSuccessV2 = Extract<WalletRegistrationFinalizeResponse, {
     ok: true;

package/dist/types/wallet/src/core/rpcClients/relayer/walletSessionAuthorizationStatus.d.ts

@@ -1,5 +1,7 @@
+import type { Variant } from '../../../../../shared-ts/src/utils/variant';
 import { type MpcWalletSigningQuotaId, type WalletSessionId } from '../../../../../shared-ts/src/authorization/capabilityKinds';
 import type { ActiveWalletSessionV1, WalletSessionOperationCredentialV1 } from '../../../../../shared-ts/src/device-linking/contracts';
+import type { RegistrationEstablishedSessionV2 } from '../../../../../shared-ts/src/utils/registrationEstablishedSession';
 type ExactWalletSessionStatusIdentity = {
     readonly walletSessionId: WalletSessionId;
     readonly quotaId: MpcWalletSigningQuotaId;
@@ -45,6 +47,9 @@ export type ExactWalletSessionStatus = (ActiveWalletSessionQuotaStatusV1 & Obser
     readonly quotaLifecycle?: never;
     readonly authorization?: never;
 });
+export type PreparedWalletSessionStatus = Variant<ExactWalletSessionStatus, 'status', 'active'>;
+/** What a registration response states about the session it issued. */
+type RegistrationIssuedSession = Pick<RegistrationEstablishedSessionV2, 'walletSessionId' | 'quotaId' | 'remainingUses' | 'expiresAtMs' | 'walletSession' | 'operationCredential'>;
 interface ExactWalletSessionStatusPort {
     read(input: ExactWalletSessionStatusIdentity): Promise<ExactWalletSessionStatus>;
 }
@@ -53,9 +58,38 @@ type RelayerExactWalletSessionStatusPortOptions = {
     readonly operationCredential: WalletSessionOperationCredentialV1;
     readonly fetchImpl?: typeof fetch;
 };
+type LocalWalletSessionObservation = {
+    readonly kind: 'local_wallet_session_observation';
+    readonly sequence: number;
+    readonly status: ExactWalletSessionStatus;
+};
 /** One operation owns this snapshot; subsequent operations create a new scope. */
 export declare class WalletSessionStatusReadScope {
     private readonly readsByFetch;
+    private suppliedStatus;
+    static fromPrepare(options: RelayerExactWalletSessionStatusPortOptions, status: PreparedWalletSessionStatus): WalletSessionStatusReadScope;
+    /** Initial prefill uses the issued response. Each refill request still verifies
+     * current server authorization before it generates or admits material. */
+    static fromRegistration(relayerUrl: string, session: RegistrationIssuedSession): WalletSessionStatusReadScope;
+    /**
+     * A NEAR-only registration's finalize response states the session the server
+     * issued as its last step. The wallet host's next observation of this exact
+     * session reads it from the response; asking the server would repeat it.
+     * An ECDSA registration keeps changing its session after it is issued, so
+     * that path observes the server.
+     */
+    static acceptRegistrationSession(relayerUrl: string, session: RegistrationIssuedSession): void;
+    /** One wallet-host observation. It reads a session that a registration response
+     * issued once; every other read, and every explicit session query, asks the server. */
+    static forHostObservation(): WalletSessionStatusReadScope;
+    /**
+     * The server refused an operation under this credential's session and asked
+     * for step-up. What the wallet holds about that session no longer plans a
+     * confirmation, so the next plan reads the server. Signing requests use the
+     * default fetch, and so do the observations they contradict.
+     */
+    static forgetCredential(token: string): void;
+    static observationForConfirmation(options: RelayerExactWalletSessionStatusPortOptions, identity: ExactWalletSessionStatusIdentity): LocalWalletSessionObservation | null;
     read(options: RelayerExactWalletSessionStatusPortOptions, identity: ExactWalletSessionStatusIdentity): Promise<ExactWalletSessionStatus>;
 }
 export declare function parseExactWalletSessionStatusResponse(value: unknown, expected: ExactWalletSessionStatusIdentity): ExactWalletSessionStatus | null;

package/dist/types/wallet/src/core/signingEngine/assembly/ports/shared.d.ts

@@ -91,7 +91,7 @@ export type CreateSigningEnginePortsArgs = {
     getWalletSessionStatus: (args: SigningSessionStatusCheck) => Promise<SigningSessionStatus | null>;
     signerWorkerManager: SignerWorkerManager;
     getWorkerBaseOrigin: () => string;
-    workerWarmupPolicy: WorkerResourceWarmupDeps['workerWarmupPolicy'];
+    shouldPrewarmUiConfirmUi: WorkerResourceWarmupDeps['shouldPrewarmUiConfirmUi'];
     getTheme: () => ThemeMode;
     signTempo: SigningEngineConveniencePorts['signTempo'];
     activateAuthenticatedWalletState: WorkerResourceWarmupDeps['activateAuthenticatedWalletState'];