@seams/wallet 0.5.1 → 0.5.3

package/dist/esm/react/core/signingEngine/flows/signNear/signTransactions.js

@@ -112,6 +112,51 @@ function createNearTransactionSigningOperationId() {
 	const randomId = secureRandomBase64Url(32, "NEAR transaction signing operation IDs");
 	return SigningSessionIds.signingOperation(`near-transaction-sign:${randomId}`);
 }
+async function prepareNearTransactionConfirmationReadiness(args) {
+	const material = await prepareNearOperationStepUpMaterial({
+		method: args.method,
+		preparation: args.preparation,
+		executor: args.executor
+	});
+	const materialFacts = nearOperationStepUpMaterialFacts(material);
+	if (String(materialFacts.thresholdSessionId) !== args.expectedThresholdSessionId) throw new Error("[SigningEngine][near] prepared operation material changed threshold session");
+	registerNearOperationStepUpBuilder({
+		requestId: args.requestId,
+		build: async (preparation) => {
+			if (preparation.kind !== "near_transaction") throw new Error("[SigningEngine][near] transaction step-up preparation kind changed");
+			if (preparation.operationId !== String(args.operation.operationId)) throw new Error("[SigningEngine][near] operation step-up operation identity changed");
+			return await prepareRouterAbEd25519NearTransactionOperationStepUp({
+				...args.operation,
+				thresholdSessionId: materialFacts.thresholdSessionId,
+				materialFacts,
+				materialActivation: material.materialActivation,
+				transactionContext: preparation.transactionContext,
+				displayDigest: preparation.displayDigest
+			});
+		}
+	});
+	registerNearImplicitAccountFunder({
+		requestId: args.requestId,
+		fund: async (request) => await fundNearImplicitAccountForOperationStepUp({
+			...args.funding,
+			request,
+			fundingSession: await args.executor.resolveFundingSession(),
+			method: args.method
+		})
+	});
+	return material;
+}
+function clearNearTransactionConfirmationResources(requestId) {
+	clearNearOperationStepUpBuilder(requestId);
+	clearNearImplicitAccountFunder(requestId);
+}
+function clearNearTransactionConfirmationReadinessWhenSettled(args) {
+	if (!args.readiness) {
+		clearNearTransactionConfirmationResources(args.requestId);
+		return;
+	}
+	args.readiness.then(clearNearTransactionConfirmationResources.bind(void 0, args.requestId), clearNearTransactionConfirmationResources.bind(void 0, args.requestId));
+}
 /**
 * Sign one NEAR transaction. A transaction may contain multiple actions.
 */
@@ -201,44 +246,28 @@ async function runNearAuthorizationRequiredTransactionSigning(payload) {
 		...emailOtpEd25519StepUp ? { emailOtpEd25519StepUp } : {}
 	});
 	if (preparedStepUp.kind === "warm_session") throw new Error("[SigningEngine][near] deferred Ed25519 transaction cannot use warm session");
-	const operationStepUpMaterial = await prepareNearOperationStepUpMaterial({
-		method: preparedStepUp.kind,
-		preparation: yaoSigningPreparation,
-		executor: yaoMaterialExecutor
-	});
-	const materialFacts = nearOperationStepUpMaterialFacts(operationStepUpMaterial);
 	const signingOperationUses = requiredNearTransactionSignatureUses(transaction);
-	registerNearOperationStepUpBuilder({
-		requestId: String(operationId),
-		build: async (preparation) => {
-			if (preparation.kind !== "near_transaction") throw new Error("[SigningEngine][near] transaction step-up preparation kind changed");
-			return await prepareRouterAbEd25519NearTransactionOperationStepUp({
-				ctx,
-				thresholdSessionId: materialFacts.thresholdSessionId,
-				materialFacts,
-				thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
-				walletId: commandSubject.walletSession.walletId,
-				nearAccountId,
-				materialActivation: operationStepUpMaterial.materialActivation,
-				operationId,
-				operationFingerprint,
-				txSigningRequest,
-				transactionContext: preparation.transactionContext,
-				displayDigest: preparation.displayDigest
-			});
-		}
-	});
-	registerNearImplicitAccountFunder({
+	const operationStepUpReadiness = prepareNearTransactionConfirmationReadiness({
 		requestId: String(operationId),
-		fund: async (fundingRequest) => await fundNearImplicitAccountForOperationStepUp({
-			request: fundingRequest,
+		expectedThresholdSessionId: String(deferredIdentity.thresholdSessionId),
+		method: preparedStepUp.kind,
+		preparation: yaoSigningPreparation,
+		executor: yaoMaterialExecutor,
+		operation: {
+			ctx,
+			thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
+			walletId: commandSubject.walletSession.walletId,
+			nearAccountId,
+			operationId,
+			operationFingerprint,
+			txSigningRequest
+		},
+		funding: {
 			ctx,
 			nearPublicKeyStr: signingContext.signingNearPublicKeyStr,
-			fundingSession: await yaoMaterialExecutor.resolveFundingSession(),
-			method: preparedStepUp.kind,
 			signingOperation,
 			signatureUses: signingOperationUses
-		})
+		}
 	});
 	let confirmation;
 	try {
@@ -274,6 +303,10 @@ async function runNearAuthorizationRequiredTransactionSigning(payload) {
 				}),
 				title,
 				body,
+				confirmationReadiness: {
+					promise: operationStepUpReadiness,
+					body: "Preparing secure signing session…"
+				},
 				onProgress: emitNearSigningConfirmationProgress.bind(void 0, {
 					onEvent,
 					nearAccountId,
@@ -282,9 +315,13 @@ async function runNearAuthorizationRequiredTransactionSigning(payload) {
 			}
 		});
 	} finally {
-		clearNearOperationStepUpBuilder(String(operationId));
-		clearNearImplicitAccountFunder(String(operationId));
+		clearNearTransactionConfirmationReadinessWhenSettled({
+			requestId: String(operationId),
+			readiness: operationStepUpReadiness
+		});
 	}
+	const operationStepUpMaterial = await operationStepUpReadiness;
+	const materialFacts = nearOperationStepUpMaterialFacts(operationStepUpMaterial);
 	const stepUpAuthorization = buildNearEd25519StepUpAuthorization({
 		prepared: preparedStepUp,
 		confirmation
@@ -493,50 +530,28 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 			overlay: "show"
 		}
 	});
-	let operationStepUpMaterial = null;
-	if (preparedStepUp.kind !== "warm_session") {
-		operationStepUpMaterial = await prepareNearOperationStepUpMaterial({
-			method: preparedStepUp.kind,
-			preparation: yaoSigningPreparation,
-			executor: yaoMaterialExecutor
-		});
-		const material = operationStepUpMaterial;
-		const materialFacts = nearOperationStepUpMaterialFacts(material);
-		registerNearOperationStepUpBuilder({
-			requestId: thresholdSessionId,
-			build: async (preparation) => {
-				if (preparation.kind !== "near_transaction") throw new Error("[SigningEngine][near] transaction step-up preparation kind changed");
-				if (preparation.operationId !== String(signingOperation.operationId)) throw new Error("[SigningEngine][near] operation step-up operation identity changed");
-				return await prepareRouterAbEd25519NearTransactionOperationStepUp({
-					ctx,
-					thresholdSessionId: materialFacts.thresholdSessionId,
-					materialFacts,
-					thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
-					walletId: commandSubject.walletSession.walletId,
-					nearAccountId,
-					materialActivation: material.materialActivation,
-					operationId: signingOperation.operationId,
-					operationFingerprint,
-					txSigningRequest,
-					transactionContext: preparation.transactionContext,
-					displayDigest: preparation.displayDigest
-				});
-			}
-		});
-		const stepUpFundingMethod = preparedStepUp.kind;
-		registerNearImplicitAccountFunder({
-			requestId: thresholdSessionId,
-			fund: async (fundingRequest) => await fundNearImplicitAccountForOperationStepUp({
-				request: fundingRequest,
-				ctx,
-				nearPublicKeyStr: signingContext.signingNearPublicKeyStr,
-				fundingSession: await yaoMaterialExecutor.resolveFundingSession(),
-				method: stepUpFundingMethod,
-				signingOperation,
-				signatureUses: requiredSignatureUses
-			})
-		});
-	}
+	const operationStepUpReadiness = preparedStepUp.kind === "warm_session" ? null : prepareNearTransactionConfirmationReadiness({
+		requestId: thresholdSessionId,
+		expectedThresholdSessionId: thresholdSessionId,
+		method: preparedStepUp.kind,
+		preparation: yaoSigningPreparation,
+		executor: yaoMaterialExecutor,
+		operation: {
+			ctx,
+			thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
+			walletId: commandSubject.walletSession.walletId,
+			nearAccountId,
+			operationId: signingOperation.operationId,
+			operationFingerprint,
+			txSigningRequest
+		},
+		funding: {
+			ctx,
+			nearPublicKeyStr: signingContext.signingNearPublicKeyStr,
+			signingOperation,
+			signatureUses: requiredSignatureUses
+		}
+	});
 	let confirmation;
 	try {
 		confirmation = await runSigningConfirmationCommand({
@@ -571,13 +586,20 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 				}),
 				title,
 				body,
+				...operationStepUpReadiness ? { confirmationReadiness: {
+					promise: operationStepUpReadiness,
+					body: "Preparing secure signing session…"
+				} } : {},
 				onProgress: emitUiConfirmProgress
 			}
 		});
 	} finally {
-		clearNearOperationStepUpBuilder(thresholdSessionId);
-		clearNearImplicitAccountFunder(thresholdSessionId);
+		clearNearTransactionConfirmationReadinessWhenSettled({
+			requestId: thresholdSessionId,
+			readiness: operationStepUpReadiness
+		});
 	}
+	const operationStepUpMaterial = operationStepUpReadiness ? await operationStepUpReadiness : null;
 	emitNearSigningEvent(onEvent, nearAccountId, {
 		phase: SigningEventPhase.STEP_05_CONFIRMATION_APPROVED,
 		status: "succeeded",

package/dist/esm/react/core/signingEngine/session/identity/exactWalletSessionReader.js

@@ -1,4 +1,4 @@
-import { WalletSessionAuthorizationUpgradeRequiredError, walletSessionAuthorizations } from "../../../indexedDB/seamsWalletDB/walletSessionAuthorizationStore.js";
+import { WalletSessionAuthorizationUpgradeRequiredError } from "../../../indexedDB/seamsWalletDB/walletSessionAuthorizationStore.js";
 //#region src/core/signingEngine/session/identity/exactWalletSessionReader.ts
 function exactWalletSessionMatchesAuthorityScope(args) {
 	const { record, operationCredential, scope } = args;
@@ -48,32 +48,7 @@ function exactWalletSessionWithOperationCredentialOrThrow(result, message) {
 		case "upgrade_required": throw new WalletSessionAuthorizationUpgradeRequiredError(message);
 	}
 }
-async function readExactOwnerLaneWalletSession(args) {
-	const read = await walletSessionAuthorizations.readExactActiveForWallet({
-		walletId: args.walletId,
-		authorityId: args.authorityId,
-		authMethodId: args.authMethodId
-	});
-	switch (read.kind) {
-		case "found":
-			if (!exactWalletSessionMatchesAuthorityScope({
-				record: read.record,
-				operationCredential: read.operationCredential,
-				scope: args
-			})) throw new Error("[SigningEngine] selected Wallet Authority session identity mismatch");
-			if (read.record.expiresAtMs <= Date.now()) throw new Error("[SigningEngine] selected Wallet Authority session is unavailable: expired");
-			return;
-		case "missing": throw new Error("[SigningEngine] selected Wallet Authority session is unavailable: missing");
-		case "upgrade_required": throw new WalletSessionAuthorizationUpgradeRequiredError("[SigningEngine] selected Wallet Authority Wallet Session requires a newer client");
-		case "corrupt": throw new Error("[SigningEngine] selected Wallet Authority session is unavailable: corrupt");
-		case "persistence_unavailable": throw new Error("[SigningEngine] selected Wallet Authority session is unavailable: persistence_unavailable");
-		default: return assertNeverWalletSessionAuthorizationRead(read);
-	}
-}
-function assertNeverWalletSessionAuthorizationRead(value) {
-	throw new Error(`Unknown exact Wallet Session authorization read: ${String(value)}`);
-}
 //#endregion
-export { exactWalletSessionWithOperationCredentialOrThrow, readExactOwnerLaneWalletSession, readExactWalletSessionAuthentication };
+export { exactWalletSessionWithOperationCredentialOrThrow, readExactWalletSessionAuthentication };
 
 //# sourceMappingURL=exactWalletSessionReader.js.map

package/dist/esm/react/core/signingEngine/uiConfirm/handlers/flows/signing.js

@@ -496,7 +496,7 @@ async function handleIntentDigestSigningFlow(ctx, request, worker, opts) {
 		};
 		const promptDecisionPromise = session.promptUser({
 			securityContext,
-			loading: !!intentPreparation,
+			loading: !!intentPreparation && signingAuthMode !== "warmSession",
 			onMounted: () => {
 				markPromptReady();
 			}

package/dist/esm/sdk/{display-rIXVrumh.js → display-CV_FRBAv.js}

@@ -1,5 +1,5 @@
 import { i as normalizeHexData } from "./bytes-BGPfIYh5.js";
-import { _ as selectorFromHexData, g as resolveFunctionDisplayName, h as formatCalldataForDisplay, m as formatCompactGas } from "./signatureUses-BsYpH81W.js";
+import { _ as selectorFromHexData, g as resolveFunctionDisplayName, h as formatCalldataForDisplay, m as formatCompactGas } from "./signatureUses-Dg0S52Mp.js";
 //#region src/core/signingEngine/chains/tempo/display.ts
 function toSafeJson(value) {
 	try {