@seams/wallet 0.6.2 → 0.7.3

package/dist/esm/react/core/signingEngine/routerAb/ecdsaDerivation/presignaturePool.js

@@ -4,11 +4,12 @@ import { MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS } from "../../workerManager
 import "../../../../shared-ts/src/utils/encoders.js";
 import { DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY } from "../../../config/defaultConfigs.js";
 import { canonicalRouterAbMpcMaterialActivationRefBytes } from "../../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import { buildRouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1, buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1, parseRouterAbEcdsaDerivationNormalSigningScopeV1, routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1, routerAbEcdsaRerandomizationClientCommitmentV1 } from "../../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { formatEcdsaKeyHandleForWire, parseEcdsaClientVerifyingShareB64u, parseEcdsaThresholdKeyId } from "../../session/keyMaterialBrands.js";
+import { ROUTER_AB_ECDSA_PRESIGN_CEREMONY_MAX_LIFETIME_MS, buildRouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1, buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1, parseRouterAbEcdsaDerivationNormalSigningScopeV1, routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1, routerAbEcdsaRerandomizationClientCommitmentV1 } from "../../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
+import { formatEcdsaKeyHandleForWire, parseEcdsaClientVerifyingShareB64u } from "../../../../shared-ts/src/threshold/keyMaterialBrands.js";
+import { parseEcdsaThresholdKeyId } from "../../session/keyMaterialBrands.js";
 import { FIXED_ECDSA_PRESIGN_PROTOCOL_ID, ecdsaClientPresignPoolKey } from "../../workerManager/ecdsaPresignPoolIdentity.js";
 import { emitEcdsaServerTiming, emitEcdsaSigningTiming, emitSigningSessionFlowTrace } from "../../session/operationState/trace.js";
-import { RouterAbSigningRequestError, finalizeRouterAbEcdsaDerivationEvmDigestSigningV1, prepareRouterAbEcdsaDerivationEvmDigestSigningV1, prepareRouterAbEcdsaFinalPresignBatchV1 } from "../../../rpcClients/relayer/routerAbNormalSigning.js";
+import { RouterAbSigningRequestError, finalizeRouterAbEcdsaDerivationEvmDigestSigningV1, prepareRouterAbEcdsaDerivationEvmDigestSigningV1 } from "../../../rpcClients/relayer/routerAbNormalSigning.js";
 import { addSecp256k1PublicKeys33Wasm, validateSecp256k1PublicKey33Wasm, verifySecp256k1RecoverableSignatureAgainstPublicKey33Wasm } from "../../chains/evm/evmCryptoWasm.js";
 import { routerAbEcdsaDerivationPresignaturePoolFillInit, routerAbEcdsaDerivationPresignaturePoolFillStep } from "./poolFillRoutes.js";
 import { PresignatureRefillProgressV1 } from "./presignatureRefillProgress.js";
@@ -43,6 +44,7 @@ function assertRouterAbEcdsaDerivationClientSigningMaterialSource(source) {
 }
 const MAX_HANDSHAKE_STEPS = 64;
 const ROUTER_AB_ECDSA_DERIVATION_SIGNING_TTL_MS = 6e4;
+const PRESIGN_CEREMONY_CLOCK_SKEW_MARGIN_MS = 3e4;
 const ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_EXPIRY_SKEW_MS = 2e3;
 const MAX_CLIENT_PRESIGNATURE_CLAIM_RETRIES = 4;
 const clientPresignaturePool = /* @__PURE__ */ new Map();
@@ -551,8 +553,6 @@ async function runPresignHandshakeAttempt(args) {
 		scope: args.routerAbEcdsaDerivationPoolFill.scope,
 		materialActivation: args.materialActivation
 	});
-	let terminalCandidate = null;
-	let handoff = null;
 	let localPresignatureHandle = null;
 	let localBigR33 = null;
 	let serverPresignatureId = null;
@@ -611,7 +611,6 @@ async function runPresignHandshakeAttempt(args) {
 					incomingMessages: pendingServerOutgoing,
 					workerCtx: args.workerCtx
 				});
-				if (localStepped.event === "final_batch_ready") terminalCandidate = localStepped.candidateBigR33;
 				clientStage = localStepped.stage;
 				pendingServerOutgoing = [];
 				pendingClientOutgoing.push(...localStepped.outgoingMessages);
@@ -620,32 +619,6 @@ async function runPresignHandshakeAttempt(args) {
 					localBigR33 = localStepped.presignatureBigR33;
 				}
 			}
-			if (terminalCandidate && !serverDone) {
-				const waiting = finalBatchHandoffs.get(args.poolKey);
-				if (waiting?.state.kind === "waiting") {
-					handoff = waiting;
-					finalBatchHandoffs.delete(args.poolKey);
-					if (pendingClientOutgoing.length !== 2) throw new Error("Final batch must contain two messages");
-					const prepared = await handoff.prepare(terminalCandidate, {
-						kind: "final_presign_batch",
-						batch: {
-							scope: args.routerAbEcdsaDerivationPoolFill.scope,
-							presign_session_id: presignSessionId,
-							requested_stage: "presign",
-							outgoing_messages_b64u: [base64UrlEncode(pendingClientOutgoing[0]), base64UrlEncode(pendingClientOutgoing[1])],
-							ceremony_expires_at_ms: ceremonyExpiresAtMs,
-							material_expires_at_ms: materialExpiresAtMs
-						}
-					});
-					pendingClientOutgoing = [];
-					pendingServerOutgoing = fromB64uMessages(prepared.outgoingMessagesB64u);
-					serverStage = "presign";
-					serverPresignatureId = prepared.preparedResponse.server_presignature_id;
-					serverBigRB64u = prepared.preparedResponse.server_big_r33_b64u;
-					serverDone = true;
-				}
-				terminalCandidate = null;
-			}
 			if (!serverDone) {
 				const roundStartedAt = performance.now();
 				const requestTag = presignHandshakeRequestTag(args);
@@ -713,22 +686,6 @@ async function runPresignHandshakeAttempt(args) {
 				code: "presign_mismatch",
 				message: "Client/server presignature mismatch (bigR mismatch)"
 			};
-			if (handoff) {
-				handoff.complete({
-					presignatureId: serverPresignatureId,
-					bigRB64u: localBigRB64u,
-					materialHandle: localPresignatureHandle,
-					createdAtMs,
-					expiresAtMs: materialExpiresAtMs
-				});
-				keepLocalMaterial = true;
-				shouldAbortLocalSession = false;
-				return {
-					ok: true,
-					kind: "handed_off",
-					presignatureId: serverPresignatureId
-				};
-			}
 			const admission = await args.clientSigningMaterial.admitClientPresignature({
 				materialHandle: localPresignatureHandle,
 				expectedPresignatureId: serverPresignatureId,
@@ -763,10 +720,6 @@ async function runPresignHandshakeAttempt(args) {
 			zeroizeBytes(localBigR33);
 		}
 	} catch (e) {
-		if (handoff) handoff.state = {
-			kind: "failed",
-			error: e
-		};
 		return {
 			ok: false,
 			code: "presign_failed",
@@ -810,68 +763,7 @@ function resolveSigningRequestExpiresAtMs(input) {
 	const expiresAtMs = Math.min(materialExpiresAtMs, authorizationExpiresAtMs, input.nowMs + ROUTER_AB_ECDSA_DERIVATION_SIGNING_TTL_MS);
 	return Number.isSafeInteger(expiresAtMs) && expiresAtMs > input.nowMs ? expiresAtMs : null;
 }
-var EcdsaFinalBatchHandoff = class {
-	constructor(input, poolKey, generation) {
-		this.input = input;
-		this.poolKey = poolKey;
-		this.generation = generation;
-		this.state = { kind: "waiting" };
-		this.contribution = secureRerandomizationContribution32();
-	}
-	async prepare(candidateBigR33, source) {
-		if (this.state.kind !== "waiting" || getClientPresignaturePoolGeneration(this.poolKey) !== this.generation) throw new Error("Signing handoff was cancelled before prepare");
-		this.state = { kind: "submitted" };
-		const idDigest = await crypto.subtle.digest("SHA-256", new Uint8Array(candidateBigR33));
-		const expiresAtMs = resolveSigningRequestExpiresAtMs({
-			authorizationExpiresAtMs: this.input.expiresAtMs,
-			materialExpiresAtMs: source.batch.material_expires_at_ms,
-			nowMs: Date.now()
-		});
-		if (!expiresAtMs) throw new Error("Signing handoff expired before prepare");
-		const commitment = await routerAbEcdsaRerandomizationClientCommitmentV1(this.contribution);
-		const request = buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1({
-			scope: this.input.scope,
-			requestId: secureRandomId("router-ab-ecdsa-sign", 32, "ECDSA signing request"),
-			operationId: this.input.operationId,
-			operationDigests: this.input.operationDigests,
-			authorization: this.input.authorization,
-			materialActivation: this.input.materialActivation,
-			clientPresignatureId: `presig-${base64UrlEncode(new Uint8Array(idDigest))}`,
-			expiresAtMs,
-			signingDigest32: this.input.signingDigest32,
-			clientRerandomizationCommitment32: commitment
-		});
-		zeroizeBytes(commitment);
-		if (getClientPresignaturePoolGeneration(this.poolKey) !== this.generation) throw new Error("Signing handoff was cancelled before submission");
-		const result = await prepareRouterAbEcdsaFinalPresignBatchV1({
-			relayServerUrl: this.input.relayerUrl,
-			credential: this.input.credential,
-			request,
-			source
-		});
-		if (getClientPresignaturePoolGeneration(this.poolKey) !== this.generation) throw new Error("Signing handoff was cancelled during prepare");
-		this.state = {
-			kind: "prepared",
-			prepared: {
-				request,
-				response: result.preparedResponse
-			}
-		};
-		return result;
-	}
-	complete(presignature) {
-		if (this.state.kind !== "prepared" || getClientPresignaturePoolGeneration(this.poolKey) !== this.generation) throw new Error("Signing handoff cannot claim completed material");
-		this.state = {
-			kind: "ready",
-			prepared: this.state.prepared,
-			presignature
-		};
-	}
-};
-const finalBatchHandoffs = /* @__PURE__ */ new Map();
 async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCount, supply) {
-	let handoff = null;
-	let handedOffPrepare = null;
 	let poolKey = null;
 	let poolIdentity = null;
 	let foregroundStarted = false;
@@ -949,10 +841,6 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 			});
 		}
 		if (!presignature) {
-			if (!finalBatchHandoffs.has(poolKey)) {
-				handoff = new EcdsaFinalBatchHandoff(args, poolKey, poolGeneration);
-				finalBatchHandoffs.set(poolKey, handoff);
-			}
 			const refillWaitStartedAt = performance.now();
 			await waitForAvailablePresignatureFromInFlightRefill(poolKey, "foreground");
 			emitEcdsaSigningTiming(args.operationId, "refill_wait", refillWaitStartedAt);
@@ -964,16 +852,17 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 				workerCtx: args.workerCtx
 			});
 		}
-		if (!presignature && handoff?.state.kind === "waiting" && supply.kind === "on_demand") {
+		if (!presignature && supply.kind === "on_demand") {
+			const foregroundRefillStartedAt = performance.now();
 			let refill = await refillRouterAbEcdsaDerivationClientPresignaturePool({
 				...supply.refill,
 				trafficClass: "foreground"
 			});
-			if (!refill.ok && refill.code === "invalidated" && handoff.state.kind === "waiting") refill = await refillRouterAbEcdsaDerivationClientPresignaturePool({
+			if (!refill.ok && refill.code === "invalidated") refill = await refillRouterAbEcdsaDerivationClientPresignaturePool({
 				...supply.refill,
 				trafficClass: "foreground"
 			});
-			if (!refill.ok && handoff.state.kind === "waiting" && refill.code !== "pool_full") return refill;
+			if (!refill.ok && refill.code !== "pool_full") return refill;
 			if (!refill.ok && refill.code === "pool_full") await hydrateClientPresignaturePool({
 				poolKey,
 				poolIdentity,
@@ -988,14 +877,7 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 				clientSigningMaterial: args.clientSigningMaterial,
 				workerCtx: args.workerCtx
 			});
-		}
-		if (handoff && handoff.state.kind !== "waiting") {
-			if (handoff.state.kind !== "ready") throw new Error("Terminal signing prepare did not complete; automatic replacement is prohibited");
-			if (presignature) pushClientPresignature(poolKey, poolIdentity, presignature);
-			presignature = handoff.state.presignature;
-			handedOffPrepare = handoff.state.prepared;
-			preparationState = { kind: "prepare_submitted" };
-			clientPresignatureCleanupState = { kind: "destroy" };
+			emitEcdsaSigningTiming(args.operationId, "foreground_refill", foregroundRefillStartedAt);
 		}
 		emitSigningSessionFlowTrace("evm-family", {
 			event: "ecdsa_presignature_selection",
@@ -1026,9 +908,9 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 			code: "pool_entry_unavailable",
 			message: "Router A/B ECDSA derivation client presignature pool was invalidated before prepare"
 		};
-		clientRerandomizationContribution32 = handedOffPrepare && handoff ? handoff.contribution : secureRerandomizationContribution32();
+		clientRerandomizationContribution32 = secureRerandomizationContribution32();
 		const clientRerandomizationCommitment32 = await routerAbEcdsaRerandomizationClientCommitmentV1(clientRerandomizationContribution32);
-		const prepareRequest = handedOffPrepare?.request ?? buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1({
+		const prepareRequest = buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1({
 			scope: args.scope,
 			requestId: secureRandomId("router-ab-ecdsa-sign", 32, "Router A/B ECDSA derivation sign request"),
 			operationId: args.operationId,
@@ -1056,7 +938,7 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 		emitEcdsaSigningTiming(args.operationId, "presignature_reserve", reserveStartedAt);
 		if (reservation.kind === "unavailable") {
 			if (reservation.reason === "claimed_elsewhere") clientPresignatureCleanupState = { kind: "owned_elsewhere" };
-			if (!handedOffPrepare && retryCount < MAX_CLIENT_PRESIGNATURE_CLAIM_RETRIES) return await signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCount + 1, supply);
+			if (retryCount < MAX_CLIENT_PRESIGNATURE_CLAIM_RETRIES) return await signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCount + 1, supply);
 			return {
 				ok: false,
 				code: reservation.reason === "expired" ? "pool_entry_expired" : "pool_entry_unavailable",
@@ -1070,7 +952,7 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 		};
 		preparationState = { kind: "prepare_submitted" };
 		const prepareStartedAt = performance.now();
-		const prepareResponse = handedOffPrepare?.response ?? await prepareRouterAbEcdsaDerivationEvmDigestSigningV1({
+		const prepareResponse = await prepareRouterAbEcdsaDerivationEvmDigestSigningV1({
 			relayServerUrl: relayerUrl,
 			credential: args.credential,
 			request: prepareRequest,
@@ -1181,11 +1063,6 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 		};
 	} catch (e) {
 		const msg = String(e && typeof e === "object" && "message" in e ? e.message : e || "Router A/B ECDSA derivation signing failed");
-		if (handoff && handoff.state.kind !== "waiting" && handoff.state.kind !== "cancelled") return {
-			ok: false,
-			code: "router_ab_sign_failed",
-			message: msg
-		};
 		if (e instanceof RouterAbSigningRequestError && e.code === "expired_local_request") return {
 			ok: false,
 			code: "pool_entry_expired",
@@ -1210,11 +1087,6 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 			message: msg
 		};
 	} finally {
-		if (handoff) {
-			if (finalBatchHandoffs.get(handoff.poolKey) === handoff) finalBatchHandoffs.delete(handoff.poolKey);
-			zeroizeBytes(handoff.contribution);
-			if (handoff.state.kind === "waiting") handoff.state = { kind: "cancelled" };
-		}
 		zeroizeBytes(clientSignatureShare32);
 		zeroizeBytes(clientRerandomizationContribution32);
 		if (presignature && poolIdentity && clientPresignatureCleanupState.kind !== "consumed" && clientPresignatureCleanupState.kind !== "owned_elsewhere") {
@@ -1261,7 +1133,7 @@ async function signRouterAbEcdsaDerivationDigestWithPool(args) {
 				routerAbEcdsaDerivationPoolFill: {
 					kind: "router_ab_ecdsa_derivation_signing_worker_pool",
 					scope: args.scope,
-					ceremonyExpiresAtMs: expiresAtMs,
+					ceremonyExpiresAtMs: Math.min(expiresAtMs, Date.now() + ROUTER_AB_ECDSA_PRESIGN_CEREMONY_MAX_LIFETIME_MS - PRESIGN_CEREMONY_CLOCK_SKEW_MARGIN_MS),
 					materialExpiresAtMs: args.authorization.kind === "operation_step_up" ? expiresAtMs : Date.now() + MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS
 				},
 				workerCtx: args.workerCtx,
@@ -1310,10 +1182,6 @@ async function refillRouterAbEcdsaDerivationClientPresignaturePool(args) {
 			...ecdsaPoolFillAuthorization(args)
 		});
 		if (!generated.ok) return generated;
-		if (generated.kind === "handed_off") return {
-			ok: true,
-			presignatureId: generated.presignatureId
-		};
 		if (getClientPresignaturePoolGeneration(poolKey) !== startedGeneration) {
 			await args.clientSigningMaterial.destroyClientPresignature({
 				materialHandle: generated.presignature.materialHandle,

package/dist/esm/react/core/signingEngine/routerAb/ecdsaDerivation/signingMaterialRef.js

@@ -1,5 +1,6 @@
 import { requireRouterAbEcdsaDerivationNormalSigningStateV1, routerAbEcdsaDerivationActiveStateId } from "../../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { parseEcdsaClientVerifyingShareB64u, parseEcdsaThresholdKeyId } from "../../session/keyMaterialBrands.js";
+import { parseEcdsaClientVerifyingShareB64u } from "../../../../shared-ts/src/threshold/keyMaterialBrands.js";
+import { parseEcdsaThresholdKeyId } from "../../session/keyMaterialBrands.js";
 //#region src/core/signingEngine/routerAb/ecdsaDerivation/signingMaterialRef.ts
 function buildRouterAbEcdsaDerivationSigningMaterialRef(args) {
 	const routerAbState = requireRouterAbEcdsaDerivationNormalSigningStateV1(args.routerAbState);

package/dist/esm/react/core/signingEngine/session/SigningSessionCoordinator.js

@@ -1,5 +1,5 @@
-import { toWalletId } from "../interfaces/ecdsaChainTarget.js";
 import { signingLaneAuthMethod } from "./identity/signingLaneAuthBinding.js";
+import { toWalletId } from "../interfaces/ecdsaChainTarget.js";
 import { requiredSigningSubjectForExactSigningLane, resolveExactWalletSessionOperationCredential } from "./identity/exactWalletSessionCredential.js";
 import { resolveActiveAuthorizedRouterAbEd25519WalletSessionState } from "./warmCapabilities/routerAbEd25519WalletSessionState.js";
 import { createSigningSessionExpiredEvent } from "../../types/sdkSentEvents.js";

package/dist/esm/react/core/signingEngine/session/availability/availableSigningLanes.js

@@ -1,13 +1,14 @@
 import { mpcMaterialActivationRefsEqual } from "../../../../shared-ts/src/utils/domainIds.js";
-import { nearEd25519SigningKeyIdFromString } from "../../../../shared-ts/src/utils/registrationIntent.js";
 import { walletAuthAuthorityRef } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
+import { signingLaneAuthBindingKey, signingLaneAuthMethod } from "../identity/signingLaneAuthBinding.js";
+import { nearEd25519SigningKeyIdFromString } from "../../../../shared-ts/src/utils/registrationIds.js";
 import { thresholdEcdsaChainTargetKey, toWalletId } from "../../interfaces/ecdsaChainTarget.js";
 import { deriveEvmFamilyKeyFingerprintFromPublicFacts, toRpId } from "../identity/evmFamilyEcdsaIdentity.js";
-import { signingLaneAuthBindingKey, signingLaneAuthMethod } from "../identity/signingLaneAuthBinding.js";
 import { parseSignerSlot } from "../../../../shared-ts/src/utils/signerSlot.js";
 import { toAccountId } from "../../../types/accountIds.js";
 import { nearEd25519SessionMatchesMaterialActivation } from "../material/nearEd25519YaoSigningPreparation.js";
 import { canonicalizeLaneFacts, serverIssuedGenerationFromNumber } from "./canonicalLaneInventory.js";
+import { materialActivationKey } from "../sealedRecovery/materialActivationKey.js";
 //#region src/core/signingEngine/session/availability/availableSigningLanes.ts
 function activeWalletAuthorityAvailableLaneFromProjection(projection) {
 	const base = {
@@ -39,16 +40,6 @@ function ecdsaAuthorizationPolicyMatchesLane(lane) {
 	if (!authorization) return true;
 	return lane.remainingUses === authorization.runtime.remainingUses && lane.expiresAtMs === authorization.runtime.expiresAtMs;
 }
-function materialActivationKey(activation) {
-	return [
-		activation.activationId,
-		activation.capability,
-		activation.materialOwner,
-		activation.keyBinding,
-		activation.lifecycleBinding,
-		activation.signingWorker
-	].map((part) => encodeURIComponent(String(part))).join(":");
-}
 function availableEcdsaSigningLaneAuthMethod(lane) {
 	return signingLaneAuthMethod(lane.auth);
 }
@@ -774,7 +765,7 @@ function canonicalEcdsaLaneSelectionForFacts(facts) {
 	}
 }
 /**
-* R109C: an added auth method holds its own access projection over the wallet's
+* An added auth method holds its own access projection over the wallet's
 * existing activation, so the same lane is reachable through two credentials.
 * For a wallet-level read that names no method, those are one lane, not two
 * competing ones - and they are indistinguishable to the canonical tie-break,
@@ -873,7 +864,7 @@ function suppressPublicEd25519CandidatesWithDurablePolicy(candidates) {
 	});
 }
 /**
-* R103C owner-scope matching. Ed25519 lanes bind an owner's credential AND
+* Owner-scope matching. Ed25519 lanes bind an owner's credential AND
 * signer slot; ECDSA lanes bind the credential alone. State stays untouched:
 * the scope decides whose lane it is, never whether it is usable.
 */

package/dist/esm/react/core/signingEngine/session/availability/persistedAvailableSigningLanes.js

@@ -1,8 +1,8 @@
 import { isEmailOtpWalletAuthAuthority, isPasskeyWalletAuthAuthority } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
-import { thresholdEcdsaChainTargetKey, toWalletId } from "../../interfaces/ecdsaChainTarget.js";
 import { SIGNER_AUTH_METHODS } from "../../../../shared-ts/src/utils/signerDomain.js";
-import { buildBaseEvmFamilyEcdsaKeyIdentity, buildPasskeyEcdsaAuthBinding, buildResolvedEvmFamilyEcdsaKey, toRpId } from "../identity/evmFamilyEcdsaIdentity.js";
 import { signingLaneAuthMethod } from "../identity/signingLaneAuthBinding.js";
+import { thresholdEcdsaChainTargetKey, toWalletId } from "../../interfaces/ecdsaChainTarget.js";
+import { buildBaseEvmFamilyEcdsaKeyIdentity, buildPasskeyEcdsaAuthBinding, buildResolvedEvmFamilyEcdsaKey, toRpId } from "../identity/evmFamilyEcdsaIdentity.js";
 import { listEcdsaSealedSessionsForWallet, listExactSealedSessionsForWallet } from "../persistence/sealedSessionStore.js";
 import { WalletSessionStatusReadScope } from "../../../rpcClients/relayer/walletSessionAuthorizationStatus.js";
 import { activeWalletAuthorityAvailableLaneFromProjection, ecdsaAvailableLaneIdentityKey, readAvailableSigningLanes } from "./availableSigningLanes.js";
@@ -82,10 +82,10 @@ async function readPersistedAvailableSigningLanes(deps, args, ecdsaChainTargets)
 		...args,
 		ecdsaChainTargets,
 		requiredEcdsaCapability: "sign"
-	}, new WalletSessionStatusReadScope());
+	}, new WalletSessionStatusReadScope(), "all");
 }
 /**
-* R103C human operational read: lanes for one exact owner. The auth-method
+* Human operational read: lanes for one exact owner. The auth-method
 * narrowing and the owner filter both derive from the scope — callers supply
 * nothing the scope does not already carry.
 */
@@ -97,7 +97,7 @@ async function readOwnerScopedAvailableSigningLanes(deps, args, statusReads) {
 		ecdsaChainTargets: args.ecdsaChainTargets,
 		requiredEcdsaCapability: args.requiredEcdsaCapability,
 		...args.nowMs !== void 0 ? { nowMs: args.nowMs } : {}
-	}, statusReads);
+	}, statusReads, "all");
 }
 async function readPersistedAvailableSigningLanesForSigning(deps, args, defaultEcdsaChainTargets) {
 	if (args.curve === "ecdsa") {
@@ -108,7 +108,7 @@ async function readPersistedAvailableSigningLanesForSigning(deps, args, defaultE
 			...availableLanesArgs,
 			ecdsaChainTargets: [...ecdsaChainTargetsByKey.values()],
 			requiredEcdsaCapability: "sign"
-		}, new WalletSessionStatusReadScope());
+		}, new WalletSessionStatusReadScope(), "ecdsa");
 	}
 	const { curve, ...availableLanesArgs } = args;
 	return await readPersistedAvailableSigningLanes(deps, availableLanesArgs, []);
@@ -133,17 +133,18 @@ function filterEmailOtpCompanionEcdsaRecords(records, chainTargets) {
 	}
 	return matchingRecords;
 }
-async function readPersistedAvailableSigningLanesForTargets(deps, args, statusReads) {
+async function readPersistedAvailableSigningLanesForTargets(deps, args, statusReads, curves) {
 	const walletId = String(toWalletId(args.walletId)).trim();
 	return await readAvailableSigningLanes({
 		...args,
 		walletId,
 		ecdsaChainTargets: args.ecdsaChainTargets
 	}, {
-		listPublicCapabilityReferences: deps.ed25519YaoPublicCapabilityLanes ? deps.ed25519YaoPublicCapabilityLanes.listLanes.bind(deps.ed25519YaoPublicCapabilityLanes) : void 0,
+		listPublicCapabilityReferences: curves === "all" && deps.ed25519YaoPublicCapabilityLanes ? deps.ed25519YaoPublicCapabilityLanes.listLanes.bind(deps.ed25519YaoPublicCapabilityLanes) : void 0,
 		isPublicCapabilityActive: deps.isEd25519YaoPublicCapabilityActive,
-		readActiveWalletSessionAuthorization: deps.readActiveWalletSessionAuthorization?.bind(null, statusReads),
+		readActiveWalletSessionAuthorization: curves === "all" ? deps.readActiveWalletSessionAuthorization?.bind(null, statusReads) : void 0,
 		listSealedRecordsForWallet: async ({ walletId: recordWalletId, filter }) => {
+			if (curves === "ecdsa") return [];
 			const listByAuthMethod = async (authMethod) => {
 				const ed25519Records = await listExactSealedSessionsForWallet({
 					walletId: recordWalletId,

package/dist/esm/react/core/signingEngine/session/emailOtp/EmailOtpWalletSessionCoordinator.js

@@ -1,44 +1,128 @@
-import { EmailOtpWalletSessionRuntime } from "./coordinatorRuntime.js";
+import { createEmailOtpEcdsaSigningSessionMaterialRestorer } from "./ecdsaRecovery.js";
+import { EmailOtpEcdsaLifecycleRuntime } from "./ecdsaLifecycleRuntime.js";
+import { EmailOtpExportRecoveryRuntime } from "./exportRecoveryRuntime.js";
+import { EmailOtpRuntimeConfig } from "./runtimeConfig.js";
+import { EmailOtpSealedSessionRegistry } from "./sealedSessionRegistry.js";
+import { EmailOtpSealedRefreshPolicy } from "./sealedRefreshPolicy.js";
+import { EmailOtpSealedRestoreOrchestrator } from "./sealedRestoreOrchestrator.js";
+import { EmailOtpWarmSessionRuntime, createEmailOtpWarmSessionWorkerClient } from "./warmSessionRuntime.js";
 //#region src/core/signingEngine/session/emailOtp/EmailOtpWalletSessionCoordinator.ts
 var EmailOtpWalletSessionCoordinator = class {
 	constructor(deps) {
-		this.runtime = new EmailOtpWalletSessionRuntime(deps);
+		this.sealedRefreshDiagnosticLogAtMsByKey = /* @__PURE__ */ new Map();
+		this.runtimeConfig = new EmailOtpRuntimeConfig({
+			configs: deps.configs,
+			getRpId: deps.getRpId
+		});
+		this.sealedSessionRegistry = new EmailOtpSealedSessionRegistry({
+			configs: deps.configs,
+			getSignerWorkerContext: deps.getSignerWorkerContext,
+			commitEvmFamilyThresholdEcdsaSessions: deps.commitEvmFamilyThresholdEcdsaSessions,
+			listActiveEcdsaCapabilityManifestsForWallet: deps.listActiveEcdsaCapabilityManifestsForWallet,
+			writeExactSealedSession: deps.writeExactSealedSession,
+			readExactSealedSession: deps.readExactSealedSession,
+			clearEcdsaRestoreCaches: () => this.clearEcdsaRestoreCaches()
+		});
+		this.ecdsaLifecycleRuntime = new EmailOtpEcdsaLifecycleRuntime({
+			configs: deps.configs,
+			getSignerWorkerContext: deps.getSignerWorkerContext,
+			loadWalletCustodyEd25519Material: deps.loadWalletCustodyEd25519Material,
+			restoreWalletCustodyEcdsaContinuity: deps.restoreWalletCustodyEcdsaContinuity,
+			provisionThresholdEcdsaSession: deps.provisionThresholdEcdsaSession,
+			provisionEmailOtpEcdsaExplicitExportSession: deps.provisionEmailOtpEcdsaExplicitExportSession,
+			runtimeConfig: this.runtimeConfig,
+			ownerLaneScopeStores: deps.ownerLaneScopeStores,
+			resolveSelectedWalletAuthority: deps.resolveSelectedWalletAuthority,
+			resolveCurrentEcdsaCapabilityRuntime: deps.resolveCurrentEcdsaCapabilityRuntime,
+			publicationPorts: () => this.sealedSessionRegistry.ecdsaPublicationPorts()
+		});
+		this.exportRecoveryRuntime = new EmailOtpExportRecoveryRuntime({
+			getSignerWorkerContext: deps.getSignerWorkerContext,
+			requireRelayUrl: () => this.runtimeConfig.requireRelayUrl(),
+			requireSigningSessionSealGroupId: () => this.runtimeConfig.requireSigningSessionSealGroupId(),
+			resolveSelectedWalletAuthority: deps.resolveSelectedWalletAuthority,
+			prepareEcdsaExportCapability: (request) => this.ecdsaLifecycleRuntime.prepareEcdsaExportCapability(request)
+		});
+		const restoreEcdsaSigningSessionMaterialFromSealedRecord = createEmailOtpEcdsaSigningSessionMaterialRestorer({
+			configs: deps.configs,
+			withThresholdEcdsaSigningQueue: deps.withThresholdEcdsaSigningQueue,
+			getSignerWorkerContext: deps.getSignerWorkerContext,
+			resolveSelectedWalletAuthority: deps.resolveSelectedWalletAuthority,
+			readExactWalletSessionAuthorization: deps.readExactWalletSessionAuthorization,
+			provisionThresholdEcdsaSession: deps.provisionThresholdEcdsaSession,
+			commitEvmFamilyThresholdEcdsaSessions: deps.commitEvmFamilyThresholdEcdsaSessions,
+			resolveCurrentEcdsaCapabilityRuntime: deps.resolveCurrentEcdsaCapabilityRuntime
+		});
+		const warmSessionWorkerClient = createEmailOtpWarmSessionWorkerClient({ worker: deps.signerWorkerManager });
+		this.sealedRefreshPolicy = new EmailOtpSealedRefreshPolicy({
+			updateExactSealedSessionPolicy: deps.updateExactSealedSessionPolicy,
+			clearEcdsaRestoreCaches: () => this.clearEcdsaRestoreCaches()
+		});
+		this.sealedRestoreOrchestrator = new EmailOtpSealedRestoreOrchestrator({
+			sessionPersistenceMode: deps.configs.signing.sessionPersistenceMode,
+			listExactSealedSessionsForWallet: deps.listExactSealedSessionsForWallet,
+			readExactSealedSession: deps.readExactSealedSession,
+			acquireSigningSessionRestoreLease: deps.acquireSigningSessionRestoreLease,
+			releaseSigningSessionRestoreLease: deps.releaseSigningSessionRestoreLease,
+			readWarmSessionStatusFromWorker: (thresholdSessionId) => warmSessionWorkerClient.readStatus({
+				kind: "ecdsa",
+				thresholdSessionId
+			}),
+			restoreEcdsaSigningSessionMaterialFromSealedRecord: (restoreArgs) => restoreEcdsaSigningSessionMaterialFromSealedRecord(restoreArgs),
+			recordSessionMaterialRestored: (purpose, status) => this.sealedRefreshPolicy.recordSessionMaterialRestored(purpose, status),
+			shouldLogDiagnostic: (key) => this.shouldLogSealedRefreshDiagnostic(key)
+		});
+		this.warmSessionRuntime = new EmailOtpWarmSessionRuntime({
+			workerClient: warmSessionWorkerClient,
+			sealedRefreshPolicy: this.sealedRefreshPolicy,
+			sealedRestoreOrchestrator: this.sealedRestoreOrchestrator
+		});
 	}
-	persistEcdsaSessionForRefresh(args) {
-		return this.runtime.persistEcdsaSessionForRefresh(args);
+	async persistEcdsaSessionForRefresh(args) {
+		await this.sealedSessionRegistry.persistEcdsaSessionForRefresh(args);
 	}
-	discoverPersistedSessionsForWallet(args) {
-		return this.runtime.discoverPersistedSessionsForWallet(args);
+	clearEcdsaRestoreCaches() {
+		this.sealedRestoreOrchestrator.clearCache();
 	}
-	restorePersistedSessionForSigning(args) {
-		return this.runtime.restorePersistedSessionForSigning(args);
+	shouldLogSealedRefreshDiagnostic(key, nowMs = Date.now()) {
+		const normalizedKey = String(key || "").trim();
+		if (!normalizedKey) return false;
+		if (nowMs - (this.sealedRefreshDiagnosticLogAtMsByKey.get(normalizedKey) || 0) < 6e4) return false;
+		this.sealedRefreshDiagnosticLogAtMsByKey.set(normalizedKey, nowMs);
+		return true;
 	}
-	readWarmSessionStatusOnly(target) {
-		return this.runtime.readWarmSessionStatusOnly(target);
+	async discoverPersistedSessionsForWallet(args) {
+		return await this.sealedRestoreOrchestrator.discoverPersistedSessionsForWallet(args);
 	}
-	consumeWarmSessionUses(args) {
-		return this.runtime.consumeWarmSessionUses(args);
+	async restorePersistedSessionForSigning(args) {
+		return await this.sealedRestoreOrchestrator.restorePersistedSessionForSigning(args);
 	}
-	clearVolatileWarmSessionMaterial(target) {
-		return this.runtime.clearVolatileWarmSessionMaterial(target);
+	async readWarmSessionStatusOnly(target) {
+		return await this.warmSessionRuntime.readWarmSessionStatusOnly(target);
+	}
+	async consumeWarmSessionUses(args) {
+		return await this.warmSessionRuntime.consumeWarmSessionUses(args);
+	}
+	async clearVolatileWarmSessionMaterial(target) {
+		await this.warmSessionRuntime.clearVolatileWarmSessionMaterial(target);
 	}
 	async requestTransactionSigningChallenge(args) {
-		return await this.runtime.requestTransactionSigningChallenge(args);
+		return await this.exportRecoveryRuntime.requestTransactionSigningChallenge(args);
 	}
 	async requestExportChallenge(args) {
-		return await this.runtime.requestExportChallenge(args);
+		return await this.exportRecoveryRuntime.requestExportChallenge(args);
 	}
-	exportEcdsaKeyWithDurableAuthorization(args) {
-		return this.runtime.exportEcdsaKeyWithDurableAuthorization(args);
+	async exportEcdsaKeyWithDurableAuthorization(args) {
+		return await this.exportRecoveryRuntime.exportEcdsaKeyWithDurableAuthorization(args);
 	}
-	exportEd25519YaoSeedWithFreshEmailOtpLane(args) {
-		return this.runtime.exportEd25519YaoSeedWithFreshEmailOtpLane(args);
+	async exportEd25519YaoSeedWithFreshEmailOtpLane(args) {
+		return await this.exportRecoveryRuntime.exportEd25519YaoSeedWithFreshEmailOtpLane(args);
 	}
-	loginWithEcdsaCapabilityForSigning(args) {
-		return this.runtime.loginWithEcdsaCapabilityForSigning(args);
+	async loginWithEcdsaCapabilityForSigning(args) {
+		return await this.ecdsaLifecycleRuntime.loginWithEcdsaCapabilityForSigning(args);
 	}
-	loginWithEcdsaCapabilityInternal(args) {
-		return this.runtime.loginWithEcdsaCapabilityInternal(args);
+	async loginWithEcdsaCapabilityInternal(args) {
+		return await this.ecdsaLifecycleRuntime.loginWithEcdsaCapabilityInternal(args);
 	}
 };
 //#endregion

package/dist/esm/react/core/signingEngine/session/emailOtp/ecdsaLogin.js

@@ -1,12 +1,13 @@
+import { sameRuntimePolicyScope } from "../../../../shared-ts/src/threshold/signingRootScope.js";
 import { DEFAULT_THRESHOLD_SESSION_POLICY, DEFAULT_UNLOCK_REMAINING_USES, clampThresholdSessionPolicy, resolveWalletUnlockSessionUsesFromRequestedUses } from "../../threshold/sessionPolicy.js";
 import { mpcMaterialActivationRefsEqual, parseThresholdEcdsaSessionId, parseWalletAuthMethodId } from "../../../../shared-ts/src/utils/domainIds.js";
 import { parseWalletSessionMintId } from "../../../../shared-ts/src/authorization/capabilityKinds.js";
 import { buildEmailOtpWalletAuthAuthority, isEmailOtpWalletAuthAuthority, walletAuthAuthorityRef } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
 import { sameRouterAbEcdsaDerivationPublicCapabilityV1, sameRouterAbEcdsaRegistrationActivationReceiptV1 } from "../../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { thresholdEcdsaChainTargetsEqual, toWalletId } from "../../interfaces/ecdsaChainTarget.js";
 import { WALLET_EMAIL_OTP_DEVICE_LINK_OPERATION, WALLET_EMAIL_OTP_EXPORT_OPERATION, WALLET_EMAIL_OTP_TRANSACTION_SIGN_OPERATION, WALLET_EMAIL_OTP_UNLOCK_OPERATION } from "../../../../shared-ts/src/utils/emailOtpDomain.js";
-import { buildEvmFamilyEcdsaRecoveredMaterialLanePolicy, buildEvmFamilyEcdsaSessionLanePolicy, toEvmFamilyEcdsaKeyHandle } from "../identity/evmFamilyEcdsaIdentity.js";
 import { SigningSessionIds } from "../operationState/types.js";
+import { thresholdEcdsaChainTargetsEqual, toWalletId } from "../../interfaces/ecdsaChainTarget.js";
+import { buildEvmFamilyEcdsaRecoveredMaterialLanePolicy, buildEvmFamilyEcdsaSessionLanePolicy, toEvmFamilyEcdsaKeyHandle } from "../identity/evmFamilyEcdsaIdentity.js";
 import { buildEmailOtpAuthContextForCanonicalWallet, buildEmailOtpAuthContextForWalletAuthMethod, emailOtpAuthContextProviderUserId, isEmailOtpPendingSingleUseAuthContext, isEmailOtpSessionAuthContext } from "../identity/laneIdentity.js";
 import { parseEmailOtpEcdsaExportWorkerIssuedSessionHandle, parseEmailOtpWorkerIssuedSessionHandle } from "../../../platform/secretSources.js";
 import { resolveExactWalletAuthAuthority } from "../identity/ownerLaneScope.js";
@@ -288,12 +289,9 @@ function requireEmailOtpEcdsaCustodySigner(continuity, walletId, keyHandle) {
 	const first = continuity.signers[0];
 	if (!first) throw new Error("Email OTP ECDSA custody continuity is empty");
 	if (first.walletKey.walletId !== walletId || first.walletKey.keyHandle !== keyHandle) throw new Error("Email OTP ECDSA custody continuity changed the requested wallet key");
-	for (const signer of continuity.signers) if (signer.walletKey.walletId !== first.walletKey.walletId || signer.walletKey.keyHandle !== first.walletKey.keyHandle || signer.walletKey.ecdsaThresholdKeyId !== first.walletKey.ecdsaThresholdKeyId || signer.walletKey.signingRootId !== first.walletKey.signingRootId || signer.walletKey.signingRootVersion !== first.walletKey.signingRootVersion || signer.walletKey.relayerKeyId !== first.walletKey.relayerKeyId || !sameRouterAbEcdsaDerivationPublicCapabilityV1(signer.walletKey.publicCapability, first.walletKey.publicCapability) || !sameRouterAbEcdsaRegistrationActivationReceiptV1(signer.activationReceipt, first.activationReceipt) || !sameEmailOtpRuntimePolicyScope(signer.runtimePolicyScope, first.runtimePolicyScope)) throw new Error("Email OTP ECDSA custody continuity conflicts across targets");
+	for (const signer of continuity.signers) if (signer.walletKey.walletId !== first.walletKey.walletId || signer.walletKey.keyHandle !== first.walletKey.keyHandle || signer.walletKey.ecdsaThresholdKeyId !== first.walletKey.ecdsaThresholdKeyId || signer.walletKey.signingRootId !== first.walletKey.signingRootId || signer.walletKey.signingRootVersion !== first.walletKey.signingRootVersion || signer.walletKey.relayerKeyId !== first.walletKey.relayerKeyId || !sameRouterAbEcdsaDerivationPublicCapabilityV1(signer.walletKey.publicCapability, first.walletKey.publicCapability) || !sameRouterAbEcdsaRegistrationActivationReceiptV1(signer.activationReceipt, first.activationReceipt) || !sameRuntimePolicyScope(signer.runtimePolicyScope, first.runtimePolicyScope)) throw new Error("Email OTP ECDSA custody continuity conflicts across targets");
 	return first;
 }
-function sameEmailOtpRuntimePolicyScope(left, right) {
-	return left.orgId === right.orgId && left.projectId === right.projectId && left.envId === right.envId && left.signingRootVersion === right.signingRootVersion;
-}
 function nonEmptyEmailOtpEcdsaChainTargets(continuity) {
 	const [first, ...rest] = continuity.signers;
 	if (!first) throw new Error("Email OTP ECDSA custody continuity is empty");
@@ -504,7 +502,7 @@ async function provisionEmailOtpExistingKeySessions(args) {
 		},
 		authorization: additionalAuthorization
 	};
-	const bootstraps = [primaryBootstrap, ...await Promise.all(args.publicationChainTargets.slice(1).map(provisionEmailOtpAdditionalExistingKeySessionForTarget.bind(null, additionalContext)))];
+	const bootstraps = [primaryBootstrap, ...await Promise.all(args.publicationChainTargets.slice(1).map(provisionEmailOtpExistingKeySessionForTarget.bind(null, additionalContext)))];
 	if (!primaryBootstrap) throw new Error("Email OTP ECDSA activation did not return a primary warm session");
 	return bootstraps;
 }
@@ -526,9 +524,6 @@ async function provisionEmailOtpExistingKeySessionForTarget(context, chainTarget
 		authorization: context.authorization
 	}));
 }
-async function provisionEmailOtpAdditionalExistingKeySessionForTarget(context, chainTarget) {
-	return await provisionEmailOtpExistingKeySessionForTarget(context, chainTarget);
-}
 async function provisionEmailOtpExplicitExportSession(args) {
 	return await args.ports.provisionEmailOtpEcdsaExplicitExportSession(buildEmailOtpExplicitExportEcdsaActivation({
 		relayerUrl: args.relayerUrl,

package/dist/esm/react/core/signingEngine/session/emailOtp/ecdsaPublication.js

@@ -3,9 +3,9 @@ import { SIGNING_SESSION_SEAL_GROUP_ID } from "../../../../shared-ts/src/utils/s
 import { mpcMaterialActivationRefsEqual } from "../../../../shared-ts/src/utils/domainIds.js";
 import { walletAuthAuthorityRef } from "../../../../shared-ts/src/utils/walletAuthAuthority.js";
 import { routerAbEcdsaDerivationActiveStateId, sameRouterAbEcdsaDerivationPublicCapabilityV1 } from "../../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
+import { SigningSessionIds } from "../operationState/types.js";
 import { thresholdEcdsaChainTargetKey, thresholdEcdsaChainTargetsEqual } from "../../interfaces/ecdsaChainTarget.js";
 import { buildEvmFamilyEcdsaWalletKey } from "../identity/evmFamilyEcdsaIdentity.js";
-import { SigningSessionIds } from "../operationState/types.js";
 import { emailOtpAuthContextEmailHashHex, emailOtpAuthContextProvider, emailOtpAuthContextProviderUserId, emailOtpAuthContextRetention } from "../identity/laneIdentity.js";
 import { buildEcdsaRoleLocalPublicFacts } from "../persistence/ecdsaRoleLocalRecords.js";
 import { buildPersistedEcdsaRoleLocalMaterial } from "../material/ecdsaRoleLocalMaterialResolver.js";