@seams/wallet 0.7.1 → 0.7.3

package/dist/esm/sdk/{runtimeLoader-hod6T2-m.js → runtimeLoader-DQVEFVaW.js}

@@ -5,7 +5,7 @@ let registrationPreparationPromise = null;
 let recoveryCodeSurfacePromise = null;
 function loadWalletHostRuntime(route) {
 	if (route.type === "PM_ACKNOWLEDGE_WALLET_RECOVERY_CODE_BACKUP") {
-		recoveryCodeRuntimePromise ??= import("./runtime-recovery-codes-bTm3fLV4.js");
+		recoveryCodeRuntimePromise ??= import("./runtime-recovery-codes-BSCLVHQj.js");
 		return recoveryCodeRuntimePromise;
 	}
 	runtimePromises[route.kind] ??= loadRuntimeForKind(route.kind);
@@ -16,24 +16,24 @@ async function preloadWalletHostRegistrationSurface() {
 	await Promise.all([runtimePromises.near, preloadRegistrationPreparation()]);
 }
 async function preloadWalletHostRecoveryCodeSurface() {
-	recoveryCodeRuntimePromise ??= import("./runtime-recovery-codes-bTm3fLV4.js");
+	recoveryCodeRuntimePromise ??= import("./runtime-recovery-codes-BSCLVHQj.js");
 	recoveryCodeSurfacePromise ??= Promise.all([recoveryCodeRuntimePromise, import("./mountRecoveryCodeBackupSurface-DXrExiJ7.js")]).then(() => void 0);
 	await recoveryCodeSurfacePromise;
 }
 async function preloadRegistrationPreparation() {
-	registrationPreparationPromise ??= import("./registrationPreparationPreload-CIAuRlxI.js");
+	registrationPreparationPromise ??= import("./registrationPreparationPreload-D6zpWp4O.js");
 	await (await registrationPreparationPromise).preloadWalletHostRegistrationPreparation();
 }
 function loadRuntimeForKind(kind) {
 	switch (kind) {
-		case "auth": return import("./runtime-auth-DFTqwj3u.js");
-		case "near": return import("./runtime-near-B9cjurVD.js");
-		case "ecdsa": return import("./runtime-ecdsa-tempo-rkWwolw1.js");
-		case "email_otp": return import("./runtime-email-otp-vuUG5LYl.js");
-		case "recovery": return import("./runtime-recovery-C-vfFKF3.js");
-		case "export": return import("./runtime-export-FZWj0HxJ.js");
-		case "device_link": return import("./runtime-device-link-C1Oub8Lw.js");
-		case "preferences": return import("./runtime-preferences-Dq0bfyS5.js");
+		case "auth": return import("./runtime-auth-DdfynDKt.js");
+		case "near": return import("./runtime-near-CxtQi4b2.js");
+		case "ecdsa": return import("./runtime-ecdsa-tempo-BGLsTAWR.js");
+		case "email_otp": return import("./runtime-email-otp-CpX88VZJ.js");
+		case "recovery": return import("./runtime-recovery-i08vCJST.js");
+		case "export": return import("./runtime-export-DIVY473L.js");
+		case "device_link": return import("./runtime-device-link-HJ2ptFux.js");
+		case "preferences": return import("./runtime-preferences-vnJc5Svg.js");
 	}
 	return assertNever(kind);
 }

package/dist/{public/sdk/secp256k1-el9aE4Sv.js → esm/sdk/secp256k1-D-I6Gh4D.js}

@@ -2,13 +2,13 @@ import { n as __exportAll } from "./chunk-BtrIJ4_z.js";
 import { B as normalizeTrimmedString, V as stripTrailingSlashes, h as parseMpcMaterialActivationRef, r as mpcMaterialActivationRefsEqual } from "./domainIds-lcrFg6Sa.js";
 import { i as base64UrlEncode, r as base64UrlDecode } from "./base64-Clm8C-e9.js";
 import { r as secureRandomId } from "./secureRandomId-BORsmdS4.js";
-import { F as routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1, I as routerAbEcdsaRerandomizationClientCommitmentV1, bt as canonicalRouterAbMpcMaterialActivationRefBytes, d as buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1, et as parseWalletAuthAuthorityRef, g as parseRouterAbEcdsaDerivationNormalSigningScopeV1, l as ROUTER_AB_ECDSA_PRESIGN_CEREMONY_MAX_LIFETIME_MS, o as ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_INIT_PATH, s as ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_STEP_PATH, t as MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS, u as buildRouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1, wt as routerAbMpcMaterialActivationRefToWire } from "./ecdsaPresignLifecycle-BFOTNYCK.js";
-import { a as parseEcdsaRoleLocalPersistedMaterialRef, c as formatEcdsaKeyHandleForWire, l as parseEcdsaClientVerifyingShareB64u, o as parseEcdsaRoleLocalWorkerHandle, s as parseEcdsaThresholdKeyId, u as parseEcdsaKeyHandle } from "./keyMaterialBrands-CX41hur6.js";
+import { Et as routerAbMpcMaterialActivationRefToWire, F as routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1, I as routerAbEcdsaRerandomizationClientCommitmentV1, St as canonicalRouterAbMpcMaterialActivationRefBytes, d as buildRouterAbEcdsaDerivationEvmDigestSigningRequestV1, g as parseRouterAbEcdsaDerivationNormalSigningScopeV1, l as ROUTER_AB_ECDSA_PRESIGN_CEREMONY_MAX_LIFETIME_MS, nt as parseWalletAuthAuthorityRef, o as ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_INIT_PATH, s as ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_FILL_STEP_PATH, t as MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS, u as buildRouterAbEcdsaDerivationEvmDigestSigningFinalizeRequestV1 } from "./ecdsaPresignLifecycle-Bfx2AQKb.js";
+import { a as parseEcdsaRoleLocalPersistedMaterialRef, c as formatEcdsaKeyHandleForWire, l as parseEcdsaClientVerifyingShareB64u, o as parseEcdsaRoleLocalWorkerHandle, s as parseEcdsaThresholdKeyId, u as parseEcdsaKeyHandle } from "./keyMaterialBrands-CogGAAZn.js";
 import { t as executeWorkerOperation } from "./executeWorkerOperation-Cl9whMK7.js";
 import { n as ecdsaClientPresignPoolKey, t as FIXED_ECDSA_PRESIGN_PROTOCOL_ID } from "./ecdsaPresignPoolIdentity-BjxZVIqn.js";
-import { i as emitEcdsaSigningTiming, n as emitEcdsaPresignServerTiming, r as emitEcdsaServerTiming, u as emitSigningSessionFlowTrace } from "./trace-rHe0wz7q.js";
-import { t as DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY } from "./defaultConfigs-B3c16M_8.js";
-import { c as prepareRouterAbEcdsaDerivationEvmDigestSigningV1, o as finalizeRouterAbEcdsaDerivationEvmDigestSigningV1, t as RouterAbSigningRequestError } from "./routerAbNormalSigning-fhvpDtmY.js";
+import { i as emitEcdsaSigningTiming, n as emitEcdsaPresignServerTiming, r as emitEcdsaServerTiming, u as emitSigningSessionFlowTrace } from "./trace-DKLQZvec.js";
+import { t as DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY } from "./defaultConfigs-D_33pPT9.js";
+import { c as prepareRouterAbEcdsaDerivationEvmDigestSigningV1, o as finalizeRouterAbEcdsaDerivationEvmDigestSigningV1, t as RouterAbSigningRequestError } from "./routerAbNormalSigning-CVFEOZ2m.js";
 import { o as validateSecp256k1PublicKey33Wasm, s as verifySecp256k1RecoverableSignatureAgainstPublicKey33Wasm, t as addSecp256k1PublicKeys33Wasm } from "./evmCryptoWasm-DWklhEEb.js";
 //#region src/core/signingEngine/workerManager/workerTypes.ts
 /**
@@ -677,16 +677,19 @@ async function thresholdEcdsaRoleLocalCommitPresignatureWasm(input) {
 		}
 	})).type !== EcdsaPresignClientResponseType.CommitSuccess) throw new Error("ThresholdEcdsaRoleLocalCommitPresignature failed");
 }
-async function thresholdEcdsaRoleLocalListAvailablePresignaturesWasm(input) {
+async function thresholdEcdsaListAvailablePresignaturesWasm(authorityKind, input) {
 	const response = await requestEcdsaPresignOperation({
 		workerCtx: input.workerCtx,
 		request: {
 			type: EcdsaPresignClientRequestType.ListAvailable,
 			timeoutMs: ECDSA_DERIVATION_CLIENT_WORKER_TIMEOUT_MS,
-			payload: { poolIdentity: input.poolIdentity }
+			payload: {
+				authority: { kind: authorityKind },
+				poolIdentity: input.poolIdentity
+			}
 		}
 	});
-	if (response.type !== EcdsaPresignClientResponseType.ListAvailableSuccess) throw new Error("ThresholdEcdsaRoleLocalListAvailablePresignatures failed");
+	if (response.type !== EcdsaPresignClientResponseType.ListAvailableSuccess) throw new Error("ThresholdEcdsaListAvailablePresignatures failed");
 	return response.payload.map(parseListedClientPresignature);
 }
 async function thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm(input) {
@@ -1894,6 +1897,7 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 			});
 		}
 		if (!presignature && supply.kind === "on_demand") {
+			const foregroundRefillStartedAt = performance.now();
 			let refill = await refillRouterAbEcdsaDerivationClientPresignaturePool({
 				...supply.refill,
 				trafficClass: "foreground"
@@ -1917,6 +1921,7 @@ async function signRouterAbEcdsaDerivationDigestWithPoolHitAttempt(args, retryCo
 				clientSigningMaterial: args.clientSigningMaterial,
 				workerCtx: args.workerCtx
 			});
+			emitEcdsaSigningTiming(args.operationId, "foreground_refill", foregroundRefillStartedAt);
 		}
 		emitSigningSessionFlowTrace("evm-family", {
 			event: "ecdsa_presignature_selection",
@@ -2271,21 +2276,7 @@ async function loadRouterAbEcdsaDerivationSigningMaterialSource(args) {
 		const holderHandleId = clientShare.holderHandleId;
 		return {
 			signerSession,
-			clientSigningMaterial: {
-				kind: "router_ab_ecdsa_derivation_client_signing_material_source_v1",
-				initClientPresignSession: async (input) => await thresholdEcdsaLinkedHolderPresignSessionInitWasm({
-					holderHandleId,
-					...input
-				}),
-				stepClientPresignSession: thresholdEcdsaRoleLocalPresignSessionStepWasm,
-				abortClientPresignSession: thresholdEcdsaRoleLocalPresignSessionAbortWasm,
-				admitClientPresignature: thresholdEcdsaRoleLocalAdmitPresignatureWasm,
-				destroyClientPresignature: thresholdEcdsaRoleLocalDestroyPresignatureWasm,
-				reserveClientPresignature: thresholdEcdsaRoleLocalReservePresignatureWasm,
-				commitClientPresignature: thresholdEcdsaRoleLocalCommitPresignatureWasm,
-				listAvailableClientPresignatures: thresholdEcdsaRoleLocalListAvailablePresignaturesWasm,
-				computeSignatureShareFromPresignatureHandle: thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm
-			},
+			clientSigningMaterial: createLinkedHolderClientSigningMaterialSource(holderHandleId),
 			cleanupAfterSign: async () => void 0
 		};
 	}
@@ -2317,12 +2308,32 @@ async function loadRouterAbEcdsaDerivationSigningMaterialSource(args) {
 			destroyClientPresignature: thresholdEcdsaRoleLocalDestroyPresignatureWasm,
 			reserveClientPresignature: thresholdEcdsaRoleLocalReservePresignatureWasm,
 			commitClientPresignature: thresholdEcdsaRoleLocalCommitPresignatureWasm,
-			listAvailableClientPresignatures: thresholdEcdsaRoleLocalListAvailablePresignaturesWasm,
+			listAvailableClientPresignatures: thresholdEcdsaListAvailablePresignaturesWasm.bind(void 0, "role_local_derivation_handle"),
 			computeSignatureShareFromPresignatureHandle: thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm
 		},
 		cleanupAfterSign: async () => void 0
 	};
 }
+async function initLinkedHolderPresignSession(holderHandleId, input) {
+	return await thresholdEcdsaLinkedHolderPresignSessionInitWasm({
+		holderHandleId,
+		...input
+	});
+}
+function createLinkedHolderClientSigningMaterialSource(holderHandleId) {
+	return {
+		kind: "router_ab_ecdsa_derivation_client_signing_material_source_v1",
+		initClientPresignSession: initLinkedHolderPresignSession.bind(void 0, holderHandleId),
+		stepClientPresignSession: thresholdEcdsaRoleLocalPresignSessionStepWasm,
+		abortClientPresignSession: thresholdEcdsaRoleLocalPresignSessionAbortWasm,
+		admitClientPresignature: thresholdEcdsaRoleLocalAdmitPresignatureWasm,
+		destroyClientPresignature: thresholdEcdsaRoleLocalDestroyPresignatureWasm,
+		reserveClientPresignature: thresholdEcdsaRoleLocalReservePresignatureWasm,
+		commitClientPresignature: thresholdEcdsaRoleLocalCommitPresignatureWasm,
+		listAvailableClientPresignatures: thresholdEcdsaListAvailablePresignaturesWasm.bind(void 0, "linked_holder_signing_material"),
+		computeSignatureShareFromPresignatureHandle: thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm
+	};
+}
 //#endregion
 //#region src/core/signingEngine/flows/signEvmFamily/signers/secp256k1.ts
 var secp256k1_exports = /* @__PURE__ */ __exportAll({
@@ -2501,4 +2512,4 @@ var Secp256k1Engine = class {
 	}
 };
 //#endregion
-export { thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm as A, SignerWorkerOperationError as B, prepareLinkedDeviceEcdsaSourceContributionWasm as C, storeLinkedDeviceEcdsaHolderMaterialWasm as D, storeEcdsaRoleLocalSigningMaterialWasm as E, thresholdEcdsaRoleLocalPresignSessionStepWasm as F, getSignerWorkerOperationCoreCode as H, thresholdEcdsaRoleLocalReservePresignatureWasm as I, verifyRouterAbEcdsaRegistrationClientProofsWasm as L, thresholdEcdsaRoleLocalListAvailablePresignaturesWasm as M, thresholdEcdsaRoleLocalPresignSessionAbortWasm as N, thresholdEcdsaRoleLocalAdmitPresignatureWasm as O, thresholdEcdsaRoleLocalPresignSessionInitFromMaterialHandleWasm as P, EcdsaDerivationClientCustomRequestType as R, prepareEcdsaClientBootstrapCommandWasm as S, signWalletRecoveryEcdsaMaterialPossessionProofWasm as T, getSignerWorkerOperationErrorCode as U, WorkerControlMessage as V, finalizeEcdsaHolderOrdinaryExportWasm as _, resolveRouterAbEcdsaDerivationPresignaturePoolPolicy as a, openEcdsaRoleLocalSigningMaterialWasm as b, clearLinkedDeviceEcdsaHolderMaterialsWasm as c, createEcdsaHolderOrdinaryExportRequestWasm as d, createRouterAbEcdsaPostRegistrationCeremonyWasm as f, finalizeEcdsaClientBootstrapCommandWasm as g, destroyLinkedDeviceEcdsaHolderMaterialsWasm as h, clearRouterAbEcdsaDerivationClientPresignaturesForWallet as i, thresholdEcdsaRoleLocalDestroyPresignatureWasm as j, thresholdEcdsaRoleLocalCommitPresignatureWasm as k, closeRouterAbEcdsaPostRegistrationCeremonyWasm as l, destroyLinkedDeviceEcdsaHolderMaterialWasm as m, secp256k1_exports as n, scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill as o, createRouterAbEcdsaRegistrationCeremonyWasm as p, clearAllRouterAbEcdsaDerivationClientPresignatures as r, waitForRouterAbEcdsaDerivationClientPresignaturePoolReady as s, buildReadySecp256k1SigningMaterial as t, closeRouterAbEcdsaRegistrationCeremonyWasm as u, finalizeRouterAbEcdsaExplicitExportWasm as v, reconcileCanonicalEcdsaActivationWasm as w, persistInitialCanonicalEcdsaActivationWasm as x, finalizeRouterAbEcdsaRegistrationActivationWasm as y, EcdsaPresignClientRequestType as z };
+export { thresholdEcdsaRoleLocalAdmitPresignatureWasm as A, EcdsaPresignClientRequestType as B, prepareEcdsaClientBootstrapCommandWasm as C, storeEcdsaRoleLocalSigningMaterialWasm as D, signWalletRecoveryEcdsaMaterialPossessionProofWasm as E, thresholdEcdsaRoleLocalPresignSessionInitFromMaterialHandleWasm as F, WorkerControlMessage as H, thresholdEcdsaRoleLocalPresignSessionStepWasm as I, thresholdEcdsaRoleLocalReservePresignatureWasm as L, thresholdEcdsaRoleLocalComputeSignatureShareFromPresignatureHandleWasm as M, thresholdEcdsaRoleLocalDestroyPresignatureWasm as N, storeLinkedDeviceEcdsaHolderMaterialWasm as O, thresholdEcdsaRoleLocalPresignSessionAbortWasm as P, verifyRouterAbEcdsaRegistrationClientProofsWasm as R, persistInitialCanonicalEcdsaActivationWasm as S, reconcileCanonicalEcdsaActivationWasm as T, getSignerWorkerOperationCoreCode as U, SignerWorkerOperationError as V, getSignerWorkerOperationErrorCode as W, finalizeEcdsaClientBootstrapCommandWasm as _, clearRouterAbEcdsaDerivationClientPresignaturesForWallet as a, finalizeRouterAbEcdsaRegistrationActivationWasm as b, waitForRouterAbEcdsaDerivationClientPresignaturePoolReady as c, closeRouterAbEcdsaRegistrationCeremonyWasm as d, createEcdsaHolderOrdinaryExportRequestWasm as f, destroyLinkedDeviceEcdsaHolderMaterialsWasm as g, destroyLinkedDeviceEcdsaHolderMaterialWasm as h, clearAllRouterAbEcdsaDerivationClientPresignatures as i, thresholdEcdsaRoleLocalCommitPresignatureWasm as j, thresholdEcdsaListAvailablePresignaturesWasm as k, clearLinkedDeviceEcdsaHolderMaterialsWasm as l, createRouterAbEcdsaRegistrationCeremonyWasm as m, secp256k1_exports as n, resolveRouterAbEcdsaDerivationPresignaturePoolPolicy as o, createRouterAbEcdsaPostRegistrationCeremonyWasm as p, createLinkedHolderClientSigningMaterialSource as r, scheduleRouterAbEcdsaDerivationClientPresignaturePoolRefill as s, buildReadySecp256k1SigningMaterial as t, closeRouterAbEcdsaPostRegistrationCeremonyWasm as u, finalizeEcdsaHolderOrdinaryExportWasm as v, prepareLinkedDeviceEcdsaSourceContributionWasm as w, openEcdsaRoleLocalSigningMaterialWasm as x, finalizeRouterAbEcdsaExplicitExportWasm as y, EcdsaDerivationClientCustomRequestType as z };

package/dist/esm/sdk/{sessionPolicy-CHiilOAB.js → sessionPolicy-DO-MkL65.js}

@@ -175,6 +175,10 @@ function requireCanonicalBase64Url(value, label) {
 	if (base64UrlEncode(decoded) !== value) throw new Error(`${label} must be canonical base64url`);
 	return decoded;
 }
+function requireParsed(result, label) {
+	if (result.ok) return result.value;
+	throw new Error(`${label} ${result.error.message}`);
+}
 function parseDigestField(value, label) {
 	try {
 		return parseDigestB64u(value);
@@ -288,6 +292,9 @@ function normalizeRuntimePolicyScopeFields(input) {
 		...normalizeOptionalTrimmedString(scope.signingRootVersion) ? { signingRootVersion: normalizeOptionalTrimmedString(scope.signingRootVersion) } : {}
 	};
 }
+function sameRuntimePolicyScope(left, right) {
+	return left.orgId === right.orgId && left.projectId === right.projectId && left.envId === right.envId && left.signingRootVersion === right.signingRootVersion;
+}
 function signingRootScopeFromRuntimePolicyScope(scope) {
 	return {
 		signingRootId: deriveSigningRootId(scope),
@@ -450,4 +457,4 @@ async function buildExactEd25519SessionPolicy(params) {
 	};
 }
 //#endregion
-export { parseDelegatedWalletAuthorityV1 as A, parseEnvelopeRevision as C, buildFullOwnerDelegatedWalletAuthorityV1 as D, parseUnixMs as E, sameDelegatedWalletAuthorityV1 as M, exactRecord as N, delegatedWalletPermissionNamesV1 as O, rejectUnknownFields as P, parseEnvelopeNonceB64u as S, parseSecp256k1CompressedPublicKeyB64u as T, deriveEvmFamilySigningKeySlotId as _, clampThresholdSessionPolicy as a, parseEd25519PublicKeyB64u as b, resolveWalletUnlockSessionUsesFromRequestedUses as c, normalizeThresholdEd25519ParticipantIds as d, parseThresholdEd25519ParticipantsV1 as f, signingRootScopeFromRuntimePolicyScope as g, normalizeRuntimePolicyScope as h, buildEd25519SessionPolicy as i, parseDelegatedWalletPermissionSetV1 as j, hasDelegatedWalletPermissionV1 as k, THRESHOLD_ED25519_2P_PARTICIPANT_IDS as l, deriveSigningRootId as m, DEFAULT_THRESHOLD_SESSION_TTL_MS as n, normalizeThresholdRuntimePolicyScope as o, coerceThemeMode as p, DEFAULT_UNLOCK_REMAINING_USES as r, parsePositiveSessionUses as s, DEFAULT_THRESHOLD_SESSION_POLICY as t, buildThresholdEd25519Participants2pV1 as u, requireEvmFamilySigningKeySlotId as v, parseKeyCreationSignerSlot as w, parseEnvelopeCiphertextB64u as x, parseDigestField as y };
+export { delegatedWalletPermissionNamesV1 as A, parseEnvelopeNonceB64u as C, parseUnixMs as D, parseSecp256k1CompressedPublicKeyB64u as E, exactRecord as F, rejectUnknownFields as I, parseDelegatedWalletAuthorityV1 as M, parseDelegatedWalletPermissionSetV1 as N, requireParsed as O, sameDelegatedWalletAuthorityV1 as P, parseEnvelopeCiphertextB64u as S, parseKeyCreationSignerSlot as T, signingRootScopeFromRuntimePolicyScope as _, clampThresholdSessionPolicy as a, parseDigestField as b, resolveWalletUnlockSessionUsesFromRequestedUses as c, normalizeThresholdEd25519ParticipantIds as d, parseThresholdEd25519ParticipantsV1 as f, sameRuntimePolicyScope as g, normalizeRuntimePolicyScope as h, buildEd25519SessionPolicy as i, hasDelegatedWalletPermissionV1 as j, buildFullOwnerDelegatedWalletAuthorityV1 as k, THRESHOLD_ED25519_2P_PARTICIPANT_IDS as l, deriveSigningRootId as m, DEFAULT_THRESHOLD_SESSION_TTL_MS as n, normalizeThresholdRuntimePolicyScope as o, coerceThemeMode as p, DEFAULT_UNLOCK_REMAINING_USES as r, parsePositiveSessionUses as s, DEFAULT_THRESHOLD_SESSION_POLICY as t, buildThresholdEd25519Participants2pV1 as u, deriveEvmFamilySigningKeySlotId as v, parseEnvelopeRevision as w, parseEd25519PublicKeyB64u as x, requireEvmFamilySigningKeySlotId as y };

package/dist/{public/sdk/signEvmFamily-e4IWWsZs.js → esm/sdk/signEvmFamily-C3C97Th-.js}

@@ -3,35 +3,35 @@ import { h as parseMpcMaterialActivationRef, r as mpcMaterialActivationRefsEqual
 import { r as reviewAdmissionForBinding } from "./transactionReviewAdmission-BCPvl8OZ.js";
 import { r as base64UrlDecode } from "./base64-Clm8C-e9.js";
 import { n as secureRandomBase64Url } from "./secureRandomId-BORsmdS4.js";
-import { h as normalizeRuntimePolicyScope } from "./sessionPolicy-CHiilOAB.js";
-import { At as walletSessionPreservesCapabilities, Ct as routerAbMpcMaterialActivationRefFromWire, L as sameRouterAbEcdsaDerivationNormalSigningScopeV1, M as routerAbEcdsaDerivationActiveStateId, X as isPasskeyWalletAuthAuthority, Y as isEmailOtpWalletAuthAuthority, Z as parseEmailOtpWalletAuthAuthority, a as ROUTER_AB_ECDSA_DERIVATION_OPERATION_STEP_UP_PATH, b as parseRouterAbEcdsaOperationStepUpAuthorizationRequestV1, et as parseWalletAuthAuthorityRef, f as computeRouterAbEcdsaOperationStepUpChallengeB64u, g as parseRouterAbEcdsaDerivationNormalSigningScopeV1, ht as computeEcdsaDerivationRoleLocalRelayerKeyId, j as requireRouterAbEcdsaDerivationNormalSigningStateV1, nt as walletAuthAuthorityRef, tt as walletAuthAuthoritiesMatch, wt as routerAbMpcMaterialActivationRefToWire, x as parseRouterAbEcdsaOperationStepUpAuthorizationResponseV1 } from "./ecdsaPresignLifecycle-BFOTNYCK.js";
+import { h as normalizeRuntimePolicyScope } from "./sessionPolicy-DO-MkL65.js";
+import { $ as parseEmailOtpWalletAuthAuthority, Et as routerAbMpcMaterialActivationRefToWire, M as routerAbEcdsaDerivationActiveStateId, Mt as walletSessionPreservesCapabilities, Q as isPasskeyWalletAuthAuthority, Tt as routerAbMpcMaterialActivationRefFromWire, Z as isEmailOtpWalletAuthAuthority, _t as computeEcdsaDerivationRoleLocalRelayerKeyId, a as ROUTER_AB_ECDSA_DERIVATION_OPERATION_STEP_UP_PATH, b as parseRouterAbEcdsaOperationStepUpAuthorizationRequestV1, f as computeRouterAbEcdsaOperationStepUpChallengeB64u, g as parseRouterAbEcdsaDerivationNormalSigningScopeV1, it as walletAuthAuthorityRef, j as requireRouterAbEcdsaDerivationNormalSigningStateV1, nt as parseWalletAuthAuthorityRef, rt as walletAuthAuthoritiesMatch, x as parseRouterAbEcdsaOperationStepUpAuthorizationResponseV1, z as sameRouterAbEcdsaDerivationNormalSigningScopeV1 } from "./ecdsaPresignLifecycle-Bfx2AQKb.js";
 import { t as chainFamilyFromNetwork } from "./chains-BMh3btVo.js";
 import { c as toWalletId, o as thresholdEcdsaChainTargetKey, s as thresholdEcdsaChainTargetsEqual } from "./ecdsaChainTarget-Bl-JWyuw.js";
 import { f as WALLET_EMAIL_OTP_TRANSACTION_SIGN_OPERATION, n as SIGNER_AUTH_METHODS } from "./signerDomain-IEAVrOrc.js";
 import { a as toIndexedDbChainTargetKey } from "./normalization-CBt413-z.js";
-import { C as toThresholdOwnerAddress, c as buildResolvedEvmFamilyEcdsaKey, f as deriveEvmFamilyKeyFingerprintFromPublicFacts, l as buildVerifiedEcdsaPublicFacts, n as buildBaseEvmFamilyEcdsaKeyIdentity, o as buildHydratedEcdsaSignerMaterial, s as buildPasskeyEcdsaAuthBinding, u as deriveEvmFamilyEcdsaKeyHandle, x as toRpId, y as toEvmFamilyEcdsaKeyHandle } from "./evmFamilyEcdsaIdentity-Co5XDcEA.js";
-import { a as isActiveEcdsaWalletAuthorityV1, l as isEd25519ExtensionOfEcdsaWalletAuthority, s as isCombinedWalletSignerActivationSetV1 } from "./walletAuthority-BQBxgUBn.js";
-import { a as parseEcdsaRoleLocalPersistedMaterialRef, l as parseEcdsaClientVerifyingShareB64u, s as parseEcdsaThresholdKeyId } from "./keyMaterialBrands-CX41hur6.js";
+import { C as toThresholdOwnerAddress, It as sameEcdsaSourceSigner, Lt as sameEcdsaTarget, c as buildResolvedEvmFamilyEcdsaKey, f as deriveEvmFamilyKeyFingerprintFromPublicFacts, l as buildVerifiedEcdsaPublicFacts, n as buildBaseEvmFamilyEcdsaKeyIdentity, o as buildHydratedEcdsaSignerMaterial, s as buildPasskeyEcdsaAuthBinding, u as deriveEvmFamilyEcdsaKeyHandle, x as toRpId, y as toEvmFamilyEcdsaKeyHandle } from "./evmFamilyEcdsaIdentity-CqGafQsI.js";
+import { a as isActiveEcdsaWalletAuthorityV1, l as isEd25519ExtensionOfEcdsaWalletAuthority, s as isCombinedWalletSignerActivationSetV1 } from "./walletAuthority-DD9T25F6.js";
+import { a as parseEcdsaRoleLocalPersistedMaterialRef, l as parseEcdsaClientVerifyingShareB64u, s as parseEcdsaThresholdKeyId } from "./keyMaterialBrands-CogGAAZn.js";
 import { a as SIGNING_SESSION_EXPIRY_DETECTION_SOURCES, m as createSigningFlowEvent, o as SigningEventPhase } from "./sdkSentEvents-MqDkbQg1.js";
 import { t as parseSignerSlot } from "./signerSlot-_ovonwVX.js";
 import { c as signingLaneAuthMethod, i as SigningSessionPlanKind, n as SigningOperationIntent, r as SigningSessionIds, s as signingLaneAuthBindingKey } from "./types-Dx9fczU7.js";
-import { t as demoEmailOtpCodeFromDelivery } from "./challengeDelivery-Dd0586fo.js";
-import { b as openEcdsaRoleLocalSigningMaterialWasm, t as buildReadySecp256k1SigningMaterial } from "./secp256k1-el9aE4Sv.js";
-import { O as projectEcdsaRoleLocalPublicFactsToChainTarget, y as routerAbEcdsaDerivationPublicCapabilitiesEqual } from "./ecdsaCapabilityManifest-kzO_fW09.js";
+import { t as demoEmailOtpCodeFromDelivery } from "./challengeDelivery-DZtopOAG.js";
+import { t as buildReadySecp256k1SigningMaterial, x as openEcdsaRoleLocalSigningMaterialWasm } from "./secp256k1-D-I6Gh4D.js";
+import { O as projectEcdsaRoleLocalPublicFactsToChainTarget, y as routerAbEcdsaDerivationPublicCapabilitiesEqual } from "./ecdsaCapabilityManifest-DuMs0VtU.js";
 import { c as evmNonceLeaseToManagedReservation, l as evmReserveNonceInputToLane, s as evmManagedReservationToLane } from "./nonceLaneKeys-C3c9lG6u.js";
-import { c as exactSigningLaneIdentityKey, g as requireEvmFamilyEcdsaSigner, n as exactEcdsaSigningLaneIdentity, r as exactEcdsaSigningLaneIdentityFromSelectedLane, s as exactSigningLaneIdentityFromSelectedLane, t as buildEvmFamilyEcdsaSignerBinding } from "./exactSigningLaneIdentity-DQeqPMST.js";
-import { c as buildTempoTransactionSigningLane, o as buildEvmTransactionSigningLane, x as selectedEcdsaLane, y as laneCandidateAuthMethod } from "./nearEd25519YaoSigningPreparation-BeD-SmbK.js";
+import { c as exactSigningLaneIdentityKey, g as requireEvmFamilyEcdsaSigner, n as exactEcdsaSigningLaneIdentity, r as exactEcdsaSigningLaneIdentityFromSelectedLane, s as exactSigningLaneIdentityFromSelectedLane, t as buildEvmFamilyEcdsaSignerBinding } from "./exactSigningLaneIdentity-m6uTXV_A.js";
+import { c as buildTempoTransactionSigningLane, o as buildEvmTransactionSigningLane, x as selectedEcdsaLane, y as laneCandidateAuthMethod } from "./nearEd25519YaoSigningPreparation-CdOT5RuC.js";
 import { a as throwEmailOtpSigningSessionAuthStateError, o as buildEmailOtpRoutePlan } from "./routePlan-D59x5xzQ.js";
 import { r as parseSigningOperationFingerprintDigest } from "./operationFingerprint-CGZui5dR.js";
-import { c as emitSigningPlannerDecisionTrace, l as emitSigningSessionFlowFailure, o as emitSigningBoundaryTrace, s as emitSigningLaneResolutionTrace, t as createSigningBoundaryTraceEvent, u as emitSigningSessionFlowTrace } from "./trace-rHe0wz7q.js";
-import { i as loadWebAuthnP256EngineCtor, n as loadSignEvmFamilyWithUiConfirmForTempo, r as loadSignEvmWithUiConfirm, t as loadSecp256k1EngineCtor } from "./signerLoader-D7Aey0FD.js";
+import { c as emitSigningPlannerDecisionTrace, l as emitSigningSessionFlowFailure, o as emitSigningBoundaryTrace, s as emitSigningLaneResolutionTrace, t as createSigningBoundaryTraceEvent, u as emitSigningSessionFlowTrace } from "./trace-DKLQZvec.js";
+import { i as loadWebAuthnP256EngineCtor, n as loadSignEvmFamilyWithUiConfirmForTempo, r as loadSignEvmWithUiConfirm, t as loadSecp256k1EngineCtor } from "./signerLoader-B7orgq5Z.js";
 import { a as isPasskeySigningAuthPlan, i as isEmailOtpSigningAuthPlan, n as SigningAuthPlanKind } from "./promptText-CuRa_ivd.js";
 import { t as computeSigningOperationFingerprint, u as signingAuthPlanFromSigningSessionPlan } from "./operationFingerprint-C8Trar4R.js";
-import { _ as WalletSessionQuotaAdmissionError, b as classifyWalletSessionQuotaAdmissionFailure, g as WALLET_SESSION_FAILURE_CODES, h as walletSessionFailureFromError, p as walletSessionFailureErrorFromPayload, v as buildOperationAuthorizationQueueKey, x as decideWalletSessionQuotaAdmissionFailure } from "./routerAbNormalSigning-fhvpDtmY.js";
-import { b as withThresholdCommitQueue, f as ecdsaAvailableLaneCandidatesForTarget, h as isConcreteAvailableSigningLane, o as selectEvmFamilyEcdsaMaterialCandidate, r as prepareTransactionSigningOperation, u as availableEcdsaSigningLaneAuthMethod, v as requireAuthoritativeExpiredWalletSessionAuthorizationBoundary, y as clearThresholdCommitQueue } from "./transactionState-DP9O8F6f.js";
+import { _ as WalletSessionQuotaAdmissionError, b as classifyWalletSessionQuotaAdmissionFailure, g as WALLET_SESSION_FAILURE_CODES, h as walletSessionFailureFromError, p as walletSessionFailureErrorFromPayload, v as buildOperationAuthorizationQueueKey, x as decideWalletSessionQuotaAdmissionFailure } from "./routerAbNormalSigning-CVFEOZ2m.js";
+import { C as withThresholdCommitQueue, S as resolveThresholdCommitQueueKey, b as requireAuthoritativeExpiredWalletSessionAuthorizationBoundary, f as ecdsaAvailableLaneCandidatesForTarget, h as isConcreteAvailableSigningLane, o as selectEvmFamilyEcdsaMaterialCandidate, r as prepareTransactionSigningOperation, u as availableEcdsaSigningLaneAuthMethod } from "./transactionState-CJ4U8pcl.js";
 import { t as bytesToHex } from "./bytes-qKxKn4gg.js";
-import { d as buildEvmDisplayModel, l as fromManagedNonceReservationSnapshot, n as isEvmFamilyEcdsaMaterialSupersededError, u as reserveNonceInputFromBoundary } from "./signingFlow-rZfPegH9.js";
-import { t as buildTempoDisplayModel } from "./display-KdIL0ff7.js";
+import { d as buildEvmDisplayModel, l as fromManagedNonceReservationSnapshot, n as isEvmFamilyEcdsaMaterialSupersededError, u as reserveNonceInputFromBoundary } from "./signingFlow-SZ8t_lxv.js";
+import { t as buildTempoDisplayModel } from "./display-P4nQF-yc.js";
 //#region src/core/signingEngine/session/material/linkedEcdsaHolderRuntime.ts
 const linkedHolderRuntimes = /* @__PURE__ */ new Map();
 function runtimeKey(input) {
@@ -1023,56 +1023,14 @@ function isEvmFamilySigningOperationTraceEnabled() {
 }
 //#endregion
 //#region src/core/signingEngine/threshold/ecdsa/signingQueue.ts
-function ecdsaSigningQueueWalletIdLabel(walletId) {
-	return String(walletId).trim();
-}
-function createThresholdEcdsaSigningQueueOverflowError(walletId, queueKey, maxQueueLength) {
-	const normalizedWalletId = ecdsaSigningQueueWalletIdLabel(walletId);
-	const err = /* @__PURE__ */ new Error(`[SigningEngine] threshold ECDSA signing queue overflow for ${normalizedWalletId} (queueKey=${queueKey}, max=${maxQueueLength})`);
-	err.code = "commit_queue_overflow";
-	return err;
-}
-function createThresholdEcdsaSigningQueueTimeoutError(walletId, queueKey, timeoutMs) {
-	const normalizedWalletId = ecdsaSigningQueueWalletIdLabel(walletId);
-	const err = /* @__PURE__ */ new Error(`[SigningEngine] threshold ECDSA signing queue timeout for ${normalizedWalletId} (queueKey=${queueKey}, waited>${timeoutMs}ms before start)`);
-	err.code = "commit_queue_timeout";
-	return err;
-}
-function createThresholdEcdsaSigningQueueCancelledError(walletId, queueKey, reason = "cancelled") {
-	const normalizedWalletId = ecdsaSigningQueueWalletIdLabel(walletId);
-	const message = reason === "queue_cleared" ? `[SigningEngine] threshold ECDSA queued signing operation cancelled for ${normalizedWalletId} (queueKey=${queueKey}, queue_cleared)` : `[SigningEngine] threshold ECDSA queued signing operation cancelled for ${normalizedWalletId} (queueKey=${queueKey})`;
-	const err = new Error(message);
-	err.code = "cancelled";
-	return err;
-}
-function resolveThresholdEcdsaSigningQueueKey(args) {
-	return [
-		"material",
-		encodeURIComponent(String(args.materialActivation.materialOwner)),
-		encodeURIComponent(String(args.materialActivation.capability)),
-		encodeURIComponent(String(args.materialActivation.activationId))
-	].join(":");
-}
-function clearThresholdEcdsaSigningQueue(queueByKey) {
-	clearThresholdCommitQueue(queueByKey);
-}
 async function withThresholdEcdsaSigningQueue(args) {
-	const queueKey = String(args.queueKey || "").trim();
-	if (!queueKey) throw new Error("[SigningEngine] threshold ECDSA signing queue requires non-empty queueKey");
-	const walletKey = args.walletId;
 	return await withThresholdCommitQueue({
-		queueByKey: args.queueByKey,
-		queueKey,
-		enabled: args.enabled,
-		shouldAbort: args.shouldAbort,
-		maxQueueLength: args.maxQueueLength,
-		queueTimeoutMs: args.queueTimeoutMs,
-		task: args.task,
-		errors: {
-			makeOverflowError: (queueKey, maxQueueLength) => createThresholdEcdsaSigningQueueOverflowError(walletKey, queueKey, maxQueueLength),
-			makeTimeoutError: (queueKey, timeoutMs) => createThresholdEcdsaSigningQueueTimeoutError(walletKey, queueKey, timeoutMs),
-			makeCancelledError: (queueKey, reason) => createThresholdEcdsaSigningQueueCancelledError(walletKey, queueKey, reason)
-		}
+		...args,
+		labels: {
+			queue: "threshold ECDSA signing queue",
+			queuedOperation: "threshold ECDSA queued signing operation"
+		},
+		owner: String(args.walletId).trim()
 	});
 }
 //#endregion
@@ -1277,7 +1235,7 @@ async function refreshEmailOtpSigningSession(deps, args) {
 		chainTarget: args.chainTarget
 	})).runtime.materialActivation;
 	return await deps.withThresholdEcdsaSigningQueue({
-		queueKey: resolveThresholdEcdsaSigningQueueKey({ materialActivation: activationBeforeRefresh }),
+		queueKey: resolveThresholdCommitQueueKey({ materialActivation: activationBeforeRefresh }),
 		walletId: args.walletSession.walletId,
 		enabled: true,
 		task: runFencedEmailOtpSigningSessionRefresh.bind(void 0, {
@@ -1921,13 +1879,6 @@ async function prepareEvmFamilyEcdsaSigningSession(args) {
 				diagnostics: selection.diagnostics
 			});
 			const committedSelectionAuthMethod = selection.committedLane.authority.factor.kind;
-			const availableLanes = await args.deps.readAvailableSigningLanesForSigning({
-				walletId,
-				curve: "ecdsa",
-				ecdsaChainTargets: [chainTarget],
-				authMethod: committedSelectionAuthMethod,
-				ownerScope
-			});
 			emitSigningLaneResolutionTrace("evm-family", selection.lane, { reason: "evm_family_ecdsa_selection" });
 			args.diagnostics.selection = {
 				kind: selection.kind,
@@ -1970,7 +1921,7 @@ async function prepareEvmFamilyEcdsaSigningSession(args) {
 					expiresAtMs: readiness.expiresAtMs,
 					remainingUses: readiness.remainingUses
 				},
-				availableLanesGeneration: availableLanes.generation,
+				availableLanesGeneration: candidateAvailableLanes.generation,
 				metadata: {
 					accountAuth: selection.accountAuth,
 					authMethod: committedSelectionAuthMethod,
@@ -1981,7 +1932,7 @@ async function prepareEvmFamilyEcdsaSigningSession(args) {
 						...args.signingOperation.operationFingerprint ? { operationFingerprint: args.signingOperation.operationFingerprint } : {},
 						laneIdentityKey: exactSigningLaneIdentityKey(exactSigningLaneIdentityFromSelectedLane(resolvedLane))
 					},
-					availableLanesGeneration: availableLanes.generation
+					availableLanesGeneration: candidateAvailableLanes.generation
 				}
 			};
 		} }
@@ -2425,9 +2376,6 @@ function requireRawEip1559ThresholdOwnerNonceSenderIdentity(args) {
 	if (args.state.kind === "not_required") throw new Error(`[SigningEngine][evm-family] raw EIP-1559 signing requires prepared threshold ECDSA owner address for ${args.walletId}`);
 	return thresholdOwnerNonceSenderIdentity(args.state.thresholdOwnerAddress);
 }
-function resolvePreparedNonceSenderIdentity(args) {
-	return resolveThresholdOwnerNonceSenderIdentity(args);
-}
 function resolveFallbackChainAccountNonceSenderIdentity(args) {
 	return resolveWalletChainNonceSenderIdentity({
 		deps: args.deps,
@@ -2482,7 +2430,7 @@ async function executeEvmFamilyTransactionSigning(args) {
 			walletId: args.walletId,
 			chainTarget: args.chainTarget
 		}) : void 0;
-		const preparedSenderIdentity = resolvePreparedNonceSenderIdentity({ state: args.thresholdEcdsaState });
+		const preparedSenderIdentity = resolveThresholdOwnerNonceSenderIdentity({ state: args.thresholdEcdsaState });
 		const getSenderIdentity = (nonceArgs) => {
 			const exactSenderIdentity = rawEip1559SenderIdentity || preparedSenderIdentity;
 			if (exactSenderIdentity) return Promise.resolve(exactSenderIdentity);
@@ -2521,7 +2469,7 @@ async function executeEvmFamilyTransactionSigning(args) {
 		});
 	}
 	let tempoFallbackSenderIdentityPromise = null;
-	const tempoPreparedSenderIdentity = resolvePreparedNonceSenderIdentity({ state: args.thresholdEcdsaState });
+	const tempoPreparedSenderIdentity = resolveThresholdOwnerNonceSenderIdentity({ state: args.thresholdEcdsaState });
 	const getTempoSenderIdentity = (nonceArgs) => {
 		if (tempoPreparedSenderIdentity) return Promise.resolve(tempoPreparedSenderIdentity);
 		if (!tempoFallbackSenderIdentityPromise) tempoFallbackSenderIdentityPromise = resolveFallbackChainAccountNonceSenderIdentity({
@@ -3344,14 +3292,8 @@ function normalSigningAddress(normalSigning) {
 		return null;
 	}
 }
-function linkedEcdsaSourceSignerIdentitiesEqual(left, right) {
-	return mpcMaterialActivationRefsEqual(left.activation, right.activation) && left.clientPublicKey33B64u === right.clientPublicKey33B64u && left.relayerPublicKey33B64u === right.relayerPublicKey33B64u && left.thresholdPublicKey33B64u === right.thresholdPublicKey33B64u && left.thresholdEthereumAddress20B64u === right.thresholdEthereumAddress20B64u;
-}
-function linkedEcdsaTargetRecipientPreparationsEqual(left, right) {
-	return mpcMaterialActivationRefsEqual(left.activation, right.activation) && left.targetDeviceId === right.targetDeviceId && left.targetFactorVerificationDigestB64u === right.targetFactorVerificationDigestB64u && left.clientRecipientPublicKeyB64u === right.clientRecipientPublicKeyB64u && left.signingWorkerRecipientPublicKeyB64u === right.signingWorkerRecipientPublicKeyB64u;
-}
 function linkedEcdsaSourceContributionBindingsEqual(left, right) {
-	return left.linkSessionId === right.linkSessionId && left.enrollmentId === right.enrollmentId && left.sourceAuthorityId === right.sourceAuthorityId && linkedEcdsaSourceSignerIdentitiesEqual(left.source, right.source) && linkedEcdsaTargetRecipientPreparationsEqual(left.target, right.target) && left.targetClientPublicKey33B64u === right.targetClientPublicKey33B64u;
+	return left.linkSessionId === right.linkSessionId && left.enrollmentId === right.enrollmentId && left.sourceAuthorityId === right.sourceAuthorityId && sameEcdsaSourceSigner(left.source, right.source) && sameEcdsaTarget(left.target, right.target) && left.targetClientPublicKey33B64u === right.targetClientPublicKey33B64u;
 }
 function linkedEcdsaNormalSigningStatesEqual(left, right) {
 	return left.kind === right.kind && sameRouterAbEcdsaDerivationNormalSigningScopeV1(left.scope, right.scope);
@@ -3687,7 +3629,7 @@ async function prepareSessionBoundEcdsaOperationStepUp(sessionScope, input) {
 }
 async function runSerializedEcdsaMaterialUse(args, task) {
 	return await args.deps.withThresholdEcdsaSigningQueue({
-		queueKey: resolveThresholdEcdsaSigningQueueKey({ materialActivation: args.materialActivation }),
+		queueKey: resolveThresholdCommitQueueKey({ materialActivation: args.materialActivation }),
 		walletId: args.walletId,
 		enabled: true,
 		...args.shouldAbort ? { shouldAbort: args.shouldAbort } : {},
@@ -3837,18 +3779,19 @@ async function createEvmFamilySigningFlowRuntime(args) {
 	const ctx = args.deps.touchConfirm.getContext();
 	const walletId = toWalletId(args.walletSession.walletId);
 	const relayerUrl = requireEvmFamilyRelayerUrl(args.deps);
-	const resolvedSigner = args.senderSignatureAlgorithm === "secp256k1" ? requireEvmFamilyEcdsaSigner(args.getEcdsaSigningLaneIdentity(), "ECDSA signing material hydration") : void 0;
+	const resolvedSigner = args.senderSignatureAlgorithm === "secp256k1" ? requireEvmFamilyEcdsaSigner(args.preparedSession.kind === "authorized" ? args.preparedSession.signingLane.identity : args.preparedSession.identity, "ECDSA signing material hydration") : void 0;
 	if (args.activeWalletAuthority && !resolvedSigner) throw new Error("[SigningEngine] active Wallet Authority runtime requires a threshold ECDSA signer");
 	const capability = resolvedSigner && !args.activeWalletAuthority ? await args.deps.resolveCanonicalEcdsaSigningCapability({
 		walletId: resolvedSigner.walletId,
 		chainTarget: resolvedSigner.chainTarget,
 		materialActivation: resolvedSigner.materialActivation
 	}) : void 0;
-	const activeAuthorization = resolvedSigner && !args.activeWalletAuthority ? await args.deps.resolveActiveEcdsaWalletSessionAuthorization({
-		walletId: resolvedSigner.walletId,
-		chainTarget: resolvedSigner.chainTarget,
-		materialActivation: resolvedSigner.materialActivation
-	}) : null;
+	const preparedAuthorization = args.preparedSession?.kind === "authorized" ? args.preparedSession.selection.lane.authorization : null;
+	const activeAuthorization = capability && preparedAuthorization && preparedAuthorization.runtime.remainingUses > 0 && exactAuthorizationMatchesCapability({
+		capability,
+		authorization: preparedAuthorization,
+		nowMs: Date.now()
+	}) ? preparedAuthorization : null;
 	const exactOperationCredentialScope = resolvedSigner && capability && !args.activeWalletAuthority ? {
 		walletId: resolvedSigner.walletId,
 		chainTarget: resolvedSigner.chainTarget,
@@ -4413,10 +4356,6 @@ async function signEvmFamilyAttempt(deps, args, attempt) {
 		if (preparedEcdsaSigningSession) return preparedEcdsaSigningSession;
 		throw new Error("[SigningEngine][ecdsa] prepared signing session is required");
 	};
-	const getEcdsaSigningLaneIdentity = () => {
-		const prepared = getPreparedEcdsaSigningSession();
-		return prepared.kind === "authorized" ? prepared.signingLane.identity : prepared.identity;
-	};
 	const getPreparedEcdsaSigningSessionIfEcdsa = () => args.request.senderSignatureAlgorithm === "secp256k1" ? getPreparedEcdsaSigningSession() : void 0;
 	const reResolveSupersededPreparation = async (error) => {
 		if (!isEvmFamilyEcdsaMaterialSupersededError(error)) return null;
@@ -4480,7 +4419,11 @@ async function signEvmFamilyAttempt(deps, args, attempt) {
 			walletSession: args.walletSession,
 			request: args.request,
 			chainTarget: requestChainTarget,
-			senderSignatureAlgorithm: args.request.senderSignatureAlgorithm,
+			...args.request.senderSignatureAlgorithm === "secp256k1" ? {
+				senderSignatureAlgorithm: args.request.senderSignatureAlgorithm,
+				preparedSession: getPreparedEcdsaSigningSession(),
+				...activeWalletAuthorityFlowRuntime ? { activeWalletAuthority: activeWalletAuthorityFlowRuntime } : {}
+			} : { senderSignatureAlgorithm: args.request.senderSignatureAlgorithm },
 			...signingSessionPlan ? { signingSessionPlan } : {},
 			signingOperation: createTransactionSigningOperation(),
 			onSigningOperationTransition: emitEvmFamilySigningOperationTrace,
@@ -4488,9 +4431,7 @@ async function signEvmFamilyAttempt(deps, args, attempt) {
 			confirmationConfigOverride: args.confirmationConfigOverride,
 			shouldAbort: args.shouldAbort,
 			onEvent: args.onEvent,
-			onAuthSideEffectStarted: markFreshAuthRetrySideEffect,
-			getEcdsaSigningLaneIdentity,
-			...activeWalletAuthorityFlowRuntime ? { activeWalletAuthority: activeWalletAuthorityFlowRuntime } : {}
+			onAuthSideEffectStarted: markFreshAuthRetrySideEffect
 		});
 		return {
 			signingAuthPlan,
@@ -4663,4 +4604,4 @@ async function reconcileTempoNonceLane(deps, args) {
 	return await reconcileEvmFamilyNonceLane(deps, args);
 }
 //#endregion
-export { authorizeEvmFamilyEcdsaSigningCapability as A, listLinkedEcdsaHolderRuntimesV1 as B, buildExactPasskeyOwnerLaneScope as C, buildPersistedEcdsaRoleLocalMaterial as D, resolveExactWalletAuthAuthority as E, signingAuthorizationFromPreprocessing as F, resolveLinkedEcdsaHolderRuntimeV1 as H, ensureSealedRefreshStartupParityForThresholdEcdsaBootstrap as I, isRetryableSealedRefreshCapabilityFetchError as L, buildEcdsaPreprocessingCapability as M, buildExactEcdsaDirectCapabilityRuntime as N, ecdsaRoleLocalPersistedMaterialSource as O, buildExactEvmFamilyWalletSessionAuthorization as P, clearLinkedEcdsaHolderRuntimesV1 as R, buildExactLinkedEmailOtpOwnerLaneScope as S, resolveExactOwnerLaneScope as T, removeLinkedEcdsaHolderRuntimeV1 as V, resolveEmailOtpEcdsaSigningSessionAuth as _, reportTempoFinalized as a, withThresholdEcdsaSigningQueue as b, resolveActiveWalletAuthorityEcdsaRuntimeV1 as c, createActiveEcdsaCapabilityRuntimeForChainResolver as d, createActiveEcdsaCapabilityRuntimeResolver as f, requestEmailOtpSigningSessionChallenge as g, refreshEmailOtpSigningSession as h, reportTempoDroppedOrReplaced as i, buildCanonicalEvmFamilyEcdsaSigningCapability as j, resolveEcdsaRoleLocalMaterial as k, issueEcdsaOperationStepUpAuthorization as l, resolveExactEcdsaSealedRuntime as m, reportTempoBroadcastAccepted as n, signEvmFamily as o, resolveExactEcdsaCapabilityRuntime as p, reportTempoBroadcastRejected as r, signEvmFamily_exports as s, reconcileTempoNonceLane as t, prepareEcdsaOperationStepUp as u, clearThresholdEcdsaSigningQueue as v, isOwnerRelinkRequiredError as w, buildExactEcdsaPasskeyOwnerLaneScope as x, resolveThresholdEcdsaSigningQueueKey as y, installLinkedEcdsaHolderRuntimeV1 as z };
+export { buildCanonicalEvmFamilyEcdsaSigningCapability as A, removeLinkedEcdsaHolderRuntimeV1 as B, isOwnerRelinkRequiredError as C, ecdsaRoleLocalPersistedMaterialSource as D, buildPersistedEcdsaRoleLocalMaterial as E, ensureSealedRefreshStartupParityForThresholdEcdsaBootstrap as F, isRetryableSealedRefreshCapabilityFetchError as I, clearLinkedEcdsaHolderRuntimesV1 as L, buildExactEcdsaDirectCapabilityRuntime as M, buildExactEvmFamilyWalletSessionAuthorization as N, resolveEcdsaRoleLocalMaterial as O, signingAuthorizationFromPreprocessing as P, installLinkedEcdsaHolderRuntimeV1 as R, buildExactPasskeyOwnerLaneScope as S, resolveExactWalletAuthAuthority as T, resolveLinkedEcdsaHolderRuntimeV1 as V, requestEmailOtpSigningSessionChallenge as _, reportTempoFinalized as a, buildExactEcdsaPasskeyOwnerLaneScope as b, resolveActiveWalletAuthorityEcdsaRuntimeV1 as c, createActiveEcdsaCapabilityRuntimeForChainResolver as d, createActiveEcdsaCapabilityRuntimeResolver as f, refreshEmailOtpSigningSession as g, buildRouterAbEcdsaDerivationSigningMaterialRef as h, reportTempoDroppedOrReplaced as i, buildEcdsaPreprocessingCapability as j, authorizeEvmFamilyEcdsaSigningCapability as k, issueEcdsaOperationStepUpAuthorization as l, resolveExactEcdsaSealedRuntime as m, reportTempoBroadcastAccepted as n, signEvmFamily as o, resolveExactEcdsaCapabilityRuntime as p, reportTempoBroadcastRejected as r, signEvmFamily_exports as s, reconcileTempoNonceLane as t, prepareEcdsaOperationStepUp as u, resolveEmailOtpEcdsaSigningSessionAuth as v, resolveExactOwnerLaneScope as w, buildExactLinkedEmailOtpOwnerLaneScope as x, withThresholdEcdsaSigningQueue as y, listLinkedEcdsaHolderRuntimesV1 as z };

package/dist/esm/sdk/{signEvmFamilyWithUiConfirmForTempo-Cu9qdk8M.js → signEvmFamilyWithUiConfirmForTempo-BI9DSTIS.js}

@@ -7,8 +7,8 @@ import "./signerDomain-IEAVrOrc.js";
 import "./signingSessionSeal-Cu-GHm6y.js";
 import { t as executeWorkerOperation } from "./executeWorkerOperation-Cl9whMK7.js";
 import { t as bytesToHex } from "./bytes-qKxKn4gg.js";
-import { d as buildEvmDisplayModel, r as signEvmFamilyWithUiConfirm } from "./signingFlow-rZfPegH9.js";
-import { t as buildTempoDisplayModel } from "./display-KdIL0ff7.js";
+import { d as buildEvmDisplayModel, r as signEvmFamilyWithUiConfirm } from "./signingFlow-SZ8t_lxv.js";
+import { t as buildTempoDisplayModel } from "./display-P4nQF-yc.js";
 import { i as decodeCoseP256PublicKeyWasm } from "./evmCryptoWasm-DWklhEEb.js";
 import { n as EvmAdapter, t as requiredEvmFamilyRequestSignatureUses } from "./signatureUses-BkGyYt8F.js";
 //#region src/core/signingEngine/chains/tempo/tempoSignerWasm.ts

package/dist/{public/sdk/signEvmWithUiConfirm-C61TCBnh.js → esm/sdk/signEvmWithUiConfirm-Bmcim5-g.js}

@@ -3,7 +3,7 @@ import "./errors-93h9uAW9.js";
 import "./capabilityKinds-hvYqa6S_.js";
 import "./signerDomain-IEAVrOrc.js";
 import "./signingSessionSeal-Cu-GHm6y.js";
-import { d as buildEvmDisplayModel, r as signEvmFamilyWithUiConfirm } from "./signingFlow-rZfPegH9.js";
+import { d as buildEvmDisplayModel, r as signEvmFamilyWithUiConfirm } from "./signingFlow-SZ8t_lxv.js";
 import { n as EvmAdapter, t as requiredEvmFamilyRequestSignatureUses } from "./signatureUses-BkGyYt8F.js";
 //#region src/core/signingEngine/flows/signEvmFamily/signEvmWithUiConfirm.ts
 async function signEvmWithUiConfirm(args) {