@seams/wallet 0.8.0 → 0.9.1

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

@@ -1,3 +1,4 @@
+import type { WalletSessionStatusReadScope } from '../../../rpcClients/relayer/walletSessionAuthorizationStatus';
 import type { SeamsConfigsReadonly } from '../../../types/seams';
 import type { ThresholdEcdsaCanonicalExportArtifact } from '../../interfaces/signing';
 import { type WarmSigningStatusReader } from '../../session/warmCapabilities/statusReader';
@@ -17,7 +18,7 @@ import type { EmailOtpWarmMaterialTarget } from '../../workerManager/workerTypes
 type EcdsaExportArtifactStorePorts = {
     exportArtifactsByLane: Map<string, ThresholdEcdsaCanonicalExportArtifact>;
 };
-type WarmSigningEd25519AuthorizationResolver = (walletId: import('../../interfaces/ecdsaChainTarget').WalletId) => Promise<ExactNearEd25519WalletSessionAuthorization | null>;
+type WarmSigningEd25519AuthorizationResolver = (walletId: import('../../interfaces/ecdsaChainTarget').WalletId, statusReads: WalletSessionStatusReadScope) => Promise<ExactNearEd25519WalletSessionAuthorization | null>;
 type WarmSigningPortsArgs = {
     resolveActiveEcdsaCapabilityRuntime: import('../../session/material/activeEcdsaCapabilityRuntime').ActiveEcdsaCapabilityRuntimeResolver;
     resolveActiveEcdsaCapabilityRuntimeForChain: import('../../session/material/activeEcdsaCapabilityRuntime').ActiveEcdsaCapabilityRuntimeForChainResolver;

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

@@ -9,23 +9,13 @@ import type { NearAccountBinding } from '../../../../../shared-ts/src/utils/wall
 export type WorkerResourceWarmupStorePort = ProfileAccountContextPort & AccountKeyMaterialStorePort & {
     getLastProfileState: () => Promise<LastProfileState | null>;
 };
-type WorkerResourceWarmupPredicate = (workerBaseOrigin: string) => boolean;
-export type WorkerResourceWarmupPolicy = {
-    kind: 'local_worker_warmup_disabled';
-    shouldPrewarmWorkers: WorkerResourceWarmupPredicate;
-    shouldPrewarmUiConfirmUi: WorkerResourceWarmupPredicate;
-} | {
-    kind: 'local_worker_warmup_enabled';
-    shouldPrewarmWorkers: WorkerResourceWarmupPredicate;
-    shouldPrewarmUiConfirmUi: WorkerResourceWarmupPredicate;
-};
+export type UiConfirmPrewarmPredicate = (workerBaseOrigin: string) => boolean;
 export type WorkerResourceWarmupDeps = {
     workerBaseOrigin: string;
     store: WorkerResourceWarmupStorePort;
     nearClient: NearClient;
     nonceCoordinator: Pick<NonceCoordinator, 'prefetchNearContext'>;
-    prewarmWorkers: () => Promise<void>;
-    workerWarmupPolicy: WorkerResourceWarmupPolicy;
+    shouldPrewarmUiConfirmUi: UiConfirmPrewarmPredicate;
     prewarmUiConfirmUi: () => Promise<void>;
     activateAuthenticatedWalletState: (args: {
         walletId: WalletId;
@@ -40,7 +30,6 @@ export type WorkerResourceWarmupDiagnostics = {
     noncePrefetchMs: number;
     keyMaterialReadMs: number;
     uiConfirmPrewarmMs: number;
-    signerWorkerPrewarmMs: number;
 };
 export type WorkerResourceWarmupAccountContext = {
     kind: 'none';
@@ -50,5 +39,4 @@ export type WorkerResourceWarmupAccountContext = {
     account: NearAccountBinding;
 };
 export declare function warmCriticalResources(deps: WorkerResourceWarmupDeps, accountContext?: WorkerResourceWarmupAccountContext): Promise<WorkerResourceWarmupDiagnostics>;
-export {};
 //# sourceMappingURL=warmup.d.ts.map

package/dist/types/wallet/src/core/signingEngine/chains/near/nearSignerWasm.d.ts

@@ -1,11 +1,7 @@
-import { type DelegatePayload, type ThresholdEd25519BuildDelegateSigningPayloadResult, type ThresholdEd25519ComputeSigningDigestResult, type ThresholdEd25519FinalizeNearTxFromSignatureResult, type ThresholdEd25519NearTxUnsignedBorsh, type ThresholdEd25519DecodeSignedNearTxBorshResult, type WasmSignedDelegate, type TransactionPayload } from '../../../types/signer-worker';
+import { type DelegatePayload, type ThresholdEd25519BuildDelegateSigningPayloadResult, type ThresholdEd25519ComputeSigningDigestResult, type ThresholdEd25519ComputeNep413SigningDigestRequest, type ThresholdEd25519FinalizeNearTxFromSignatureResult, type ThresholdEd25519NearTxUnsignedBorsh, type ThresholdEd25519DecodeSignedNearTxBorshResult, type WasmSignedDelegate, type TransactionPayload } from '../../../types/signer-worker';
 import type { TransactionContext } from '../../../types/rpc';
 import { type WorkerOperationContext } from '../../workerManager/executeWorkerOperation';
-export declare function computeThresholdEd25519Nep413SigningDigestWasm(args: {
-    message: string;
-    recipient: string;
-    nonce: string;
-    state?: string;
+export declare function computeThresholdEd25519Nep413SigningDigestWasm(args: ThresholdEd25519ComputeNep413SigningDigestRequest & {
     workerCtx: WorkerOperationContext;
 }): Promise<ThresholdEd25519ComputeSigningDigestResult>;
 export declare function computeThresholdEd25519DelegateSigningDigestWasm(args: {

package/dist/types/wallet/src/core/signingEngine/flows/recovery/public.d.ts

@@ -1,5 +1,5 @@
 import type { ThemeMode } from '../../../types/seams';
-import { type ExportKeypairWithUIDeps, type SigningEngineExportKeypairWithUIInput, type SigningEngineResolveExactKeyExportLaneInput, type SigningEngineResolveExactKeyExportLaneResult } from './exportKeypairOperation';
+import type { ExportKeypairWithUIDeps, SigningEngineExportKeypairWithUIInput, SigningEngineResolveExactKeyExportLaneInput, SigningEngineResolveExactKeyExportLaneResult } from './exportKeypairOperation';
 import type { KeyExportEventCallback } from './keyExportFlow';
 export type RecoveryPublicDeps = {
     laneSelection: ExportKeypairWithUIDeps['laneSelection'];

package/dist/types/wallet/src/core/signingEngine/flows/signEvmFamily/emailOtpPublic.d.ts

@@ -1,4 +1,4 @@
-import { enrollEmailOtpWallet, prepareEmailOtpRegistrationEnrollmentMaterial } from '../../session/emailOtp/workerEnrollment';
+import { prepareEmailOtpRegistrationEnrollmentMaterial } from '../../session/emailOtp/workerEnrollment';
 import type { EmailOtpAuthPolicy } from '../../../types/seams';
 import type { WorkerOperationContext } from '../../workerManager/executeWorkerOperation';
 import type { WalletEmailOtpChannel, WalletEmailOtpLoginOperation } from '../../../../../../shared-ts/src/utils/emailOtpDomain';
@@ -6,9 +6,7 @@ import type { ThresholdEcdsaChainTarget, WalletId, WalletSessionRef } from '../.
 import type { ThresholdRuntimePolicyScope } from '../../threshold/sessionPolicy';
 import type { EmailOtpAuthoritySelector, EmailOtpWorkerProgressEvent } from '../../workerManager/workerTypes';
 import type { EmailOtpEcdsaBootstrapAuthorization } from '../../session/emailOtp/routePlan';
-import { requestEmailOtpSigningSessionChallenge as requestEmailOtpSigningSessionChallengeValue, refreshEmailOtpSigningSession as refreshEmailOtpSigningSessionValue } from './emailOtpSigningSession';
 import type { EmailOtpEcdsaProviderIdentity, EmailOtpThresholdEcdsaLoginResult, LoginEmailOtpEcdsaCapabilityArgs } from '../../session/emailOtp/ecdsaLogin';
-import type { EmailOtpEcdsaSigningSessionAuthorityPorts } from '../../session/emailOtp/ecdsaSigningSessionAuthority';
 export type LoginWithEmailOtpEcdsaCapabilityInternalArgs = {
     walletSession: WalletSessionRef;
     authoritySelector: EmailOtpAuthoritySelector;
@@ -35,16 +33,6 @@ export type LoginWithEmailOtpEcdsaCapabilityInternalArgs = {
     ed25519YaoRecovery?: LoginEmailOtpEcdsaCapabilityArgs['ed25519YaoRecovery'];
 };
 export type LoginWithEmailOtpEcdsaCapabilityInternalResult = EmailOtpThresholdEcdsaLoginResult;
-export type EnrollEmailOtpInternalArgs = {
-    walletId: WalletId;
-    otpCode: string;
-    relayUrl?: string;
-    challengeId?: string;
-    groupId?: string;
-    clientSecret32?: Uint8Array;
-    otpChannel?: WalletEmailOtpChannel;
-};
-export type EnrollEmailOtpInternalResult = Awaited<ReturnType<typeof enrollEmailOtpWallet>>;
 type PrepareEmailOtpRegistrationEnrollmentMaterialInternalArgsBase = {
     walletId: WalletId;
     userId: string;
@@ -59,30 +47,11 @@ export type EmailOtpPublicDeps = {
     relayerUrl: string;
     groupId: string;
     getSignerWorkerContext: () => WorkerOperationContext;
-    withThresholdEcdsaSigningQueue: Parameters<typeof refreshEmailOtpSigningSessionValue>[0]['withThresholdEcdsaSigningQueue'];
-    signingSessionAuthorityPorts: EmailOtpEcdsaSigningSessionAuthorityPorts;
     emailOtpSessions: {
-        requestTransactionSigningChallenge: Parameters<typeof requestEmailOtpSigningSessionChallengeValue>[0]['emailOtpSessions']['requestTransactionSigningChallenge'];
         loginWithEcdsaCapabilityInternal: (args: LoginEmailOtpEcdsaCapabilityArgs) => Promise<LoginWithEmailOtpEcdsaCapabilityInternalResult>;
     };
 };
 export declare function loginWithEmailOtpEcdsaCapabilityInternal(deps: EmailOtpPublicDeps, args: LoginWithEmailOtpEcdsaCapabilityInternalArgs): Promise<LoginWithEmailOtpEcdsaCapabilityInternalResult>;
-export declare function requestEmailOtpSigningSessionChallenge(deps: EmailOtpPublicDeps, args: {
-    walletSession: WalletSessionRef;
-    chainTarget: ThresholdEcdsaChainTarget;
-}): Promise<{
-    challengeId: string;
-    emailHint?: string;
-}>;
-export declare function refreshEmailOtpSigningSession(deps: EmailOtpPublicDeps, args: {
-    walletSession: WalletSessionRef;
-    chainTarget: ThresholdEcdsaChainTarget;
-    challengeId: string;
-    otpCode: string;
-    ttlMs?: number;
-    remainingUses?: number;
-}): Promise<LoginWithEmailOtpEcdsaCapabilityInternalResult>;
-export declare function enrollEmailOtpInternal(deps: EmailOtpPublicDeps, args: EnrollEmailOtpInternalArgs): Promise<EnrollEmailOtpInternalResult>;
 export declare function prepareEmailOtpRegistrationEnrollmentMaterialInternal(deps: EmailOtpPublicDeps, args: PrepareEmailOtpRegistrationEnrollmentMaterialInternalArgs): Promise<PrepareEmailOtpRegistrationEnrollmentMaterialInternalResult>;
 export {};
 //# sourceMappingURL=emailOtpPublic.d.ts.map

package/dist/types/wallet/src/core/signingEngine/flows/signEvmFamily/emailOtpSigningSession.d.ts

@@ -1,65 +1,13 @@
-import type { EmailOtpAuthPolicy } from '../../../types/seams';
-import { WALLET_EMAIL_OTP_TRANSACTION_SIGN_OPERATION } from '../../../../../../shared-ts/src/utils/emailOtpDomain';
-import { buildEmailOtpRoutePlan, type EmailOtpSigningSessionAuthLane } from '../../stepUpConfirmation/otpPrompt/authLane';
-import type { ExactEcdsaSealedRuntime } from '../../session/material/ecdsaSealedRuntime';
-import type { ActiveEcdsaCapabilityManifest } from '../../session/material/ecdsaCapabilityManifest';
-import { type EmailOtpEcdsaSigningSessionAuthorityPorts } from '../../session/emailOtp/ecdsaSigningSessionAuthority';
-import type { ExactEvmFamilyWalletSessionAuthorization } from '../../session/material/ecdsaSigningCapability';
+import type { EmailOtpSigningSessionAuthLane } from '../../stepUpConfirmation/otpPrompt/authLane';
 import { type MpcMaterialActivationRef } from '../../../../../../shared-ts/src/utils/domainIds';
 import { type EmailOtpWalletAuthAuthority, type WalletAuthAuthority } from '../../../../../../shared-ts/src/utils/walletAuthAuthority';
 import type { CanonicalEvmFamilyEcdsaSigningCapability } from '../../session/material/ecdsaSigningCapability';
-import type { ThresholdEcdsaChainTarget, WalletId, WalletSessionRef } from '../../interfaces/ecdsaChainTarget';
-import type { ThresholdRuntimePolicyScope } from '../../threshold/sessionPolicy';
-import type { RequestEmailOtpChallengeArgs } from '../../session/emailOtp/exportRecoveryRuntime';
-import type { VerifiedEcdsaPublicFacts } from '../../session/identity/evmFamilyEcdsaIdentity';
+import type { WalletSessionRef } from '../../interfaces/ecdsaChainTarget';
 import type { EvmFamilyChain, EvmFamilyLifecycleEventCallback } from './types';
-import { type ResolvedEvmFamilyEcdsaSigningLane } from './ecdsaLanes';
-import { type EmailOtpEcdsaBootstrapAuthorization } from '../../session/emailOtp/routePlan';
-import type { EmailOtpEcdsaProviderIdentity, EmailOtpThresholdEcdsaLoginResult } from '../../session/emailOtp/ecdsaLogin';
-import type { EmailOtpAuthoritySelector } from '../../workerManager/workerTypes';
+import type { ResolvedEvmFamilyEcdsaSigningLane } from './ecdsaLanes';
 import type { EmailOtpEcdsaSigningSessionCommittedLane } from './ecdsaSelection';
 import type { EmailOtpTransactionSigningChallenge } from '../../session/emailOtp/publicTypes';
 import type { DigestB64u } from '../../../../../../shared-ts/src/utils/canonicalPrimitives';
-type WalletSessionEmailOtpChallengeArgs = Extract<RequestEmailOtpChallengeArgs, {
-    kind: 'wallet_session_challenge';
-}>;
-export type EmailOtpEcdsaSigningSessionDeps = {
-    resolveSigningSessionAuth: (args: {
-        walletId: WalletId;
-        chainTarget: ThresholdEcdsaChainTarget;
-    }) => ReturnType<typeof resolveEmailOtpEcdsaSigningSessionAuth>;
-    withThresholdEcdsaSigningQueue: <T>(args: {
-        queueKey: string;
-        walletId: WalletId;
-        enabled: boolean;
-        task: () => Promise<T>;
-    }) => Promise<T>;
-    emailOtpSessions: {
-        requestTransactionSigningChallenge: (args: WalletSessionEmailOtpChallengeArgs) => Promise<EmailOtpTransactionSigningChallenge>;
-        loginWithEcdsaCapabilityInternal: (args: {
-            walletSession: WalletSessionRef;
-            authoritySelector: EmailOtpAuthoritySelector;
-            subjectId?: never;
-            chainTarget: ThresholdEcdsaChainTarget;
-            emailOtpAuthPolicy?: EmailOtpAuthPolicy;
-            emailOtpAuthReason?: 'login' | 'sign';
-            challengeId?: string;
-            otpCode: string;
-            operation?: typeof WALLET_EMAIL_OTP_TRANSACTION_SIGN_OPERATION;
-            routePlan: ReturnType<typeof buildEmailOtpRoutePlan>;
-            publicFacts: VerifiedEcdsaPublicFacts;
-            participantIds?: never;
-            ttlMs?: number;
-            remainingUses?: number;
-            runtimePolicyScope?: ThresholdRuntimePolicyScope;
-            routeAuth?: never;
-            ecdsaBootstrapAuthorization: EmailOtpEcdsaBootstrapAuthorization;
-            providerIdentity: EmailOtpEcdsaProviderIdentity;
-            emailHashHex: string;
-            authSubjectId?: never;
-        }) => Promise<EmailOtpThresholdEcdsaLoginResult>;
-    };
-};
 export type EvmFamilyEmailOtpTransactionSigningBridge = {
     challenge: () => Promise<{
         challengeId: string;
@@ -124,32 +72,5 @@ export declare function createEmailOtpEcdsaTransactionSigningBridge(args: {
         operationFingerprintDigest: DigestB64u;
     }) => Promise<EmailOtpTransactionSigningChallenge>;
 }): EvmFamilyEmailOtpTransactionSigningBridge;
-/** Canonical Email OTP signing-session resolution: the manifest proves exact
- * material, the sealed runtime supplies session-scoped facts and the Email OTP
- * binding, and the reusable Wallet Session is resolved independently. Refresh
- * must land on the same material activation it started from, so the caller
- * checks that before and after; nothing here invokes Yao recovery or device
- * linking. */
-export declare function resolveEmailOtpEcdsaSigningSessionAuth(args: {
-    walletId: WalletId;
-    chainTarget: ThresholdEcdsaChainTarget;
-}, authorityPorts: EmailOtpEcdsaSigningSessionAuthorityPorts): Promise<{
-    manifest: ActiveEcdsaCapabilityManifest;
-    runtime: ExactEcdsaSealedRuntime;
-    authority: ExactEvmFamilyWalletSessionAuthorization;
-}>;
-export declare function requestEmailOtpSigningSessionChallenge(deps: EmailOtpEcdsaSigningSessionDeps, args: {
-    walletSession: WalletSessionRef;
-    chainTarget: ThresholdEcdsaChainTarget;
-}): Promise<EmailOtpTransactionSigningChallenge>;
-export type RefreshEmailOtpSigningSessionArgs = {
-    walletSession: WalletSessionRef;
-    chainTarget: ThresholdEcdsaChainTarget;
-    challengeId: string;
-    otpCode: string;
-    ttlMs?: number;
-    remainingUses?: number;
-};
-export declare function refreshEmailOtpSigningSession(deps: EmailOtpEcdsaSigningSessionDeps, args: RefreshEmailOtpSigningSessionArgs): Promise<EmailOtpThresholdEcdsaLoginResult>;
 export {};
 //# sourceMappingURL=emailOtpSigningSession.d.ts.map

package/dist/types/wallet/src/core/signingEngine/flows/signEvmFamily/readySecp256k1Material.d.ts

@@ -1,12 +1,72 @@
+import type { WalletSessionHome } from '../../../../../../shared-ts/src/device-linking/contracts';
+import type { SignRequest, SignatureBytes } from '../../interfaces/signing';
+import type { EvmFamilyThresholdEcdsaOperation } from './thresholdAdmission';
+import type { OperationDigestSet } from '../../../../../../shared-ts/src/authorization/operationFingerprint';
+import type { RouterAbNormalSigningAuthorizationWire } from '../../../../../../shared-ts/src/utils/routerAbNormalSigningIdentity';
+import type { RouterAbEcdsaOperationStepUpPreparationV1Wire } from '../../../../../../shared-ts/src/utils/routerAbEcdsaDerivation';
 import { type MpcMaterialActivationRef } from '../../../../../../shared-ts/src/utils/domainIds';
 import { type HydratedEcdsaSignerMaterial } from '../../session/identity/evmFamilyEcdsaIdentity';
 import type { WorkerOperationContext } from '../../workerManager/executeWorkerOperation';
 import { type ThresholdEcdsaChainTarget } from '../../interfaces/ecdsaChainTarget';
 import type { ExactEcdsaCapabilityRuntime, ExactEcdsaMaterialRuntime } from '../../session/material/ecdsaSealedRuntime';
-import { type ReadySecp256k1SigningMaterial } from './signers/secp256k1';
 import type { CanonicalEvmFamilyEcdsaSigningCapability, ExactEvmFamilyWalletSessionAuthorization } from '../../session/material/ecdsaSigningCapability';
 import type { ActiveWalletAuthorityEcdsaRuntimeV1 } from '../../session/material/activeWalletAuthorityEcdsaRuntime';
 import type { ReadonlyExclusiveUnion } from '../../../../../../shared-ts/src/utils/variant';
+export type ReusableEcdsaSigningAuthorization = Extract<RouterAbNormalSigningAuthorizationWire, {
+    readonly kind: 'reusable_wallet_session';
+}>;
+type ReusableEcdsaSigningCredential = {
+    readonly kind: 'reusable_wallet_session';
+    readonly ownershipGeneration: number;
+    readonly walletSessionToken: string;
+    readonly home: WalletSessionHome;
+};
+type OperationStepUpEcdsaSigningCredential = {
+    readonly kind: 'operation_step_up';
+    readonly ownershipGeneration: number;
+    readonly walletSessionToken: string;
+    readonly home: WalletSessionHome;
+};
+type ReadySecp256k1SigningMaterialBase = {
+    kind: 'ready_secp256k1_signing_material';
+    walletId: string;
+    signerSession: HydratedEcdsaSignerMaterial;
+    expiresAtMs: number;
+    singleUseEmailOtpSession: boolean;
+};
+export type ReadySecp256k1SigningMaterial = (ReadySecp256k1SigningMaterialBase & {
+    authorization: ReusableEcdsaSigningAuthorization;
+    credential: ReusableEcdsaSigningCredential;
+    operationStepUpPreparation?: never;
+}) | (ReadySecp256k1SigningMaterialBase & {
+    authorization: Extract<RouterAbNormalSigningAuthorizationWire, {
+        readonly kind: 'operation_step_up';
+    }>;
+    credential: OperationStepUpEcdsaSigningCredential;
+    operationStepUpPreparation: RouterAbEcdsaOperationStepUpPreparationV1Wire;
+});
+export type ReadySecp256k1Signer = {
+    readonly algorithm: 'secp256k1';
+    signReady: (req: SignRequest, material: ReadySecp256k1SigningMaterial, operation: EvmFamilyThresholdEcdsaOperation, operationDigests: OperationDigestSet) => Promise<SignatureBytes>;
+};
+type BuildReadySecp256k1SigningMaterialInputBase = {
+    walletId: unknown;
+    expiresAtMs: number;
+    singleUseEmailOtpSession: boolean;
+    signerSession: HydratedEcdsaSignerMaterial;
+};
+export type BuildReadySecp256k1SigningMaterialInput = (BuildReadySecp256k1SigningMaterialInputBase & {
+    authorization: ReusableEcdsaSigningAuthorization;
+    credential: ReusableEcdsaSigningCredential;
+    operationStepUpPreparation?: never;
+}) | (BuildReadySecp256k1SigningMaterialInputBase & {
+    authorization: Extract<RouterAbNormalSigningAuthorizationWire, {
+        readonly kind: 'operation_step_up';
+    }>;
+    credential: OperationStepUpEcdsaSigningCredential;
+    operationStepUpPreparation: RouterAbEcdsaOperationStepUpPreparationV1Wire;
+});
+export declare function buildReadySecp256k1SigningMaterial(args: BuildReadySecp256k1SigningMaterialInput): ReadySecp256k1SigningMaterial;
 export type ReadySecp256k1SigningMaterialResolution = ReadonlyExclusiveUnion<{
     readonly kind: 'ready';
     readonly material: ReadySecp256k1SigningMaterial;
@@ -47,4 +107,5 @@ export declare function buildActiveWalletAuthorityReadySecp256k1Material(args: {
     readonly chainTarget: ThresholdEcdsaChainTarget;
     readonly relayerUrl: string;
 }): ReadySecp256k1SigningMaterial;
+export {};
 //# sourceMappingURL=readySecp256k1Material.d.ts.map

package/dist/types/wallet/src/core/signingEngine/flows/signEvmFamily/requireEvmFamilyStepUpAuth.d.ts

@@ -3,7 +3,7 @@ import type { EvmFamilyThresholdEcdsaOperation } from './thresholdAdmission';
 import type { EvmFamilyEcdsaEmailOtpStepUpAuthorization, EvmFamilyEcdsaPasskeyStepUpAuthorization } from './stepUpAuthorization';
 import type { EvmFamilySigningAuthSideEffect } from './freshAuthRetryPolicy';
 import type { OperationDigestSet } from '../../../../../../shared-ts/src/authorization/operationFingerprint';
-import type { ReadySecp256k1SigningMaterial } from './signers/secp256k1';
+import type { ReadySecp256k1SigningMaterial } from './readySecp256k1Material';
 import type { PreparedEcdsaOperationStepUp } from '../../threshold/ecdsa/operationStepUp';
 import type { HydratedEcdsaSignerMaterial } from '../../session/identity/evmFamilyEcdsaIdentity';
 import type { SignerAuthMethod } from '../../../../../../shared-ts/src/utils/signerDomain';

package/dist/types/wallet/src/core/signingEngine/flows/signEvmFamily/signers/secp256k1.d.ts

@@ -1,67 +1,17 @@
+import type { PreparedWalletSessionStatus } from '../../../../rpcClients/relayer/walletSessionAuthorizationStatus';
 import type { SignRequest, SignatureBytes } from '../../../interfaces/signing';
 import type { WorkerOperationContext } from '../../../workerManager/executeWorkerOperation';
-import type { HydratedEcdsaSignerMaterial } from '../../../session/identity/evmFamilyEcdsaIdentity';
 import type { EvmFamilyThresholdEcdsaOperation } from '../thresholdAdmission';
+import type { ReadySecp256k1SigningMaterial } from '../readySecp256k1Material';
 import type { OperationDigestSet } from '../../../../../../../shared-ts/src/authorization/operationFingerprint';
-import type { RouterAbNormalSigningAuthorizationWire } from '../../../../../../../shared-ts/src/utils/routerAbNormalSigningIdentity';
-import type { RouterAbEcdsaOperationStepUpPreparationV1Wire } from '../../../../../../../shared-ts/src/utils/routerAbEcdsaDerivation';
-export type ReusableEcdsaSigningAuthorization = Extract<RouterAbNormalSigningAuthorizationWire, {
-    readonly kind: 'reusable_wallet_session';
-}>;
-type ReusableEcdsaSigningCredential = {
-    readonly kind: 'reusable_wallet_session';
-    readonly walletSessionToken: string;
-};
-type OperationStepUpEcdsaSigningCredential = {
-    readonly kind: 'operation_step_up';
-    readonly walletSessionToken: string;
-};
-type ReadySecp256k1SigningMaterialBase = {
-    kind: 'ready_secp256k1_signing_material';
-    walletId: string;
-    signerSession: HydratedEcdsaSignerMaterial;
-    expiresAtMs: number;
-    singleUseEmailOtpSession: boolean;
-};
-export type ReadySecp256k1SigningMaterial = (ReadySecp256k1SigningMaterialBase & {
-    authorization: ReusableEcdsaSigningAuthorization;
-    credential: ReusableEcdsaSigningCredential;
-    operationStepUpPreparation?: never;
-}) | (ReadySecp256k1SigningMaterialBase & {
-    authorization: Extract<RouterAbNormalSigningAuthorizationWire, {
-        readonly kind: 'operation_step_up';
-    }>;
-    credential: OperationStepUpEcdsaSigningCredential;
-    operationStepUpPreparation: RouterAbEcdsaOperationStepUpPreparationV1Wire;
-});
-export type ReadySecp256k1Signer = {
-    readonly algorithm: 'secp256k1';
-    signReady: (req: SignRequest, material: ReadySecp256k1SigningMaterial, operation: EvmFamilyThresholdEcdsaOperation, operationDigests: OperationDigestSet) => Promise<SignatureBytes>;
-};
-type BuildReadySecp256k1SigningMaterialInputBase = {
-    walletId: unknown;
-    expiresAtMs: number;
-    singleUseEmailOtpSession: boolean;
-    signerSession: HydratedEcdsaSignerMaterial;
-};
-export type BuildReadySecp256k1SigningMaterialInput = (BuildReadySecp256k1SigningMaterialInputBase & {
-    authorization: ReusableEcdsaSigningAuthorization;
-    credential: ReusableEcdsaSigningCredential;
-    operationStepUpPreparation?: never;
-}) | (BuildReadySecp256k1SigningMaterialInputBase & {
-    authorization: Extract<RouterAbNormalSigningAuthorizationWire, {
-        readonly kind: 'operation_step_up';
-    }>;
-    credential: OperationStepUpEcdsaSigningCredential;
-    operationStepUpPreparation: RouterAbEcdsaOperationStepUpPreparationV1Wire;
-});
-export declare function buildReadySecp256k1SigningMaterial(args: BuildReadySecp256k1SigningMaterialInput): ReadySecp256k1SigningMaterial;
 export declare class Secp256k1Engine {
     readonly algorithm: "secp256k1";
     private readonly beforeSigning?;
     private readonly shouldAbort?;
     private readonly workerCtx;
+    private readonly reconcileSession;
     constructor(opts: {
+        reconcileSession: (status: PreparedWalletSessionStatus) => Promise<void>;
         beforeSigning?: () => void;
         getRpId?: () => string | null;
         shouldAbort?: () => boolean;
@@ -70,5 +20,4 @@ export declare class Secp256k1Engine {
     private signReadySecp256k1Digest;
     signReady(req: SignRequest, material: ReadySecp256k1SigningMaterial, operation: EvmFamilyThresholdEcdsaOperation, operationDigests: OperationDigestSet): Promise<SignatureBytes>;
 }
-export {};
 //# sourceMappingURL=secp256k1.d.ts.map

package/dist/types/wallet/src/core/signingEngine/flows/signEvmFamily/signingFlow.d.ts

@@ -13,7 +13,7 @@ import type { SigningOperationContext, SigningSessionPlan } from '../../session/
 import type { ThresholdEcdsaChainTarget } from '../../interfaces/ecdsaChainTarget';
 import { type SigningOperationTransitionObserver } from '../shared/signingStateMachine';
 import { type EvmFamilyThresholdEcdsaStepUp } from './requireEvmFamilyStepUpAuth';
-import type { ReadySecp256k1Signer, ReadySecp256k1SigningMaterial } from './signers/secp256k1';
+import type { ReadySecp256k1Signer, ReadySecp256k1SigningMaterial } from './readySecp256k1Material';
 import type { HydratedSecp256k1SigningMaterialResolution, ReadySecp256k1SigningMaterialResolution } from './readySecp256k1Material';
 import type { CapabilityPreparationResult } from '../../session/material/capabilityPreparationResult';
 import type { HydratedEcdsaSignerMaterial } from '../../session/identity/evmFamilyEcdsaIdentity';

package/dist/types/wallet/src/core/signingEngine/flows/signEvmFamily/thresholdAdmission.d.ts

@@ -1,3 +1,4 @@
+import type { WalletSessionOperationCredentialV1 } from '../../../../../../shared-ts/src/device-linking/contracts';
 import type { OperationDigestSet } from '../../../../../../shared-ts/src/authorization/operationFingerprint';
 import type { TransactionSigningIntent } from '../../session/operationState/transactionState';
 import type { SigningAuthPlan } from '../../stepUpConfirmation/types';
@@ -5,7 +6,7 @@ import type { EvmFamilyEcdsaEmailOtpStepUpAuthorization, EvmFamilyEcdsaPasskeySt
 import { type WalletAuthAuthority } from '../../../../../../shared-ts/src/utils/walletAuthAuthority';
 import { type PreparedEcdsaOperationStepUp } from '../../threshold/ecdsa/operationStepUp';
 import type { HydratedEcdsaSignerMaterial } from '../../session/identity/evmFamilyEcdsaIdentity';
-import { type ReadySecp256k1SigningMaterial } from './signers/secp256k1';
+import { type ReadySecp256k1SigningMaterial } from './readySecp256k1Material';
 /** The operation a step-up authorizes: the intent it was prepared for, and the
  * plan that will authorize it. It carries no `SelectedEcdsaLane` — an
  * auth-neutral candidate has none, and nothing here ever read one. */
@@ -26,7 +27,7 @@ export declare function authorizeEvmFamilyEcdsaOperationStepUp(args: {
     readonly authorization: EvmFamilyEcdsaOperationStepUpAuthorization;
     readonly prepared: PreparedEcdsaOperationStepUp;
     readonly material: HydratedEcdsaSignerMaterial;
-    readonly walletSessionToken: string;
+    readonly operationCredential: WalletSessionOperationCredentialV1;
 }): Promise<ReadySecp256k1SigningMaterial>;
 export {};
 //# sourceMappingURL=thresholdAdmission.d.ts.map

package/dist/types/wallet/src/core/signingEngine/flows/signNear/shared/ed25519YaoNormalSigning.d.ts

@@ -1,9 +1,11 @@
+import type { SigningSessionCoordinator } from '../../../session/SigningSessionCoordinator';
 import type { ThresholdEd25519KeyMaterial } from '../../../../accountData/near/nearAccountData.types';
 import { WorkerRequestType, type DelegatePayload, type TransactionPayload, type WasmSignedDelegate, type WorkerSuccessResponse } from '../../../../types/signer-worker';
 import type { RouterAbEd25519YaoActiveClientV1 } from '../../../threshold/ed25519/yaoClient';
 import type { TransactionContext } from '../../../../types/rpc';
 import type { NearSigningRuntimeDeps } from '../../../interfaces/runtime';
 import type { WalletId } from '../../../interfaces/ecdsaChainTarget';
+import { prepareRouterAbNormalSigningV2, type RouterAbNormalSigningPrepareRequestV2BuildResult } from '../../../../rpcClients/relayer/routerAbNormalSigning';
 import type { SigningOperationFingerprint, SigningOperationId } from '../../../session/operationState/types';
 import type { AuthorizedRouterAbEd25519WalletSessionState } from '../../../session/warmCapabilities/routerAbEd25519WalletSessionState';
 import { type ThresholdEd25519NearAction } from '../../../../../../../shared-ts/src/threshold/ed25519OperationFingerprint';
@@ -25,7 +27,8 @@ export type RouterAbEd25519SignatureOnlyIntentWire = {
     message: string;
     recipient: string;
     nonce: string;
-    state?: string;
+    callbackUrl: string | null;
+    state?: never;
 } | {
     kind: 'near_delegate_action_v1';
     delegate: {
@@ -69,6 +72,18 @@ export declare function finalizeThresholdEd25519DelegateSignatureResult(args: {
     signedDelegate: WasmSignedDelegate;
     hash: string;
 }>;
+type Ed25519PrepareSessionResult = Awaited<ReturnType<typeof prepareRouterAbNormalSigningV2>>;
+/**
+ * A prepare sent while the confirmation dialog is open. It is bound to the
+ * digest the dialog shows and to the signing digest, so the signature after
+ * the confirmation can only use it for the same operation.
+ */
+export type RouterAbEd25519StartedPrepare = {
+    readonly prepare: RouterAbNormalSigningPrepareRequestV2BuildResult;
+    readonly displayDigest: string;
+    readonly signingDigestB64u: string;
+    readonly response: Promise<Ed25519PrepareSessionResult>;
+};
 type RouterAbEd25519SignatureOnlyNormalSigningBase = {
     ctx: NearSigningRuntimeDeps;
     thresholdSessionId: string;
@@ -84,12 +99,15 @@ type RouterAbEd25519SignatureOnlyNormalSigningBase = {
 };
 type RouterAbEd25519SignatureOnlyNormalSigningArgs = RouterAbEd25519SignatureOnlyNormalSigningBase & ({
     walletSessionState: AuthorizedRouterAbEd25519WalletSessionState;
+    sessionCoordinator: SigningSessionCoordinator;
     authorization: {
         kind: 'reusable_wallet_session';
     };
+    startedPrepare?: RouterAbEd25519StartedPrepare;
 } | {
     materialFacts: NearEd25519YaoOperationMaterialFacts;
     walletSessionState?: never;
+    sessionCoordinator?: never;
     authorization: {
         kind: 'operation_step_up';
         prepared: Extract<PreparedNearOperationStepUp, {
@@ -136,6 +154,18 @@ export declare function buildNearEd25519OperationStepUpProof(args: {
 }): Ed25519OperationStepUpProof;
 export declare function requireNearEd25519OperationStepUpProof(proof: Ed25519OperationStepUpProof | null): Ed25519OperationStepUpProof;
 export declare function tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning(args: RouterAbEd25519SignatureOnlyNormalSigningArgs): Promise<RouterAbEd25519SignatureOnlyNormalSigningResult | null>;
+type RouterAbEd25519SignatureOnlyWarmArgs = RouterAbEd25519SignatureOnlyNormalSigningBase & {
+    walletSessionState: AuthorizedRouterAbEd25519WalletSessionState;
+};
+/**
+ * Sends the prepare of a warm-session signature before the user confirms.
+ * The caller shows the dialog meanwhile and passes the result to the
+ * signature; a result that is never passed on expires with its lease and
+ * keeps the quota use it claimed.
+ */
+export declare function startRouterAbEd25519SignatureOnlyPrepare(args: RouterAbEd25519SignatureOnlyWarmArgs): Promise<RouterAbEd25519StartedPrepare | null>;
+/** Leaves a started prepare to expire with its lease. */
+export declare function abandonRouterAbEd25519StartedPrepare(started: RouterAbEd25519StartedPrepare): void;
 export declare function prepareRouterAbEd25519NearTransactionOperationStepUp(args: {
     ctx: NearSigningRuntimeDeps;
     thresholdSessionId: string;
@@ -168,12 +198,16 @@ type RouterAbEd25519NearTransactionNormalSigningBase = {
 };
 type RouterAbEd25519NearTransactionNormalSigningArgs = RouterAbEd25519NearTransactionNormalSigningBase & ({
     walletSessionState: AuthorizedRouterAbEd25519WalletSessionState;
+    sessionCoordinator: SigningSessionCoordinator;
     authorization: {
         kind: 'reusable_wallet_session';
     };
+    startedPrepare?: RouterAbEd25519StartedPrepare | null;
 } | {
     materialFacts: NearEd25519YaoOperationMaterialFacts;
     walletSessionState?: never;
+    sessionCoordinator?: never;
+    startedPrepare?: never;
     authorization: {
         kind: 'operation_step_up';
         prepared: Extract<PreparedNearOperationStepUp, {
@@ -184,6 +218,16 @@ type RouterAbEd25519NearTransactionNormalSigningArgs = RouterAbEd25519NearTransa
         issuedAuthorization: NearEd25519OperationStepUpAuthorization | null;
     };
 });
+type RouterAbEd25519NearTransactionWarmPrepareArgs = Pick<RouterAbEd25519NearTransactionNormalSigningBase, 'activeClient' | 'walletId' | 'operationId' | 'displayDigest' | 'nearAccountId'> & {
+    walletSessionState: AuthorizedRouterAbEd25519WalletSessionState;
+};
+/**
+ * Sends the prepare of a warm-session transaction while the confirmation
+ * dialog is open. The transaction context is the one the dialog reserved.
+ */
+export declare function startRouterAbEd25519NearTransactionPrepare(args: RouterAbEd25519NearTransactionWarmPrepareArgs & Pick<RouterAbEd25519NearTransactionNormalSigningBase, 'ctx' | 'thresholdSessionId' | 'thresholdKeyMaterial' | 'txSigningRequest'> & {
+    transactionContext: TransactionContext;
+}): Promise<RouterAbEd25519StartedPrepare>;
 export declare function tryFinalizeRouterAbEd25519NearTransactionNormalSigning(args: RouterAbEd25519NearTransactionNormalSigningArgs): Promise<RouterAbEd25519NearTransactionNormalSigningResult | null>;
 export {};
 //# sourceMappingURL=ed25519YaoNormalSigning.d.ts.map

package/dist/types/wallet/src/core/signingEngine/flows/signNear/shared/signatureOnlySigning.d.ts

@@ -15,7 +15,7 @@ import { type ConfirmSignatureOnlySigningOperationRequest, type ConfirmSignature
 import { type NearPreparedStepUpAuth } from '../requireNearStepUpAuth';
 import { type PreparedNearOperationStepUp } from './operationStepUpPreparation';
 import { resolveConfirmedNearEd25519YaoCapability, type NearOperationStepUpMaterial, type ResolvedNearOperationStepUpMaterial } from './ed25519YaoCapabilityResolution';
-import { type RouterAbEd25519SignatureOnlyIntentWire } from './ed25519YaoNormalSigning';
+import { type RouterAbEd25519SignatureOnlyIntentWire, type RouterAbEd25519StartedPrepare } from './ed25519YaoNormalSigning';
 /** One delegate-action or NEP-413 signing operation, fixed before its step-up starts. */
 export type NearSignatureOnlyOperation = {
     /** Names the operation in error messages. */
@@ -63,6 +63,7 @@ type NearSignatureOnlySigningMaterial = {
     thresholdSessionId: ThresholdEd25519SessionId;
     displayDigest: string;
     resolved: Awaited<ReturnType<typeof resolveConfirmedNearEd25519YaoCapability>>;
+    startedPrepare?: RouterAbEd25519StartedPrepare;
 } | {
     kind: 'operation_step_up';
     thresholdSessionId: ThresholdEd25519SessionId;
@@ -113,7 +114,20 @@ export declare function confirmNearSignatureOnlyOperation(operation: NearSignatu
 }): Promise<ConfirmSignatureOnlySigningOperationResult>;
 /** Turns the confirmation into the authorization that the signing step presents. */
 export declare function authorizeNearSignatureOnlyOperation(operation: NearSignatureOnlyOperation, stepUp: NearSignatureOnlyStepUp, confirmation: ConfirmSignatureOnlySigningOperationResult): NearSignatureOnlyAuthorization;
-export declare function resolveNearSignatureOnlySigningMaterial(operation: NearSignatureOnlyOperation, authorization: NearSignatureOnlyAuthorization): Promise<NearSignatureOnlySigningMaterial>;
+/** A prepare that left while the confirmation dialog was open. */
+export type NearSignatureOnlyStartedPrepare = {
+    readonly resolved: Awaited<ReturnType<typeof resolveConfirmedNearEd25519YaoCapability>>;
+    readonly started: RouterAbEd25519StartedPrepare;
+};
+/**
+ * Sends the server prepare of a warm-session NEP-413 signature while the
+ * confirmation dialog is open. The request is bound to the digest the dialog
+ * shows and to the signing digest. A confirmation that returns another digest,
+ * a declined confirmation or a step-up leaves the prepare to expire with its
+ * lease; the quota use it claimed stays spent.
+ */
+export declare function startNearSignatureOnlyPrepare(operation: NearSignatureOnlyOperation, stepUp: NearSignatureOnlyStepUp, signingSessionCoordinator: SigningSessionCoordinator): Promise<NearSignatureOnlyStartedPrepare | null>;
+export declare function resolveNearSignatureOnlySigningMaterial(operation: NearSignatureOnlyOperation, authorization: NearSignatureOnlyAuthorization, startedPrepare?: NearSignatureOnlyStartedPrepare | null): Promise<NearSignatureOnlySigningMaterial>;
 /** Signs through Router A/B with the reusable Wallet Session or the operation step-up. */
 export declare function signNearSignatureOnlyOperation(operation: NearSignatureOnlyOperation, material: NearSignatureOnlySigningMaterial, signingSessionCoordinator: SigningSessionCoordinator): Promise<{
     signingDigestB64u: string;

package/dist/types/wallet/src/core/signingEngine/flows/signNear/signNear.d.ts

@@ -17,6 +17,7 @@ type SignNep413MessagePayload = {
     message: string;
     recipient: string;
     nonce: string;
+    callbackUrl: string | null;
     state: string | null;
     commandSubject: NearCommandSubject;
     onEvent?: (update: SigningFlowEvent) => void;
@@ -84,8 +85,6 @@ export type NearSignIntentResult<TRequest extends NearSignIntentRequest> = TRequ
     kind: infer TKind;
 } ? TKind extends keyof NearSignIntentResultByKind ? NearSignIntentResultByKind[TKind] : never : never;
 export declare function signNear<TRequest extends NearSignIntentRequest>(deps: NearSigningApiDeps, request: TRequest): Promise<NearSignIntentResult<TRequest>>;
-export declare function signTransactionWithActions(deps: NearSigningApiDeps, args: SignTransactionWithActionsInput): Promise<SignTransactionResult>;
 export declare function signDelegateAction(deps: NearSigningApiDeps, args: SignDelegateActionInput): Promise<SignDelegateActionResult>;
-export declare function signNEP413Message(deps: NearSigningApiDeps, payload: SignNep413MessagePayload): Promise<SignNep413MessageResult>;
 export {};
 //# sourceMappingURL=signNear.d.ts.map

package/dist/types/wallet/src/core/signingEngine/flows/signNear/signNep413.d.ts

@@ -3,7 +3,7 @@ import type { ExclusiveUnion } from '../../../../../../shared-ts/src/utils/varia
 /**
  * Sign a NEP-413 message using the active threshold-controlled NEAR key.
  *
- * @param payload - NEP-413 signing parameters including message, recipient, nonce, and state
+ * @param payload - NEP-413 payload and response transport state
  * @returns Promise resolving to signing result with account ID, public key, and signature
  */
 type InternalSignNep413MessageResult = ExclusiveUnion<{

package/dist/types/wallet/src/core/signingEngine/interfaces/ecdsaChainTarget.d.ts

@@ -85,7 +85,7 @@ export declare function thresholdEcdsaChainTargetFromChainFamily(args: {
  * `rpcUrl` and `explorerUrl` are accepted so a full `SeamsChainConfig` stays
  * assignable, but they are ignored: the RPC endpoint is resolved at execution
  * time from `configs.network.chains` by target key (`resolveEvmFamilyRpcUrl`).
- * Prefer `seams.chainTarget(selector)`, which can only name a configured chain.
+ * Prefer `seams.config.chainTarget(selector)`, which can only name a configured chain.
  */
 export declare function thresholdEcdsaChainTargetFromConfig(chain: ThresholdEcdsaChainTargetConfigInput): ThresholdEcdsaChainTarget;
 export declare function configuredThresholdEcdsaChainTargets(chains: readonly SeamsChainConfig[]): ThresholdEcdsaChainTarget[];