@seams/wallet 0.7.1 → 0.8.0

package/dist/public/sdk/operationFingerprint-C8Trar4R.js

@@ -1,929 +0,0 @@
-import { i as isUserCancellationError } from "./errors-93h9uAW9.js";
-import { i as base64UrlEncode } from "./base64-Clm8C-e9.js";
-import { r as secureRandomId } from "./secureRandomId-BORsmdS4.js";
-import { f as alphabetizeStringify, m as sha256BytesUtf8 } from "./chains-BMh3btVo.js";
-import { o as SigningEventPhase } from "./sdkSentEvents-MqDkbQg1.js";
-import { a as summarizeSigningLane, c as signingLaneAuthMethod, i as SigningSessionPlanKind, o as summarizeSigningSessionPlan, r as SigningSessionIds, t as SigningKeyRefIntentKind } from "./types-Dx9fczU7.js";
-import { n as SigningAuthPlanKind, t as formatEmailOtpSentText } from "./promptText-CuRa_ivd.js";
-//#region src/core/signingEngine/flows/shared/signingStateMachine.ts
-const SigningOperationStateKind = {
-	Created: "created",
-	Planned: "planned",
-	ConfirmationApproved: "confirmation_approved",
-	AuthenticationInProgress: "authentication_in_progress",
-	AuthReady: "auth_ready",
-	ThresholdConnected: "threshold_connected",
-	PayloadPrepared: "payload_prepared",
-	Signed: "signed",
-	CleanedUp: "cleaned_up",
-	Completed: "completed",
-	Failed: "failed",
-	Cancelled: "cancelled"
-};
-const SigningOperationCommandKind = {
-	ShowConfirmation: "showConfirmation",
-	RequestOtp: "requestOtp",
-	RequestPasskey: "requestPasskey",
-	ConnectThreshold: "connectThreshold",
-	PreparePayload: "preparePayload",
-	Sign: "sign",
-	Cleanup: "cleanup"
-};
-const SigningOperationCancellationPhase = {
-	Review: "review",
-	Authentication: "authentication",
-	Execution: "execution"
-};
-const SigningOperationReviewApproval = {
-	Pending: "pending",
-	Approved: "approved"
-};
-const SigningOperationInteractionEventKind = {
-	ReviewApproved: "review_approved",
-	AuthenticationStarted: "authentication_started",
-	AuthenticationCompleted: "authentication_completed"
-};
-function createSigningOperationStateRef(args) {
-	return {
-		operationId: args.operationId,
-		current: { kind: SigningOperationStateKind.Created }
-	};
-}
-function planSigningOperationAttempt(stateRef, plan) {
-	switch (stateRef.current.kind) {
-		case SigningOperationStateKind.Created:
-		case SigningOperationStateKind.Planned: {
-			const nextState = {
-				kind: SigningOperationStateKind.Planned,
-				plan
-			};
-			stateRef.current = nextState;
-			return nextState;
-		}
-		case SigningOperationStateKind.ConfirmationApproved:
-		case SigningOperationStateKind.AuthReady:
-		case SigningOperationStateKind.ThresholdConnected:
-		case SigningOperationStateKind.PayloadPrepared:
-		case SigningOperationStateKind.Signed:
-		case SigningOperationStateKind.CleanedUp: {
-			const nextState = {
-				kind: SigningOperationStateKind.ConfirmationApproved,
-				plan
-			};
-			stateRef.current = nextState;
-			return nextState;
-		}
-		case SigningOperationStateKind.AuthenticationInProgress: {
-			const nextState = {
-				kind: stateRef.current.reviewApproval === SigningOperationReviewApproval.Approved ? SigningOperationStateKind.ConfirmationApproved : SigningOperationStateKind.Planned,
-				plan
-			};
-			stateRef.current = nextState;
-			return nextState;
-		}
-		case SigningOperationStateKind.Completed: throw new Error("[SigningOperationMachine] completed operation cannot be replanned");
-		case SigningOperationStateKind.Failed: throw new Error("[SigningOperationMachine] failed operation cannot be replanned");
-		case SigningOperationStateKind.Cancelled: throw new Error("[SigningOperationMachine] cancelled operation cannot be replanned");
-		default: return assertNeverSigningOperationState(stateRef.current);
-	}
-}
-function approveSigningOperationConfirmation(stateRef) {
-	switch (stateRef.current.kind) {
-		case SigningOperationStateKind.Planned:
-			stateRef.current = {
-				kind: SigningOperationStateKind.ConfirmationApproved,
-				plan: stateRef.current.plan
-			};
-			return;
-		case SigningOperationStateKind.ConfirmationApproved:
-		case SigningOperationStateKind.AuthReady:
-		case SigningOperationStateKind.ThresholdConnected:
-		case SigningOperationStateKind.PayloadPrepared:
-		case SigningOperationStateKind.Signed:
-		case SigningOperationStateKind.CleanedUp: return;
-		case SigningOperationStateKind.AuthenticationInProgress:
-			stateRef.current = {
-				kind: SigningOperationStateKind.AuthenticationInProgress,
-				plan: stateRef.current.plan,
-				reviewApproval: SigningOperationReviewApproval.Approved
-			};
-			return;
-		case SigningOperationStateKind.Created: throw new Error("[SigningOperationMachine] operation must be planned before confirmation");
-		case SigningOperationStateKind.Completed: throw new Error("[SigningOperationMachine] completed operation cannot be confirmed");
-		case SigningOperationStateKind.Failed: throw new Error("[SigningOperationMachine] failed operation cannot be confirmed");
-		case SigningOperationStateKind.Cancelled: throw new Error("[SigningOperationMachine] cancelled operation cannot be confirmed");
-		default: return assertNeverSigningOperationState(stateRef.current);
-	}
-}
-function beginSigningOperationAuthentication(stateRef) {
-	switch (stateRef.current.kind) {
-		case SigningOperationStateKind.Planned:
-			stateRef.current = {
-				kind: SigningOperationStateKind.AuthenticationInProgress,
-				plan: stateRef.current.plan,
-				reviewApproval: SigningOperationReviewApproval.Pending
-			};
-			return;
-		case SigningOperationStateKind.ConfirmationApproved:
-			stateRef.current = {
-				kind: SigningOperationStateKind.AuthenticationInProgress,
-				plan: stateRef.current.plan,
-				reviewApproval: SigningOperationReviewApproval.Approved
-			};
-			return;
-		case SigningOperationStateKind.AuthenticationInProgress: return;
-		case SigningOperationStateKind.Created: throw new Error("[SigningOperationMachine] operation must be planned before authentication");
-		case SigningOperationStateKind.AuthReady:
-		case SigningOperationStateKind.ThresholdConnected:
-		case SigningOperationStateKind.PayloadPrepared:
-		case SigningOperationStateKind.Signed:
-		case SigningOperationStateKind.CleanedUp: return;
-		case SigningOperationStateKind.Completed: throw new Error("[SigningOperationMachine] completed operation cannot authenticate");
-		case SigningOperationStateKind.Failed: throw new Error("[SigningOperationMachine] failed operation cannot authenticate");
-		case SigningOperationStateKind.Cancelled: throw new Error("[SigningOperationMachine] cancelled operation cannot authenticate");
-		default: return assertNeverSigningOperationState(stateRef.current);
-	}
-}
-function completeSigningOperationAuthentication(stateRef) {
-	switch (stateRef.current.kind) {
-		case SigningOperationStateKind.AuthenticationInProgress:
-			if (stateRef.current.reviewApproval !== SigningOperationReviewApproval.Approved) throw new Error("[SigningOperationMachine] authentication cannot complete before transaction approval");
-			stateRef.current = {
-				kind: SigningOperationStateKind.AuthReady,
-				plan: stateRef.current.plan
-			};
-			return;
-		case SigningOperationStateKind.ConfirmationApproved:
-		case SigningOperationStateKind.AuthReady:
-		case SigningOperationStateKind.ThresholdConnected:
-		case SigningOperationStateKind.PayloadPrepared:
-		case SigningOperationStateKind.Signed:
-		case SigningOperationStateKind.CleanedUp: return;
-		case SigningOperationStateKind.Created:
-		case SigningOperationStateKind.Planned: throw new Error("[SigningOperationMachine] authentication cannot complete before transaction approval");
-		case SigningOperationStateKind.Completed: throw new Error("[SigningOperationMachine] completed operation cannot authenticate");
-		case SigningOperationStateKind.Failed: throw new Error("[SigningOperationMachine] failed operation cannot authenticate");
-		case SigningOperationStateKind.Cancelled: throw new Error("[SigningOperationMachine] cancelled operation cannot authenticate");
-		default: return assertNeverSigningOperationState(stateRef.current);
-	}
-}
-function applySigningOperationInteractionEvent(stateRef, event) {
-	switch (event.kind) {
-		case SigningOperationInteractionEventKind.ReviewApproved:
-			approveSigningOperationConfirmation(stateRef);
-			return;
-		case SigningOperationInteractionEventKind.AuthenticationStarted:
-			beginSigningOperationAuthentication(stateRef);
-			return;
-		case SigningOperationInteractionEventKind.AuthenticationCompleted:
-			completeSigningOperationAuthentication(stateRef);
-			return;
-		default: return assertNeverSigningOperationInteractionEvent(event);
-	}
-}
-function cancelSigningOperation(stateRef) {
-	let phase;
-	switch (stateRef.current.kind) {
-		case SigningOperationStateKind.Planned:
-			phase = SigningOperationCancellationPhase.Review;
-			break;
-		case SigningOperationStateKind.AuthenticationInProgress:
-			phase = SigningOperationCancellationPhase.Authentication;
-			break;
-		case SigningOperationStateKind.ConfirmationApproved:
-		case SigningOperationStateKind.AuthReady:
-		case SigningOperationStateKind.ThresholdConnected:
-		case SigningOperationStateKind.PayloadPrepared:
-			phase = SigningOperationCancellationPhase.Execution;
-			break;
-		case SigningOperationStateKind.Created: throw new Error("[SigningOperationMachine] operation must be planned before cancellation");
-		case SigningOperationStateKind.Signed:
-		case SigningOperationStateKind.CleanedUp:
-		case SigningOperationStateKind.Completed: throw new Error("[SigningOperationMachine] completed signing cannot be cancelled");
-		case SigningOperationStateKind.Failed: throw new Error("[SigningOperationMachine] failed operation cannot be cancelled");
-		case SigningOperationStateKind.Cancelled: return stateRef.current;
-		default: return assertNeverSigningOperationState(stateRef.current);
-	}
-	const cancelled = {
-		kind: SigningOperationStateKind.Cancelled,
-		plan: stateRef.current.plan,
-		phase
-	};
-	stateRef.current = cancelled;
-	return cancelled;
-}
-function isSigningOperationReviewApprovedStateKind(kind) {
-	switch (kind) {
-		case SigningOperationStateKind.Planned: return false;
-		case SigningOperationStateKind.ConfirmationApproved: return true;
-		default: return assertNeverSigningOperationStateKind(kind);
-	}
-}
-function isSigningOperationReviewApprovedState(state) {
-	switch (state.kind) {
-		case SigningOperationStateKind.Created:
-		case SigningOperationStateKind.Planned:
-		case SigningOperationStateKind.Failed:
-		case SigningOperationStateKind.Cancelled: return false;
-		case SigningOperationStateKind.AuthenticationInProgress: return state.reviewApproval === SigningOperationReviewApproval.Approved;
-		case SigningOperationStateKind.ConfirmationApproved:
-		case SigningOperationStateKind.AuthReady:
-		case SigningOperationStateKind.ThresholdConnected:
-		case SigningOperationStateKind.PayloadPrepared:
-		case SigningOperationStateKind.Signed:
-		case SigningOperationStateKind.CleanedUp:
-		case SigningOperationStateKind.Completed: return true;
-		default: return assertNeverSigningOperationState(state);
-	}
-}
-function createSigningOperationPlan(args) {
-	return {
-		kind: "signing_operation_plan",
-		sessionPlan: args.sessionPlan,
-		operation: args.operation,
-		commands: args.commands
-	};
-}
-async function runSigningOperationCommandSteps(args) {
-	const executedSteps = [];
-	for (const step of args.steps) {
-		if (step.command) try {
-			await args.executor.execute(step.command);
-		} catch (error) {
-			const failedStep = transition({
-				from: step.from,
-				to: {
-					kind: SigningOperationStateKind.Failed,
-					plan: step.command.plan,
-					reason: getExecutionErrorReason(error)
-				},
-				command: step.command,
-				reason: getExecutionErrorReason(error)
-			});
-			await args.onTransition?.(failedStep.traceEvent);
-			executedSteps.push(failedStep);
-			return {
-				ok: false,
-				finalState: failedStep.to,
-				steps: executedSteps,
-				error
-			};
-		}
-		await args.onTransition?.(step.traceEvent);
-		executedSteps.push(step);
-		if (step.to.kind === SigningOperationStateKind.Failed) return {
-			ok: true,
-			finalState: step.to,
-			steps: executedSteps
-		};
-	}
-	const finalState = executedSteps.at(-1)?.to || args.steps.at(-1)?.from;
-	if (!finalState) throw new Error("[SigningOperationMachine] command sequence produced no steps");
-	return {
-		ok: true,
-		finalState,
-		steps: executedSteps
-	};
-}
-async function runUnplannedSigningOperationCommandSequence(args) {
-	for (const command of args.commands) await args.execute(command);
-}
-function buildSigningOperationCommandSteps(operationPlan) {
-	const steps = buildSigningOperationSteps(operationPlan);
-	let lastCommandIndex = -1;
-	steps.forEach((step, index) => {
-		if (step.command) lastCommandIndex = index;
-	});
-	return lastCommandIndex >= 0 ? steps.slice(0, lastCommandIndex + 1) : [];
-}
-async function runSigningOperationCommand(args) {
-	let value;
-	const result = await runSigningOperationCommandSteps({
-		steps: buildSigningOperationCommandSteps(createSigningOperationPlan({
-			sessionPlan: args.signingSessionPlan,
-			operation: args.signingOperation,
-			commands: [args.commandKind]
-		})),
-		executor: { execute: async (command) => {
-			if (command.kind !== args.commandKind) return;
-			value = await args.execute();
-		} }
-	});
-	if (!result.ok) throw result.error;
-	if (result.finalState.kind === SigningOperationStateKind.Failed) throw new Error(result.finalState.reason);
-	return value;
-}
-function buildSigningOperationSteps(operationPlan, initialState = {
-	kind: SigningOperationStateKind.Planned,
-	plan: operationPlan.sessionPlan
-}) {
-	const plan = operationPlan.sessionPlan;
-	if (plan.kind === SigningSessionPlanKind.NotReady) return [transition({
-		from: initialState,
-		to: {
-			kind: SigningOperationStateKind.Failed,
-			plan,
-			reason: plan.reason
-		},
-		reason: plan.reason
-	})];
-	const steps = [];
-	let state = initialState;
-	state = pushTransition(steps, state, {
-		to: {
-			kind: SigningOperationStateKind.ConfirmationApproved,
-			plan
-		},
-		command: commandForPlan(operationPlan, {
-			kind: SigningOperationCommandKind.ShowConfirmation,
-			plan,
-			lane: plan.lane
-		})
-	});
-	if (plan.kind === SigningSessionPlanKind.EmailOtpReauth) {
-		state = pushTransition(steps, state, {
-			to: {
-				kind: SigningOperationStateKind.AuthReady,
-				plan
-			},
-			command: commandForPlan(operationPlan, {
-				kind: SigningOperationCommandKind.RequestOtp,
-				plan,
-				lane: plan.lane
-			})
-		});
-		state = pushTransition(steps, state, {
-			to: {
-				kind: SigningOperationStateKind.ThresholdConnected,
-				plan
-			},
-			command: commandForPlan(operationPlan, {
-				kind: SigningOperationCommandKind.ConnectThreshold,
-				plan,
-				lane: plan.lane
-			})
-		});
-	} else if (plan.kind === SigningSessionPlanKind.PasskeyReauth) {
-		state = pushTransition(steps, state, {
-			to: {
-				kind: SigningOperationStateKind.AuthReady,
-				plan
-			},
-			command: commandForPlan(operationPlan, {
-				kind: SigningOperationCommandKind.RequestPasskey,
-				plan,
-				lane: plan.lane
-			})
-		});
-		state = pushTransition(steps, state, {
-			to: {
-				kind: SigningOperationStateKind.ThresholdConnected,
-				plan
-			},
-			command: commandForPlan(operationPlan, {
-				kind: SigningOperationCommandKind.ConnectThreshold,
-				plan,
-				lane: plan.lane
-			})
-		});
-	} else state = pushTransition(steps, state, { to: {
-		kind: SigningOperationStateKind.AuthReady,
-		plan
-	} });
-	state = pushTransition(steps, state, {
-		to: {
-			kind: SigningOperationStateKind.PayloadPrepared,
-			plan
-		},
-		command: commandForPlan(operationPlan, {
-			kind: SigningOperationCommandKind.PreparePayload,
-			plan,
-			lane: plan.lane
-		})
-	});
-	state = pushTransition(steps, state, {
-		to: {
-			kind: SigningOperationStateKind.Signed,
-			plan
-		},
-		command: commandForPlan(operationPlan, {
-			kind: SigningOperationCommandKind.Sign,
-			plan,
-			lane: plan.lane
-		})
-	});
-	state = pushTransition(steps, state, {
-		to: {
-			kind: SigningOperationStateKind.CleanedUp,
-			plan
-		},
-		command: commandForPlan(operationPlan, {
-			kind: SigningOperationCommandKind.Cleanup,
-			plan,
-			lane: plan.lane
-		})
-	});
-	pushTransition(steps, state, { to: {
-		kind: SigningOperationStateKind.Completed,
-		plan
-	} });
-	return steps;
-}
-function pushTransition(steps, from, args) {
-	const step = transition({
-		from,
-		to: args.to,
-		command: args.command,
-		reason: args.reason
-	});
-	steps.push(step);
-	return step.to;
-}
-function transition(args) {
-	const plan = getTransitionPlan(args.from, args.to);
-	return {
-		from: args.from,
-		to: args.to,
-		command: args.command,
-		traceEvent: {
-			event: "signing_operation_transition",
-			from: args.from.kind,
-			to: args.to.kind,
-			...args.command ? { command: args.command.kind } : {},
-			...args.command?.operation ? { operationId: args.command.operation.operationId } : {},
-			plan: summarizeSigningSessionPlan(plan),
-			lane: summarizeSigningLane(plan.lane),
-			...args.reason ? { reason: args.reason } : {}
-		}
-	};
-}
-function getTransitionPlan(from, to) {
-	if ("plan" in to) return to.plan;
-	if ("plan" in from) return from.plan;
-	throw new Error("[SigningOperationMachine] transition has no signing plan");
-}
-function commandForPlan(operationPlan, command) {
-	if (!operationPlan.commands.includes(command.kind)) return void 0;
-	return withOperation(command, operationPlan.operation);
-}
-function withOperation(command, operation) {
-	return operation ? {
-		...command,
-		operation
-	} : command;
-}
-function getExecutionErrorReason(error) {
-	if (error instanceof Error && error.message.trim()) return error.message;
-	return "execution_command_failed";
-}
-function assertNeverSigningOperationState(value) {
-	throw new Error(`Unsupported signing operation state: ${String(value)}`);
-}
-function assertNeverSigningOperationInteractionEvent(value) {
-	throw new Error(`[SigningOperationMachine] unsupported interaction event: ${String(value)}`);
-}
-function assertNeverSigningOperationStateKind(value) {
-	throw new Error(`Unsupported signing operation state kind: ${String(value)}`);
-}
-//#endregion
-//#region src/core/signingEngine/stepUpConfirmation/otpPrompt/signingPrompt.ts
-function buildEmailOtpSigningPrompt(args) {
-	return {
-		challengeId: args.challenge.challengeId,
-		...args.challenge.emailHint ? { emailHint: args.challenge.emailHint } : {},
-		title: "Enter email code to sign",
-		helperText: formatEmailOtpSentText(args.challenge.emailHint),
-		...args.resend ? { onResend: args.resend } : {}
-	};
-}
-//#endregion
-//#region src/core/signingEngine/stepUpConfirmation/methodSelection.ts
-var StepUpMethodSelectionError = class extends Error {
-	constructor(code, method, message) {
-		super(message);
-		this.name = "StepUpMethodSelectionError";
-		this.code = code;
-		this.method = method;
-	}
-};
-function methodFromPolicy(selectedLane, policy) {
-	if (policy.kind === "reuse_warm_session") return "warm_session";
-	if (policy.kind === "force_method") return policy.method;
-	return selectedLane.authMethod;
-}
-function selectStepUpMethod(args) {
-	if (args.policy.kind === "reuse_warm_session") return {
-		method: "warm_session",
-		authorization: args.policy.authorization
-	};
-	const selectedMethod = methodFromPolicy(args.selectedLane, args.policy);
-	if (selectedMethod === "passkey") {
-		if (!args.methods.passkey) throw new StepUpMethodSelectionError("missing_step_up_runner", selectedMethod, "Passkey step-up runner is required for this operation");
-		return {
-			method: "passkey",
-			runner: args.methods.passkey
-		};
-	}
-	if (selectedMethod === "email_otp") {
-		if (!args.methods.emailOtp) throw new StepUpMethodSelectionError("missing_step_up_runner", selectedMethod, "Email OTP step-up runner is required for this operation");
-		return {
-			method: "email_otp",
-			runner: args.methods.emailOtp
-		};
-	}
-	const unsupportedMethod = selectedMethod;
-	throw new StepUpMethodSelectionError("unsupported_step_up_method", unsupportedMethod, `Unsupported step-up method: ${unsupportedMethod}`);
-}
-//#endregion
-//#region src/core/signingEngine/stepUpConfirmation/requireStepUpAuth.ts
-async function prepareStepUpAuth(args) {
-	const route = selectStepUpMethod({
-		selectedLane: args.selectedLane,
-		policy: args.policy,
-		methods: args.methods
-	});
-	if (route.method === "warm_session") return {
-		method: "warm_session",
-		authorization: route.authorization
-	};
-	if (route.method === "passkey") {
-		const prompt = await route.runner.prepare({
-			operation: args.operation,
-			selectedLane: args.selectedLane,
-			policy: args.policy
-		});
-		return {
-			method: "passkey",
-			prompt,
-			complete: async (confirmation) => await route.runner.complete({
-				operation: args.operation,
-				selectedLane: args.selectedLane,
-				policy: args.policy,
-				prompt,
-				confirmation
-			})
-		};
-	}
-	const challenge = await route.runner.prepareChallenge({
-		operation: args.operation,
-		selectedLane: args.selectedLane,
-		policy: args.policy
-	});
-	const promptRef = {};
-	const prompt = buildEmailOtpSigningPrompt({
-		challenge,
-		resend: route.runner.resendChallenge ? async () => await route.runner.resendChallenge({
-			operation: args.operation,
-			selectedLane: args.selectedLane,
-			policy: args.policy,
-			currentPrompt: promptRef.prompt || prompt
-		}) : void 0
-	});
-	promptRef.prompt = prompt;
-	return {
-		method: "email_otp",
-		prompt,
-		complete: async (confirmation) => await route.runner.complete({
-			operation: args.operation,
-			selectedLane: args.selectedLane,
-			policy: args.policy,
-			prompt,
-			confirmation
-		})
-	};
-}
-//#endregion
-//#region src/core/signingEngine/stepUpConfirmation/confirmOperation.ts
-function buildSigningConfirmationAuthParams(args) {
-	switch (args.signingAuthPlan.kind) {
-		case SigningAuthPlanKind.WarmSession: return { signingAuthPlan: args.signingAuthPlan };
-		case SigningAuthPlanKind.ActiveWalletAuthority: return { signingAuthPlan: args.signingAuthPlan };
-		case SigningAuthPlanKind.PasskeyReauth: return {
-			signingAuthPlan: args.signingAuthPlan,
-			...args.webauthnChallenge ? { webauthnChallenge: args.webauthnChallenge } : {}
-		};
-		case SigningAuthPlanKind.EmailOtpReauth: {
-			const emailOtpPrompt = args.emailOtpPrompt ?? args.signingAuthPlan.emailOtpPrompt;
-			if (!emailOtpPrompt) throw new Error("[SigningConfirmation] missing_email_otp_prompt");
-			return {
-				signingAuthPlan: args.signingAuthPlan,
-				emailOtpPrompt
-			};
-		}
-		default: return assertNeverSigningAuthPlan(args.signingAuthPlan);
-	}
-}
-function assertNeverSigningAuthPlan(value) {
-	throw new Error(`Unsupported signing auth plan: ${String(value.kind)}`);
-}
-async function confirmSigningOperation(args) {
-	validateSigningConfirmationAuthRoute(args.request);
-	const orchestrate = args.runtime.orchestrateSigningConfirmation;
-	return await orchestrate(args.request);
-}
-function validateSigningConfirmationAuthRoute(request) {
-	const raw = request;
-	switch (request.signingAuthPlan.kind) {
-		case SigningAuthPlanKind.WarmSession:
-			if (raw.emailOtpPrompt !== void 0 || raw.webauthnChallenge !== void 0) throw new Error("[SigningConfirmation] auth_method_route_mismatch");
-			return;
-		case SigningAuthPlanKind.ActiveWalletAuthority:
-			if (raw.emailOtpPrompt !== void 0 || raw.webauthnChallenge !== void 0) throw new Error("[SigningConfirmation] auth_method_route_mismatch");
-			return;
-		case SigningAuthPlanKind.PasskeyReauth:
-			if (raw.emailOtpPrompt !== void 0) throw new Error("[SigningConfirmation] auth_method_route_mismatch");
-			return;
-		case SigningAuthPlanKind.EmailOtpReauth:
-			if (raw.webauthnChallenge !== void 0 || !raw.emailOtpPrompt) throw new Error("[SigningConfirmation] auth_method_route_mismatch");
-			return;
-		default: return assertNeverSigningAuthPlan(request.signingAuthPlan);
-	}
-}
-//#endregion
-//#region src/core/signingEngine/session/material/walletSigningStateFailure.ts
-const WALLET_SIGNING_MATERIAL_INVALID = "wallet_signing_material_invalid";
-const WALLET_FULL_LOGIN_REQUIRED = "wallet_full_login_required";
-const WALLET_SIGNING_MATERIAL_TEMPORARILY_UNAVAILABLE = "wallet_signing_material_temporarily_unavailable";
-const WALLET_OPERATION_STEP_UP_CANCELLED = "wallet_operation_step_up_cancelled";
-function classifyWalletSigningMaterialBlock(reason) {
-	switch (reason) {
-		case "missing_capability":
-		case "missing_material":
-		case "authority_ambiguous":
-		case "binding_mismatch":
-		case "exact_record_conflict":
-		case "corrupt": return {
-			kind: "invalid_material",
-			reason
-		};
-		case "revoked":
-		case "replaced": return {
-			kind: "full_login_required",
-			reason
-		};
-		case "persistence_unavailable": return {
-			kind: "temporarily_unavailable",
-			reason
-		};
-		default: throw new Error("[SigningEngine] unsupported signing material block reason");
-	}
-}
-var InvalidWalletSigningMaterialError = class extends Error {
-	constructor(reason) {
-		super("Wallet signing material is invalid. Log in again or recover the wallet.");
-		this.reason = reason;
-		this.name = "InvalidWalletSigningMaterialError";
-		this.code = WALLET_SIGNING_MATERIAL_INVALID;
-	}
-};
-var WalletFullLoginRequiredError = class extends Error {
-	constructor(reason) {
-		super("A full wallet login is required before signing.");
-		this.reason = reason;
-		this.name = "WalletFullLoginRequiredError";
-		this.code = WALLET_FULL_LOGIN_REQUIRED;
-	}
-};
-var WalletOperationStepUpCancelled = class extends Error {
-	constructor() {
-		super("Request cancelled.");
-		this.name = "WalletOperationStepUpCancelled";
-		this.code = WALLET_OPERATION_STEP_UP_CANCELLED;
-	}
-};
-var WalletSigningMaterialTemporarilyUnavailableError = class extends Error {
-	constructor() {
-		super("Wallet signing material storage is temporarily unavailable. Retry the operation.");
-		this.name = "WalletSigningMaterialTemporarilyUnavailableError";
-		this.code = WALLET_SIGNING_MATERIAL_TEMPORARILY_UNAVAILABLE;
-		this.reason = "persistence_unavailable";
-	}
-};
-function invalidWalletSigningMaterial(reason) {
-	return new InvalidWalletSigningMaterialError(reason);
-}
-function fullWalletLoginRequired(reason) {
-	return new WalletFullLoginRequiredError(reason);
-}
-function walletSigningMaterialBlockError(reason) {
-	const disposition = classifyWalletSigningMaterialBlock(reason);
-	switch (disposition.kind) {
-		case "invalid_material": return invalidWalletSigningMaterial(disposition.reason);
-		case "full_login_required": return fullWalletLoginRequired(disposition.reason);
-		case "temporarily_unavailable": return new WalletSigningMaterialTemporarilyUnavailableError();
-		default: throw new Error("[SigningEngine] unsupported signing material disposition");
-	}
-}
-function walletOperationStepUpCancelled() {
-	return new WalletOperationStepUpCancelled();
-}
-function isWalletSigningStateFailure(error) {
-	return error instanceof InvalidWalletSigningMaterialError || error instanceof WalletFullLoginRequiredError || error instanceof WalletOperationStepUpCancelled;
-}
-//#endregion
-//#region src/core/signingEngine/flows/shared/signingConfirmation.ts
-function makeRequestId(prefix) {
-	return secureRandomId(prefix, 32, "signing confirmation request IDs");
-}
-function confirmationConfigForSigningAuthPlan(args) {
-	return args.override;
-}
-function inferDigest32FromSignRequest(req) {
-	return req.kind === "digest" ? req.digest32 : req.challenge32;
-}
-function createSigningConfirmationCommandHandler(args) {
-	const run = confirmSigningOperation;
-	return async () => await run({
-		runtime: args.runtime,
-		request: args.request
-	});
-}
-async function runTransactionSigningConfirmationCommand(args) {
-	const confirmationState = planSigningOperationAttempt(args.signingOperationState, args.signingSessionPlan);
-	const request = {
-		...args.request,
-		signingOperationStateKind: confirmationState.kind,
-		onSigningOperationInteractionEvent: applySigningOperationInteractionEvent.bind(void 0, args.signingOperationState)
-	};
-	const runConfirmation = createSigningConfirmationCommandHandler({
-		runtime: args.runtime,
-		request
-	});
-	try {
-		return await runSigningOperationCommand({
-			signingSessionPlan: args.signingSessionPlan,
-			signingOperation: args.signingOperation,
-			commandKind: SigningOperationCommandKind.ShowConfirmation,
-			execute: runConfirmation
-		});
-	} catch (error) {
-		if (!isUserCancellationError(error)) throw error;
-		if (cancelSigningOperation(args.signingOperationState).phase === SigningOperationCancellationPhase.Authentication) throw walletOperationStepUpCancelled();
-		throw error;
-	}
-}
-async function runSigningConfirmationCommand(args) {
-	const runConfirmation = createSigningConfirmationCommandHandler({
-		runtime: args.runtime,
-		request: args.request
-	});
-	return await runSigningOperationCommand({
-		signingSessionPlan: args.signingSessionPlan,
-		signingOperation: args.signingOperation,
-		commandKind: SigningOperationCommandKind.ShowConfirmation,
-		execute: runConfirmation
-	});
-}
-function signingAuthPlanFromSigningSessionPlan(args) {
-	const plan = args.plan;
-	if (plan.kind === SigningSessionPlanKind.WarmSession) {
-		if (plan.keyRef.kind !== SigningKeyRefIntentKind.Cached) throw new Error("[SigningEngine] warm signing-session plan requires a cached key ref");
-		const expiresAtMs = Math.floor(Number(args.expiresAtMs) || 0);
-		const remainingUses = Math.floor(Number(args.remainingUses) || 0);
-		if (expiresAtMs <= 0 || remainingUses <= 0) throw new Error("[SigningEngine] warm signing-session auth plan requires positive expiresAtMs and remainingUses");
-		if (args.curve === "ed25519") {
-			if (plan.keyRef.curve !== "ed25519") throw new Error("[SigningEngine] Ed25519 warm plan requires an Ed25519 key ref");
-			return {
-				kind: SigningAuthPlanKind.WarmSession,
-				method: signingLaneAuthMethod(plan.lane.auth),
-				accountId: args.accountId,
-				intent: args.intent,
-				curve: "ed25519",
-				thresholdSessionId: String(plan.keyRef.thresholdSessionId),
-				retention: plan.lane.retention,
-				expiresAtMs,
-				remainingUses
-			};
-		}
-		if (plan.keyRef.curve !== "ecdsa") throw new Error("[SigningEngine] ECDSA warm plan requires an ECDSA key ref");
-		return {
-			kind: SigningAuthPlanKind.WarmSession,
-			method: signingLaneAuthMethod(plan.lane.auth),
-			accountId: args.accountId,
-			intent: args.intent,
-			curve: "ecdsa",
-			materialActivation: plan.keyRef.materialActivation,
-			authorization: plan.keyRef.authorization,
-			retention: plan.lane.retention,
-			expiresAtMs,
-			remainingUses
-		};
-	}
-	if (plan.kind === SigningSessionPlanKind.EmailOtpReauth) return {
-		kind: SigningAuthPlanKind.EmailOtpReauth,
-		method: "email_otp",
-		...args.emailOtpPrompt ? { emailOtpPrompt: args.emailOtpPrompt } : {}
-	};
-	return {
-		kind: SigningAuthPlanKind.PasskeyReauth,
-		method: "passkey"
-	};
-}
-function resolveSigningConfirmationAuthMethod(authPlan) {
-	switch (authPlan.kind) {
-		case SigningAuthPlanKind.EmailOtpReauth: return "email_otp";
-		case SigningAuthPlanKind.WarmSession: return "warm_session";
-		case SigningAuthPlanKind.ActiveWalletAuthority: return "warm_session";
-		case SigningAuthPlanKind.PasskeyReauth: return "passkey";
-		default: {
-			const exhaustive = authPlan.kind;
-			throw new Error(`Unsupported signing confirmation auth method: ${String(exhaustive)}`);
-		}
-	}
-}
-function mapSigningConfirmationProgress(progress, authMethod) {
-	const phase = String(progress.phase || "");
-	const failed = progress.status === "failed";
-	if (phase === "intent-confirmation-required") return {
-		phase: SigningEventPhase.STEP_05_CONFIRMATION_DISPLAYED,
-		status: "waiting_for_user",
-		interaction: {
-			kind: "transaction_confirmation",
-			overlay: "show"
-		},
-		data: toEventData(progress.data)
-	};
-	if (phase === "confirmation.complete") {
-		if (failed) return {
-			phase: SigningEventPhase.STEP_05_CONFIRMATION_CANCELLED,
-			status: "cancelled",
-			interaction: {
-				kind: "transaction_confirmation",
-				overlay: "hide"
-			},
-			error: { message: progress.message || "Transaction rejected" },
-			data: toEventData(progress.data)
-		};
-		return {
-			phase: authMethod === "email_otp" ? SigningEventPhase.STEP_06_AUTH_EMAIL_OTP_VERIFY_SUCCEEDED : SigningEventPhase.STEP_05_CONFIRMATION_APPROVED,
-			status: "succeeded",
-			interaction: {
-				kind: authMethod === "email_otp" ? "otp_input" : "transaction_confirmation",
-				overlay: "hide"
-			},
-			data: toEventData(progress.data)
-		};
-	}
-	if (phase === "auth.passkey.prompt.started") return {
-		phase: SigningEventPhase.STEP_06_AUTH_PASSKEY_PROMPT_STARTED,
-		status: "waiting_for_user",
-		interaction: {
-			kind: "passkey_assert",
-			overlay: "show"
-		},
-		data: toEventData(progress.data)
-	};
-	if (phase === "auth.passkey.prompt.succeeded") {
-		const interactionKind = "passkey_assert";
-		if (failed) return {
-			phase: SigningEventPhase.FAILED,
-			status: "failed",
-			interaction: {
-				kind: interactionKind,
-				overlay: "hide"
-			},
-			error: { message: progress.message || "Transaction signing failed" },
-			data: toEventData(progress.data)
-		};
-		return {
-			phase: SigningEventPhase.STEP_06_AUTH_PASSKEY_PROMPT_SUCCEEDED,
-			status: "succeeded",
-			interaction: {
-				kind: interactionKind,
-				overlay: "hide"
-			},
-			data: toEventData(progress.data)
-		};
-	}
-	return null;
-}
-function toEventData(value) {
-	if (value == null) return void 0;
-	if (typeof value === "object" && !Array.isArray(value)) return value;
-	return { value };
-}
-//#endregion
-//#region src/core/signingEngine/session/planning/operationFingerprint.ts
-async function computeSigningOperationFingerprint(args) {
-	const digest = await sha256BytesUtf8(alphabetizeStringify({
-		kind: String(args.kind || "").trim() || "unknown",
-		payload: normalizeOperationFingerprintValue(args.payload)
-	}));
-	return SigningSessionIds.signingOperationFingerprint(`sha256:${base64UrlEncode(digest)}`);
-}
-function normalizeOperationFingerprintValue(value) {
-	if (typeof value === "bigint") return value.toString(10);
-	if (value instanceof Uint8Array) return { __bytesB64u: base64UrlEncode(value) };
-	if (ArrayBuffer.isView(value)) return { __bytesB64u: base64UrlEncode(new Uint8Array(value.buffer, value.byteOffset, value.byteLength)) };
-	if (value instanceof ArrayBuffer) return { __bytesB64u: base64UrlEncode(new Uint8Array(value)) };
-	if (Array.isArray(value)) return value.map(normalizeOperationFingerprintValue);
-	if (!value || typeof value !== "object") return value;
-	const out = {};
-	for (const key of Object.keys(value).sort()) {
-		const next = normalizeOperationFingerprintValue(value[key]);
-		if (next !== void 0) out[key] = next;
-	}
-	return out;
-}
-//#endregion
-export { isSigningOperationReviewApprovedStateKind as C, runUnplannedSigningOperationCommandSequence as E, isSigningOperationReviewApprovedState as S, runSigningOperationCommandSteps as T, SigningOperationCommandKind as _, makeRequestId as a, createSigningOperationPlan as b, runSigningConfirmationCommand as c, fullWalletLoginRequired as d, invalidWalletSigningMaterial as f, prepareStepUpAuth as g, buildSigningConfirmationAuthParams as h, inferDigest32FromSignRequest as i, runTransactionSigningConfirmationCommand as l, walletSigningMaterialBlockError as m, confirmationConfigForSigningAuthPlan as n, mapSigningConfirmationProgress as o, isWalletSigningStateFailure as p, createSigningConfirmationCommandHandler as r, resolveSigningConfirmationAuthMethod as s, computeSigningOperationFingerprint as t, signingAuthPlanFromSigningSessionPlan as u, SigningOperationInteractionEventKind as v, runSigningOperationCommand as w, createSigningOperationStateRef as x, buildSigningOperationCommandSteps as y };