@seams/wallet 0.7.1 → 0.7.3

package/dist/types/wallet/src/core/signingEngine/session/warmCapabilities/capabilityReaderCore.d.ts

@@ -1,9 +1,7 @@
 import type { ActiveEcdsaCapabilityRuntimeForChainResolver, ActiveEcdsaCapabilityRuntimeResolver } from '../material/activeEcdsaCapabilityRuntime';
-import type { EcdsaSealTransportAuthMaterial } from '../persistence/sealedSessionTransportAuth';
-import type { ExactEcdsaSigningLaneIdentity } from '../identity/exactSigningLaneIdentity';
-import type { ExactEcdsaWalletSessionAuthorizationResolver, ExactEvmFamilyWalletSessionAuthorization } from '../material/ecdsaSigningCapability';
+import type { ExactEcdsaWalletSessionAuthorizationResolver } from '../material/ecdsaSigningCapability';
 import { type WalletId } from '../../interfaces/ecdsaChainTarget';
-import type { WarmSessionEcdsaCapabilityState, WarmSessionEnvelope } from './types';
+import type { WarmSessionCapabilityReader } from './types';
 import type { WarmSigningStatusReader } from './statusReader';
 import type { ExactNearEd25519WalletSessionAuthorization } from '../material/nearEd25519YaoSigningPreparation';
 type WarmSessionCapabilityReaderSealConfigured = {
@@ -23,17 +21,6 @@ type WarmSessionCapabilityReaderCoreDeps = {
     resolveActiveEcdsaWalletSessionAuthorization?: ExactEcdsaWalletSessionAuthorizationResolver;
     resolveActiveEd25519WalletSessionAuthorization?: (walletId: WalletId) => Promise<ExactNearEd25519WalletSessionAuthorization | null>;
 };
-type WarmSessionCapabilityReaderCore = {
-    getWarmSession: (walletId: WalletId) => Promise<WarmSessionEnvelope>;
-    getEcdsaCapabilityForLane: (args: {
-        lane: ExactEcdsaSigningLaneIdentity;
-        authorization: ExactEvmFamilyWalletSessionAuthorization;
-    }) => Promise<WarmSessionEcdsaCapabilityState | null>;
-    resolveEcdsaSealTransportForLane: (args: {
-        lane: ExactEcdsaSigningLaneIdentity;
-        authorization: ExactEvmFamilyWalletSessionAuthorization;
-    }) => Promise<EcdsaSealTransportAuthMaterial | null>;
-};
-export declare function createWarmSessionCapabilityReaderCore(deps: WarmSessionCapabilityReaderCoreDeps): WarmSessionCapabilityReaderCore;
+export declare function createWarmSessionCapabilityReaderCore(deps: WarmSessionCapabilityReaderCoreDeps): WarmSessionCapabilityReader;
 export {};
 //# sourceMappingURL=capabilityReaderCore.d.ts.map

package/dist/types/wallet/src/core/signingEngine/session/warmCapabilities/ed25519SealedSessionRuntime.d.ts

@@ -12,21 +12,17 @@ import type { RouterAbEd25519NormalSigningState } from '../../threshold/ed25519/
 import type { ExactEd25519SigningLaneIdentity } from '../identity/exactSigningLaneIdentity';
 import { type WalletAuthAuthorityRef } from '../../../../../../shared-ts/src/utils/walletAuthAuthority';
 import type { WalletAuthMethodId } from '../../../../../../shared-ts/src/utils/domainIds';
-type Ed25519SealedSessionFactor = {
+import type { ReadonlyExclusiveUnion } from '../../../../../../shared-ts/src/utils/variant';
+type Ed25519SealedSessionFactor = ReadonlyExclusiveUnion<{
     readonly kind: 'passkey';
     readonly rpId: ReturnType<typeof toRpId>;
     readonly credentialIdB64u: string;
-    readonly provider?: never;
-    readonly providerSubjectId?: never;
-    readonly emailHashHex?: never;
 } | {
     readonly kind: 'email_otp';
     readonly provider: 'google' | 'email';
     readonly providerSubjectId: string;
     readonly emailHashHex: string;
-    readonly rpId?: never;
-    readonly credentialIdB64u?: never;
-};
+}>;
 export type ExactEd25519SealedSessionRuntime = {
     readonly kind: 'exact_ed25519_sealed_session_runtime';
     readonly sealedRecord: CurrentEd25519SealedSessionRecord;
@@ -47,32 +43,16 @@ export type ExactEd25519SealedSessionRuntime = {
     readonly signingRootVersion: string;
     readonly routerAbNormalSigning: RouterAbEd25519NormalSigningState;
 };
-type Ed25519SealedSessionRuntimeResolution = {
-    readonly kind: 'resolved';
-    readonly runtime: ExactEd25519SealedSessionRuntime;
-} | {
-    readonly kind: 'missing';
-    readonly runtime?: never;
-} | {
-    readonly kind: 'conflict';
-    readonly runtime?: never;
-} | {
-    readonly kind: 'corrupt';
-    readonly runtime?: never;
-};
-export type Ed25519WalletSealedSessionRuntimeResolution = {
+export type Ed25519WalletSealedSessionRuntimeResolution = ReadonlyExclusiveUnion<{
     readonly kind: 'resolved';
     readonly runtime: ExactEd25519SealedSessionRuntime;
 } | {
     readonly kind: 'missing';
-    readonly runtime?: never;
 } | {
     readonly kind: 'conflict';
-    readonly runtime?: never;
 } | {
     readonly kind: 'corrupt';
-    readonly runtime?: never;
-};
+}>;
 export declare function parseExactEd25519SealedSessionRuntime(record: CurrentEd25519SealedSessionRecord): ExactEd25519SealedSessionRuntime | null;
 export declare function ed25519SealedRuntimeAuthorityRef(args: {
     runtime: ExactEd25519SealedSessionRuntime;
@@ -85,7 +65,7 @@ export declare function ed25519AuthorizationIdentityMatchesRuntime(args: {
 export declare function resolveExactEd25519SealedSessionRuntimeForLane(args: {
     readonly walletId: WalletId;
     readonly laneIdentity: ExactEd25519SigningLaneIdentity;
-}): Promise<Ed25519SealedSessionRuntimeResolution>;
+}): Promise<Ed25519WalletSealedSessionRuntimeResolution>;
 export declare function resolveExactEd25519SealedSessionRuntimeForWallet(walletId: WalletId): Promise<Ed25519WalletSealedSessionRuntimeResolution>;
 export declare function resolveExactEd25519SealedSessionRuntimeForWalletSubject(args: {
     walletId: WalletId;

package/dist/types/wallet/src/core/signingEngine/session/warmCapabilities/persistencePorts.d.ts

@@ -2,15 +2,14 @@ import type { ThresholdEcdsaChainTarget, WalletId } from '../../interfaces/ecdsa
 import type { ThresholdEcdsaEmailOtpAuthContext } from '../identity/laneIdentity';
 import type { ThresholdEcdsaSessionId } from '../operationState/types';
 import type { MpcWalletSigningQuotaId, WalletSessionId } from '../../../../../../shared-ts/src/authorization/capabilityKinds';
-type EmailOtpWarmSessionMaterial = {
+import type { ExclusiveUnion } from '../../../../../../shared-ts/src/utils/variant';
+type EmailOtpWarmSessionMaterial = ExclusiveUnion<{
     kind: 'inline';
     clientSecretB64u: string;
-    workerSessionId?: never;
 } | {
     kind: 'worker_handle';
     workerSessionId: string;
-    clientSecretB64u?: never;
-};
+}>;
 type BaseEmailOtpReadyPersistInput = {
     authMethod: 'email_otp';
     walletId: WalletId;

package/dist/types/wallet/src/core/signingEngine/stepUpConfirmation/channel/confirmTypes.d.ts

@@ -11,6 +11,7 @@ import type { SigningOperationConfirmationStateKind } from '../../flows/shared/s
 import type { WalletRecoveryRegistrationOptions } from '../../../rpcClients/relayer/walletRecoveryPrepare';
 import type { WalletAddAuthMethodRegistrationOptions } from '../../../rpcClients/relayer/walletRegistration';
 import { UserConfirmationType } from '../userConfirmationType';
+import type { ExclusiveUnion } from '../../../../../../shared-ts/src/utils/variant';
 export { UserConfirmationType } from '../userConfirmationType';
 export type { ForbiddenMainThreadSecrets, RegistrationConfirmationDiagnostics, SerializableCredential, UserConfirmDecision, WalletSessionExpiredConfirmationFailure, WebAuthnChallenge, } from '../types';
 export declare enum UserConfirmMessageType {
@@ -109,13 +110,11 @@ export type WorkerConfirmationResponse = (WorkerConfirmationSuccessBase & {
     near_transaction_readiness?: never;
     transaction_context?: never;
     nonce_leases?: never;
-} & ({
+} & ExclusiveUnion<{
     wallet_session_failure: WalletSessionExpiredConfirmationFailure;
-    error?: never;
 } | {
-    wallet_session_failure?: never;
     error?: string;
-}));
+}>);
 interface RegistrationSummary {
     walletId: string;
     nearAccountId?: string;
@@ -171,97 +170,73 @@ type SignTransactionPayloadBase = {
 type NearTransactionSigningPayload = SignTransactionPayloadBase & {
     signingKind: 'transaction';
     signingOperationStateKind: SigningOperationConfirmationStateKind;
-} & ({
+} & ExclusiveUnion<{
     signingAuthPlan: Extract<SigningAuthPlan, {
         kind: 'warmSession';
     }>;
     nearFundingRequest: NearFundingRequest;
-    webauthnChallenge?: never;
-    emailOtpPrompt?: never;
 } | {
     signingAuthPlan: Extract<SigningAuthPlan, {
         kind: 'active_wallet_authority';
     }>;
     nearFundingRequest: NearFundingRequest;
-    webauthnChallenge?: never;
-    emailOtpPrompt?: never;
 } | {
     signingAuthPlan: Extract<SigningAuthPlan, {
         kind: 'passkeyReauth';
     }>;
     nearFundingRequest: NearFundingRequest;
     webauthnChallenge?: WebAuthnChallenge;
-    emailOtpPrompt?: never;
 } | {
     signingAuthPlan: Extract<SigningAuthPlan, {
         kind: 'emailOtpReauth';
     }>;
     nearFundingRequest: NearFundingRequest;
-    webauthnChallenge?: never;
     emailOtpPrompt: EmailOtpConfirmPrompt;
-});
+}>;
 type NearDelegateSigningPayload = SignTransactionPayloadBase & {
     signingKind: 'delegate';
     nearFundingRequest?: never;
-} & ({
+} & ExclusiveUnion<{
     signingAuthPlan: Extract<SigningAuthPlan, {
         kind: 'warmSession';
     }>;
-    webauthnChallenge?: never;
-    emailOtpPrompt?: never;
 } | {
     signingAuthPlan: Extract<SigningAuthPlan, {
         kind: 'active_wallet_authority';
     }>;
-    webauthnChallenge?: never;
-    emailOtpPrompt?: never;
 } | {
     signingAuthPlan: Extract<SigningAuthPlan, {
         kind: 'passkeyReauth';
     }>;
     webauthnChallenge?: WebAuthnChallenge;
-    emailOtpPrompt?: never;
 } | {
     signingAuthPlan: Extract<SigningAuthPlan, {
         kind: 'emailOtpReauth';
     }>;
-    webauthnChallenge?: never;
     emailOtpPrompt: EmailOtpConfirmPrompt;
-});
+}>;
 export type SignTransactionPayload = NearTransactionSigningPayload | NearDelegateSigningPayload;
-export type RegisterAccountPayload = {
+export type RegisterAccountPayload = ExclusiveUnion<{
     walletId: string;
     nearAccountId?: string;
     signerSlot?: number;
     webauthnChallenge?: Extract<WebAuthnChallenge, {
         kind: 'intent_digest';
     }>;
-    walletRecoveryRegistration?: never;
-    walletAddAuthMethodRegistration?: never;
 } | {
     walletId: string;
     walletRecoveryRegistration: WalletRecoveryRegistrationOptions;
-    nearAccountId?: never;
-    signerSlot?: never;
-    webauthnChallenge?: never;
-    walletAddAuthMethodRegistration?: never;
 } | {
     walletId: string;
     walletAddAuthMethodRegistration: WalletAddAuthMethodRegistrationOptions;
-    nearAccountId?: never;
-    signerSlot?: never;
-    webauthnChallenge?: never;
-    walletRecoveryRegistration?: never;
-};
-export type LocalOnlyExportSubject = {
+}>;
+export type LocalOnlyExportSubject = ExclusiveUnion<{
     kind: 'near_wallet';
     nearAccountId: string;
-    walletId?: never;
 } | {
     kind: 'evm_wallet';
     walletId: string;
-    nearAccountId?: never;
-};
+}>;
 export interface AuthorizeKeyExportPayload {
     subject: LocalOnlyExportSubject;
     credentialIdB64u: string;

package/dist/types/wallet/src/core/signingEngine/stepUpConfirmation/otpPrompt/authLane.d.ts

@@ -1,6 +1,7 @@
 import { type ThresholdEcdsaChainTarget } from '../../interfaces/ecdsaChainTarget';
 import { WALLET_EMAIL_OTP_EXPORT_OPERATION, WALLET_EMAIL_OTP_REGISTRATION_OPERATION, WALLET_EMAIL_OTP_TRANSACTION_SIGN_OPERATION, type WalletEmailOtpLoginOperation } from '../../../../../../shared-ts/src/utils/emailOtpDomain';
 import { type WalletSessionOperationCredentialV1 } from '../../../../../../shared-ts/src/device-linking';
+import type { ExclusiveUnion } from '../../../../../../shared-ts/src/utils/variant';
 export type EmailOtpAuthLane = EmailOtpSigningSessionAuthLane;
 export type EmailOtpSigningSessionAuthLane = {
     kind: 'signing_session';
@@ -14,32 +15,28 @@ export type EmailOtpSigningSessionAuthLane = {
     chainTarget: ThresholdEcdsaChainTarget;
 };
 export type EmailOtpRouteFamily = 'login' | 'registration' | 'signing_session';
-export type EmailOtpRoutePlan = {
+export type EmailOtpRoutePlan = ExclusiveUnion<{
     routeFamily: 'login';
-    authLane?: never;
     operation: WalletEmailOtpLoginOperation;
 } | {
     routeFamily: 'registration';
-    authLane?: never;
     operation: typeof WALLET_EMAIL_OTP_REGISTRATION_OPERATION;
 } | {
     routeFamily: 'signing_session';
     authLane: EmailOtpSigningSessionAuthLane;
     operation: typeof WALLET_EMAIL_OTP_TRANSACTION_SIGN_OPERATION | typeof WALLET_EMAIL_OTP_EXPORT_OPERATION;
-};
-export declare function buildEmailOtpRoutePlan(args: {
+}>;
+export declare function buildEmailOtpRoutePlan(args: ExclusiveUnion<{
     routeFamily: 'login';
-    authLane?: never;
     operation: WalletEmailOtpLoginOperation;
 } | {
     routeFamily: 'registration';
-    authLane?: never;
     operation: typeof WALLET_EMAIL_OTP_REGISTRATION_OPERATION;
 } | {
     routeFamily: 'signing_session';
     authLane: EmailOtpSigningSessionAuthLane;
     operation: typeof WALLET_EMAIL_OTP_TRANSACTION_SIGN_OPERATION | typeof WALLET_EMAIL_OTP_EXPORT_OPERATION;
-}): EmailOtpRoutePlan;
+}>): EmailOtpRoutePlan;
 export declare function emailOtpRoutePath(plan: EmailOtpRoutePlan, action: 'challenge' | 'seal' | 'finalize'): string;
 export declare function normalizeEmailOtpRoutePlan(value: unknown): EmailOtpRoutePlan | undefined;
 //# sourceMappingURL=authLane.d.ts.map

package/dist/types/wallet/src/core/signingEngine/stepUpConfirmation/passkeyPrompt/touchIdPrompt.d.ts

@@ -3,19 +3,17 @@ import type { WebAuthnAuthenticationCredential } from '../../../types/webauthn';
 import { type RegistrationWebAuthnPromptOwner, type ReservedRegistrationWebAuthnPrompt, type WebAuthnPromptCancellation } from './webauthnPromptCoordinator';
 import type { WalletRecoveryRegistrationOptions } from '../../../rpcClients/relayer/walletRecoveryPrepare';
 import type { WalletAddAuthMethodRegistrationOptions } from '../../../rpcClients/relayer/walletRegistration';
-export type RegistrationCredentialPrompt = {
+import type { ExclusiveUnion } from '../../../../../../shared-ts/src/utils/variant';
+export type RegistrationCredentialPrompt = ExclusiveUnion<{
     kind: 'immediate';
     requestId: string;
     cancellation: WebAuthnPromptCancellation;
-    reservation?: never;
-    owner?: never;
 } | {
     kind: 'reserved';
     reservation: ReservedRegistrationWebAuthnPrompt;
     owner: RegistrationWebAuthnPromptOwner;
     cancellation: WebAuthnPromptCancellation;
-    requestId?: never;
-};
+}>;
 type RegisterCredentialsArgsCommon = {
     walletId: string;
     intendedUserName: string;

package/dist/types/wallet/src/core/signingEngine/stepUpConfirmation/passkeyPrompt/webauthnPromptCoordinator.d.ts

@@ -1,4 +1,5 @@
 import type { WalletIframeAuthMenuSessionId, WalletIframeRequestId } from '../../../types/walletIframeIdentity';
+import type { ExclusiveUnion } from '../../../../../../shared-ts/src/utils/variant';
 export type WebAuthnPromptReservationId = string & {
     readonly __webAuthnPromptReservationId: unique symbol;
 };
@@ -25,22 +26,16 @@ export type ReservedRegistrationWebAuthnPrompt<Owner extends RegistrationWebAuth
     owner: Owner;
     expiresAtMs: number;
 };
-export type WebAuthnPromptCoordinatorState = {
+export type WebAuthnPromptCoordinatorState = ExclusiveUnion<{
     kind: 'idle';
-    reservation?: never;
-    operationId?: never;
-    owner?: never;
 } | {
     kind: 'reserved';
     reservation: ReservedRegistrationWebAuthnPrompt;
-    operationId?: never;
-    owner?: never;
 } | {
     kind: 'running';
     operationId: WebAuthnPromptOperationId;
     owner: WebAuthnPromptOwner;
-    reservation?: never;
-};
+}>;
 export type WebAuthnPromptCancellation = {
     kind: 'none';
     signal?: never;

package/dist/types/wallet/src/core/signingEngine/stepUpConfirmation/types.d.ts

@@ -8,6 +8,7 @@ import type { NearOperationStepUpPreparationRef } from '../interfaces/operationS
 import type { ActiveWalletAuthorityEcdsaSigningAuthPlan } from '../session/material/activeWalletAuthorityEcdsaRuntime';
 import type { ExactEvmFamilyWalletSessionAuthorization } from '../session/material/ecdsaSigningCapability';
 import type { MpcMaterialActivationRef } from '../../../../../shared-ts/src/utils/domainIds';
+import type { ExclusiveUnion } from '../../../../../shared-ts/src/utils/variant';
 export interface UserConfirmProgressEvent {
     requestId: string;
     step: number;
@@ -59,19 +60,12 @@ type UserConfirmSuccessDecisionBase = UserConfirmDecisionBase & {
     registrationDiagnostics?: RegistrationConfirmationDiagnostics;
     error?: never;
 };
-type UserConfirmSuccessDecision = UserConfirmSuccessDecisionBase & ({
+type UserConfirmSuccessDecision = UserConfirmSuccessDecisionBase & ExclusiveUnion<{
     nearTransactionReadiness: NearTransactionReadiness;
-    transactionContext?: never;
-    nonceLeases?: never;
 } | {
-    nearTransactionReadiness?: never;
     transactionContext: TransactionContext;
     nonceLeases?: NonceLeaseRef[];
-} | {
-    nearTransactionReadiness?: never;
-    transactionContext?: never;
-    nonceLeases?: never;
-});
+} | {}>;
 type UserConfirmFailureDecisionBase = UserConfirmDecisionBase & {
     confirmed: false;
     registrationDiagnostics?: RegistrationConfirmationDiagnostics;
@@ -85,13 +79,11 @@ type UserConfirmFailureDecisionBase = UserConfirmDecisionBase & {
 export type WalletSessionExpiredConfirmationFailure = Extract<WalletSessionFailure, {
     readonly kind: 'expired';
 }>;
-type UserConfirmFailureDecision = UserConfirmFailureDecisionBase & ({
+type UserConfirmFailureDecision = UserConfirmFailureDecisionBase & ExclusiveUnion<{
     walletSessionFailure: WalletSessionExpiredConfirmationFailure;
-    error?: never;
 } | {
-    walletSessionFailure?: never;
     error?: string;
-});
+}>;
 export type UserConfirmDecision = UserConfirmSuccessDecision | UserConfirmFailureDecision;
 export type SigningAuthMode = 'webauthn' | 'warmSession' | 'emailOtp';
 export declare const SigningAuthPlanKind: {
@@ -146,25 +138,18 @@ export type SigningAuthPlan = WarmSessionSigningAuthPlan | ActiveWalletAuthority
     method: 'email_otp';
     emailOtpPrompt?: EmailOtpConfirmPrompt;
 };
-export type WebAuthnChallenge = {
+export type WebAuthnChallenge = ExclusiveUnion<{
     kind: 'intent_digest';
     challengeB64u: string;
-    digest32B64u?: never;
-    requestId?: never;
-    thresholdSessionId?: never;
 } | {
     kind: 'threshold_session_policy';
     digest32B64u: string;
-    challengeB64u?: never;
-    requestId?: never;
-    thresholdSessionId?: never;
 } | {
     kind: 'ecdsa_role_local_bootstrap';
     digest32B64u: string;
     requestId: string;
     thresholdSessionId: string;
-    challengeB64u?: never;
-};
+}>;
 export declare function isWarmSessionSigningAuthPlan(plan: Pick<SigningAuthPlan, 'kind'> | null | undefined): plan is Extract<SigningAuthPlan, {
     kind: typeof SigningAuthPlanKind.WarmSession;
 }>;

package/dist/types/wallet/src/core/signingEngine/threshold/commitQueueShared.d.ts

@@ -1,7 +1,8 @@
-type ThresholdCommitQueueErrorCode = 'commit_queue_overflow' | 'commit_queue_timeout' | 'cancelled';
-export type ThresholdCommitQueueCancelledReason = 'cancelled' | 'queue_cleared';
-export type ThresholdCommitQueueError = Error & {
-    code: ThresholdCommitQueueErrorCode;
+import type { MpcMaterialActivationRef } from '../../../../../shared-ts/src/utils/domainIds';
+type ThresholdCommitQueueCancelledReason = 'cancelled' | 'queue_cleared';
+type ThresholdCommitQueueLabels = {
+    readonly queue: string;
+    readonly queuedOperation: string;
 };
 type ThresholdCommitQueueItem = {
     enqueuedAtMs: number;
@@ -19,21 +20,20 @@ type ThresholdCommitQueueState = {
     items: ThresholdCommitQueueItem[];
 };
 export type ThresholdCommitQueueByKey = Map<string, ThresholdCommitQueueState>;
-type ThresholdCommitQueueErrorFactory = {
-    makeOverflowError: (queueKey: string, maxQueueLength: number) => unknown;
-    makeTimeoutError: (queueKey: string, timeoutMs: number) => unknown;
-    makeCancelledError: (queueKey: string, reason: ThresholdCommitQueueCancelledReason) => unknown;
-};
 export declare function clearThresholdCommitQueue(queueByKey: ThresholdCommitQueueByKey): void;
+export declare function resolveThresholdCommitQueueKey(args: {
+    materialActivation: MpcMaterialActivationRef;
+}): string;
 export declare function withThresholdCommitQueue<T>(args: {
     queueByKey: ThresholdCommitQueueByKey;
     queueKey: string;
+    labels: ThresholdCommitQueueLabels;
+    owner: string;
     enabled: boolean;
     shouldAbort?: () => boolean;
     maxQueueLength?: number;
     queueTimeoutMs?: number;
     task: () => Promise<T>;
-    errors: ThresholdCommitQueueErrorFactory;
 }): Promise<T>;
 export {};
 //# sourceMappingURL=commitQueueShared.d.ts.map

package/dist/types/wallet/src/core/signingEngine/threshold/crypto/ecdsaDerivationClientWasm.d.ts

@@ -190,7 +190,7 @@ export declare function thresholdEcdsaRoleLocalCommitPresignatureWasm(input: {
     reservationId: string;
     workerCtx: WorkerOperationContext;
 }): Promise<void>;
-export declare function thresholdEcdsaRoleLocalListAvailablePresignaturesWasm(input: {
+export declare function thresholdEcdsaListAvailablePresignaturesWasm(authorityKind: 'role_local_derivation_handle' | 'linked_holder_signing_material', input: {
     poolIdentity: EcdsaClientPresignPoolIdentity;
     workerCtx: WorkerOperationContext;
 }): Promise<ListedClientPresignature[]>;

package/dist/types/wallet/src/core/signingEngine/threshold/ecdsa/bootstrapSession.d.ts

@@ -8,6 +8,7 @@ import { activateStrictEcdsaPostRegistrationSession, type EcdsaPreauthorizedSess
 import type { PersistedEcdsaRoleLocalMaterial } from '../../session/material/ecdsaRoleLocalMaterialResolver';
 import type { MpcWalletSigningQuotaId, EcdsaAuthorizationSessionId, WalletSessionAuthorizationId, WalletSessionId } from '../../../../../../shared-ts/src/authorization/capabilityKinds';
 import type { ActiveWalletSessionV1, WalletSessionOperationCredentialV1 } from '../../../../../../shared-ts/src/device-linking/contracts';
+import type { ExclusiveUnion } from '../../../../../../shared-ts/src/utils/variant';
 type BootstrapEcdsaSessionBaseArgs = {
     touchIdPrompt: Pick<ThresholdWebAuthnPromptPort, 'getRpId'>;
     relayerUrl: string;
@@ -23,15 +24,13 @@ type BootstrapEcdsaExactSessionArgsBase = BootstrapEcdsaSessionBaseArgs & {
     evmFamilySigningKeySlotId?: never;
     ecdsaThresholdKeyId?: never;
 };
-type BootstrapEcdsaExactSessionArgs = BootstrapEcdsaExactSessionArgsBase & ({
+type BootstrapEcdsaExactSessionArgs = BootstrapEcdsaExactSessionArgsBase & ExclusiveUnion<{
     bootstrapAuth: Extract<ThresholdEcdsaDerivationRouteAuth, {
         kind: 'opaque_wallet_session_operation_credential_v1';
     }>;
-    sessionActivation?: never;
 } | {
     sessionActivation: EcdsaPreauthorizedSessionActivation;
-    bootstrapAuth?: never;
-});
+}>;
 type BootstrapEcdsaSessionFailure = {
     ok: false;
     code: string;

package/dist/types/wallet/src/core/signingEngine/threshold/ecdsa/signingQueue.d.ts

@@ -1,12 +1,7 @@
 import type { WalletId } from '../../interfaces/ecdsaChainTarget';
-import type { MpcMaterialActivationRef } from '../../../../../../shared-ts/src/utils/domainIds';
 import { type ThresholdCommitQueueByKey } from '../commitQueueShared';
-type ThresholdEcdsaSigningQueueKeyInput = {
-    materialActivation: MpcMaterialActivationRef;
-};
+export { clearThresholdCommitQueue as clearThresholdEcdsaSigningQueue, resolveThresholdCommitQueueKey as resolveThresholdEcdsaSigningQueueKey, } from '../commitQueueShared';
 export type ThresholdEcdsaSigningQueueByKey = ThresholdCommitQueueByKey;
-export declare function resolveThresholdEcdsaSigningQueueKey(args: ThresholdEcdsaSigningQueueKeyInput): string;
-export declare function clearThresholdEcdsaSigningQueue(queueByKey: ThresholdEcdsaSigningQueueByKey): void;
 export declare function withThresholdEcdsaSigningQueue<T>(args: {
     queueByKey: ThresholdEcdsaSigningQueueByKey;
     queueKey: string;
@@ -17,5 +12,4 @@ export declare function withThresholdEcdsaSigningQueue<T>(args: {
     queueTimeoutMs?: number;
     task: () => Promise<T>;
 }): Promise<T>;
-export {};
 //# sourceMappingURL=signingQueue.d.ts.map

package/dist/types/wallet/src/core/signingEngine/threshold/ed25519/commitQueue.d.ts

@@ -1,11 +1,7 @@
 import { type AccountId } from '../../../types/accountIds';
-import type { MpcMaterialActivationRef } from '../../../../../../shared-ts/src/utils/domainIds';
 import { type ThresholdCommitQueueByKey } from '../commitQueueShared';
-type ThresholdEd25519CommitQueueKeyInput = {
-    materialActivation: MpcMaterialActivationRef;
-};
+export { resolveThresholdCommitQueueKey as resolveThresholdEd25519CommitQueueKey } from '../commitQueueShared';
 export type ThresholdEd25519CommitQueueByKey = ThresholdCommitQueueByKey;
-export declare function resolveThresholdEd25519CommitQueueKey(args: ThresholdEd25519CommitQueueKeyInput): string;
 export declare function withThresholdEd25519CommitQueue<T>(args: {
     queueByKey: ThresholdEd25519CommitQueueByKey;
     queueKey: string;
@@ -16,5 +12,4 @@ export declare function withThresholdEd25519CommitQueue<T>(args: {
     queueTimeoutMs?: number;
     task: () => Promise<T>;
 }): Promise<T>;
-export {};
 //# sourceMappingURL=commitQueue.d.ts.map

package/dist/types/wallet/src/core/signingEngine/threshold/ed25519/walletSession.d.ts

@@ -2,12 +2,13 @@ import { type Ed25519SessionPolicy, type ThresholdRuntimePolicyScope } from '../
 import type { WebAuthnAuthenticationCredential } from '../../../types/webauthn';
 import { type WebAuthnPrfFirstSecretSource } from '../../../platform/types';
 import type { RouterAbOwnerNormalSigningCredential, RouterAbNormalSigningPrepareRequestV2Wire } from '../../../rpcClients/relayer/routerAbNormalSigning';
+import type { RouterAbEd25519OperationStepUpMaterialRecoveryRequest, RouterAbEd25519OperationStepUpMaterialRecoveryResponse } from '../../../../../../shared-ts/src/utils/routerAbNormalSigningIdentity';
 import type { PasskeyWalletAuthAuthority } from '../../../../../../shared-ts/src/utils/walletAuthAuthority';
 import type { WalletAuthAuthorityRef } from '../../../../../../shared-ts/src/utils/walletAuthAuthority';
 import { type ThresholdEd25519SessionId } from '../../../../../../shared-ts/src/utils/domainIds';
 import { type MpcWalletSigningQuotaId, type WalletSessionAuthorizationId, type WalletSessionId } from '../../../../../../shared-ts/src/authorization/capabilityKinds';
 import { type WalletSessionOperationCredentialV1 } from '../../../../../../shared-ts/src/device-linking';
-import { type WalletSessionCommittedIdentityV1 } from '../../../../../../shared-ts/src/authorization';
+import { type WalletSessionAlreadyCommittedResponseV1, type WalletSessionRejectionV1 } from '../../../../../../shared-ts/src/authorization';
 export type ThresholdEd25519WebAuthnPrfSecretSource = {
     kind: 'webauthn_prf_first_credential';
     credential: WebAuthnAuthenticationCredential;
@@ -50,21 +51,7 @@ type Ed25519WalletSessionMintSuccess = {
     readonly runtimePolicyScope: ThresholdRuntimePolicyScope;
     readonly operationCredential?: never;
 };
-type Ed25519WalletSessionMintAlreadyCommitted = {
-    readonly ok: false;
-    readonly code: 'already_committed';
-    readonly message: string;
-    readonly next: 'unlock_exact_method';
-    readonly committed: WalletSessionCommittedIdentityV1;
-};
-type Ed25519WalletSessionMintFailure = {
-    readonly ok: false;
-    readonly code: string;
-    readonly message: string;
-    readonly next?: never;
-    readonly committed?: never;
-};
-type Ed25519WalletSessionMintResult = Ed25519WalletSessionMintSuccess | Ed25519WalletSessionMintAlreadyCommitted | Ed25519WalletSessionMintFailure;
+type Ed25519WalletSessionMintResult = Ed25519WalletSessionMintSuccess | WalletSessionAlreadyCommittedResponseV1 | WalletSessionRejectionV1;
 /**
  * Ed25519 Wallet Session mint.
  *
@@ -99,30 +86,13 @@ export type Ed25519OperationStepUpProof = {
     credential?: never;
     authority?: never;
 };
-type Ed25519OperationStepUpMaterialRecoveryRequest = {
-    kind: 'not_requested';
-} | {
-    kind: 'email_otp_factor_release_v1';
-    workerEphemeralPublicKey65B64u: string;
-};
-type Ed25519OperationStepUpMaterialRecoveryResponse = {
-    kind: 'not_requested';
-} | {
-    kind: 'email_otp_factor_release_v1';
-    challengeId: string;
-    enrollmentId: string;
-    enrollmentSealKeyVersion: string;
-    serverEphemeralPublicKey65B64u: string;
-    nonce12B64u: string;
-    ciphertextB64u: string;
-};
 type Ed25519EmailOtpOperationStepUpProof = Extract<Ed25519OperationStepUpProof, {
     kind: 'email_otp';
 }>;
-type Ed25519NoMaterialRecoveryRequest = Extract<Ed25519OperationStepUpMaterialRecoveryRequest, {
+type Ed25519NoMaterialRecoveryRequest = Extract<RouterAbEd25519OperationStepUpMaterialRecoveryRequest, {
     kind: 'not_requested';
 }>;
-type Ed25519EmailOtpFactorReleaseRequest = Extract<Ed25519OperationStepUpMaterialRecoveryRequest, {
+type Ed25519EmailOtpFactorReleaseRequest = Extract<RouterAbEd25519OperationStepUpMaterialRecoveryRequest, {
     kind: 'email_otp_factor_release_v1';
 }>;
 type Ed25519OperationStepUpAuthorizationRequestBase = {
@@ -148,7 +118,7 @@ export type IssuedEd25519OperationStepUpAuthorization = {
         evidence_set_digest: string;
     };
     expiresAtMs: number;
-    materialRecovery: Ed25519OperationStepUpMaterialRecoveryResponse;
+    materialRecovery: RouterAbEd25519OperationStepUpMaterialRecoveryResponse;
 };
 export declare function issueEd25519OperationStepUpAuthorization(args: Ed25519OperationStepUpAuthorizationRequest): Promise<IssuedEd25519OperationStepUpAuthorization>;
 export {};

package/dist/types/wallet/src/core/signingEngine/threshold/ed25519/yaoPublicCapabilityReferences.d.ts

@@ -3,6 +3,7 @@ import type { ThresholdEd25519SessionId } from '../../session/operationState/typ
 import type { ThresholdRuntimePolicyScope } from '../sessionPolicy';
 import { nearEd25519SigningKeyIdFromString } from '../../../../../../shared-ts/src/utils/registrationIds';
 import type { SigningLaneAuthBinding } from '../../session/identity/signingLaneAuthBinding';
+import type { ExclusiveUnion } from '../../../../../../shared-ts/src/utils/variant';
 export type Ed25519YaoPublicCapabilityReferenceV1 = Ed25519YaoActiveClientIdentityV1 & {
     thresholdSessionId: ThresholdEd25519SessionId;
     runtimePolicyScope: ThresholdRuntimePolicyScope;
@@ -11,7 +12,7 @@ type Ed25519YaoPublicCapabilityLaneReferenceBaseV1 = Ed25519YaoPublicCapabilityR
     nearEd25519SigningKeyId: ReturnType<typeof nearEd25519SigningKeyIdFromString>;
     signerSlot: number;
 };
-export type Ed25519YaoPublicCapabilityLaneReferenceV1 = Ed25519YaoPublicCapabilityLaneReferenceBaseV1 & ({
+export type Ed25519YaoPublicCapabilityLaneReferenceV1 = Ed25519YaoPublicCapabilityLaneReferenceBaseV1 & ExclusiveUnion<{
     auth: Extract<SigningLaneAuthBinding, {
         kind: 'email_otp';
     }>;
@@ -21,9 +22,7 @@ export type Ed25519YaoPublicCapabilityLaneReferenceV1 = Ed25519YaoPublicCapabili
     auth: Extract<SigningLaneAuthBinding, {
         kind: 'passkey';
     }>;
-    remainingUses?: never;
-    expiresAtMs?: never;
-});
+}>;
 type Ed25519YaoPublicCapabilityReferenceTransactionStore = {
     get(key: string): Promise<{
         readonly key: string;