@seams/wallet 0.7.1 → 0.8.0

package/dist/esm/sdk/signingFlow-rZfPegH9.js

@@ -1,1320 +0,0 @@
-import { i as base64UrlEncode } from "./base64-Clm8C-e9.js";
-import { f as alphabetizeStringify, t as chainFamilyFromNetwork } from "./chains-BMh3btVo.js";
-import { o as sha256Utf8DigestB64u, r as parseDigestB64u } from "./canonicalPrimitives-BTHWz80v.js";
-import { a as thresholdEcdsaChainTargetFromRequest, c as toWalletId, r as thresholdEcdsaChainTargetFromChainFamily } from "./ecdsaChainTarget-Bl-JWyuw.js";
-import { m as createSigningFlowEvent, o as SigningEventPhase } from "./sdkSentEvents-MqDkbQg1.js";
-import { r as SigningSessionIds } from "./types-Dx9fczU7.js";
-import { i as normalizeAuthenticationCredential } from "./helpers-ZrowMnev.js";
-import { r as parseSigningOperationFingerprintDigest } from "./operationFingerprint-CGZui5dR.js";
-import { i as emitEcdsaSigningTiming } from "./trace-rHe0wz7q.js";
-import { t as createEvmClient } from "./EvmClient-f3gUhS2L.js";
-import { a as isPasskeySigningAuthPlan, i as isEmailOtpSigningAuthPlan, o as isWarmSessionSigningAuthPlan, r as isActiveWalletAuthoritySigningAuthPlan } from "./promptText-CuRa_ivd.js";
-import { E as runUnplannedSigningOperationCommandSequence, T as runSigningOperationCommandSteps, _ as SigningOperationCommandKind, a as makeRequestId, b as createSigningOperationPlan, g as prepareStepUpAuth, i as inferDigest32FromSignRequest, o as mapSigningConfirmationProgress, r as createSigningConfirmationCommandHandler, s as resolveSigningConfirmationAuthMethod, y as buildSigningOperationCommandSteps } from "./operationFingerprint-C8Trar4R.js";
-import { a as normalizeHexSelector, i as normalizeHexData, r as deriveSelectorFromHexData, t as bytesToHex } from "./bytes-qKxKn4gg.js";
-//#region src/core/signingEngine/chains/evm/display/functionSelectors.ts
-const EVM_ADDRESS_RE = /^0x[0-9a-f]{40}$/;
-const TEMPO_GREETING_CONTRACT = "0xbb442b54c85efba2d7b81ea52990ad638cdba483";
-const ARC_GREETING_CONTRACT = "0xeb7ab5a6f761072c96147a54b8a15f012e836691";
-const KNOWN_FUNCTION_SIGNATURES = Object.freeze({
-	"0x06fdde03": "name()",
-	"0x095ea7b3": "approve(address,uint256)",
-	"0x18160ddd": "totalSupply()",
-	"0x23b872dd": "transferFrom(address,address,uint256)",
-	"0x2e1a7d4d": "withdraw(uint256)",
-	"0x313ce567": "decimals()",
-	"0x42842e0e": "safeTransferFrom(address,address,uint256)",
-	"0x47e1da2a": "executeBatch(address[],uint256[],bytes[])",
-	"0x6352211e": "ownerOf(uint256)",
-	"0x70a08231": "balanceOf(address)",
-	"0x081812fc": "getApproved(uint256)",
-	"0x95d89b41": "symbol()",
-	"0xa22cb465": "setApprovalForAll(address,bool)",
-	"0xa9059cbb": "transfer(address,uint256)",
-	"0xb61d27f6": "execute(address,uint256,bytes)",
-	"0xb88d4fde": "safeTransferFrom(address,address,uint256,bytes)",
-	"0xd0e30db0": "deposit()",
-	"0xd505accf": "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)",
-	"0xdd62ed3e": "allowance(address,address)",
-	"0xe985e9c5": "isApprovedForAll(address,address)",
-	"0xe7897444": "setUserToken(address)",
-	"0xf2fde38b": "transferOwnership(address)"
-});
-const KNOWN_CONTRACT_FUNCTION_SIGNATURES = Object.freeze({
-	[TEMPO_GREETING_CONTRACT]: Object.freeze({
-		"0xa4136862": "setGreeting(string)",
-		"0xef690cc0": "greeting()",
-		"0x867ae9d4": "dripTo(address,address[])"
-	}),
-	[ARC_GREETING_CONTRACT]: Object.freeze({
-		"0xa4136862": "setGreeting(string)",
-		"0xcfae3217": "greet()"
-	})
-});
-function normalizeSelector(selector) {
-	return normalizeHexSelector(selector);
-}
-function normalizeContractAddress(contractAddress) {
-	const normalized = String(contractAddress || "").trim().toLowerCase();
-	if (!EVM_ADDRESS_RE.test(normalized)) return void 0;
-	return normalized;
-}
-function selectorFromHexData(data) {
-	return deriveSelectorFromHexData(data);
-}
-function resolveFunctionSignature(selector, contractAddress) {
-	const normalized = normalizeSelector(selector);
-	if (!normalized) return void 0;
-	const normalizedContractAddress = normalizeContractAddress(contractAddress);
-	if (normalizedContractAddress) {
-		const contractMap = KNOWN_CONTRACT_FUNCTION_SIGNATURES[normalizedContractAddress];
-		if (contractMap && contractMap[normalized]) return contractMap[normalized];
-	}
-	return KNOWN_FUNCTION_SIGNATURES[normalized];
-}
-function resolveFunctionDisplayName(selector, contractAddress) {
-	const signature = resolveFunctionSignature(selector, contractAddress);
-	if (signature) {
-		const idx = signature.indexOf("(");
-		const normalizedName = (idx > 0 ? signature.slice(0, idx) : signature).trim();
-		if (normalizedName) return `${normalizedName}()`;
-	}
-	const normalizedSelector = normalizeSelector(selector);
-	if (normalizedSelector) return `function ${normalizedSelector}`;
-}
-//#endregion
-//#region src/core/signingEngine/chains/evm/display/calldata.ts
-function splitIntoRows(hexWithoutPrefix, charsPerRow) {
-	const rows = [];
-	for (let index = 0; index < hexWithoutPrefix.length; index += charsPerRow) rows.push(hexWithoutPrefix.slice(index, index + charsPerRow));
-	return rows;
-}
-/**
-* EVM calldata starts with a 4-byte selector followed by ABI words (32-byte slots).
-* Render selector on the first line and then split remaining bytes into 32-byte rows.
-*/
-function formatCalldataForDisplay(dataHex) {
-	const normalized = normalizeHexData(dataHex, { lowercase: true });
-	if (normalized === "0x") return "data: 0x";
-	const hex = normalized.slice(2);
-	if (!hex) return "data: 0x";
-	if (hex.length <= 8) return `data: 0x${hex}`;
-	const selector = hex.slice(0, 8);
-	const rows = splitIntoRows(hex.slice(8), 64);
-	return [`data: 0x${selector}`, ...rows].join("\n");
-}
-//#endregion
-//#region src/core/signingEngine/chains/evm/display/gas.ts
-function formatScaled(value, scale) {
-	const integer = value / scale;
-	const remainder = value % scale;
-	if (remainder === 0n) return integer.toString();
-	const scaledRemainder = remainder * 100n / scale;
-	if (scaledRemainder === 0n) return integer.toString();
-	const fractional = scaledRemainder.toString().padStart(2, "0").replace(/0+$/, "");
-	return fractional ? `${integer.toString()}.${fractional}` : integer.toString();
-}
-function formatCompactGas(value) {
-	if (value >= 1000000n) return `${formatScaled(value, 1000000n)}mil`;
-	if (value >= 1000n) return `${formatScaled(value, 1000n)}k`;
-	return value.toString();
-}
-//#endregion
-//#region src/core/signingEngine/chains/evm/display/evmTx.ts
-function toSafeJson(value) {
-	try {
-		return JSON.stringify(value, (_key, fieldValue) => typeof fieldValue === "bigint" ? fieldValue.toString() : fieldValue, 2);
-	} catch {
-		return String(value);
-	}
-}
-function makeField(label, value, copyValue) {
-	const normalized = String(value ?? "").trim();
-	if (!normalized) return void 0;
-	return {
-		label,
-		value: normalized,
-		...typeof copyValue === "string" && copyValue.trim() ? { copyValue } : {}
-	};
-}
-function buildAbiDecodeHint(args) {
-	const normalizedDataHex = normalizeHexData(args.dataHex);
-	if (normalizedDataHex === "0x") return void 0;
-	if (!Array.isArray(args.abi) || args.abi.length === 0) return void 0;
-	return {
-		dataHex: normalizedDataHex,
-		abi: args.abi
-	};
-}
-function buildDefaultContractCallOperation(args) {
-	const functionLabel = resolveFunctionDisplayName(args.selector, args.to);
-	const hasCallData = !!args.to && args.dataHex !== "0x";
-	const formattedGasLimit = formatCompactGas(args.tx.gasLimit);
-	const rowLabel = args.to ? "Transaction to contract" : "Contract Deployment";
-	const dataField = makeField("Data", formatCalldataForDisplay(args.dataHex), args.dataHex);
-	if (dataField) {
-		dataField.renderAs = "file-content";
-		dataField.hideLabel = true;
-		dataField.hideChevron = true;
-	}
-	const callFields = [dataField, makeField("Value (wei)", args.valueWei)].filter(Boolean);
-	let children;
-	if (hasCallData) {
-		const childOperation = {
-			id: "evm.eip1559.call",
-			kind: "generic.contractCall",
-			label: `Calling ${functionLabel || "contract function"} using ${formattedGasLimit} gas`,
-			to: args.to,
-			value: args.valueWei,
-			selector: args.selector,
-			fields: callFields
-		};
-		const abiDecodeHint = buildAbiDecodeHint({
-			dataHex: args.dataHex,
-			abi: args.tx.abi
-		});
-		if (abiDecodeHint) childOperation.abiDecodeHint = abiDecodeHint;
-		children = [childOperation];
-	}
-	return {
-		id: "evm.eip1559",
-		kind: "generic.contractCall",
-		label: rowLabel,
-		to: args.to,
-		value: args.valueWei,
-		selector: args.selector,
-		...children ? { children } : {}
-	};
-}
-function buildEvmDisplayModel(args) {
-	const request = args.request;
-	if (request.kind !== "eip1559") return {
-		chain: "evm",
-		intentDigest: args.intentDigest,
-		signerAccount: args.signerAccount,
-		title: args.title || "EVM Transaction",
-		subtitle: args.subtitle,
-		operations: [{
-			id: "evm.raw",
-			kind: "raw.fallback",
-			label: "Unsupported EVM Payload",
-			raw: toSafeJson(request)
-		}],
-		raw: {
-			format: "json",
-			value: toSafeJson(request)
-		}
-	};
-	const tx = request.tx;
-	const to = tx.to == null ? void 0 : String(tx.to).toLowerCase();
-	const valueWei = tx.value.toString();
-	const dataHex = normalizeHexData(String(tx.data || "0x"));
-	const operation = buildDefaultContractCallOperation({
-		to,
-		valueWei,
-		tx,
-		dataHex,
-		selector: selectorFromHexData(dataHex)
-	});
-	const totalValueWei = tx.value > 0n ? tx.value : void 0;
-	return {
-		chain: "evm",
-		chainId: tx.chainId,
-		intentDigest: args.intentDigest,
-		signerAccount: args.signerAccount,
-		title: args.title || "EVM Transaction",
-		subtitle: args.subtitle,
-		operations: [operation],
-		...totalValueWei != null ? { totals: {
-			nativeValue: totalValueWei.toString(),
-			nativeSymbol: "wei"
-		} } : {}
-	};
-}
-//#endregion
-//#region src/core/rpcClients/evm/nonceBackend.ts
-function toManagedNonceReservationSnapshot(input) {
-	const subjectId = toWalletId(input.subjectId);
-	const leaseId = normalizeSessionStatusRequiredString(input.leaseId, "leaseId");
-	const operationId = normalizeSessionStatusRequiredString(input.operationId, "operationId");
-	const operationFingerprint = normalizeSessionStatusRequiredString(input.operationFingerprint, "operationFingerprint");
-	const snapshot = {
-		chainTarget: input.chainTarget,
-		subjectId,
-		sender: normalizeSender(input.sender),
-		nonce: normalizeBigint(input.nonce, "nonce").toString(),
-		leaseId,
-		operationId,
-		operationFingerprint
-	};
-	if (input.nonceKey != null) snapshot.nonceKey = normalizeBigint(input.nonceKey, "nonceKey").toString();
-	if (Number.isSafeInteger(input.reservedAtMs)) snapshot.reservedAtMs = input.reservedAtMs;
-	if (Number.isSafeInteger(input.expiresAtMs)) snapshot.expiresAtMs = input.expiresAtMs;
-	return snapshot;
-}
-function fromManagedNonceReservationSnapshot(snapshot) {
-	if (!snapshot || typeof snapshot !== "object") throw new Error("[evmNonceBackend] invalid managed nonce snapshot: object");
-	const chainTarget = parseManagedNonceSnapshotChainTarget(snapshot);
-	const subjectId = toWalletId(snapshot.subjectId ?? snapshot.walletId);
-	const sender = normalizeSender(snapshot.sender);
-	const nonce = normalizeBigint(snapshot.nonce, "nonce");
-	const parsedNonceKey = snapshot.nonceKey == null ? void 0 : normalizeBigint(snapshot.nonceKey, "nonceKey");
-	const leaseId = normalizeSessionStatusRequiredString(snapshot.leaseId, "leaseId");
-	const operationId = normalizeSessionStatusRequiredString(snapshot.operationId, "operationId");
-	const operationFingerprint = normalizeSessionStatusRequiredString(snapshot.operationFingerprint, "operationFingerprint");
-	const reservedAtMs = normalizeOptionalSafeInteger(snapshot.reservedAtMs);
-	const expiresAtMs = normalizeOptionalSafeInteger(snapshot.expiresAtMs);
-	return {
-		chainTarget,
-		subjectId,
-		sender,
-		...parsedNonceKey != null ? { nonceKey: parsedNonceKey } : {},
-		nonce,
-		leaseId,
-		operationId,
-		operationFingerprint,
-		...reservedAtMs != null ? { reservedAtMs } : {},
-		...expiresAtMs != null ? { expiresAtMs } : {}
-	};
-}
-function reserveNonceInputFromBoundary(input) {
-	const reservationInput = {
-		chainTarget: thresholdEcdsaChainTargetFromChainFamily({
-			chain: input.chain,
-			chainId: input.chainId,
-			networkSlug: input.networkKey
-		}),
-		subjectId: toWalletId(input.walletId),
-		sender: normalizeSender(input.sender)
-	};
-	if (input.nonceKey != null) reservationInput.nonceKey = normalizeBigint(input.nonceKey, "nonceKey");
-	return reservationInput;
-}
-const DEFAULT_RPC_TIMEOUT_MS = 15e3;
-function createEvmNonceBackendWithFetcher(args) {
-	return {
-		async fetchChainNonce(input) {
-			const normalized = normalizeInput(input);
-			return await args.fetchChainNonce(normalized);
-		},
-		async fetchBroadcastTransactionStatus(input) {
-			const normalized = normalizeInput(input);
-			return await args.fetchBroadcastTransactionStatus({
-				...normalized,
-				txHash: normalizeTxHash(input.txHash)
-			});
-		}
-	};
-}
-function createEvmNonceBackend(args) {
-	const fetchImpl = args.fetchImpl || fetch.bind(globalThis);
-	return createEvmNonceBackendWithFetcher({
-		fetchChainNonce: async (input) => await fetchChainNonceFromRpc({
-			chains: args.chains,
-			input,
-			fetchImpl
-		}),
-		fetchBroadcastTransactionStatus: async (input) => await fetchBroadcastTransactionStatusFromRpc({
-			chains: args.chains,
-			input,
-			fetchImpl
-		})
-	});
-}
-async function fetchBroadcastTransactionStatusFromRpc(args) {
-	const rpcUrl = resolveRpcUrlForInput(args.chains, args.input);
-	const receipt = await fetchEvmRpcResult({
-		rpcUrl,
-		method: "eth_getTransactionReceipt",
-		params: [args.input.txHash],
-		fetchImpl: args.fetchImpl
-	});
-	if (receipt && typeof receipt === "object") return { kind: "finalized" };
-	const transaction = await fetchEvmRpcResult({
-		rpcUrl,
-		method: "eth_getTransactionByHash",
-		params: [args.input.txHash],
-		fetchImpl: args.fetchImpl
-	});
-	return transaction && typeof transaction === "object" ? { kind: "pending" } : { kind: "missing" };
-}
-async function fetchEvmRpcResult(args) {
-	return await createEvmClient({
-		rpcUrl: args.rpcUrl,
-		fetchImpl: args.fetchImpl,
-		requestTimeoutMs: DEFAULT_RPC_TIMEOUT_MS
-	}).request({
-		method: args.method,
-		params: args.params
-	});
-}
-async function fetchChainNonceFromRpc(args) {
-	return parseRpcHexQuantity(await createEvmClient({
-		rpcUrl: resolveRpcUrlForInput(args.chains, args.input),
-		fetchImpl: args.fetchImpl,
-		requestTimeoutMs: DEFAULT_RPC_TIMEOUT_MS
-	}).request({
-		method: "eth_getTransactionCount",
-		params: [args.input.sender, "pending"]
-	}), "eth_getTransactionCount");
-}
-function resolveRpcUrlForInput(chains, input) {
-	const requestedChain = input.chain;
-	const targetChainId = input.chainId;
-	const networkKey = String(input.networkKey || "").trim().toLowerCase();
-	const byChainId = (source) => source.filter((chain) => {
-		const chainId = getOptionalConfigChainId(chain);
-		return typeof chainId === "number" && chainId === targetChainId;
-	});
-	const byNetworkKey = (source) => source.filter((chain) => String(chain.network || "").trim().toLowerCase() === networkKey);
-	const supportedChains = chains.filter((chain) => isSupportedNonceRoutingChain(chain));
-	if (!supportedChains.length) throw new Error("[evmNonceBackend] missing RPC config for nonce-enabled chains");
-	const networkMatches = byNetworkKey(supportedChains);
-	if (networkMatches.length === 1) {
-		const only = networkMatches[0];
-		assertChainSupportsRequestedRoute({
-			chain: only,
-			requestedChain,
-			networkKey: input.networkKey,
-			chainId: targetChainId
-		});
-		assertConfiguredChainIdMatchesInput({
-			chain: only,
-			chainId: targetChainId,
-			networkKey: input.networkKey
-		});
-		return mustTrimmedRpcUrl(only.rpcUrl, only.network);
-	}
-	if (networkMatches.length > 1) {
-		const chainIdMatched = byChainId(networkMatches).filter((chain) => isChainCompatibleWithRequestChain(chain, requestedChain));
-		if (chainIdMatched.length === 1) {
-			const only = chainIdMatched[0];
-			return mustTrimmedRpcUrl(only.rpcUrl, only.network);
-		}
-		throw new Error(`[evmNonceBackend] ambiguous networkKey mapping for ${input.networkKey} (chainId=${String(targetChainId)})`);
-	}
-	const chainIdMatches = byChainId(supportedChains);
-	const compatibleMatches = chainIdMatches.filter((chain) => isChainCompatibleWithRequestChain(chain, requestedChain));
-	if (compatibleMatches.length === 1) {
-		const only = compatibleMatches[0];
-		return mustTrimmedRpcUrl(only.rpcUrl, only.network);
-	}
-	if (compatibleMatches.length > 1) {
-		const candidates = compatibleMatches.map((chain) => String(chain.network || "").trim()).join(", ");
-		throw new Error(`[evmNonceBackend] ambiguous chainId routing for ${requestedChain} chainId=${String(targetChainId)} across [${candidates}]`);
-	}
-	if (chainIdMatches.length > 0) {
-		const families = Array.from(new Set(chainIdMatches.map((chain) => chainFamilyFromNetwork(chain.network))));
-		throw new Error(`[evmNonceBackend] chainId=${String(targetChainId)} is configured for [${families.join(", ")}] but is incompatible with ${requestedChain} routing`);
-	}
-	throw new Error(`[evmNonceBackend] unable to resolve RPC URL for ${requestedChain} ${input.networkKey} (chainId=${String(targetChainId)})`);
-}
-function isSupportedNonceRoutingChain(chain) {
-	const family = chainFamilyFromNetwork(chain.network);
-	return family === "evm" || family === "tempo";
-}
-function isChainCompatibleWithRequestChain(chain, requestedChain) {
-	const family = chainFamilyFromNetwork(chain.network);
-	if (requestedChain === "tempo") return family === "tempo";
-	return family === "evm" || family === "tempo";
-}
-function assertConfiguredChainIdMatchesInput(args) {
-	const configuredChainId = getOptionalConfigChainId(args.chain);
-	if (typeof configuredChainId !== "number") throw new Error(`[evmNonceBackend] configured network ${args.chain.network} is missing numeric chainId`);
-	if (configuredChainId !== args.chainId) throw new Error(`[evmNonceBackend] chainId mismatch for network ${args.networkKey}: expected ${configuredChainId}, received ${String(args.chainId)}`);
-}
-function assertChainSupportsRequestedRoute(args) {
-	if (isChainCompatibleWithRequestChain(args.chain, args.requestedChain)) return;
-	const resolvedFamily = chainFamilyFromNetwork(args.chain.network);
-	throw new Error(`[evmNonceBackend] network ${args.networkKey} (family=${resolvedFamily}) is incompatible with ${args.requestedChain} request (chainId=${String(args.chainId)})`);
-}
-function getOptionalConfigChainId(chain) {
-	return isChainWithChainId(chain) ? chain.chainId : void 0;
-}
-function isChainWithChainId(chain) {
-	return chainFamilyFromNetwork(chain.network) !== "near";
-}
-function mustTrimmedRpcUrl(rpcUrl, network) {
-	const trimmed = String(rpcUrl || "").trim();
-	if (!trimmed) throw new Error(`[evmNonceBackend] missing rpcUrl for ${network}`);
-	return trimmed;
-}
-function normalizeInput(input) {
-	const chain = input.chainTarget.kind;
-	if (chain !== "evm" && chain !== "tempo") throw new Error(`[evmNonceBackend] invalid chain '${String(chain)}'`);
-	const networkKey = String(input.chainTarget.networkSlug || "").trim().toLowerCase();
-	if (!networkKey) throw new Error("[evmNonceBackend] networkKey is required");
-	return {
-		chain,
-		networkKey,
-		chainId: input.chainTarget.chainId,
-		sender: normalizeAddress(input.sender, "sender"),
-		nonceKey: chain === "tempo" ? normalizeBigint(input.nonceKey, "nonceKey") : 0n,
-		walletId: String(toWalletId(input.subjectId))
-	};
-}
-function parseManagedNonceSnapshotChainTarget(snapshot) {
-	if (snapshot.chainTarget) return thresholdEcdsaChainTargetFromRequest(snapshot.chainTarget);
-	const chain = snapshot.chain;
-	if (chain !== "evm" && chain !== "tempo") throw new Error("[evmNonceBackend] invalid managed nonce snapshot: chain");
-	const networkKey = String(snapshot.networkKey || "").trim();
-	if (!networkKey) throw new Error("[evmNonceBackend] invalid managed nonce snapshot: networkKey");
-	const chainId = snapshot.chainId;
-	if (typeof chainId !== "number" || !Number.isSafeInteger(chainId) || chainId <= 0) throw new Error("[evmNonceBackend] invalid managed nonce snapshot: chainId");
-	return thresholdEcdsaChainTargetFromChainFamily({
-		chain,
-		chainId,
-		networkSlug: networkKey
-	});
-}
-function normalizeAddress(value, label) {
-	const normalized = String(value || "").trim().toLowerCase();
-	if (!/^0x[0-9a-f]{40}$/.test(normalized)) throw new Error(`[evmNonceBackend] invalid ${label}: expected 20-byte 0x-prefixed hex`);
-	return normalized;
-}
-function normalizeSender(value) {
-	return normalizeAddress(value, "sender");
-}
-function normalizeTxHash(value) {
-	const normalized = String(value || "").trim().toLowerCase();
-	if (!/^0x[0-9a-f]{64}$/.test(normalized)) throw new Error("[evmNonceBackend] invalid txHash: expected 32-byte 0x-prefixed hex");
-	return normalized;
-}
-function normalizeBigint(value, label) {
-	try {
-		const parsed = BigInt(value);
-		if (parsed < 0n) throw new Error(`[evmNonceBackend] ${label} must be non-negative`);
-		return parsed;
-	} catch {
-		throw new Error(`[evmNonceBackend] invalid ${label}: expected bigint-compatible value`);
-	}
-}
-function normalizeSessionStatusRequiredString(value, label) {
-	const normalized = String(value || "").trim();
-	if (!normalized) throw new Error(`[evmNonceBackend] invalid managed nonce snapshot: ${label}`);
-	return normalized;
-}
-function normalizeOptionalSafeInteger(value) {
-	if (value == null) return void 0;
-	const parsed = Math.floor(Number(value));
-	return Number.isSafeInteger(parsed) ? parsed : void 0;
-}
-function parseRpcHexQuantity(value, method) {
-	const raw = String(value || "").trim();
-	if (!/^0x[0-9a-fA-F]+$/.test(raw)) throw new Error(`[evmNonceBackend] invalid ${method} result: expected hex quantity`);
-	return BigInt(raw);
-}
-//#endregion
-//#region src/core/signingEngine/flows/signEvmFamily/requireEvmFamilyStepUpAuth.ts
-function signingAuthPlanFromThresholdEcdsaStepUp(stepUp) {
-	return stepUp.kind === "required" ? stepUp.authPlan.signingAuthPlan : void 0;
-}
-async function requireEvmFamilyStepUpAuth(args) {
-	const signingAuthPlan = signingAuthPlanFromThresholdEcdsaStepUp(args.thresholdEcdsaStepUp);
-	const runtime = args.thresholdEcdsaStepUp.kind === "required" ? args.thresholdEcdsaStepUp.runtime : void 0;
-	const reusableAuthorization = runtime?.reusableAuthorization ?? { kind: "active" };
-	const selectedLane = resolveEvmFamilyStepUpLane({
-		signingAuthPlan,
-		hasEmailOtpSigning: Boolean(runtime?.emailOtpSigning),
-		hasThresholdEcdsaRequest: args.hasThresholdEcdsaRequest,
-		needsWebAuthn: args.needsWebAuthn,
-		reusableAuthorization
-	});
-	if (!selectedLane) throw new Error(`[chains] ${args.explicitAuthErrorLabel} signing requires explicit auth input`);
-	const prepared = await prepareStepUpAuth({
-		operation: {
-			kind: "evm_family_threshold_ecdsa_step_up",
-			usesNeeded: Math.max(1, Math.floor(Number(args.requiredSignatureUses) || 1))
-		},
-		selectedLane,
-		policy: stepUpPolicyFromSigningAuthPlan(signingAuthPlan, reusableAuthorization),
-		methods: {
-			...runtime?.emailOtpSigning ? { emailOtp: {
-				method: "email_otp",
-				prepareChallenge: runtime.emailOtpSigning.prepare,
-				...runtime.emailOtpSigning.resend ? { resendChallenge: runtime.emailOtpSigning.resend } : {},
-				complete: async () => void 0
-			} } : {},
-			passkey: {
-				method: "passkey",
-				prepare: async () => ({}),
-				complete: async () => void 0
-			}
-		}
-	});
-	if (prepared.method === "warm_session") {
-		if (!signingAuthPlan || !isEcdsaWarmSessionSigningAuthPlan(signingAuthPlan)) throw new Error("[chains] warm-session step-up requires an existing warm-session plan");
-		return {
-			kind: "warm_session",
-			confirmationAuthPayload: { signingAuthPlan }
-		};
-	}
-	if (prepared.method === "email_otp") {
-		const plan = signingAuthPlanFromPreparedEvmFamilyStepUp({
-			signingAuthPlan,
-			prepared
-		});
-		if (!isEmailOtpSigningAuthPlan(plan)) throw new Error("[chains] Email OTP step-up requires an Email OTP signing auth plan");
-		return {
-			kind: "email_otp",
-			confirmationAuthPayload: { signingAuthPlan: plan },
-			emailOtpPrompt: prepared.prompt
-		};
-	}
-	const plan = signingAuthPlanFromPreparedEvmFamilyStepUp({
-		signingAuthPlan,
-		prepared
-	});
-	if (!isPasskeySigningAuthPlan(plan)) throw new Error("[chains] passkey step-up requires a passkey signing auth plan");
-	return {
-		kind: "passkey",
-		confirmationAuthPayload: { signingAuthPlan: plan }
-	};
-}
-function resolveEvmFamilyStepUpLane(args) {
-	if (args.reusableAuthorization.kind === "absent") return { authMethod: args.reusableAuthorization.requiredFactor };
-	if (args.signingAuthPlan) {
-		if (isEmailOtpSigningAuthPlan(args.signingAuthPlan)) return { authMethod: "email_otp" };
-		if (isPasskeySigningAuthPlan(args.signingAuthPlan)) return { authMethod: "passkey" };
-		return { authMethod: args.signingAuthPlan.method };
-	}
-	if (args.hasEmailOtpSigning) return { authMethod: "email_otp" };
-	if (!args.hasThresholdEcdsaRequest && args.needsWebAuthn) return { authMethod: "passkey" };
-	return null;
-}
-function stepUpPolicyFromSigningAuthPlan(signingAuthPlan, reusableAuthorization) {
-	if (reusableAuthorization.kind === "absent") return { kind: "use_selected_lane" };
-	if (signingAuthPlan && isWarmSessionSigningAuthPlan(signingAuthPlan)) {
-		if (signingAuthPlan.curve !== "ecdsa") throw new Error("[chains] EVM-family warm-session step-up requires an ECDSA auth plan");
-		return {
-			kind: "reuse_warm_session",
-			authorization: {
-				method: signingAuthPlan.method,
-				curve: "ecdsa",
-				materialActivation: signingAuthPlan.materialActivation,
-				authorization: signingAuthPlan.authorization,
-				expiresAtMs: signingAuthPlan.expiresAtMs,
-				remainingUses: signingAuthPlan.remainingUses
-			}
-		};
-	}
-	return { kind: "use_selected_lane" };
-}
-function isEcdsaWarmSessionSigningAuthPlan(plan) {
-	return isWarmSessionSigningAuthPlan(plan) && plan.curve === "ecdsa";
-}
-function signingAuthPlanFromPreparedEvmFamilyStepUp(args) {
-	if (args.signingAuthPlan) {
-		if (args.prepared.method === "email_otp") return {
-			kind: "emailOtpReauth",
-			method: "email_otp",
-			emailOtpPrompt: args.prepared.prompt
-		};
-		if (args.prepared.method === "passkey" && !isPasskeySigningAuthPlan(args.signingAuthPlan)) return {
-			kind: "passkeyReauth",
-			method: "passkey"
-		};
-		return args.signingAuthPlan;
-	}
-	if (args.prepared.method === "email_otp") return {
-		kind: "emailOtpReauth",
-		method: "email_otp",
-		emailOtpPrompt: args.prepared.prompt
-	};
-	if (args.prepared.method === "passkey") return {
-		kind: "passkeyReauth",
-		method: "passkey"
-	};
-	throw new Error("[chains] warm-session step-up requires an existing signing auth plan");
-}
-//#endregion
-//#region src/core/signingEngine/flows/signEvmFamily/stepUpAuthorization.ts
-function buildEvmFamilyWarmSessionStepUpAuthorization(args) {
-	return {
-		kind: "warm_session",
-		signingAuthPlan: args.signingAuthPlan,
-		materialActivation: args.signingAuthPlan.materialActivation,
-		authorization: args.signingAuthPlan.authorization,
-		expiresAtMs: args.signingAuthPlan.expiresAtMs,
-		remainingUses: args.signingAuthPlan.remainingUses
-	};
-}
-function buildEvmFamilyEmailOtpStepUpAuthorization(args) {
-	return {
-		kind: "email_otp",
-		signingAuthPlan: args.signingAuthPlan,
-		challengeId: normalizeChallengeId(args.confirmation.emailOtpChallengeId, args.prompt, "EVM-family step-up authorization"),
-		otpCode: normalizeOtpCode(args.confirmation.otpCode),
-		...args.prompt.emailHint ? { emailHint: args.prompt.emailHint } : {}
-	};
-}
-function buildEvmFamilyPasskeyStepUpAuthorization(args) {
-	if (!args.confirmation.credential) throw new Error("[chains] missing WebAuthn credential for EVM-family step-up authorization");
-	return {
-		kind: "passkey",
-		signingAuthPlan: args.signingAuthPlan,
-		credential: normalizeAuthenticationCredential(args.confirmation.credential)
-	};
-}
-function buildEvmFamilyEcdsaStepUpAuthorization(args) {
-	if (args.prepared.kind === "active_wallet_authority") throw new Error("[chains] active Wallet Authority confirmation has no threshold step-up");
-	if (args.prepared.kind === "warm_session") return buildEvmFamilyWarmSessionStepUpAuthorization({ signingAuthPlan: args.prepared.confirmationAuthPayload.signingAuthPlan });
-	if (args.prepared.kind === "email_otp") return buildEvmFamilyEmailOtpStepUpAuthorization({
-		signingAuthPlan: args.prepared.confirmationAuthPayload.signingAuthPlan,
-		prompt: args.prepared.emailOtpPrompt,
-		confirmation: args.confirmation
-	});
-	return buildEvmFamilyPasskeyStepUpAuthorization({
-		signingAuthPlan: args.prepared.confirmationAuthPayload.signingAuthPlan,
-		confirmation: args.confirmation
-	});
-}
-function normalizeOtpCode(otpCodeRaw) {
-	const otpCode = String(otpCodeRaw || "").trim();
-	if (!/^\d{6}$/.test(otpCode)) throw new Error("[chains] missing Email OTP code from touchConfirm");
-	return otpCode;
-}
-function normalizeChallengeId(challengeIdRaw, prompt, context) {
-	const challengeId = String(challengeIdRaw || prompt.challengeId || "").trim();
-	if (!challengeId) throw new Error(`[chains] missing Email OTP challenge id for ${context}`);
-	return challengeId;
-}
-//#endregion
-//#region src/core/signingEngine/stepUpConfirmation/intentDigestPreparation.ts
-const PENDING_CHALLENGE_B64U = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
-const PENDING_INTENT_DIGEST = "pending-intent-digest";
-const pendingIntentPreparations = /* @__PURE__ */ new Map();
-function normalizeRequestId(value) {
-	return String(value || "").trim();
-}
-function registerIntentDigestPreparation(args) {
-	const requestId = normalizeRequestId(args.requestId);
-	if (!requestId) return;
-	pendingIntentPreparations.set(requestId, args.preparation);
-}
-function consumeIntentDigestPreparation(requestIdRaw) {
-	const requestId = normalizeRequestId(requestIdRaw);
-	if (!requestId) return void 0;
-	const preparation = pendingIntentPreparations.get(requestId);
-	if (!preparation) return void 0;
-	pendingIntentPreparations.delete(requestId);
-	return preparation;
-}
-function clearIntentDigestPreparation(requestIdRaw) {
-	const requestId = normalizeRequestId(requestIdRaw);
-	if (!requestId) return;
-	pendingIntentPreparations.delete(requestId);
-}
-//#endregion
-//#region src/core/signingEngine/flows/signEvmFamily/signingFlow.ts
-/** Thrown so a superseded preparation unwinds to the retry boundary rather than
-* surfacing as a signing failure. `signEvmFamily` catches it and re-prepares
-* once against current canonical state. */
-var EvmFamilyEcdsaMaterialSupersededError = class extends Error {
-	constructor(superseded) {
-		super(`[chains] threshold ECDSA material was superseded (${superseded.supersessionKind}): prepared ${String(superseded.preparedMaterialActivation.activationId)}, current ${String(superseded.currentMaterialActivation.activationId)}`);
-		this.name = "EvmFamilyEcdsaMaterialSupersededError";
-		this.superseded = superseded;
-	}
-};
-function isEvmFamilyEcdsaMaterialSupersededError(error) {
-	return error instanceof EvmFamilyEcdsaMaterialSupersededError;
-}
-function warmSessionClaimedProgressData(plan) {
-	if (plan.curve === "ed25519") return {
-		curve: plan.curve,
-		thresholdSessionId: plan.thresholdSessionId,
-		expiresAtMs: plan.expiresAtMs,
-		remainingUses: plan.remainingUses
-	};
-	return {
-		curve: plan.curve,
-		materialActivationId: String(plan.materialActivation.activationId),
-		expiresAtMs: plan.expiresAtMs,
-		remainingUses: plan.remainingUses
-	};
-}
-function hydratedMaterialFromSource(source) {
-	switch (source.kind) {
-		case "material_for_step_up": return source.material;
-		case "material_from_canonical_capability":
-		case "material_from_step_up": return source.material.signerSession;
-	}
-}
-function isReadySecp256k1Signer(engine) {
-	return typeof engine?.signReady === "function";
-}
-async function buildEvmFamilyOperationDigests(input) {
-	const operationFingerprint = String(input.operationFingerprint || "").trim();
-	if (!operationFingerprint) throw new Error("[chains] exact EVM signing operation fingerprint digest is required");
-	return {
-		laneDigest: parseSigningOperationFingerprintDigest(SigningSessionIds.signingOperationFingerprint(operationFingerprint)),
-		intentDigest: parseDigestB64u(base64UrlEncode(input.signingDigest32)),
-		displayDigest: await sha256Utf8DigestB64u(alphabetizeStringify(input.displayModel))
-	};
-}
-function intentDigestPreparationFromEvmIntent(args) {
-	return {
-		intentDigest: args.intentDigestHex,
-		challengeB64u: args.challengeB64u,
-		displayModel: args.displayModel
-	};
-}
-function digestsEqual(left, right) {
-	return String(left.laneDigest) === String(right.laneDigest) && String(left.intentDigest) === String(right.intentDigest) && String(left.displayDigest) === String(right.displayDigest);
-}
-function assertPreparedEcdsaOperationStepUpMatches(args) {
-	if (args.prepared.operation !== args.operation) throw new Error("[chains] prepared ECDSA operation step-up does not match the operation being signed");
-	if (!digestsEqual(args.prepared.operationDigests, args.operationDigests)) throw new Error("[chains] prepared ECDSA operation step-up digest drift");
-}
-function requirePreparedEcdsaStepUpChallenge(args) {
-	if (!args.prepared) throw new Error("[chains] passkey ECDSA step-up requires an operation prepared before confirmation");
-	const challengeB64u = String(args.prepared.prepared.challengeB64u || "").trim();
-	if (!challengeB64u || challengeB64u !== String(args.challengeB64u || "").trim()) throw new Error("[chains] passkey ECDSA step-up challenge does not match the prepared operation");
-	return challengeB64u;
-}
-function assertNeverEvmFamilySigningAuthorization(value) {
-	throw new Error(`[chains] unsupported EVM-family signing authorization: ${String(value)}`);
-}
-async function resolvePreparedEvmFamilyAuthorization(input) {
-	switch (input.authorization.kind) {
-		case "active_wallet_authority": return {
-			kind: "active_wallet_authority",
-			confirmationAuthPayload: { signingAuthPlan: input.authorization.confirmationAuthPlan }
-		};
-		case "owner": return await requireEvmFamilyStepUpAuth({
-			thresholdEcdsaStepUp: input.thresholdEcdsaStepUp,
-			hasThresholdEcdsaRequest: input.hasThresholdEcdsaRequest,
-			needsWebAuthn: input.needsWebAuthn,
-			requiredSignatureUses: input.requiredSignatureUses,
-			explicitAuthErrorLabel: input.explicitAuthErrorLabel
-		});
-		default: return assertNeverEvmFamilySigningAuthorization(input.authorization);
-	}
-}
-function buildPendingActiveWalletAuthorityConfirmationRequest(args) {
-	if (args.input.authorization.kind !== "active_wallet_authority") throw new Error("[chains] pending active Wallet Authority confirmation requires exact authorization");
-	return {
-		ctx: { touchConfirm: args.input.touchConfirm },
-		sessionId: args.sessionId,
-		chain: args.config.targetKind,
-		kind: "intentDigest",
-		signingSubject: {
-			kind: "evm_wallet",
-			walletId: args.input.walletId
-		},
-		signingAuthPlan: args.input.authorization.confirmationAuthPlan,
-		challengeB64u: PENDING_CHALLENGE_B64U,
-		intentDigest: PENDING_INTENT_DIGEST,
-		displayModel: args.config.buildDisplayModel({
-			request: args.input.request,
-			signerAccount: args.input.walletId,
-			title: args.config.title,
-			subtitle: args.config.body
-		}),
-		title: args.config.title,
-		body: args.config.body,
-		confirmationConfigOverride: args.input.confirmationConfigOverride
-	};
-}
-async function signQueuedEcdsaRequest(args) {
-	const operationId = String(args.operation.intent.operationId);
-	emitEcdsaSigningTiming(operationId, "material_queue", args.queuedAt);
-	const authorizationStartedAt = performance.now();
-	const ready = await args.resolveMaterial(args.request, args.operation, args.operationDigests);
-	emitEcdsaSigningTiming(operationId, "material_authorization", authorizationStartedAt);
-	return await args.engine.signReady(args.request, ready.material, args.operation, args.operationDigests);
-}
-async function signEvmFamilyWithUiConfirm(args) {
-	const { config, input } = args;
-	const sessionId = makeRequestId("intent");
-	const flowId = `signing:${config.flowName}:${input.walletId}:${sessionId}`;
-	const hasThresholdEcdsaRequest = input.request.senderSignatureAlgorithm === "secp256k1";
-	const thresholdEcdsaStepUp = input.thresholdEcdsaStepUp;
-	const thresholdEcdsaStepUpRuntime = thresholdEcdsaStepUp.kind === "not_required" ? void 0 : thresholdEcdsaStepUp.runtime;
-	const signingAuthPlan = signingAuthPlanFromThresholdEcdsaStepUp(thresholdEcdsaStepUp);
-	const requiresThresholdEcdsaOperationStepUp = input.authorization.kind === "owner" && thresholdEcdsaStepUp.kind === "required" && (thresholdEcdsaStepUp.runtime.reusableAuthorization.kind === "absent" || !isWarmSessionSigningAuthPlan(thresholdEcdsaStepUp.authPlan.signingAuthPlan));
-	if (hasThresholdEcdsaRequest && !signingAuthPlan) switch (input.authorization.kind) {
-		case "owner": throw new Error("[chains] threshold ECDSA transaction signing requires an explicit auth plan");
-		case "active_wallet_authority": break;
-		default: assertNeverEvmFamilySigningAuthorization(input.authorization);
-	}
-	const confirmationSigningAuthPlan = signingAuthPlan ?? (input.authorization.kind === "active_wallet_authority" ? input.authorization.confirmationAuthPlan : null);
-	const authMethod = confirmationSigningAuthPlan ? resolveSigningConfirmationAuthMethod(confirmationSigningAuthPlan) : "passkey";
-	const emitProgress = (event) => {
-		try {
-			input.onEvent?.(createSigningFlowEvent({
-				...event,
-				flowId,
-				walletId: input.walletId,
-				authMethod
-			}));
-		} catch {}
-	};
-	const authSideEffectsStarted = /* @__PURE__ */ new Set();
-	const notifyAuthSideEffectStarted = (sideEffect) => {
-		if (authSideEffectsStarted.has(sideEffect)) return;
-		authSideEffectsStarted.add(sideEffect);
-		try {
-			thresholdEcdsaStepUpRuntime?.onAuthSideEffectStarted?.(sideEffect);
-		} catch {}
-	};
-	const emitUiConfirmProgress = (progress) => {
-		if (progress.phase === "auth.passkey.prompt.started") notifyAuthSideEffectStarted("passkey_reauth");
-		const mapped = mapSigningConfirmationProgress(progress, authMethod);
-		if (mapped) emitProgress(mapped);
-	};
-	const runSharedSigningCommandSequence = async (commands, handlers) => {
-		const executeCommand = async (kind) => {
-			await handlers[kind]?.();
-		};
-		if (!input.signingSessionPlan) {
-			await runUnplannedSigningOperationCommandSequence({
-				commands,
-				execute: executeCommand
-			});
-			return;
-		}
-		const result = await runSigningOperationCommandSteps({
-			steps: buildSigningOperationCommandSteps(createSigningOperationPlan({
-				sessionPlan: input.signingSessionPlan,
-				operation: input.signingOperation || null,
-				commands
-			})),
-			executor: { execute: async (command) => {
-				await executeCommand(command.kind);
-			} },
-			onTransition: input.onSigningOperationTransition
-		});
-		if (!result.ok) throw result.error;
-		if (result.finalState.kind === "failed") throw new Error(result.finalState.reason);
-	};
-	const needsWebAuthn = config.webauthn.kind === "supported" && config.webauthn.requestNeedsWebAuthn(input.request);
-	let preparedRequest = input.request;
-	let nonceReservation = null;
-	let reservationReleased = false;
-	let thresholdSignatureCreated = false;
-	const activeThresholdEcdsaOperation = thresholdEcdsaStepUp.kind === "required" ? thresholdEcdsaStepUp.operation : null;
-	const getThresholdEcdsaOperation = async () => {
-		if (activeThresholdEcdsaOperation) return activeThresholdEcdsaOperation;
-		throw new Error("[chains] threshold ECDSA transaction signing requires an operation");
-	};
-	const releaseNonceReservation = async () => {
-		if (reservationReleased || !nonceReservation || !input.releaseNonceReservation) return;
-		reservationReleased = true;
-		try {
-			await input.releaseNonceReservation(nonceReservation);
-		} catch {}
-	};
-	const markNonceReservationSigned = async () => {
-		if (!nonceReservation) return;
-		const leaseId = String(nonceReservation.leaseId || "").trim();
-		const operationId = String(nonceReservation.operationId || "").trim();
-		const operationFingerprint = String(nonceReservation.operationFingerprint || "").trim();
-		if (!leaseId || !operationId || !operationFingerprint) throw new Error(`[chains] managed ${config.nonceErrorLabel} nonce reservation is missing lease metadata`);
-		await input.ctx.nonceCoordinator.markSigned({
-			leaseId,
-			operationId,
-			operationFingerprint
-		});
-	};
-	const intentPreparationTask = (async () => {
-		if (input.prepareRequestWithManagedNonce) {
-			const prepared = await input.prepareRequestWithManagedNonce();
-			preparedRequest = prepared.request;
-			nonceReservation = prepared.reservation;
-		}
-		const intent = await config.buildIntent({
-			workerCtx: input.workerCtx,
-			request: preparedRequest
-		});
-		if (config.webauthn.kind === "supported") config.webauthn.validateIntent(intent);
-		const firstSignRequest = intent.signRequests[0];
-		if (!firstSignRequest) throw new Error("[chains] signing intent has no sign requests");
-		const firstDigest = inferDigest32FromSignRequest(firstSignRequest);
-		const intentDigestHex = bytesToHex(firstDigest);
-		const displayModel = config.buildDisplayModel({
-			request: preparedRequest,
-			intentDigest: intentDigestHex,
-			signerAccount: input.walletId,
-			title: config.title,
-			subtitle: config.body
-		});
-		let challengeB64u = base64UrlEncode(firstDigest);
-		if (requiresThresholdEcdsaOperationStepUp && firstSignRequest.algorithm === "secp256k1" && thresholdEcdsaStepUpRuntime && activeThresholdEcdsaOperation && input.resolveEcdsaSigningMaterialPlan) {
-			const operationDigests = await buildEvmFamilyOperationDigests({
-				operationFingerprint: input.signingOperation?.operationFingerprint,
-				signingDigest32: inferDigest32FromSignRequest(firstSignRequest),
-				displayModel
-			});
-			const plan = await input.resolveEcdsaSigningMaterialPlan();
-			switch (plan.kind) {
-				case "ready":
-					ecdsaSigningMaterialSource = plan.value;
-					break;
-				case "authorization_required":
-					ecdsaSigningMaterialSource = plan.requirement;
-					break;
-				case "superseded": throw new EvmFamilyEcdsaMaterialSupersededError(plan.replacement);
-				case "failed": throw new Error(`[chains] threshold ECDSA material is unavailable: ${plan.failure.reason}`);
-			}
-			const preparationMaterialSource = ecdsaSigningMaterialSource;
-			if (!preparationMaterialSource) throw new Error("[chains] ECDSA preparation did not produce signing material");
-			const prepared = await thresholdEcdsaStepUpRuntime.operationStepUp.prepare({
-				operation: activeThresholdEcdsaOperation,
-				operationDigests,
-				material: hydratedMaterialFromSource(preparationMaterialSource)
-			});
-			preparedEcdsaOperationStepUp = {
-				prepared,
-				operation: activeThresholdEcdsaOperation,
-				operationDigests
-			};
-			challengeB64u = prepared.challengeB64u;
-		}
-		return {
-			intent,
-			challengeB64u,
-			intentDigestHex,
-			displayModel
-		};
-	})();
-	if (input.authorization.kind === "active_wallet_authority") registerIntentDigestPreparation({
-		requestId: sessionId,
-		preparation: intentPreparationTask.then(intentDigestPreparationFromEvmIntent)
-	});
-	let preparedStepUpAuth = null;
-	let stepUpAuthorization = null;
-	let confirmation = null;
-	let intentPrepared = null;
-	let intentHasSecp256k1Request = false;
-	let signedResult = null;
-	let ecdsaSigningMaterialSource = null;
-	let preparedEcdsaOperationStepUp = null;
-	const ensureReadySecp256k1SigningMaterial = async (_signReq, operation, operationDigests) => {
-		if (input.resolveEcdsaSigningMaterialPlan) {
-			const plan = await input.resolveEcdsaSigningMaterialPlan();
-			switch (plan.kind) {
-				case "ready":
-					ecdsaSigningMaterialSource = plan.value;
-					break;
-				case "authorization_required":
-					ecdsaSigningMaterialSource = plan.requirement;
-					break;
-				case "superseded": throw new EvmFamilyEcdsaMaterialSupersededError(plan.replacement);
-				case "failed": throw new Error(`[chains] threshold ECDSA material is unavailable: ${plan.failure.reason}`);
-			}
-		}
-		const source = ecdsaSigningMaterialSource;
-		if (!source) throw new Error("[chains] missing ready threshold ECDSA material for secp256k1 signing");
-		if (!stepUpAuthorization || stepUpAuthorization.kind === "warm_session") {
-			if (source.kind === "material_for_step_up") throw new Error("[chains] auth-neutral ECDSA material reached signing without a same-method step-up");
-			return source;
-		}
-		if (!thresholdEcdsaStepUpRuntime) throw new Error("[chains] ECDSA operation step-up runtime is unavailable");
-		const preparedStepUp = preparedEcdsaOperationStepUp;
-		if (!preparedStepUp) throw new Error("[chains] ECDSA step-up signing requires an operation prepared before confirmation");
-		assertPreparedEcdsaOperationStepUpMatches({
-			prepared: preparedStepUp,
-			operation,
-			operationDigests
-		});
-		return {
-			kind: "material_from_step_up",
-			material: await thresholdEcdsaStepUpRuntime.operationStepUp.authorize({
-				authorization: stepUpAuthorization,
-				prepared: preparedStepUp.prepared,
-				material: hydratedMaterialFromSource(source)
-			})
-		};
-	};
-	const runShowConfirmationCommand = async () => {
-		if (input.authorization.kind === "active_wallet_authority") {
-			emitProgress({
-				phase: SigningEventPhase.STEP_05_CONFIRMATION_DISPLAYED,
-				status: "waiting_for_user",
-				interaction: {
-					kind: "transaction_confirmation",
-					overlay: "show"
-				}
-			});
-			input.onConfirmationDisplayed?.();
-			const pendingConfirmationRequest = buildPendingActiveWalletAuthorityConfirmationRequest({
-				config,
-				input,
-				sessionId
-			});
-			confirmation = await createSigningConfirmationCommandHandler({
-				runtime: input.touchConfirm,
-				request: pendingConfirmationRequest
-			})();
-			intentPrepared = await intentPreparationTask;
-			intentHasSecp256k1Request = intentPrepared.intent.signRequests.some((signReq) => signReq.algorithm === "secp256k1");
-			const stepUp = await resolvePreparedEvmFamilyAuthorization({
-				authorization: input.authorization,
-				thresholdEcdsaStepUp,
-				hasThresholdEcdsaRequest,
-				needsWebAuthn,
-				requiredSignatureUses: config.requiredSignatureUsesForRequest(input.request),
-				explicitAuthErrorLabel: config.explicitAuthErrorLabel
-			});
-			if (!isWarmSessionSigningAuthPlan(stepUp.confirmationAuthPayload.signingAuthPlan) && !isActiveWalletAuthoritySigningAuthPlan(stepUp.confirmationAuthPayload.signingAuthPlan)) throw new Error("[chains] active Wallet Authority signing requires a session auth plan");
-			preparedStepUpAuth = stepUp;
-			const confirmationAuthPlan = stepUp.confirmationAuthPayload.signingAuthPlan;
-			emitProgress({
-				phase: SigningEventPhase.STEP_06_AUTH_WARM_SESSION_CLAIMED,
-				status: "succeeded",
-				interaction: {
-					kind: "none",
-					overlay: "none"
-				},
-				data: isActiveWalletAuthoritySigningAuthPlan(confirmationAuthPlan) ? {
-					walletSessionId: String(confirmationAuthPlan.walletSessionId),
-					expiresAtMs: confirmationAuthPlan.expiresAtMs,
-					authorityId: String(confirmationAuthPlan.authorityId),
-					authMethodId: String(confirmationAuthPlan.authMethodId)
-				} : warmSessionClaimedProgressData(confirmationAuthPlan)
-			});
-			notifyAuthSideEffectStarted("auth_confirmed");
-			emitProgress({
-				phase: SigningEventPhase.STEP_05_CONFIRMATION_APPROVED,
-				status: "succeeded",
-				interaction: {
-					kind: "transaction_confirmation",
-					overlay: "hide"
-				}
-			});
-			return;
-		}
-		intentPrepared = await intentPreparationTask;
-		intentHasSecp256k1Request = intentPrepared.intent.signRequests.some((signReq) => signReq.algorithm === "secp256k1");
-		emitProgress({
-			phase: SigningEventPhase.STEP_05_CONFIRMATION_DISPLAYED,
-			status: "waiting_for_user",
-			interaction: {
-				kind: "transaction_confirmation",
-				overlay: "show"
-			}
-		});
-		input.onConfirmationDisplayed?.();
-		const stepUp = await resolvePreparedEvmFamilyAuthorization({
-			authorization: input.authorization,
-			thresholdEcdsaStepUp,
-			hasThresholdEcdsaRequest,
-			needsWebAuthn,
-			requiredSignatureUses: config.requiredSignatureUsesForRequest(input.request),
-			explicitAuthErrorLabel: config.explicitAuthErrorLabel
-		});
-		preparedStepUpAuth = stepUp;
-		const confirmationAuthPayload = stepUp.confirmationAuthPayload;
-		if (isWarmSessionSigningAuthPlan(confirmationAuthPayload.signingAuthPlan) || isActiveWalletAuthoritySigningAuthPlan(confirmationAuthPayload.signingAuthPlan)) {
-			const confirmationAuthPlan = confirmationAuthPayload.signingAuthPlan;
-			emitProgress({
-				phase: SigningEventPhase.STEP_06_AUTH_WARM_SESSION_CLAIMED,
-				status: "succeeded",
-				interaction: {
-					kind: "none",
-					overlay: "none"
-				},
-				data: isActiveWalletAuthoritySigningAuthPlan(confirmationAuthPlan) ? {
-					walletSessionId: String(confirmationAuthPlan.walletSessionId),
-					expiresAtMs: confirmationAuthPlan.expiresAtMs,
-					authorityId: String(confirmationAuthPlan.authorityId),
-					authMethodId: String(confirmationAuthPlan.authMethodId)
-				} : warmSessionClaimedProgressData(confirmationAuthPlan)
-			});
-		}
-		const confirmationRequestBase = {
-			ctx: { touchConfirm: input.touchConfirm },
-			sessionId,
-			chain: config.targetKind,
-			kind: "intentDigest",
-			signingSubject: {
-				kind: "evm_wallet",
-				walletId: input.walletId
-			},
-			challengeB64u: intentPrepared.challengeB64u,
-			intentDigest: intentPrepared.intentDigestHex,
-			displayModel: intentPrepared.displayModel,
-			title: config.title,
-			body: config.body,
-			onProgress: emitUiConfirmProgress,
-			confirmationConfigOverride: input.confirmationConfigOverride
-		};
-		const confirmationRequest = stepUp.kind === "passkey" ? {
-			...confirmationRequestBase,
-			...stepUp.confirmationAuthPayload,
-			webauthnChallenge: {
-				kind: "intent_digest",
-				challengeB64u: requirePreparedEcdsaStepUpChallenge({
-					prepared: preparedEcdsaOperationStepUp,
-					challengeB64u: intentPrepared.challengeB64u
-				})
-			}
-		} : stepUp.kind === "email_otp" ? {
-			...confirmationRequestBase,
-			...stepUp.confirmationAuthPayload,
-			emailOtpPrompt: stepUp.emailOtpPrompt
-		} : {
-			...confirmationRequestBase,
-			...stepUp.confirmationAuthPayload
-		};
-		confirmation = await createSigningConfirmationCommandHandler({
-			runtime: input.touchConfirm,
-			request: confirmationRequest
-		})();
-		const confirmed = confirmation;
-		if (!confirmed) throw new Error("[chains] signing confirmation did not produce a decision");
-		notifyAuthSideEffectStarted("auth_confirmed");
-		switch (input.authorization.kind) {
-			case "owner":
-				stepUpAuthorization = buildEvmFamilyEcdsaStepUpAuthorization({
-					prepared: stepUp,
-					confirmation: confirmed
-				});
-				break;
-			default: assertNeverEvmFamilySigningAuthorization(input.authorization);
-		}
-		emitProgress({
-			phase: SigningEventPhase.STEP_05_CONFIRMATION_APPROVED,
-			status: "succeeded",
-			interaction: {
-				kind: "transaction_confirmation",
-				overlay: "hide"
-			}
-		});
-	};
-	const runPreparePayloadCommand = async () => {
-		if (!intentPrepared) throw new Error("[chains] signing intent must be prepared before threshold admission");
-		if (!confirmation) throw new Error("[chains] signing confirmation is required before threshold admission");
-		if (!preparedStepUpAuth) throw new Error("[chains] signing auth payload is required before threshold admission");
-		switch (input.authorization.kind) {
-			case "owner":
-				if (!stepUpAuthorization) throw new Error("[chains] signing step-up authorization is required before threshold admission");
-				if (intentHasSecp256k1Request && !activeThresholdEcdsaOperation) throw new Error("[chains] threshold ECDSA operation must be prepared before signing");
-				break;
-			case "active_wallet_authority": break;
-			default: assertNeverEvmFamilySigningAuthorization(input.authorization);
-		}
-	};
-	const runSignCommand = async () => {
-		const commitStartedAt = performance.now();
-		if (!intentPrepared) throw new Error("[chains] signing intent must be prepared before signing");
-		if (!confirmation) throw new Error("[chains] signing confirmation must complete before signing");
-		const intent = intentPrepared.intent;
-		if (intentHasSecp256k1Request) emitProgress({
-			phase: SigningEventPhase.STEP_10_COMMIT_STARTED,
-			status: "running",
-			interaction: {
-				kind: "none",
-				overlay: "none"
-			}
-		});
-		const signatures = [];
-		for (const signReq of intent.signRequests) {
-			let keyRef;
-			if (signReq.kind === "webauthn") {
-				if (config.webauthn.kind !== "supported") throw new Error("[chains] WebAuthn signing is not supported for this chain");
-				if (!confirmation.credential) throw new Error("[chains] missing WebAuthn credential from touchConfirm");
-				keyRef = (await config.webauthn.resolveKeyRef({
-					ctx: input.ctx,
-					walletId: input.walletId,
-					workerCtx: input.workerCtx,
-					signReq,
-					credential: normalizeAuthenticationCredential(confirmation.credential)
-				})).keyRef;
-			} else if (signReq.algorithm === "secp256k1") {
-				const operationDigests = await buildEvmFamilyOperationDigests({
-					operationFingerprint: input.signingOperation?.operationFingerprint,
-					signingDigest32: signReq.digest32,
-					displayModel: intentPrepared.displayModel
-				});
-				switch (input.authorization.kind) {
-					case "active_wallet_authority": {
-						const operationId = input.signingOperation?.operationId;
-						if (!operationId) throw new Error("[chains] active Wallet Authority ECDSA signing requires an operation id");
-						signatures.push(await input.authorization.sign({
-							requestId: sessionId,
-							operationId: String(operationId),
-							operationDigests,
-							signingDigest32: signReq.digest32
-						}));
-						continue;
-					}
-					case "owner": break;
-					default: assertNeverEvmFamilySigningAuthorization(input.authorization);
-				}
-				const thresholdEcdsaOperation = await getThresholdEcdsaOperation();
-				const engine = input.engines.secp256k1;
-				if (!engine) throw new Error(`[chains] missing engine for algorithm: ${signReq.algorithm}`);
-				if (!isReadySecp256k1Signer(engine)) throw new Error("[chains] secp256k1 signing engine requires ready material support");
-				if (!input.runEcdsaMaterialUse) throw new Error("[chains] secp256k1 signing requires exact material serialization");
-				signatures.push(await input.runEcdsaMaterialUse(signQueuedEcdsaRequest.bind(void 0, {
-					request: signReq,
-					engine,
-					operation: thresholdEcdsaOperation,
-					operationDigests,
-					queuedAt: performance.now(),
-					resolveMaterial: ensureReadySecp256k1SigningMaterial
-				})));
-				continue;
-			} else throw new Error(`[chains] unsupported ${config.explicitAuthErrorLabel} signing algorithm: ${signReq.algorithm}`);
-			const engine = input.engines.webauthnP256;
-			if (!engine) throw new Error(`[chains] missing engine for algorithm: ${signReq.algorithm}`);
-			signatures.push(await engine.sign(signReq, keyRef));
-		}
-		const assemblyStartedAt = performance.now();
-		signedResult = await intent.finalize(signatures);
-		thresholdSignatureCreated = true;
-		await markNonceReservationSigned();
-		if (activeThresholdEcdsaOperation) {
-			const operationId = String(activeThresholdEcdsaOperation.intent.operationId);
-			emitEcdsaSigningTiming(operationId, "transaction_assembly", assemblyStartedAt);
-			emitEcdsaSigningTiming(operationId, "commit_total", commitStartedAt);
-		}
-		emitProgress({
-			phase: SigningEventPhase.STEP_11_TRANSACTION_SIGNED,
-			status: "succeeded",
-			interaction: {
-				kind: "none",
-				overlay: "hide"
-			}
-		});
-		emitProgress({
-			phase: SigningEventPhase.STEP_15_COMPLETED,
-			status: "succeeded",
-			interaction: {
-				kind: "none",
-				overlay: "none"
-			},
-			data: { operation: "sign" }
-		});
-	};
-	try {
-		await runSharedSigningCommandSequence([
-			SigningOperationCommandKind.ShowConfirmation,
-			SigningOperationCommandKind.PreparePayload,
-			SigningOperationCommandKind.Sign
-		], {
-			[SigningOperationCommandKind.ShowConfirmation]: runShowConfirmationCommand,
-			[SigningOperationCommandKind.PreparePayload]: runPreparePayloadCommand,
-			[SigningOperationCommandKind.Sign]: runSignCommand
-		});
-		if (!signedResult) throw new Error("[chains] signing operation completed without a signed result");
-		const result = signedResult;
-		if (!nonceReservation) return result;
-		return {
-			...result,
-			managedNonce: toManagedNonceReservationSnapshot(nonceReservation)
-		};
-	} catch (error) {
-		if (!thresholdSignatureCreated) {
-			if (nonceReservation) await releaseNonceReservation();
-			else if (input.releaseNonceReservation) await intentPreparationTask.then(async () => {
-				await releaseNonceReservation();
-			}).catch(() => void 0);
-		}
-		throw error;
-	}
-}
-//#endregion
-export { PENDING_INTENT_DIGEST as a, createEvmNonceBackend as c, buildEvmDisplayModel as d, formatCompactGas as f, selectorFromHexData as h, PENDING_CHALLENGE_B64U as i, fromManagedNonceReservationSnapshot as l, resolveFunctionDisplayName as m, isEvmFamilyEcdsaMaterialSupersededError as n, clearIntentDigestPreparation as o, formatCalldataForDisplay as p, signEvmFamilyWithUiConfirm as r, consumeIntentDigestPreparation as s, EvmFamilyEcdsaMaterialSupersededError as t, reserveNonceInputFromBoundary as u };