@seams/wallet 0.7.3 → 0.8.0

package/dist/esm/react/SeamsWeb/operations/session/thresholdEcdsaProvisioning.js

@@ -1,40 +0,0 @@
-import { chainFamilyFromNetwork } from "../../../core/config/chains.js";
-import { thresholdEcdsaChainTargetFromConfig, thresholdEcdsaChainTargetKey } from "../../../core/signingEngine/interfaces/ecdsaChainTarget.js";
-//#region src/SeamsWeb/operations/session/thresholdEcdsaProvisioning.ts
-function listConfiguredThresholdEcdsaPublicationTargets(chains) {
-	const targets = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const chainConfig of chains) {
-		const family = chainFamilyFromNetwork(chainConfig.network);
-		if (family !== "evm" && family !== "tempo") continue;
-		const chainTarget = thresholdEcdsaChainTargetFromConfig(chainConfig);
-		const key = thresholdEcdsaChainTargetKey(chainTarget);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		targets.push({ chainTarget });
-	}
-	return targets;
-}
-function listThresholdEcdsaProvisionTargets(args) {
-	const targets = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const chainConfig of args.chains) {
-		const family = chainFamilyFromNetwork(chainConfig.network);
-		if (family !== "evm" && family !== "tempo") continue;
-		const options = family === "tempo" ? args.signerOptions.tempo : args.signerOptions.evm;
-		if (!options.enabled) continue;
-		const chainTarget = thresholdEcdsaChainTargetFromConfig(chainConfig);
-		const key = thresholdEcdsaChainTargetKey(chainTarget);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		targets.push({
-			chainTarget,
-			options
-		});
-	}
-	return targets;
-}
-//#endregion
-export { listConfiguredThresholdEcdsaPublicationTargets, listThresholdEcdsaProvisionTargets };
-
-//# sourceMappingURL=thresholdEcdsaProvisioning.js.map

package/dist/esm/react/SeamsWeb/operations/session/thresholdWarmSessionBootstrap.js

@@ -1,20 +0,0 @@
-import { ROUTER_AB_ED25519_NORMAL_SIGNING_STATE_KIND } from "../../../shared-ts/src/utils/signingSessionSeal.js";
-//#region src/SeamsWeb/operations/session/thresholdWarmSessionBootstrap.ts
-function assertNeverNormalSigning(value) {
-	throw new Error(`Unexpected Router A/B normal-signing config branch: ${String(value)}`);
-}
-function createRouterAbNormalSigningPolicy(configs) {
-	const normalSigning = configs.signing.routerAb.normalSigning;
-	switch (normalSigning.mode) {
-		case "disabled": throw new Error("[threshold-warm-session] Router A/B normal signing must be enabled for Ed25519 sessions");
-		case "enabled": return {
-			kind: ROUTER_AB_ED25519_NORMAL_SIGNING_STATE_KIND,
-			signingWorkerId: normalSigning.signingWorkerId
-		};
-		default: return assertNeverNormalSigning(normalSigning);
-	}
-}
-//#endregion
-export { createRouterAbNormalSigningPolicy };
-
-//# sourceMappingURL=thresholdWarmSessionBootstrap.js.map

package/dist/esm/react/SeamsWeb/operations/tempo/executeEvmFamilyTransaction.js

@@ -1,568 +0,0 @@
-import { chainFamilyFromNetwork } from "../../../core/config/chains.js";
-import { thresholdEcdsaChainTargetFromConfig, thresholdEcdsaChainTargetKey, toWalletId } from "../../../core/signingEngine/interfaces/ecdsaChainTarget.js";
-import { SigningEventPhase, createSigningFlowEvent } from "../../../core/types/sdkSentEvents.js";
-import { createEvmClient } from "../../../core/rpcClients/evm/EvmClient.js";
-//#region src/SeamsWeb/operations/tempo/executeEvmFamilyTransaction.ts
-/**
-* Fills `tx.chainId` from the chain the caller already named.
-*
-* The execute path takes it as optional because `chainTarget` is authoritative;
-* everything below this point wants a concrete request. A supplied value that
-* disagrees with the target is a bug, so it is rejected rather than overwritten.
-*/
-function withResolvedChainId(request, chainTarget) {
-	const declared = request.tx.chainId;
-	if (declared !== void 0 && Number(declared) !== chainTarget.chainId) throw new Error(`[evm-family] request tx.chainId ${declared} does not match chain target ${thresholdEcdsaChainTargetKey(chainTarget)}`);
-	return {
-		...request,
-		tx: {
-			...request.tx,
-			chainId: chainTarget.chainId
-		}
-	};
-}
-const DEFAULT_FINALIZATION_TIMEOUT_MS = 9e4;
-const DEFAULT_FINALIZATION_POLL_INTERVAL_MS = 1250;
-const DEFAULT_FINALIZATION_CONFIRMATIONS = 1;
-const BEST_EFFORT_NONCE_CLEANUP_TIMEOUT_MS = 5e3;
-const MIN_BEST_EFFORT_NONCE_CLEANUP_TIMEOUT_MS = 250;
-const FINALIZATION_WATCHDOG_GRACE_MS = 2e3;
-function emitLifecycleEvent(onEvent, accountId, event) {
-	try {
-		onEvent?.(createSigningFlowEvent({
-			...event,
-			flowId: `signing:evm_family:${accountId}:${event.phase}`,
-			accountId
-		}));
-	} catch {}
-}
-function createCancelledError() {
-	const err = /* @__PURE__ */ new Error("Request cancelled");
-	err.code = "cancelled";
-	return err;
-}
-function createLifecycleTimeoutError(message) {
-	const error = new Error(message);
-	error.code = "timeout";
-	return error;
-}
-async function withLifecycleTimeout(args) {
-	const timeoutMs = Math.max(1, Math.floor(Number(args.timeoutMs) || 0));
-	let timeoutId = null;
-	let settled = false;
-	try {
-		return await new Promise((resolve, reject) => {
-			timeoutId = setTimeout(() => {
-				if (settled) return;
-				settled = true;
-				try {
-					args.onTimeout?.();
-				} catch {}
-				reject(createLifecycleTimeoutError(args.message));
-			}, timeoutMs);
-			args.promise.then((value) => {
-				if (settled) return;
-				settled = true;
-				if (timeoutId) clearTimeout(timeoutId);
-				resolve(value);
-			}, (error) => {
-				if (settled) return;
-				settled = true;
-				if (timeoutId) clearTimeout(timeoutId);
-				reject(error);
-			});
-		});
-	} finally {
-		if (timeoutId) clearTimeout(timeoutId);
-	}
-}
-function resolveBestEffortCleanupTimeoutMs(finalizationTimeoutMs) {
-	const parsed = Math.floor(Number(finalizationTimeoutMs));
-	if (!Number.isFinite(parsed) || parsed <= 0) return BEST_EFFORT_NONCE_CLEANUP_TIMEOUT_MS;
-	return Math.min(BEST_EFFORT_NONCE_CLEANUP_TIMEOUT_MS, Math.max(MIN_BEST_EFFORT_NONCE_CLEANUP_TIMEOUT_MS, parsed));
-}
-function throwIfCancelled(shouldAbort) {
-	if (typeof shouldAbort === "function" && shouldAbort()) throw createCancelledError();
-}
-function normalizeToken(value) {
-	return String(value || "").trim().toLowerCase().replace(/[\s-]+/g, "_");
-}
-function hasErrorCode(error, expected) {
-	if (!error || typeof error !== "object") return false;
-	return normalizeToken(error.code) === normalizeToken(expected);
-}
-function errorDiagnostic(error) {
-	if (error instanceof Error) {
-		const code = String(error.code || "").trim();
-		const details = "details" in error ? error.details : void 0;
-		return {
-			...code ? { code } : {},
-			message: error.message,
-			...details !== void 0 ? { details } : {}
-		};
-	}
-	if (error && typeof error === "object") {
-		const value = error;
-		const code = String(value.code || "").trim();
-		const message = String(value.message || "").trim();
-		return {
-			...code ? { code } : {},
-			message: message || String(error),
-			...value.details !== void 0 ? { details: value.details } : {}
-		};
-	}
-	return { message: String(error || "unknown error") };
-}
-function messageIncludesNonceLaneBlocked(error) {
-	const message = normalizeToken(error instanceof Error ? error.message : error && typeof error === "object" && "message" in error ? error.message : error);
-	return message.includes("nonce_lane_blocked") || message.includes("nonce lane blocked");
-}
-function extractDroppedOrReplacedReason(error) {
-	if (!error || typeof error !== "object") return null;
-	if (!hasErrorCode(error, "tx_dropped_or_replaced")) return null;
-	if (normalizeToken(error.reason) === "replaced") return "replaced";
-	return "dropped";
-}
-function normalizeHexData(value) {
-	const normalized = String(value || "").trim().toLowerCase();
-	if (!/^0x[0-9a-f]*$/.test(normalized)) return null;
-	return normalized;
-}
-function trimmedStringOrNull(value) {
-	return String(value ?? "").trim() || null;
-}
-function normalizePayloadAddress(value) {
-	const trimmed = trimmedStringOrNull(value);
-	return trimmed ? trimmed.toLowerCase() : null;
-}
-function assertNeverFinalizedPayload(value) {
-	throw new Error(`[Tempo capability] unhandled finalized payload branch: ${String(value)}`);
-}
-function requireHexData(value, label) {
-	const normalized = normalizeHexData(value);
-	if (!normalized) throw new Error(`[Tempo capability] invalid ${label} payload input`);
-	return normalized;
-}
-function eip1559PayloadExpectationFromRequest(request) {
-	return {
-		kind: "evm_eip1559",
-		to: request.tx.to ?? null,
-		input: requireHexData(request.tx.data || "0x", "EVM")
-	};
-}
-function tempoCallPayloadExpectationFromRequestCall(call) {
-	return {
-		to: call.to,
-		input: requireHexData(call.input || "0x", "Tempo call")
-	};
-}
-function tempoPayloadExpectationFromRequest(request) {
-	const [firstCall, ...remainingCalls] = request.tx.calls;
-	if (!firstCall) throw new Error("[Tempo capability] Tempo transaction has no calls");
-	return {
-		kind: "tempo_eip2718_calls",
-		calls: [tempoCallPayloadExpectationFromRequestCall(firstCall), ...remainingCalls.map(tempoCallPayloadExpectationFromRequestCall)]
-	};
-}
-function payloadExpectationFromRequest(request) {
-	switch (request.chain) {
-		case "evm": return eip1559PayloadExpectationFromRequest(request);
-		case "tempo": return tempoPayloadExpectationFromRequest(request);
-		default: return assertNeverFinalizedPayload(request);
-	}
-}
-function observedCallInput(call) {
-	return call.input ?? call.data ?? null;
-}
-function observedPayloadFromTx(tx) {
-	if (Array.isArray(tx.calls)) return {
-		kind: "tempo_eip2718_calls",
-		calls: tx.calls.map((call) => ({
-			to: call?.to ?? null,
-			input: call ? observedCallInput(call) : null,
-			data: call?.data ?? null
-		}))
-	};
-	return {
-		kind: "evm_eip1559",
-		to: tx.to ?? null,
-		input: tx.input ?? null
-	};
-}
-function eip1559PayloadMatches(args) {
-	return normalizePayloadAddress(args.observed.to) === normalizePayloadAddress(args.expected.to) && normalizeHexData(args.observed.input) === normalizeHexData(args.expected.input);
-}
-function tempoCallPayloadMatches(args) {
-	return normalizePayloadAddress(args.observed.to) === normalizePayloadAddress(args.expected.to) && normalizeHexData(observedCallInput(args.observed)) === normalizeHexData(args.expected.input);
-}
-function tempoPayloadMatches(args) {
-	if (args.observed.calls.length !== args.expected.calls.length) return false;
-	return args.expected.calls.every((expected, index) => {
-		const observed = args.observed.calls[index];
-		return observed ? tempoCallPayloadMatches({
-			expected,
-			observed
-		}) : false;
-	});
-}
-function payloadExpectationMatchesObservation(args) {
-	switch (args.expected.kind) {
-		case "evm_eip1559": return args.observed.kind === "evm_eip1559" ? eip1559PayloadMatches({
-			expected: args.expected,
-			observed: args.observed
-		}) : false;
-		case "tempo_eip2718_calls": return args.observed.kind === "tempo_eip2718_calls" ? tempoPayloadMatches({
-			expected: args.expected,
-			observed: args.observed
-		}) : false;
-		default: return assertNeverFinalizedPayload(args.expected);
-	}
-}
-function resolveEvmFamilyRpcUrl(args) {
-	const targetKey = thresholdEcdsaChainTargetKey(args.chainTarget);
-	const compatible = args.chains.filter((chain) => {
-		const family = chainFamilyFromNetwork(chain.network);
-		if (family !== "evm" && family !== "tempo") return false;
-		return thresholdEcdsaChainTargetKey(thresholdEcdsaChainTargetFromConfig(chain)) === targetKey;
-	});
-	if (compatible.length === 1) {
-		const rpcUrl = String(compatible[0].rpcUrl || "").trim();
-		if (!rpcUrl) throw new Error(`[Tempo capability] missing rpcUrl for ${compatible[0].network} ${targetKey}`);
-		return rpcUrl;
-	}
-	if (compatible.length > 1) {
-		const candidates = compatible.map((chain) => chain.network).join(", ");
-		throw new Error(`[Tempo capability] ambiguous RPC routing for ${targetKey} across [${candidates}]`);
-	}
-	throw new Error(`[Tempo capability] unable to resolve RPC URL for ${targetKey}`);
-}
-function extractManagedNonceReceiptWaitIdentity(signedResult) {
-	const senderRaw = String(signedResult?.managedNonce?.sender || "").trim();
-	const managedNonceSenderAddress = /^0x[0-9a-fA-F]{40}$/.test(senderRaw) ? senderRaw : void 0;
-	let nonceHint;
-	try {
-		const nonceRaw = String(signedResult?.managedNonce?.nonce || "").trim();
-		if (nonceRaw) {
-			const parsed = BigInt(nonceRaw);
-			if (parsed >= 0n) nonceHint = parsed;
-		}
-	} catch {}
-	return {
-		...managedNonceSenderAddress ? { managedNonceSenderAddress } : {},
-		...typeof nonceHint === "bigint" ? { nonceHint } : {}
-	};
-}
-async function verifyFinalizedPayload(args) {
-	const tx = await createEvmClient({ rpcUrl: args.rpcUrl }).getTransactionByHash({ txHash: args.txHash }).catch(() => null);
-	if (!tx) return {
-		kind: "tx_unavailable",
-		expected: args.expected
-	};
-	const observed = observedPayloadFromTx(tx);
-	if (payloadExpectationMatchesObservation({
-		expected: args.expected,
-		observed
-	})) return {
-		kind: "matched",
-		expected: args.expected,
-		observed
-	};
-	return {
-		kind: "mismatch",
-		expected: args.expected,
-		observed
-	};
-}
-async function reportBroadcastFailure(args) {
-	if (!args.broadcastAccepted) {
-		await args.lifecycle.reportBroadcastRejected({
-			walletSession: args.walletSession,
-			signedResult: args.signedResult,
-			error: args.error,
-			options: { onEvent: args.onEvent }
-		});
-		return;
-	}
-	const droppedOrReplacedReason = extractDroppedOrReplacedReason(args.error);
-	if (droppedOrReplacedReason) {
-		await args.lifecycle.reportDroppedOrReplaced({
-			walletSession: args.walletSession,
-			signedResult: args.signedResult,
-			reason: droppedOrReplacedReason,
-			...args.txHash ? { txHash: args.txHash } : {},
-			options: { onEvent: args.onEvent }
-		});
-		return;
-	}
-	try {
-		await args.lifecycle.reconcileNonceLane({
-			walletSession: args.walletSession,
-			signedResult: args.signedResult,
-			options: { onEvent: args.onEvent }
-		});
-	} catch (reconcileError) {
-		if (hasErrorCode(reconcileError, "nonce_lane_blocked") || messageIncludesNonceLaneBlocked(reconcileError)) {
-			await args.lifecycle.reportDroppedOrReplaced({
-				walletSession: args.walletSession,
-				signedResult: args.signedResult,
-				reason: "dropped",
-				...args.txHash ? { txHash: args.txHash } : {},
-				options: { onEvent: args.onEvent }
-			});
-			return;
-		}
-		throw reconcileError;
-	}
-}
-function normalizeTxHashOrThrow(value) {
-	const normalized = String(value || "").trim();
-	if (!/^0x[0-9a-fA-F]{64}$/.test(normalized)) throw new Error(`[Tempo capability] invalid transaction hash from broadcast: ${normalized || "empty"}`);
-	return normalized;
-}
-function assertRawTxHexOrThrow(value) {
-	const normalized = String(value || "").trim();
-	if (!/^0x[0-9a-fA-F]+$/.test(normalized)) throw new Error("[Tempo capability] signed rawTxHex is missing or invalid");
-	return normalized;
-}
-function ensurePayloadExpectation(args) {
-	return args.payloadExpectation ?? payloadExpectationFromRequest(args.request);
-}
-async function executeEvmFamilyTransactionLifecycle(args) {
-	const onEvent = args.input.options?.onEvent;
-	const walletId = toWalletId(args.input.walletSession.walletId);
-	throwIfCancelled(args.input.options?.shouldAbort);
-	let signedResult = null;
-	let txHash;
-	let broadcastAccepted = false;
-	let finalizedReported = false;
-	const emit = (event) => emitLifecycleEvent(onEvent, walletId, event);
-	const forwardSigningEvent = (event) => {
-		if (event.phase === SigningEventPhase.STEP_15_COMPLETED) return;
-		try {
-			onEvent?.(event);
-		} catch {}
-	};
-	try {
-		const request = args.input.request;
-		const rpcUrl = resolveEvmFamilyRpcUrl({
-			chains: args.chains,
-			chainTarget: args.input.chainTarget
-		});
-		const client = createEvmClient({ rpcUrl });
-		signedResult = await args.lifecycle.signEvmFamily({
-			walletSession: args.input.walletSession,
-			request,
-			chainTarget: args.input.chainTarget,
-			options: args.input.options ? {
-				...args.input.options.confirmationConfig ? { confirmationConfig: args.input.options.confirmationConfig } : {},
-				...args.input.options.shouldAbort ? { shouldAbort: args.input.options.shouldAbort } : {},
-				...onEvent ? { onEvent: forwardSigningEvent } : {}
-			} : void 0
-		});
-		throwIfCancelled(args.input.options?.shouldAbort);
-		emit({
-			phase: SigningEventPhase.STEP_12_BROADCAST_STARTED,
-			status: "running",
-			interaction: {
-				kind: "none",
-				overlay: "none"
-			}
-		});
-		const rawTxHex = assertRawTxHexOrThrow(signedResult.rawTxHex);
-		args.lifecycle.onBroadcastStarted({
-			walletSession: args.input.walletSession,
-			signedResult
-		});
-		txHash = normalizeTxHashOrThrow(await client.request({
-			method: "eth_sendRawTransaction",
-			params: [rawTxHex]
-		}));
-		await args.lifecycle.reportBroadcastAccepted({
-			walletSession: args.input.walletSession,
-			signedResult,
-			txHash,
-			options: { ...onEvent ? { onEvent } : {} }
-		});
-		broadcastAccepted = true;
-		emit({
-			phase: SigningEventPhase.STEP_13_NONCE_RECONCILE_STARTED,
-			status: "running",
-			message: "Waiting for transaction finalization",
-			interaction: {
-				kind: "none",
-				overlay: "none"
-			},
-			data: { txHash }
-		});
-		const abortController = new AbortController();
-		let abortInterval = null;
-		if (typeof args.input.options?.shouldAbort === "function") abortInterval = setInterval(() => {
-			if (!args.input.options?.shouldAbort?.()) return;
-			abortController.abort(createCancelledError());
-		}, 100);
-		const finalizationTimeoutMs = Math.max(1, Math.floor(Number(args.input.finalization?.timeoutMs ?? DEFAULT_FINALIZATION_TIMEOUT_MS) || 0));
-		const finalizationPollIntervalMs = Math.max(1, Math.floor(Number(args.input.finalization?.pollIntervalMs ?? DEFAULT_FINALIZATION_POLL_INTERVAL_MS) || 0));
-		const finalizationConfirmations = Math.max(1, Math.floor(Number(args.input.finalization?.confirmations ?? DEFAULT_FINALIZATION_CONFIRMATIONS) || 0));
-		const receiptWaitIdentity = extractManagedNonceReceiptWaitIdentity(signedResult);
-		const receipt = await withLifecycleTimeout({
-			promise: client.waitForTransactionReceipt({
-				txHash,
-				timeoutMs: finalizationTimeoutMs,
-				pollIntervalMs: finalizationPollIntervalMs,
-				confirmations: finalizationConfirmations,
-				maxFeePerGasHint: request.tx.maxFeePerGas,
-				signal: abortController.signal,
-				...receiptWaitIdentity.managedNonceSenderAddress ? { transactionSenderAddress: receiptWaitIdentity.managedNonceSenderAddress } : {},
-				...typeof receiptWaitIdentity.nonceHint === "bigint" ? { nonceHint: receiptWaitIdentity.nonceHint } : {}
-			}).finally(() => {
-				if (abortInterval) {
-					clearInterval(abortInterval);
-					abortInterval = null;
-				}
-				abortController.abort(/* @__PURE__ */ new Error("finalization wait settled"));
-			}),
-			timeoutMs: finalizationTimeoutMs + FINALIZATION_WATCHDOG_GRACE_MS,
-			message: `Timed out waiting for transaction finalization after ${finalizationTimeoutMs.toString()}ms`,
-			onTimeout: () => {
-				abortController.abort(createLifecycleTimeoutError("Transaction finalization watchdog timed out"));
-			}
-		});
-		const status = normalizeToken(receipt.status);
-		if (status && status !== "0x1" && status !== "0x01") {
-			await args.lifecycle.reportFinalized({
-				walletSession: args.input.walletSession,
-				signedResult,
-				txHash,
-				receiptStatus: "reverted",
-				options: { ...onEvent ? { onEvent } : {} }
-			});
-			finalizedReported = true;
-			const reverted = /* @__PURE__ */ new Error(`Transaction reverted with receipt status ${String(receipt.status || "unknown")}`);
-			reverted.code = "tx_reverted";
-			reverted.txHash = txHash;
-			throw reverted;
-		}
-		const payloadExpectation = ensurePayloadExpectation(args.input);
-		const payloadVerification = await verifyFinalizedPayload({
-			rpcUrl,
-			txHash,
-			expected: payloadExpectation
-		});
-		if (payloadVerification.kind === "mismatch") {
-			const mismatchError = /* @__PURE__ */ new Error(`Finalized transaction payload mismatch for ${txHash}.`);
-			mismatchError.code = "tx_payload_mismatch";
-			mismatchError.details = payloadVerification;
-			throw mismatchError;
-		}
-		await args.lifecycle.reportFinalized({
-			walletSession: args.input.walletSession,
-			signedResult,
-			txHash,
-			receiptStatus: "success",
-			options: { ...onEvent ? { onEvent } : {} }
-		});
-		finalizedReported = true;
-		emit({
-			phase: SigningEventPhase.STEP_13_RECEIPT_FINALIZED,
-			status: "succeeded",
-			interaction: {
-				kind: "none",
-				overlay: "none"
-			},
-			data: { txHash }
-		});
-		if (typeof args.input.postFinalizationCheck === "function") {
-			emit({
-				phase: SigningEventPhase.STEP_14_APP_STATE_SYNC_STARTED,
-				status: "running",
-				interaction: {
-					kind: "none",
-					overlay: "none"
-				},
-				data: { txHash }
-			});
-			try {
-				await args.input.postFinalizationCheck();
-			} catch (postFinalizationError) {
-				const reason = postFinalizationError instanceof Error ? postFinalizationError.message : String(postFinalizationError || "");
-				const normalized = /* @__PURE__ */ new Error(`Post-finalization state verification failed for ${txHash}: ${reason || "unknown error"}`);
-				normalized.code = "post_finalization_state_mismatch";
-				normalized.txHash = txHash;
-				normalized.details = {
-					...postFinalizationError instanceof Error && postFinalizationError.message ? { message: postFinalizationError.message } : {},
-					originalError: postFinalizationError
-				};
-				throw normalized;
-			}
-			emit({
-				phase: SigningEventPhase.STEP_14_APP_STATE_SYNC_SUCCEEDED,
-				status: "succeeded",
-				interaction: {
-					kind: "none",
-					overlay: "none"
-				},
-				data: { txHash }
-			});
-		}
-		emit({
-			phase: SigningEventPhase.STEP_15_COMPLETED,
-			status: "succeeded",
-			interaction: {
-				kind: "none",
-				overlay: "none"
-			},
-			data: {
-				operation: "execute",
-				txHash
-			}
-		});
-		return {
-			txHash,
-			signedResult,
-			payloadVerification
-		};
-	} catch (error) {
-		try {
-			const stage = !signedResult ? "sign" : !broadcastAccepted ? "broadcast" : finalizedReported ? "post_finalization" : "finalization";
-			console.warn("[EvmFamilyLifecycle][failure]", {
-				stage,
-				walletId,
-				requestChain: args.input.request.chain,
-				requestKind: args.input.request.kind,
-				requestChainId: args.input.request.tx.chainId,
-				chainTarget: args.input.chainTarget,
-				signed: Boolean(signedResult),
-				...signedResult?.managedNonce ? { managedNonce: {
-					chain: signedResult.managedNonce.chainTarget.kind,
-					networkKey: signedResult.managedNonce.chainTarget.networkSlug,
-					chainId: signedResult.managedNonce.chainTarget.chainId,
-					sender: signedResult.managedNonce.sender,
-					nonce: signedResult.managedNonce.nonce.toString(),
-					...signedResult.managedNonce.nonceKey != null ? { nonceKey: signedResult.managedNonce.nonceKey.toString() } : {}
-				} } : {},
-				broadcastAccepted,
-				finalizedReported,
-				...txHash ? { txHash } : {},
-				error: errorDiagnostic(error)
-			});
-		} catch {}
-		if (!finalizedReported && signedResult) await withLifecycleTimeout({
-			promise: reportBroadcastFailure({
-				lifecycle: args.lifecycle,
-				walletSession: args.input.walletSession,
-				signedResult,
-				error,
-				broadcastAccepted,
-				...txHash ? { txHash } : {},
-				...onEvent ? { onEvent } : {}
-			}),
-			timeoutMs: resolveBestEffortCleanupTimeoutMs(args.input.finalization?.timeoutMs),
-			message: "Timed out during best-effort nonce cleanup after EVM-family signing failure"
-		}).catch(() => null);
-		throw error;
-	}
-}
-//#endregion
-export { executeEvmFamilyTransactionLifecycle, resolveEvmFamilyRpcUrl, withResolvedChainId };
-
-//# sourceMappingURL=executeEvmFamilyTransaction.js.map

package/dist/esm/react/SeamsWeb/operations/tempo/feeTokenPreference.js

@@ -1,67 +0,0 @@
-import { resolveEvmFamilyRpcUrl } from "./executeEvmFamilyTransaction.js";
-import { buildTempoSetUserTokenRequest, parseTempoEvmAddress, readTempoFeeTokenPreference, validateTempoFeeToken } from "../../../core/signingEngine/chains/tempo/feeToken.js";
-//#region src/SeamsWeb/operations/tempo/feeTokenPreference.ts
-const DEFAULT_SET_USER_TOKEN_GAS_LIMIT = 1000000n;
-function resolveTempoRpcUrl(chains, chainTarget) {
-	return resolveEvmFamilyRpcUrl({
-		chains,
-		chainTarget
-	});
-}
-async function getTempoFeeTokenPreference(chains, args) {
-	return await readTempoFeeTokenPreference({
-		rpcUrl: resolveTempoRpcUrl(chains, args.chainTarget),
-		account: parseTempoEvmAddress("account address", args.account),
-		...args.timeoutMs !== void 0 ? { timeoutMs: args.timeoutMs } : {}
-	});
-}
-async function validateConfiguredTempoFeeToken(chains, args) {
-	return await validateTempoFeeToken({
-		rpcUrl: resolveTempoRpcUrl(chains, args.chainTarget),
-		feeToken: parseTempoEvmAddress("fee token address", args.feeToken),
-		...args.timeoutMs !== void 0 ? { timeoutMs: args.timeoutMs } : {}
-	});
-}
-async function verifyTempoFeeTokenPreference(args) {
-	const observed = await readTempoFeeTokenPreference(args);
-	if (observed?.toLowerCase() === args.feeToken.toLowerCase()) return;
-	throw new Error(`[Tempo capability] fee-token preference mismatch: expected ${args.feeToken}, received ${observed ?? "unset"}`);
-}
-async function setTempoFeeTokenPreference(context, args) {
-	const rpcUrl = resolveTempoRpcUrl(context.chains, args.chainTarget);
-	const account = parseTempoEvmAddress("account address", args.account);
-	const feeToken = parseTempoEvmAddress("fee token address", args.feeToken);
-	const validation = await validateTempoFeeToken({
-		rpcUrl,
-		feeToken
-	});
-	if (validation.kind === "invalid") throw new Error(`[Tempo capability] invalid fee token: ${validation.reason}`);
-	const request = buildTempoSetUserTokenRequest({
-		chainId: args.chainTarget.chainId,
-		feeToken,
-		maxPriorityFeePerGas: args.feeCaps.maxPriorityFeePerGas,
-		maxFeePerGas: args.feeCaps.maxFeePerGas,
-		gasLimit: args.gasLimit ?? DEFAULT_SET_USER_TOKEN_GAS_LIMIT
-	});
-	return await context.execute({
-		walletSession: args.walletSession,
-		chainTarget: args.chainTarget,
-		request,
-		payloadExpectation: {
-			kind: "evm_eip1559",
-			to: request.tx.to ?? null,
-			input: request.tx.data ?? "0x"
-		},
-		...args.finalization ? { finalization: args.finalization } : {},
-		...args.options ? { options: args.options } : {},
-		postFinalizationCheck: verifyTempoFeeTokenPreference.bind(null, {
-			rpcUrl,
-			account,
-			feeToken
-		})
-	});
-}
-//#endregion
-export { getTempoFeeTokenPreference, setTempoFeeTokenPreference, validateConfiguredTempoFeeToken };
-
-//# sourceMappingURL=feeTokenPreference.js.map