@aori/mega-swap-widget 0.1.0

package/dist/chunk-ARMW5POL.js

@@ -0,0 +1,3082 @@
+"use client";
+import {
+  require_main
+} from "./chunk-LTA7IG3J.js";
+import {
+  useSwapFormContext,
+  useWidgetSwapUIStore
+} from "./chunk-TMC4SUEV.js";
+import {
+  ChainIcon_default,
+  Checkmark,
+  DropdownIcon,
+  LoadingSpinner_default,
+  NATIVE_ASSET_ADDRESS,
+  RedoAnimation,
+  RedoIcon,
+  TokenImage_default,
+  UserIcon,
+  XAnimation,
+  balanceKeys,
+  checkedAddress,
+  fetchSwapBalances,
+  formatNumber,
+  getChainConfig,
+  getChainIdForKey,
+  getKeyForChainId,
+  getNextReviewStep,
+  getViemChainById,
+  getVtApiUrl,
+  getVtHeaders,
+  isAddress,
+  isReviewStepPast,
+  sleep,
+  toBigInt,
+  useDebounce,
+  useEnabledChainIds,
+  useWidgetConfig
+} from "./chunk-6Q7MSCKS.js";
+import {
+  useWalletState
+} from "./chunk-7AWG6OWF.js";
+import {
+  __toESM
+} from "./chunk-GGM3MDFM.js";
+
+// src/hooks/useBalanceEventListener.ts
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect, useRef } from "react";
+function getRefetchDelay(chainIds) {
+  const MIN_DELAY = 1e3;
+  const MAX_DELAY = 5e3;
+  const BUFFER = 1e3;
+  if (chainIds.length === 0) return 5e3;
+  const maxBlockTime = Math.max(
+    ...chainIds.map((id) => getChainConfig(id)?.blockTimeMs ?? 2e3)
+  );
+  return Math.min(MAX_DELAY, Math.max(MIN_DELAY, maxBlockTime * 2 + BUFFER));
+}
+var useBalanceEventListener = () => {
+  const { address: userAddress } = useWalletState();
+  const availableChainIds = useEnabledChainIds();
+  const queryClient = useQueryClient();
+  const pendingTimerRef = useRef(null);
+  const mountedRef = useRef(true);
+  const triggerBalanceUpdate = useCallback(
+    (event) => {
+      if (!userAddress) return;
+      const chainIds = [...new Set(event.tokens.map((t) => t.asset.chainId))];
+      const delay = getRefetchDelay(chainIds);
+      if (pendingTimerRef.current) {
+        clearTimeout(pendingTimerRef.current);
+        pendingTimerRef.current = null;
+      }
+      pendingTimerRef.current = setTimeout(async () => {
+        pendingTimerRef.current = null;
+        if (!mountedRef.current) return;
+        try {
+          const tokens = event.tokens.map((t) => ({
+            chainId: t.asset.chainId,
+            tokenAddress: t.asset.address
+          }));
+          const swapResult = await fetchSwapBalances(userAddress, tokens);
+          if (swapResult.balances.length === 0) return;
+          if (event.tokens.length >= 2) {
+            const base = event.tokens[0].asset;
+            const quote = event.tokens[1].asset;
+            const swapKey = balanceKeys.swap(
+              userAddress,
+              base.chainId,
+              base.address,
+              quote.chainId,
+              quote.address
+            );
+            queryClient.setQueryData(swapKey, swapResult);
+          }
+          const bulkKey = balanceKeys.bulk(userAddress, availableChainIds);
+          const existingBulk = queryClient.getQueryData(bulkKey);
+          if (existingBulk) {
+            const updatedBalances = existingBulk.balances.map((existing) => {
+              const updated = swapResult.balances.find(
+                (b) => b.chainId === existing.chainId && b.token.toLowerCase() === existing.token.toLowerCase()
+              );
+              return updated ?? existing;
+            });
+            for (const newBalance of swapResult.balances) {
+              if (!updatedBalances.some(
+                (b) => b.chainId === newBalance.chainId && b.token.toLowerCase() === newBalance.token.toLowerCase()
+              )) updatedBalances.push(newBalance);
+            }
+            for (const eventToken of event.tokens) {
+              const inResult = swapResult.balances.some(
+                (b) => b.chainId === eventToken.asset.chainId && b.token.toLowerCase() === eventToken.asset.address.toLowerCase()
+              );
+              if (!inResult) {
+                const idx = updatedBalances.findIndex(
+                  (b) => b.chainId === eventToken.asset.chainId && b.token.toLowerCase() === eventToken.asset.address.toLowerCase()
+                );
+                if (idx !== -1) {
+                  updatedBalances[idx] = { ...updatedBalances[idx], balance: "0", shiftedBalance: "0" };
+                }
+              }
+            }
+            queryClient.setQueryData(bulkKey, { balances: updatedBalances });
+          }
+        } catch {
+        }
+      }, delay);
+    },
+    [userAddress, availableChainIds, queryClient]
+  );
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      if (pendingTimerRef.current) {
+        clearTimeout(pendingTimerRef.current);
+        pendingTimerRef.current = null;
+      }
+    };
+  }, []);
+  return { triggerBalanceUpdate };
+};
+var BalanceEventEmitter = class extends EventTarget {
+  emit(event) {
+    this.dispatchEvent(new CustomEvent("balance-update", { detail: event }));
+  }
+};
+var balanceEventEmitter = new BalanceEventEmitter();
+var useEmitBalanceEvent = () => {
+  return (event) => balanceEventEmitter.emit(event);
+};
+var useBalanceEventSubscription = () => {
+  const { triggerBalanceUpdate } = useBalanceEventListener();
+  useEffect(() => {
+    const handler = (event) => {
+      triggerBalanceUpdate(event.detail);
+    };
+    balanceEventEmitter.addEventListener("balance-update", handler);
+    return () => balanceEventEmitter.removeEventListener("balance-update", handler);
+  }, [triggerBalanceUpdate]);
+};
+
+// src/providers/RfqProvider.tsx
+import {
+  createContext,
+  useCallback as useCallback2,
+  useContext,
+  useEffect as useEffect2,
+  useMemo,
+  useRef as useRef2,
+  useState
+} from "react";
+import { formatUnits, parseUnits } from "viem";
+import { jsx } from "react/jsx-runtime";
+var RfqContext = createContext(void 0);
+var POLLING_INTERVAL_MS = 1e4;
+var STALE_WINDOW_MS = 3e4;
+var TYPING_SETTLE_DELAY_MS = 1e3;
+var ROUTING_ERROR_THRESHOLD = 2;
+function selectQuote(quotes) {
+  const aori = quotes.find((q) => q.routeSteps?.[0]?.type === "AORI_V1");
+  return aori ?? quotes[0];
+}
+var RfqProvider = ({
+  children,
+  recipient: recipientProp
+}) => {
+  const { address: userAddress } = useWalletState();
+  const recipient = recipientProp || userAddress;
+  const [status, setStatus] = useState("idle");
+  const [inputState, setInputState] = useState("idle");
+  const [rfqQuote, setRfqQuote] = useState(null);
+  const [error, setError] = useState(null);
+  const [liquidityError, setLiquidityError] = useState(false);
+  const [routingError, setRoutingError] = useState(false);
+  const [sizeCapError, setSizeCapError] = useState(false);
+  const sessionIdRef = useRef2(null);
+  const lastParamsRef = useRef2(null);
+  const pollingIntervalRef = useRef2(null);
+  const staleTimerRef = useRef2(null);
+  const typingTimerRef = useRef2(null);
+  const latestRequestId = useRef2(0);
+  const lastRequestAtRef = useRef2(0);
+  const lastStartAtRef = useRef2(0);
+  const hasQuoteRef = useRef2(false);
+  const routingErrorsRef = useRef2(/* @__PURE__ */ new Map());
+  const clearTimers = useCallback2(() => {
+    if (pollingIntervalRef.current) clearTimeout(pollingIntervalRef.current);
+    if (staleTimerRef.current) clearTimeout(staleTimerRef.current);
+    if (typingTimerRef.current) clearTimeout(typingTimerRef.current);
+    pollingIntervalRef.current = null;
+    staleTimerRef.current = null;
+    typingTimerRef.current = null;
+  }, []);
+  const stop = useCallback2(() => {
+    clearTimers();
+    sessionIdRef.current = null;
+    latestRequestId.current = 0;
+    setStatus(() => hasQuoteRef.current ? "fresh" : "idle");
+  }, [clearTimers]);
+  const clear = useCallback2(() => {
+    stop();
+    lastParamsRef.current = null;
+    setRfqQuote(null);
+    setError(null);
+    setLiquidityError(false);
+    setRoutingError(false);
+    setSizeCapError(false);
+    routingErrorsRef.current.clear();
+    setStatus("idle");
+    setInputState("idle");
+  }, [stop]);
+  const scheduleStale = useCallback2((receivedAt) => {
+    if (!receivedAt) return;
+    if (staleTimerRef.current) clearTimeout(staleTimerRef.current);
+    const delay = Math.max(0, receivedAt + STALE_WINDOW_MS - Date.now());
+    staleTimerRef.current = setTimeout(() => {
+      setStatus((prev) => prev === "idle" ? "idle" : "stale");
+    }, delay);
+  }, []);
+  const requestQuoteOnce = useCallback2(
+    async (params, sessionId) => {
+      const { inputToken, outputToken, inputAmount, setOutputAmount } = params;
+      if (!inputToken || !outputToken || !inputAmount || parseFloat(inputAmount) <= 0)
+        return;
+      const now = Date.now();
+      if (now - (lastRequestAtRef.current || 0) < POLLING_INTERVAL_MS - 10)
+        return;
+      const requestId = ++latestRequestId.current;
+      try {
+        if (!inputToken?.decimals || !outputToken?.decimals) return;
+        const srcChainKey = getKeyForChainId(inputToken.chainId) || getChainConfig(inputToken.chainId)?.key || "";
+        const dstChainKey = getKeyForChainId(outputToken.chainId) || getChainConfig(outputToken.chainId)?.key || "";
+        if (!srcChainKey || !dstChainKey) throw new Error("Unknown chain");
+        const normalizedAmount = parseUnits(
+          inputAmount.toString(),
+          inputToken.decimals
+        ).toString();
+        const body = {
+          srcChainKey,
+          dstChainKey,
+          srcTokenAddress: checkedAddress(inputToken.address),
+          dstTokenAddress: checkedAddress(outputToken.address),
+          amount: normalizedAmount,
+          srcWalletAddress: userAddress || "0x0000000000000000000000000000000000000000",
+          dstWalletAddress: recipient || userAddress || "0x0000000000000000000000000000000000000000",
+          options: {
+            amountType: "EXACT_SRC_AMOUNT",
+            feeTolerance: { type: "PERCENT", amount: 2 }
+          }
+        };
+        lastRequestAtRef.current = Date.now();
+        const res = await fetch(`${getVtApiUrl()}/quotes`, {
+          method: "POST",
+          headers: getVtHeaders(),
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(15e3)
+        });
+        if (!res.ok) {
+          const errBody = await res.json().catch(() => ({}));
+          const msg = errBody?.message || res.statusText;
+          throw Object.assign(new Error(msg), { status: res.status });
+        }
+        const data = await res.json();
+        if (requestId !== latestRequestId.current || sessionIdRef.current !== sessionId)
+          return;
+        const quotes = data.quotes ?? [];
+        const selected = selectQuote(quotes);
+        if (!selected) throw Object.assign(new Error("No quotes returned"), { emptyQuotes: true });
+        const formattedOutput = Number(
+          formatUnits(toBigInt(selected.dstAmount), outputToken.decimals)
+        );
+        if (typeof setOutputAmount === "function") setOutputAmount(formattedOutput);
+        selected._receivedAt = Date.now();
+        setRfqQuote(selected);
+        setError(null);
+        setLiquidityError(false);
+        setStatus("fresh");
+        scheduleStale(selected._receivedAt);
+        if (sessionId) routingErrorsRef.current.delete(sessionId);
+      } catch (e) {
+        if (requestId !== latestRequestId.current || sessionIdRef.current !== sessionId)
+          return;
+        const statusCode = e?.status;
+        const errorMessage = e instanceof Error ? e.message : "";
+        const isEmptyQuotes = !!e?.emptyQuotes;
+        if ((statusCode === 400 || isEmptyQuotes || errorMessage.includes("Quote request failed")) && sessionId) {
+          const current = routingErrorsRef.current.get(sessionId) || 0;
+          const newCount = current + 1;
+          routingErrorsRef.current.set(sessionId, newCount);
+          if (newCount >= ROUTING_ERROR_THRESHOLD) {
+            setRoutingError(true);
+            clearTimers();
+            sessionIdRef.current = null;
+            return;
+          }
+        }
+        if (errorMessage.toLowerCase().includes("order cap exceeded")) {
+          setSizeCapError(true);
+          clearTimers();
+          sessionIdRef.current = null;
+          return;
+        }
+        if (errorMessage.toLowerCase().includes("insufficient executor balance")) {
+          setLiquidityError(true);
+          clearTimers();
+          sessionIdRef.current = null;
+          return;
+        }
+        setError(e instanceof Error ? e.message : "Unknown error");
+      }
+    },
+    [userAddress, recipient, scheduleStale, clearTimers]
+  );
+  const startPolling = useCallback2(
+    (params, sessionId) => {
+      clearTimers();
+      lastParamsRef.current = params;
+      lastRequestAtRef.current = 0;
+      routingErrorsRef.current.delete(sessionId);
+      setLiquidityError(false);
+      setRoutingError(false);
+      setSizeCapError(false);
+      setError(null);
+      setStatus("polling");
+      const poll = async () => {
+        if (sessionIdRef.current !== sessionId) return;
+        await requestQuoteOnce(params, sessionId);
+        if (sessionIdRef.current !== sessionId) return;
+        pollingIntervalRef.current = setTimeout(poll, POLLING_INTERVAL_MS);
+      };
+      poll();
+    },
+    [clearTimers, requestQuoteOnce]
+  );
+  const ensureForParams = useCallback2(
+    (params) => {
+      if (!params?.inputToken || !params?.outputToken || !params?.inputAmount || parseFloat(params.inputAmount) <= 0) {
+        stop();
+        return;
+      }
+      const prev = lastParamsRef.current;
+      const sameParams = prev && prev.inputToken?.address === params.inputToken?.address && prev.inputToken?.chainId === params.inputToken?.chainId && prev.outputToken?.address === params.outputToken?.address && prev.outputToken?.chainId === params.outputToken?.chainId && prev.inputAmount === params.inputAmount;
+      if (sameParams && sessionIdRef.current) return;
+      const now = Date.now();
+      if (now - lastStartAtRef.current < 100) return;
+      lastStartAtRef.current = now;
+      const newSessionId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+      sessionIdRef.current = newSessionId;
+      startPolling(params, newSessionId);
+    },
+    [startPolling, stop]
+  );
+  const handleInputChange = useCallback2(
+    ({ amount, inputToken, outputToken, setOutputAmount }) => {
+      setOutputAmount(null);
+      if (typingTimerRef.current) clearTimeout(typingTimerRef.current);
+      if (!amount || amount === 0) {
+        setInputState("idle");
+        stop();
+        setRfqQuote(null);
+        setError(null);
+        setLiquidityError(false);
+        setRoutingError(false);
+        setSizeCapError(false);
+      } else {
+        setInputState("typing");
+        stop();
+        setRfqQuote(null);
+        setLiquidityError(false);
+        setRoutingError(false);
+        setSizeCapError(false);
+        setError(null);
+        typingTimerRef.current = setTimeout(() => {
+          setInputState("settled");
+          if (inputToken && outputToken && amount > 0) {
+            ensureForParams({
+              inputToken,
+              outputToken,
+              inputAmount: amount.toString(),
+              setOutputAmount
+            });
+          }
+        }, TYPING_SETTLE_DELAY_MS);
+      }
+    },
+    [stop, ensureForParams]
+  );
+  const refresh = useCallback2(() => {
+    const params = lastParamsRef.current;
+    if (!params) return;
+    setRfqQuote(null);
+    const newSessionId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    sessionIdRef.current = newSessionId;
+    setStatus("refreshing");
+    if (typeof params.setOutputAmount === "function")
+      params.setOutputAmount(null);
+    startPolling(params, newSessionId);
+  }, [startPolling]);
+  useEffect2(() => {
+    hasQuoteRef.current = !!rfqQuote;
+  }, [rfqQuote]);
+  useEffect2(() => () => clearTimers(), [clearTimers]);
+  const contextValue = useMemo(
+    () => ({
+      status,
+      inputState,
+      rfqQuote,
+      error,
+      liquidityError,
+      routingError,
+      sizeCapError,
+      ensureForParams,
+      stop,
+      refresh,
+      clear,
+      handleInputChange
+    }),
+    [
+      status,
+      inputState,
+      rfqQuote,
+      error,
+      liquidityError,
+      routingError,
+      sizeCapError,
+      ensureForParams,
+      stop,
+      refresh,
+      clear,
+      handleInputChange
+    ]
+  );
+  return /* @__PURE__ */ jsx(RfqContext.Provider, { value: contextValue, children });
+};
+var useRfq = () => {
+  const context = useContext(RfqContext);
+  if (context === void 0)
+    throw new Error("useRfq must be used within an RfqProvider");
+  return context;
+};
+
+// src/wallet/WalletModalContext.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+var WalletModalContext = createContext2({
+  openConnectModal: () => {
+  }
+});
+var useWalletModal = () => useContext2(WalletModalContext);
+
+// src/components/AssetAmountInput.tsx
+import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef3, useState as useState2 } from "react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var MAX_INPUT_LENGTH = 20;
+var AssetAmountInput = ({
+  side,
+  asset,
+  otherAsset,
+  isPlacingOrder,
+  isWrappingPair,
+  isUnwrappingPair
+}) => {
+  const { baseAmount, quoteAmount, setBaseAmount, setQuoteAmount } = useSwapFormContext();
+  const { amountInputVariant, hideAmountInputSymbol, widgetType } = useWidgetConfig();
+  const isCompactMode = widgetType === "compact";
+  const [setAssetAmount, setOtherAssetAmount] = side === "base" ? [setBaseAmount, setQuoteAmount] : [setQuoteAmount, setBaseAmount];
+  const disabled = !asset || side === "quote" || isPlacingOrder;
+  const maxFontSize = isCompactMode ? 32 : amountInputVariant === "default" ? 64 : 32;
+  const [fontSize, setFontSize] = useState2(maxFontSize);
+  const [inputValue, setInputValue] = useState2("");
+  const containerRef = useRef3(null);
+  const measureRef = useRef3(null);
+  const symbolRef = useRef3(null);
+  const inputRef = useRef3(null);
+  const placeholderText = "USD";
+  const assetAmount = side === "base" ? baseAmount : quoteAmount;
+  const [isMounted, setIsMounted] = useState2(false);
+  const adjustFontSize = useCallback3(() => {
+    if (amountInputVariant !== "default") {
+      setFontSize(maxFontSize);
+      return;
+    }
+    if (!containerRef.current || !measureRef.current || !symbolRef.current)
+      return;
+    const containerWidth = containerRef.current.offsetWidth;
+    const padding = 20;
+    let newFontSize = maxFontSize;
+    while (newFontSize > 20) {
+      measureRef.current.style.fontSize = `${newFontSize}px`;
+      symbolRef.current.style.fontSize = `${newFontSize}px`;
+      const totalWidth = measureRef.current.offsetWidth + symbolRef.current.offsetWidth + padding;
+      if (totalWidth <= containerWidth) break;
+      newFontSize -= 1;
+    }
+    setFontSize(newFontSize);
+  }, [amountInputVariant, maxFontSize]);
+  const handleKeyDown = useCallback3(
+    (e) => {
+      if (e.key === "." && inputValue.includes(".")) e.preventDefault();
+    },
+    [inputValue]
+  );
+  const handleAmountChange = useCallback3(
+    (e) => {
+      let newValue = e.target.value;
+      if (newValue === ".") newValue = "0.";
+      if (!/^\d*\.?\d*$/.test(newValue)) return;
+      if ((newValue.match(/\./g) || []).length > 1) return;
+      if (newValue.length > 1 && newValue[0] === "0" && newValue[1] !== ".") {
+        newValue = newValue.replace(/^0+/, "") || "0";
+      }
+      if (asset?.decimals !== void 0 && newValue.includes(".")) {
+        const [, fracPart] = newValue.split(".");
+        if (fracPart && fracPart.length > asset.decimals) return;
+      }
+      if (newValue.length > MAX_INPUT_LENGTH) return;
+      setInputValue(newValue);
+      const newAmount = parseFloat(newValue);
+      if (newValue !== inputValue) {
+        if (newValue === "" || newValue === "0." || newValue.endsWith(".")) {
+          setAssetAmount(null);
+          if (side === "base") setOtherAssetAmount(null);
+        } else if (!Number.isNaN(newAmount) && newAmount >= 0) {
+          setAssetAmount(newAmount);
+        }
+        if (side === "base") setQuoteAmount(null);
+        if (isUnwrappingPair || isWrappingPair) setQuoteAmount(newAmount || 0);
+      }
+    },
+    [
+      inputValue,
+      setAssetAmount,
+      side,
+      setQuoteAmount,
+      asset?.decimals,
+      setOtherAssetAmount,
+      isUnwrappingPair,
+      isWrappingPair
+    ]
+  );
+  useEffect3(() => {
+    const formatAmount = (amount) => {
+      if (amount === null) return "";
+      const decimals = asset?.decimals;
+      if (decimals === void 0) return "";
+      let asString = amount.toString();
+      if (/e/i.test(asString)) {
+        asString = Number(amount).toLocaleString("en-US", {
+          useGrouping: false,
+          maximumFractionDigits: decimals
+        });
+      }
+      if (asString.includes(".")) {
+        const [intPart, fracPartRaw] = asString.split(".");
+        const fracPart = fracPartRaw.slice(0, decimals);
+        return fracPart ? `${intPart}.${fracPart}` : intPart;
+      }
+      return asString;
+    };
+    if (assetAmount === null) {
+      const isTypingDecimal = inputValue === "0." || inputValue !== "" && inputValue.endsWith(".");
+      if (!isTypingDecimal) setInputValue("");
+      return;
+    }
+    const isUserTyping = !disabled && (inputValue.endsWith(".") || inputValue.match(/\.\d*0$/) || inputValue === "0" || inputValue === "0.");
+    if (isUserTyping && inputValue !== "") return;
+    const currentNumericValue = parseFloat(inputValue) || 0;
+    if (inputValue === "" || Math.abs(currentNumericValue - assetAmount) > 1e-10) {
+      setInputValue(formatAmount(assetAmount));
+    }
+  }, [assetAmount, asset?.decimals, inputValue, disabled]);
+  useEffect3(() => {
+    adjustFontSize();
+  }, [inputValue, adjustFontSize]);
+  useEffect3(() => {
+    setIsMounted(true);
+  }, []);
+  useEffect3(() => {
+    if (isMounted) adjustFontSize();
+  }, [isMounted, adjustFontSize]);
+  useEffect3(() => {
+    if (measureRef.current && inputRef.current) {
+      inputRef.current.style.width = `${measureRef.current.offsetWidth}px`;
+    }
+  }, [inputValue]);
+  useEffect3(() => {
+    if (!isMounted) return;
+    const resizeObserver = new ResizeObserver(() => {
+      if (isMounted) adjustFontSize();
+    });
+    if (containerRef.current) resizeObserver.observe(containerRef.current);
+    return () => resizeObserver.disconnect();
+  }, [isMounted, adjustFontSize]);
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      ref: containerRef,
+      style: {
+        fontSize: `${fontSize}px`,
+        transition: "font-size 0.05s ease-in-out"
+      },
+      className: `mt-2 box-border flex ${isCompactMode ? amountInputVariant === "normal" ? "h-12 my-1" : "h-10 my-0.5" : amountInputVariant === "normal" ? "h-12 my-1" : "h-20 my-1"} w-full flex-row items-center ${disabled ? "cursor-default" : "cursor-text"}`,
+      onClick: () => inputRef.current?.focus(),
+      children: /* @__PURE__ */ jsxs("div", { className: "relative flex w-full items-center", children: [
+        /* @__PURE__ */ jsx2("label", { htmlFor: `${side}Amount`, className: "sr-only", children: side === "base" ? "Input token amount" : "Output token amount" }),
+        /* @__PURE__ */ jsx2(
+          "input",
+          {
+            ref: inputRef,
+            type: "text",
+            inputMode: "decimal",
+            placeholder: "0",
+            autoComplete: "off",
+            id: `${side}Amount`,
+            value: inputValue,
+            onWheel: (e) => e.target.blur(),
+            onKeyDown: handleKeyDown,
+            onChange: handleAmountChange,
+            style: {
+              transition: "width 0.15s ease-in-out",
+              color: disabled ? "var(--widget-foreground)" : "var(--widget-foreground)",
+              WebkitTextFillColor: disabled ? "var(--widget-foreground)" : "var(--widget-foreground)",
+              opacity: disabled ? 0.4 : 1
+            },
+            className: "flex min-w-[45px] whitespace-nowrap bg-transparent placeholder:opacity-50",
+            disabled
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          "span",
+          {
+            style: { transition: "width 0.15s ease-in-out" },
+            ref: measureRef,
+            className: "pointer-events-none absolute flex whitespace-nowrap invisible",
+            children: inputValue || 0
+          }
+        ),
+        !hideAmountInputSymbol && amountInputVariant !== "normal" && /* @__PURE__ */ jsx2(
+          "span",
+          {
+            ref: symbolRef,
+            className: "ml-2 font-light uppercase",
+            style: {
+              color: "var(--widget-foreground)",
+              opacity: 0.5,
+              fontSize: `${fontSize}px`
+            },
+            children: asset?.symbol ? asset.symbol.length > 6 ? `${asset.symbol.slice(0, 6)}...` : asset.symbol : placeholderText
+          }
+        ),
+        (hideAmountInputSymbol || amountInputVariant === "normal") && /* @__PURE__ */ jsx2("span", { ref: symbolRef, className: "hidden" })
+      ] })
+    }
+  );
+};
+var AssetAmountInput_default = AssetAmountInput;
+
+// src/components/AssetSelection.tsx
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var AssetSelection = ({
+  toggle,
+  side,
+  asset,
+  isPlacingOrder
+}) => {
+  const { baseBalance, quoteBalance } = useSwapFormContext();
+  const { tokenDisplay, tokenBadgeOrientation, widgetType } = useWidgetConfig();
+  const isCompactMode = widgetType === "compact";
+  const cardHeight = isCompactMode ? "h-10" : "h-12";
+  const iconSize = isCompactMode ? "h-10 w-10" : "h-12 w-12";
+  const userBalance = side === "base" ? baseBalance.formatted ? (() => {
+    const value = parseFloat(baseBalance.formatted);
+    return value >= 1e8 ? formatNumber(value) : value.toFixed(3);
+  })() : void 0 : quoteBalance.formatted ? (() => {
+    const value = parseFloat(quoteBalance.formatted);
+    return value >= 1e8 ? formatNumber(value) : value.toFixed(3);
+  })() : void 0;
+  const sharedProps = {
+    role: "button",
+    tabIndex: isPlacingOrder ? -1 : 0,
+    "aria-disabled": isPlacingOrder,
+    "aria-label": `Select ${side === "base" ? "input" : "output"} token${asset ? `: ${asset.symbol}` : ""}`,
+    onClick: !isPlacingOrder ? toggle : void 0,
+    onKeyDown: !isPlacingOrder ? (e) => {
+      if (e.key === "Enter" || e.key === " ") {
+        e.preventDefault();
+        toggle();
+      }
+    } : void 0
+  };
+  if (tokenDisplay === "pill") {
+    const isRight = tokenBadgeOrientation === "right";
+    return /* @__PURE__ */ jsx3(
+      "div",
+      {
+        ...sharedProps,
+        className: `inline-flex items-center gap-1.5 h-7 px-2.5 rounded-full cursor-pointer transition-colors ${isRight ? "ml-auto" : ""}`,
+        style: {
+          border: "1px solid var(--widget-border)",
+          backgroundColor: "var(--widget-secondary)",
+          color: "var(--widget-secondary-foreground)"
+        },
+        children: asset ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+          /* @__PURE__ */ jsx3(ChainIcon_default, { chain: asset.chainId, size: "xs" }),
+          /* @__PURE__ */ jsx3(
+            TokenImage_default,
+            {
+              className: "rounded-full",
+              asset,
+              size: "xxs",
+              noChain: true
+            }
+          ),
+          /* @__PURE__ */ jsx3("span", { className: "text-xs font-medium uppercase", children: asset.symbol }),
+          /* @__PURE__ */ jsx3(
+            DropdownIcon,
+            {
+              className: "w-1.5 opacity-60",
+              style: { color: "var(--widget-secondary-foreground)" }
+            }
+          )
+        ] }) : /* @__PURE__ */ jsxs2(Fragment, { children: [
+          /* @__PURE__ */ jsx3("span", { className: "text-xs opacity-70", children: "Select" }),
+          /* @__PURE__ */ jsx3(
+            DropdownIcon,
+            {
+              className: "w-1.5 opacity-60",
+              style: { color: "var(--widget-secondary-foreground)" }
+            }
+          )
+        ] })
+      }
+    );
+  }
+  if (tokenDisplay === "ghost") {
+    return /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        ...sharedProps,
+        className: "inline-flex items-center gap-1.5 cursor-pointer transition-opacity hover:opacity-70 py-1",
+        style: { color: "var(--widget-foreground)" },
+        children: [
+          asset ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+            /* @__PURE__ */ jsx3(ChainIcon_default, { chain: asset.chainId, size: "xs" }),
+            /* @__PURE__ */ jsx3(
+              TokenImage_default,
+              {
+                className: "rounded-full",
+                asset,
+                size: "xxs",
+                noChain: true
+              }
+            ),
+            /* @__PURE__ */ jsx3("span", { className: "text-sm font-medium uppercase", children: asset.symbol })
+          ] }) : /* @__PURE__ */ jsx3(
+            "span",
+            {
+              className: "text-sm",
+              style: { color: "var(--widget-muted-foreground)" },
+              children: "Select token"
+            }
+          ),
+          /* @__PURE__ */ jsx3(DropdownIcon, { className: "w-1.5 opacity-50" })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      ...sharedProps,
+      className: `relative ${cardHeight} w-full cursor-pointer text-xl duration-100 ease-linear`,
+      style: {
+        border: "1px solid var(--widget-border)",
+        backgroundColor: "var(--widget-secondary)",
+        borderTopLeftRadius: "9999px",
+        borderBottomLeftRadius: "9999px",
+        borderTopRightRadius: "var(--widget-radius)",
+        borderBottomRightRadius: "var(--widget-radius)"
+      },
+      children: /* @__PURE__ */ jsx3("div", { className: "relative flex h-full w-full flex-row items-center", children: asset ? /* @__PURE__ */ jsxs2("div", { className: "relative flex h-full w-full flex-row items-center", children: [
+        /* @__PURE__ */ jsx3(
+          "div",
+          {
+            className: `${iconSize} pl-px flex items-center justify-center`,
+            children: /* @__PURE__ */ jsx3(TokenImage_default, { className: "rounded-full", asset, size: "md" })
+          }
+        ),
+        /* @__PURE__ */ jsxs2("div", { className: "flex h-full w-full flex-row items-center justify-between pl-1.5 pr-7", children: [
+          /* @__PURE__ */ jsxs2("div", { className: "flex h-full flex-col justify-center", children: [
+            /* @__PURE__ */ jsx3(
+              "p",
+              {
+                className: "text-sm font-medium uppercase",
+                style: { color: "var(--widget-secondary-foreground)" },
+                children: asset.symbol
+              }
+            ),
+            /* @__PURE__ */ jsxs2(
+              "span",
+              {
+                className: "text-2xs font-mono",
+                style: {
+                  color: "var(--widget-secondary-foreground)",
+                  opacity: 0.6
+                },
+                children: [
+                  asset.address?.slice(0, 6),
+                  "...",
+                  asset.address?.slice(-4)
+                ]
+              }
+            )
+          ] }),
+          userBalance !== void 0 && /* @__PURE__ */ jsxs2("div", { className: "flex flex-col text-right", children: [
+            /* @__PURE__ */ jsx3(
+              "p",
+              {
+                className: "text-2xs",
+                style: {
+                  color: "var(--widget-secondary-foreground)",
+                  opacity: 0.5
+                },
+                children: "Balance"
+              }
+            ),
+            /* @__PURE__ */ jsx3(
+              "span",
+              {
+                className: "font-mono text-xs tabular-nums",
+                style: { color: "var(--widget-secondary-foreground)" },
+                children: userBalance
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx3(
+          DropdownIcon,
+          {
+            className: "absolute right-3 top-1/2 w-1.5 translate-y-[-50%]",
+            style: {
+              color: "var(--widget-secondary-foreground)",
+              opacity: 0.6
+            }
+          }
+        )
+      ] }) : /* @__PURE__ */ jsx3("div", { className: "flex h-full w-full items-center justify-center", children: /* @__PURE__ */ jsx3(
+        "span",
+        {
+          className: "text-sm",
+          style: {
+            color: "var(--widget-secondary-foreground)",
+            opacity: 0.7
+          },
+          children: "Select token"
+        }
+      ) }) })
+    }
+  );
+};
+var AssetSelection_default = AssetSelection;
+
+// src/components/RecipientForm.tsx
+var import_ethereum_gradient_base64 = __toESM(require_main(), 1);
+import { useState as useState3, useEffect as useEffect4 } from "react";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var RecipientForm = () => {
+  const [recipient, setRecipient] = useState3(null);
+  const [inputValue, setInputValue] = useState3("");
+  const debouncedValue = useDebounce(inputValue, 1e3);
+  const [isError, setIsError] = useState3(false);
+  const [errorMessage, setErrorMessage] = useState3("");
+  useEffect4(() => {
+    useWidgetSwapUIStore.getState().setRecipient(recipient);
+  }, [recipient]);
+  useEffect4(() => {
+    if (recipient) setInputValue(recipient);
+    else setInputValue("");
+  }, [recipient]);
+  const handleInputChange = (e) => {
+    const value = e.target.value;
+    if (isError) {
+      setIsError(false);
+      setErrorMessage("");
+      setRecipient(null);
+    }
+    setInputValue(value);
+    if (value === "") setRecipient(null);
+  };
+  useEffect4(() => {
+    if (debouncedValue === "" || !debouncedValue) {
+      setIsError(false);
+      setErrorMessage("");
+      setRecipient(null);
+    } else if (!isAddress(debouncedValue)) {
+      setIsError(true);
+      setErrorMessage("Invalid wallet address...");
+      setRecipient(null);
+      setInputValue("");
+    } else {
+      setIsError(false);
+      setErrorMessage("");
+      setRecipient(debouncedValue);
+    }
+  }, [debouncedValue]);
+  useEffect4(() => {
+    if (isError) {
+      const timeout = setTimeout(() => {
+        setRecipient(null);
+        setInputValue("");
+        setIsError(false);
+        setErrorMessage("");
+      }, 2e3);
+      return () => clearTimeout(timeout);
+    }
+  }, [isError]);
+  const handleClear = () => {
+    setRecipient(null);
+    setInputValue("");
+    setIsError(false);
+    setErrorMessage("");
+  };
+  return /* @__PURE__ */ jsx4("div", { className: "w-full", children: /* @__PURE__ */ jsxs3("div", { className: "relative flex flex-row items-center", children: [
+    /* @__PURE__ */ jsx4(
+      "input",
+      {
+        type: "password",
+        style: { display: "none" },
+        "aria-hidden": "true",
+        tabIndex: -1
+      }
+    ),
+    /* @__PURE__ */ jsx4("label", { htmlFor: "recipient-address", className: "sr-only", children: "Recipient wallet address" }),
+    /* @__PURE__ */ jsx4(
+      "div",
+      {
+        className: "absolute left-3 flex h-6 w-6 items-end justify-center overflow-hidden rounded-full",
+        style: { backgroundColor: "var(--widget-secondary)" },
+        children: recipient && !isError ? /* @__PURE__ */ jsx4(
+          "img",
+          {
+            className: "h-full w-full rounded-full object-cover",
+            src: (0, import_ethereum_gradient_base64.makeGradient)(recipient),
+            alt: "Recipient avatar"
+          }
+        ) : /* @__PURE__ */ jsx4(
+          UserIcon,
+          {
+            className: "h-5 w-5",
+            style: {
+              color: isError ? "var(--widget-destructive)" : "var(--widget-muted-foreground)"
+            }
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx4(
+      "div",
+      {
+        className: "absolute left-12 top-1.5 -translate-y-1 text-xs font-medium opacity-60",
+        style: {
+          color: isError ? "var(--widget-destructive)" : "var(--widget-muted-foreground)"
+        },
+        "aria-hidden": "true",
+        children: "To:"
+      }
+    ),
+    /* @__PURE__ */ jsx4(
+      "input",
+      {
+        id: "recipient-address",
+        className: "mono block h-10 w-full items-center pl-12 pt-4 pr-8 text-xs",
+        style: {
+          backgroundColor: isError ? `color-mix(in srgb, var(--widget-destructive) 10%, transparent)` : "transparent",
+          color: isError ? "var(--widget-destructive)" : "var(--widget-foreground)",
+          outline: "none",
+          opacity: isError ? 0.9 : 1
+        },
+        placeholder: isError ? errorMessage : "Enter recipient address...",
+        value: inputValue,
+        onChange: handleInputChange,
+        spellCheck: false,
+        "aria-invalid": isError,
+        "aria-describedby": isError ? "recipient-error" : void 0
+      }
+    ),
+    isError && /* @__PURE__ */ jsx4("span", { id: "recipient-error", className: "sr-only", children: errorMessage }),
+    recipient && !isError && /* @__PURE__ */ jsxs3(
+      "button",
+      {
+        type: "button",
+        className: "absolute right-2 top-1/2 -translate-y-1/2 cursor-pointer flex items-center justify-center h-4 w-4 rounded-full transition-colors hover:[color:var(--widget-destructive)]",
+        style: { color: "var(--widget-muted-foreground)" },
+        onClick: handleClear,
+        "aria-label": "Clear recipient",
+        children: [
+          /* @__PURE__ */ jsx4("svg", { className: "h-2.5 w-2.5", viewBox: "0 -0.5 21 21", fill: "none", children: /* @__PURE__ */ jsx4("g", { fill: "currentColor", fillRule: "evenodd", children: /* @__PURE__ */ jsx4(
+            "polygon",
+            {
+              points: "375.0183 90 384 98.554 382.48065 100 373.5 91.446 364.5183 100 363 98.554 371.98065 90 363 81.446 364.5183 80 373.5 88.554 382.48065 80 384 81.446",
+              transform: "translate(-363 -80)"
+            }
+          ) }) }),
+          /* @__PURE__ */ jsx4("span", { className: "sr-only", children: "Clear recipient" })
+        ]
+      }
+    )
+  ] }) });
+};
+var RecipientForm_default = RecipientForm;
+
+// src/lib/pollOrderStatus.ts
+var TERMINAL_STATUSES = ["SUCCEEDED", "FAILED", "COMPLETED", "CANCELLED"];
+async function pollOrderStatus(quoteId, baseUrl, options = {}) {
+  const {
+    onStatusChange,
+    onComplete,
+    onError,
+    interval = 4e3,
+    timeout = 3e5,
+    txHash,
+    signal
+  } = options;
+  let lastStatus = null;
+  const startTime = Date.now();
+  let consecutiveErrorCount = 0;
+  const MAX_CONSECUTIVE_ERRORS = 8;
+  let timeoutId = null;
+  const queryString = txHash ? `?txHash=${txHash}` : "";
+  return new Promise((resolve, reject) => {
+    const checkStatus = async () => {
+      try {
+        if (signal?.aborted) {
+          if (timeoutId) clearTimeout(timeoutId);
+          reject(new DOMException("Polling aborted", "AbortError"));
+          return;
+        }
+        if (Date.now() - startTime > timeout) {
+          if (timeoutId) clearTimeout(timeoutId);
+          const error = new Error("Order status polling timed out");
+          onError?.(error);
+          reject(error);
+          return;
+        }
+        const response = await fetch(`${baseUrl}/status/${quoteId}${queryString}`, {
+          headers: getVtHeaders(),
+          signal
+        });
+        if (response.status === 404) {
+          timeoutId = setTimeout(checkStatus, interval);
+          return;
+        }
+        if (!response.ok) {
+          throw new Error(`Failed to fetch order status: ${await response.text()}`);
+        }
+        const status = await response.json();
+        if (!status || typeof status !== "object" || !status.status) {
+          throw new Error(`Invalid status response format: ${JSON.stringify(status)}`);
+        }
+        consecutiveErrorCount = 0;
+        const normalized = status.status.toUpperCase();
+        if (normalized !== lastStatus) {
+          lastStatus = normalized;
+          onStatusChange?.(status);
+        }
+        if (TERMINAL_STATUSES.includes(normalized)) {
+          if (timeoutId) clearTimeout(timeoutId);
+          onComplete?.(status);
+          resolve(status);
+          return;
+        }
+        timeoutId = setTimeout(checkStatus, interval);
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          if (timeoutId) clearTimeout(timeoutId);
+          reject(error);
+          return;
+        }
+        if (++consecutiveErrorCount >= MAX_CONSECUTIVE_ERRORS) {
+          if (timeoutId) clearTimeout(timeoutId);
+          const err = error instanceof Error ? error : new Error(String(error));
+          onError?.(err);
+          reject(err);
+          return;
+        }
+        timeoutId = setTimeout(checkStatus, interval);
+      }
+    };
+    checkStatus();
+  });
+}
+
+// src/hooks/useOrderStatusPolling.ts
+import { useCallback as useCallback4, useEffect as useEffect5, useRef as useRef4 } from "react";
+function normalizeStatus(vtStatus) {
+  const upper = vtStatus.toUpperCase();
+  if (upper === "SUCCEEDED" || upper === "COMPLETED") return "completed";
+  if (upper === "FAILED") return "failed";
+  if (upper === "CANCELLED") return "cancelled";
+  if (upper === "PROCESSING") return "received";
+  return "pending";
+}
+var useOrderStatusPolling = (onStatusUpdate) => {
+  const activePolls = useRef4(/* @__PURE__ */ new Map());
+  const orderMetadata = useRef4(/* @__PURE__ */ new Map());
+  const abortControllers = useRef4(/* @__PURE__ */ new Map());
+  const pollingLock = useRef4(0);
+  const incrementPollingLock = useCallback4(() => ++pollingLock.current, []);
+  const { address: userAddress } = useWalletState();
+  const emitBalanceEvent = useEmitBalanceEvent();
+  const startPolling = useCallback4(
+    (quoteId, metadata) => {
+      if (activePolls.current.get(quoteId)) return;
+      if (metadata) orderMetadata.current.set(quoteId, metadata);
+      activePolls.current.set(quoteId, true);
+      const currentLock = pollingLock.current;
+      const abortController = new AbortController();
+      abortControllers.current.set(quoteId, abortController);
+      const isMainnet = metadata?.baseToken?.chainId === 1;
+      pollOrderStatus(
+        quoteId,
+        getVtApiUrl(),
+        {
+          interval: isMainnet ? 1e3 : 500,
+          timeout: 3e5,
+          signal: abortController.signal,
+          onStatusChange: (status) => {
+            if (!status?.status) return;
+            const statusValue = normalizeStatus(status.status);
+            onStatusUpdate?.(quoteId, statusValue);
+            if (statusValue === "completed" && userAddress) {
+              const meta = orderMetadata.current.get(quoteId);
+              if (meta && (meta.baseToken || meta.quoteToken)) {
+                const tokens = [];
+                if (meta.baseToken) tokens.push({ asset: meta.baseToken, userAddress });
+                if (meta.quoteToken) tokens.push({ asset: meta.quoteToken, userAddress });
+                emitBalanceEvent({ type: "swap", tokens });
+              }
+            }
+            if (["completed", "failed", "cancelled"].includes(statusValue)) {
+              activePolls.current.delete(quoteId);
+              orderMetadata.current.delete(quoteId);
+            }
+            if (currentLock !== pollingLock.current) {
+              activePolls.current.delete(quoteId);
+              orderMetadata.current.delete(quoteId);
+            }
+          },
+          onComplete: (status) => {
+            if (status?.status) {
+              onStatusUpdate?.(quoteId, normalizeStatus(status.status));
+            }
+            activePolls.current.delete(quoteId);
+            orderMetadata.current.delete(quoteId);
+          },
+          onError: () => {
+            activePolls.current.delete(quoteId);
+            orderMetadata.current.delete(quoteId);
+          }
+        }
+      ).catch((error) => {
+        if (error instanceof Error && error.name === "AbortError") return;
+        activePolls.current.delete(quoteId);
+        orderMetadata.current.delete(quoteId);
+        abortControllers.current.delete(quoteId);
+      });
+    },
+    [userAddress, emitBalanceEvent, onStatusUpdate]
+  );
+  const stopPolling = useCallback4(
+    (quoteId) => {
+      const controller = abortControllers.current.get(quoteId);
+      if (controller) {
+        controller.abort();
+        abortControllers.current.delete(quoteId);
+      }
+      incrementPollingLock();
+      activePolls.current.delete(quoteId);
+      orderMetadata.current.delete(quoteId);
+    },
+    [incrementPollingLock]
+  );
+  const stopAllPolling = useCallback4(() => {
+    for (const controller of abortControllers.current.values()) controller.abort();
+    abortControllers.current.clear();
+    incrementPollingLock();
+    activePolls.current.clear();
+    orderMetadata.current.clear();
+  }, [incrementPollingLock]);
+  useEffect5(() => {
+    return () => stopAllPolling();
+  }, [stopAllPolling]);
+  return {
+    startPolling,
+    stopPolling,
+    stopAllPolling,
+    isPolling: (quoteId) => activePolls.current.has(quoteId)
+  };
+};
+
+// src/wallet/TransactionRegistryContext.tsx
+import { createContext as createContext3, useContext as useContext3 } from "react";
+var TransactionRegistryContext = createContext3({
+  registerTransaction: () => {
+  },
+  enabled: false
+});
+var useTransactionRegistry = () => useContext3(TransactionRegistryContext);
+
+// src/lib/signSwap.ts
+import { signTypedData } from "viem/actions";
+function isUserRejection(error) {
+  if (!(error instanceof Error)) return false;
+  return error.name === "UserRejectedRequestError" || error.message.includes("User rejected") || error.message.includes("rejected") || error.message.includes("denied") || error.message.includes("cancelled") || error.message.includes("canceled");
+}
+async function resolveChainId(walletClient) {
+  if (walletClient.chain?.id) return walletClient.chain.id;
+  const result = walletClient.getChainId?.();
+  if (result != null) return await result;
+  return null;
+}
+var ChainSwitch = async (walletClient, requiredChainId) => {
+  try {
+    const currentChainId = await resolveChainId(walletClient);
+    if (currentChainId === requiredChainId) return true;
+    if (walletClient.request) {
+      await walletClient.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: `0x${requiredChainId.toString(16)}` }]
+      });
+    } else if (walletClient.switchChain) {
+      await walletClient.switchChain({ id: requiredChainId });
+    } else if (walletClient.send) {
+      await walletClient.send("wallet_switchEthereumChain", [
+        { chainId: `0x${requiredChainId.toString(16)}` }
+      ]);
+    } else {
+      throw new Error("Wallet doesn't support chain switching");
+    }
+    const newChainId = await resolveChainId(walletClient);
+    return newChainId === requiredChainId;
+  } catch (error) {
+    if (isUserRejection(error)) {
+      throw new Error("User rejected the chain switch request");
+    }
+    throw new Error(
+      `Please switch your wallet to the required network (Chain ID: ${requiredChainId})`
+    );
+  }
+};
+var SignSwap = async (params) => {
+  const { quote, signatureStep, userAddress, walletClient } = params;
+  if (!walletClient) throw new Error("Wallet client not available");
+  if (signatureStep.type !== "SIGNATURE" || !signatureStep.signature?.typedData)
+    throw new Error("Invalid signature step");
+  try {
+    const typed = signatureStep.signature.typedData;
+    const normalizedMessage = { ...typed.message };
+    for (const key of ["inputAmount", "outputAmount", "startTime", "endTime"]) {
+      if (normalizedMessage[key] != null) {
+        normalizedMessage[key] = BigInt(normalizedMessage[key]);
+      }
+    }
+    const domain = typed.domain;
+    if (domain.chainId != null) {
+      const chainId = Number(domain.chainId);
+      await ChainSwitch(walletClient, chainId);
+    }
+    const signature = await signTypedData(walletClient, {
+      account: userAddress,
+      domain,
+      types: typed.types,
+      primaryType: typed.primaryType,
+      message: normalizedMessage
+    });
+    const submitRes = await fetch(`${getVtApiUrl()}/submit-signature`, {
+      method: "POST",
+      headers: getVtHeaders(),
+      body: JSON.stringify({
+        quoteId: quote.id,
+        signatures: [signature]
+      })
+    });
+    if (!submitRes.ok) {
+      const errBody = await submitRes.json().catch(() => ({}));
+      throw new Error(errBody?.message || `Submit failed: ${submitRes.status}`);
+    }
+    return { quoteId: quote.id, signature };
+  } catch (error) {
+    if (isUserRejection(error)) {
+      throw new Error("User rejected the signing request");
+    }
+    if (error instanceof Error && error.message.includes("chain")) {
+      throw new Error("Chain switching failed. Please manually switch to the correct network.");
+    }
+    throw error;
+  }
+};
+
+// src/lib/submitTracker.ts
+var STORAGE_KEY = "vt_submitted_quotes";
+var QUOTE_EXPIRATION_MS = 30 * 1e3;
+var getSubmittedQuotes = () => {
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    return stored ? JSON.parse(stored) : [];
+  } catch {
+    return [];
+  }
+};
+var saveSubmittedQuotes = (quotes) => {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(quotes));
+  } catch {
+  }
+};
+var isQuoteFresh = (createdAt) => {
+  const now = Date.now();
+  const createdMs = typeof createdAt === "string" ? new Date(createdAt).getTime() : createdAt > 9999999999 ? createdAt : createdAt * 1e3;
+  return now < createdMs + QUOTE_EXPIRATION_MS;
+};
+var isOrderAlreadySubmitted = (quoteId) => {
+  return getSubmittedQuotes().some((q) => q.quoteId === quoteId);
+};
+var canSubmitOrder = (quoteId, createdAt) => {
+  if (isOrderAlreadySubmitted(quoteId)) {
+    return { canSubmit: false, reason: "Order already submitted" };
+  }
+  if (!isQuoteFresh(createdAt)) {
+    return { canSubmit: false, reason: "Quote has expired" };
+  }
+  return { canSubmit: true };
+};
+var markOrderAsSubmitted = (quoteId, createdAt) => {
+  const createdMs = typeof createdAt === "string" ? new Date(createdAt).getTime() : createdAt;
+  const submitted = getSubmittedQuotes();
+  submitted.push({ quoteId, submittedAt: Date.now(), createdAt: createdMs });
+  saveSubmittedQuotes(submitted);
+};
+var cleanupOldSubmissions = () => {
+  const submitted = getSubmittedQuotes();
+  const now = Date.now();
+  const CLEANUP_THRESHOLD = 5 * 60 * 1e3;
+  const cleaned = submitted.filter((q) => now - q.submittedAt < CLEANUP_THRESHOLD);
+  if (cleaned.length !== submitted.length) saveSubmittedQuotes(cleaned);
+};
+
+// src/queries/useUnwrapToken.ts
+import { useMutation } from "@tanstack/react-query";
+import { waitForTransactionReceipt } from "@wagmi/core";
+import { wethAbi } from "abitype/abis";
+import { useConfig } from "wagmi";
+function useUnwrapToken() {
+  const wagmiConfig = useConfig();
+  return useMutation({
+    mutationFn: async ({ chainId, accountAddress, amountRaw, writeContractAsync }) => {
+      const chainConfig = getChainConfig(chainId);
+      if (!chainConfig) throw new Error(`No wrapping contract for chain ${chainId}`);
+      const wNativeAddress = chainConfig.wrappedAsset.address;
+      const hash = await writeContractAsync({
+        abi: wethAbi,
+        functionName: "withdraw",
+        address: wNativeAddress,
+        account: accountAddress,
+        args: [amountRaw],
+        chainId
+      });
+      const receipt = await waitForTransactionReceipt(wagmiConfig, {
+        hash,
+        chainId,
+        confirmations: 1,
+        pollingInterval: 4e3
+      });
+      if (receipt.status !== "success") {
+        throw new Error("Unwrap transaction did not get successful receipt");
+      }
+      return { success: true, hash };
+    }
+  });
+}
+
+// src/queries/useWrapToken.ts
+import { useMutation as useMutation2 } from "@tanstack/react-query";
+import { waitForTransactionReceipt as waitForTransactionReceipt2 } from "@wagmi/core";
+import { wethAbi as wethAbi2 } from "abitype/abis";
+import { useConfig as useConfig2 } from "wagmi";
+function useWrapToken() {
+  const wagmiConfig = useConfig2();
+  return useMutation2({
+    mutationFn: async ({ chainId, accountAddress, amountRaw, writeContractAsync }) => {
+      const chainConfig = getChainConfig(chainId);
+      if (!chainConfig) throw new Error(`No wrapping contract for chain ${chainId}`);
+      const wNativeAddress = chainConfig.wrappedAsset.address;
+      const hash = await writeContractAsync({
+        abi: wethAbi2,
+        functionName: "deposit",
+        address: wNativeAddress,
+        account: accountAddress,
+        value: amountRaw,
+        chainId
+      });
+      const receipt = await waitForTransactionReceipt2(wagmiConfig, {
+        hash,
+        chainId,
+        confirmations: 1,
+        pollingInterval: 4e3
+      });
+      if (receipt.status !== "success") {
+        throw new Error("Wrap transaction did not get successful receipt");
+      }
+      return { success: true, hash };
+    }
+  });
+}
+
+// src/components/states/SwapButton.tsx
+import { useCallback as useCallback10, useEffect as useEffect12, useRef as useRef11, useState as useState9 } from "react";
+import { useChainId as useChainId2 } from "wagmi";
+
+// src/wallet/useTransactionTracker.ts
+import { useCallback as useCallback5, useRef as useRef5 } from "react";
+function useTransactionTracker() {
+  const { registerTransaction, enabled } = useTransactionRegistry();
+  const registeredRef = useRef5(/* @__PURE__ */ new Set());
+  const trackOrderTransaction = useCallback5(
+    (quoteId, description) => {
+      if (!enabled || registeredRef.current.has(quoteId)) return;
+      registeredRef.current.add(quoteId);
+      registerTransaction(quoteId, description);
+    },
+    [enabled, registerTransaction]
+  );
+  const trackNativeTransaction = useCallback5(
+    (txHash, description) => {
+      if (!enabled || registeredRef.current.has(txHash)) return;
+      registeredRef.current.add(txHash);
+      registerTransaction(txHash, description);
+    },
+    [enabled, registerTransaction]
+  );
+  return { trackOrderTransaction, trackNativeTransaction, txTrackingEnabled: enabled };
+}
+
+// src/components/states/ReviewActionChainSwitchRow.tsx
+import { useEffect as useEffect6, useState as useState4, useCallback as useCallback6, useRef as useRef6 } from "react";
+import { useAccount, useChainId, useSwitchChain } from "wagmi";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var WALLET_TIMEOUT_MS = 15e3;
+var ComponentStep = "chain";
+var ReviewActionChainSwitchRow = ({
+  needsChainSwitch,
+  requiredChain,
+  reviewState,
+  goToNextStep,
+  cancel
+}) => {
+  const hasSucceeded = isReviewStepPast(ComponentStep, reviewState);
+  const [chainState, setChainState] = useState4("pending");
+  const isSwitching = useRef6(false);
+  const switchAttempted = useRef6(false);
+  const timeoutRef = useRef6(null);
+  const currentChainId = useChainId();
+  const { switchChainAsync } = useSwitchChain();
+  const { status: wagmiStatus, isReconnecting } = useAccount();
+  const clearPendingTimeout = useCallback6(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  const handleChainSwitch = useCallback6(async () => {
+    if (isSwitching.current || switchAttempted.current || wagmiStatus !== "connected" || isReconnecting) return;
+    isSwitching.current = true;
+    switchAttempted.current = true;
+    setChainState("pending");
+    timeoutRef.current = setTimeout(() => {
+      if (isSwitching.current) {
+        setChainState("error");
+        isSwitching.current = false;
+      }
+    }, WALLET_TIMEOUT_MS);
+    try {
+      await switchChainAsync({ chainId: requiredChain.chainId });
+      clearPendingTimeout();
+      setChainState("success");
+      goToNextStep(ComponentStep, reviewState);
+    } catch {
+      clearPendingTimeout();
+      setChainState("error");
+    } finally {
+      isSwitching.current = false;
+    }
+  }, [switchChainAsync, wagmiStatus, isReconnecting, requiredChain.chainId, goToNextStep, reviewState, clearPendingTimeout]);
+  useEffect6(() => {
+    if (isSwitching.current || switchAttempted.current) return;
+    if (reviewState === ComponentStep && chainState === "pending" && wagmiStatus === "connected" && !isReconnecting) {
+      if (needsChainSwitch && currentChainId !== requiredChain.chainId) handleChainSwitch();
+      else {
+        setChainState("success");
+        goToNextStep(ComponentStep, reviewState);
+      }
+    }
+  }, [reviewState, chainState, needsChainSwitch, currentChainId, requiredChain.chainId, wagmiStatus, isReconnecting, handleChainSwitch, goToNextStep]);
+  useEffect6(() => () => clearPendingTimeout(), [clearPendingTimeout]);
+  const handleRetry = () => {
+    if (chainState === "error") {
+      switchAttempted.current = false;
+      setChainState("pending");
+    }
+  };
+  const isError = !hasSucceeded && chainState === "error";
+  const showCancel = !hasSucceeded && (chainState === "pending" || chainState === "error");
+  const statusVar = isError ? "var(--widget-status-failed)" : "var(--widget-status-pending)";
+  return /* @__PURE__ */ jsxs4("div", { className: "flex w-full flex-row justify-between space-x-3", children: [
+    /* @__PURE__ */ jsx5(
+      "button",
+      {
+        type: "button",
+        className: `inline-flex h-12 w-full items-center justify-center text-sm font-medium transition duration-150 ${isError ? "cursor-pointer" : "cursor-not-allowed"}`,
+        style: {
+          backgroundColor: `color-mix(in srgb, ${statusVar} 12%, transparent)`,
+          border: `1px solid color-mix(in srgb, ${statusVar} 20%, transparent)`,
+          color: statusVar,
+          borderRadius: "var(--widget-radius)"
+        },
+        onClick: isError ? handleRetry : void 0,
+        children: /* @__PURE__ */ jsxs4("div", { className: "flex h-10 w-full flex-row items-center space-x-3 px-4", children: [
+          /* @__PURE__ */ jsx5(ChainIcon_default, { chain: requiredChain.chainId, size: "xs" }),
+          /* @__PURE__ */ jsx5("p", { className: "whitespace-nowrap", children: isError ? "Retry Switch" : `Switch to ${requiredChain.name}` }),
+          /* @__PURE__ */ jsx5("div", { className: "flex flex-1 border-t", style: { borderColor: "var(--widget-border)" } }),
+          /* @__PURE__ */ jsxs4("div", { className: "flex h-6 w-3 items-center justify-center rounded-full", children: [
+            !hasSucceeded && chainState === "pending" && /* @__PURE__ */ jsx5(LoadingSpinner_default, { size: "5" }),
+            (hasSucceeded || chainState === "success") && /* @__PURE__ */ jsx5(Checkmark, { className: "h-8 w-8" }),
+            isError && /* @__PURE__ */ jsx5(RedoIcon, { className: "h-[12px] w-[12px]" })
+          ] })
+        ] })
+      }
+    ),
+    showCancel && /* @__PURE__ */ jsx5(
+      "button",
+      {
+        type: "button",
+        className: "inline-flex h-12 items-center justify-center px-8 text-sm font-medium transition duration-150 cursor-pointer",
+        style: {
+          backgroundColor: "color-mix(in srgb, var(--widget-status-failed) 12%, transparent)",
+          border: "1px solid color-mix(in srgb, var(--widget-status-failed) 20%, transparent)",
+          color: "var(--widget-status-failed)",
+          borderRadius: "var(--widget-radius)"
+        },
+        onClick: cancel,
+        children: "Cancel"
+      }
+    )
+  ] });
+};
+var ReviewActionChainSwitchRow_default = ReviewActionChainSwitchRow;
+
+// src/components/states/ReviewActionSignAndSubmitOrderRow.tsx
+import { waitForTransactionReceipt as waitForTransactionReceipt3 } from "@wagmi/core";
+import { useCallback as useCallback7, useEffect as useEffect8, useState as useState6, useRef as useRef8 } from "react";
+import { useAccount as useAccount2, useConfig as useConfig3, useSendTransaction, useSwitchChain as useSwitchChain2, useWalletClient } from "wagmi";
+
+// src/components/CountDown.tsx
+import { useEffect as useEffect7, useRef as useRef7, useState as useState5 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var CountDown = ({ startTime, onExpired }) => {
+  const [timeLeft, setTimeLeft] = useState5(30);
+  const [isExpired, setIsExpired] = useState5(false);
+  const firedRef = useRef7(false);
+  const onExpiredRef = useRef7(onExpired);
+  onExpiredRef.current = onExpired;
+  useEffect7(() => {
+    firedRef.current = false;
+  }, [startTime]);
+  useEffect7(() => {
+    const calculateTimeLeft = () => {
+      const now = Date.now();
+      const startTimeMs = startTime > 9999999999 ? startTime : startTime * 1e3;
+      const expirationTime = startTimeMs + 30 * 1e3;
+      const remaining = Math.max(0, expirationTime - now);
+      const remainingSeconds = Math.floor(remaining / 1e3);
+      if (remainingSeconds <= 0) {
+        setTimeLeft(0);
+        if (!firedRef.current) {
+          firedRef.current = true;
+          setIsExpired(true);
+          onExpiredRef.current();
+        }
+        return;
+      }
+      setTimeLeft(remainingSeconds);
+      setIsExpired(false);
+    };
+    if (isExpired) return;
+    calculateTimeLeft();
+    const interval = setInterval(calculateTimeLeft, 1e3);
+    return () => clearInterval(interval);
+  }, [startTime, isExpired]);
+  const formatTime = (seconds) => {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}`;
+  };
+  if (isExpired) return null;
+  return /* @__PURE__ */ jsx6("span", { className: "text-xs font-mono", children: formatTime(timeLeft) });
+};
+var CountDown_default = CountDown;
+
+// src/components/states/ReviewActionSignAndSubmitOrderRow.tsx
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function isUserRejectionError(error) {
+  return error.name === "UserRejectedRequestError" || error.message.includes("User rejected") || error.message.includes("rejected") || error.message.includes("denied") || error.message.includes("cancelled") || error.message.includes("canceled");
+}
+var ComponentStep2 = "signingOrder";
+async function executeTransactionStep(step, userAddress, sendTransactionAsync, wagmiConfig, fallbackChainKey) {
+  const encoded = step.transaction?.encoded;
+  const to = encoded?.to ?? step.to;
+  const data = encoded?.data ?? step.data;
+  const value = encoded?.value ?? step.value;
+  if (!to) throw new Error('Transaction step missing "to" address');
+  const encodedChainId = encoded?.chainId;
+  const resolvedChainKey = step.chainKey || fallbackChainKey;
+  const chainId = encodedChainId || (resolvedChainKey ? getChainIdForKey(resolvedChainKey) : void 0);
+  if (!chainId) throw new Error(`Unknown chain: ${resolvedChainKey}`);
+  const viemChain = getViemChainById()[chainId];
+  const hash = await sendTransactionAsync({
+    account: userAddress,
+    chain: viemChain,
+    to,
+    data: data || "0x",
+    value: BigInt(value || "0")
+  });
+  await waitForTransactionReceipt3(wagmiConfig, { hash, chainId });
+  return hash;
+}
+var ReviewActionSignAndSubmitOrderRow = ({
+  base,
+  baseAmount,
+  quote,
+  quoteAmount,
+  userAddress,
+  reviewState,
+  goToNextStep,
+  cancel,
+  isWrappingPair,
+  isUnwrappingPair,
+  restartSigningFlow,
+  onSwapInitiated,
+  onOrderSubmitted,
+  onSwapComplete,
+  startPolling,
+  trackNativeTransaction
+}) => {
+  const hasSucceeded = isReviewStepPast(ComponentStep2, reviewState);
+  const [signState, setSignState] = useState6("idle");
+  const isProcessing = useRef8(false);
+  const hasAutoStartedRef = useRef8(null);
+  const wagmiConfig = useConfig3();
+  const { isReconnecting } = useAccount2();
+  const { rfqQuote, stop: stopRfq, refresh } = useRfq();
+  const { data: walletClient } = useWalletClient({ chainId: base.chainId });
+  const { switchChain } = useSwitchChain2();
+  const { sendTransactionAsync } = useSendTransaction();
+  const quoteReceivedAtMs = rfqQuote?._receivedAt ?? 0;
+  const isQuoteStale = useCallback7(() => {
+    if (!quoteReceivedAtMs) return false;
+    return Date.now() >= quoteReceivedAtMs + 30 * 1e3;
+  }, [quoteReceivedAtMs]);
+  const handleSignAndSubmit = useCallback7(async () => {
+    if (isProcessing.current || !["idle", "error"].includes(signState)) return;
+    if (!rfqQuote?.id || !rfqQuote?._receivedAt) {
+      setSignState("error");
+      return;
+    }
+    const validation = canSubmitOrder(rfqQuote.id, rfqQuote._receivedAt);
+    if (!validation.canSubmit) {
+      setSignState("stale");
+      return;
+    }
+    isProcessing.current = true;
+    try {
+      if (!walletClient) throw new Error("Wallet client not available");
+      cleanupOldSubmissions();
+      const steps = rfqQuote.userSteps ?? [];
+      let lastTxHash;
+      for (const step of steps) {
+        if (step.type === "TRANSACTION") {
+          setSignState("submitting");
+          const resolvedKey = step.chainKey || rfqQuote.srcChainKey;
+          const chainId = resolvedKey ? getChainIdForKey(resolvedKey) : void 0;
+          if (chainId && walletClient.chain?.id !== chainId) {
+            await switchChain({ chainId });
+            await new Promise((r) => setTimeout(r, 800));
+          }
+          lastTxHash = await executeTransactionStep(step, userAddress, sendTransactionAsync, wagmiConfig, rfqQuote.srcChainKey);
+          trackNativeTransaction(lastTxHash, step.description || `Tx on ${resolvedKey}`);
+        } else if (step.type === "SIGNATURE") {
+          setSignState("signing");
+          await SignSwap({
+            quote: rfqQuote,
+            signatureStep: step,
+            userAddress,
+            walletClient
+          });
+        }
+      }
+      markOrderAsSubmitted(rfqQuote.id, rfqQuote._receivedAt);
+      onOrderSubmitted?.(rfqQuote.id);
+      startPolling(rfqQuote.id, { baseToken: base, quoteToken: quote });
+      onSwapInitiated?.();
+      stopRfq();
+      setSignState("success");
+      goToNextStep(ComponentStep2, reviewState);
+      onSwapComplete?.(rfqQuote.id);
+    } catch (error) {
+      if (error instanceof Error && isUserRejectionError(error)) {
+        hasAutoStartedRef.current = null;
+        setSignState("idle");
+      } else {
+        setSignState("error");
+      }
+    } finally {
+      isProcessing.current = false;
+    }
+  }, [signState, rfqQuote, walletClient, base, quote, userAddress, stopRfq, startPolling, goToNextStep, reviewState, onSwapComplete, switchChain, sendTransactionAsync, onSwapInitiated, onOrderSubmitted, trackNativeTransaction, wagmiConfig]);
+  useEffect8(() => {
+    if (reviewState === ComponentStep2) stopRfq();
+    if (hasSucceeded && signState !== "success") {
+      setSignState("success");
+      goToNextStep(ComponentStep2, reviewState);
+      return;
+    }
+    if (signState === "success") {
+      goToNextStep(ComponentStep2, reviewState);
+      return;
+    }
+    if (reviewState === ComponentStep2 && signState === "idle" && !rfqQuote?.id) {
+      setSignState("refreshingQuote");
+      refresh();
+      return;
+    }
+    if (reviewState === ComponentStep2 && signState === "idle" && walletClient && !isProcessing.current && !isReconnecting) {
+      const currentId = rfqQuote?.id || null;
+      if (currentId && hasAutoStartedRef.current !== currentId) {
+        hasAutoStartedRef.current = currentId;
+        handleSignAndSubmit();
+      }
+    }
+  }, [hasSucceeded, reviewState, signState, walletClient, isReconnecting, handleSignAndSubmit, goToNextStep, rfqQuote?.id, refresh, stopRfq]);
+  useEffect8(() => {
+    if (signState === "refreshingQuote" && rfqQuote?.id) {
+      setSignState("idle");
+    }
+  }, [signState, rfqQuote?.id]);
+  useEffect8(() => {
+    if (reviewState !== ComponentStep2) hasAutoStartedRef.current = null;
+  }, [reviewState]);
+  useEffect8(() => {
+    const interval = setInterval(() => {
+      if (isQuoteStale() && !isProcessing.current && signState !== "submitting" && signState !== "success") {
+        setSignState("stale");
+      }
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [isQuoteStale, signState]);
+  const handleRetry = () => {
+    if (signState === "error" && !isProcessing.current) {
+      hasAutoStartedRef.current = null;
+      setSignState("idle");
+    }
+  };
+  const handleRefreshFromStale = useCallback7(() => {
+    hasAutoStartedRef.current = null;
+    setSignState("refreshingQuote");
+    refresh();
+  }, [refresh]);
+  const handleCloseWalletAndRestart = useCallback7(() => {
+    if (restartSigningFlow) {
+      restartSigningFlow(true);
+    } else {
+      cancel();
+    }
+  }, [restartSigningFlow, cancel]);
+  const buttonText = () => {
+    if (signState === "error") return "Retry swap";
+    if (signState === "signing") return "Sign Swap Order";
+    if (signState === "submitting") return "Submitting...";
+    if (signState === "refreshingQuote") return "Refreshing Quote...";
+    if (signState === "stale") return "Quote Stale";
+    return "Sign & Submit";
+  };
+  const isErrorOrStale = !hasSucceeded && (signState === "error" || signState === "stale");
+  const statusVar = isErrorOrStale ? "var(--widget-status-failed)" : "var(--widget-status-pending)";
+  return /* @__PURE__ */ jsxs5("div", { className: "flex w-full flex-row justify-between space-x-3", children: [
+    /* @__PURE__ */ jsx7(
+      "button",
+      {
+        type: "button",
+        className: `inline-flex h-12 w-full items-center justify-center text-sm font-medium transition duration-150 ${isErrorOrStale ? "cursor-pointer" : "cursor-not-allowed"}`,
+        style: {
+          backgroundColor: `color-mix(in srgb, ${statusVar} 12%, transparent)`,
+          border: `1px solid color-mix(in srgb, ${statusVar} 20%, transparent)`,
+          color: statusVar,
+          borderRadius: "var(--widget-radius)"
+        },
+        onClick: !hasSucceeded && signState === "error" ? handleRetry : signState === "stale" ? handleCloseWalletAndRestart : void 0,
+        children: /* @__PURE__ */ jsxs5("div", { className: "flex h-10 w-full flex-row items-center space-x-3 px-4", children: [
+          /* @__PURE__ */ jsx7(TokenImage_default, { asset: base, size: "xs", noChain: true }),
+          /* @__PURE__ */ jsx7("p", { className: "whitespace-nowrap", children: buttonText() }),
+          /* @__PURE__ */ jsx7("div", { className: "flex flex-1 border-t", style: { borderColor: "var(--widget-border)" } }),
+          quoteReceivedAtMs > 0 && signState !== "success" && signState !== "error" && signState !== "stale" && /* @__PURE__ */ jsx7(CountDown_default, { startTime: quoteReceivedAtMs, onExpired: () => setSignState("stale") }),
+          /* @__PURE__ */ jsxs5("div", { className: "flex h-6 w-3 items-center justify-center rounded-full", children: [
+            !hasSucceeded && (signState === "idle" || signState === "signing" || signState === "submitting" || signState === "refreshingQuote") && /* @__PURE__ */ jsx7(LoadingSpinner_default, { size: "5" }),
+            (hasSucceeded || signState === "success") && /* @__PURE__ */ jsx7(Checkmark, { className: "h-8 w-8" }),
+            !hasSucceeded && (signState === "error" || signState === "stale") && /* @__PURE__ */ jsx7(RedoIcon, { className: "h-[12px] w-[12px]" })
+          ] })
+        ] })
+      }
+    ),
+    !hasSucceeded && signState === "error" && /* @__PURE__ */ jsx7(
+      "button",
+      {
+        type: "button",
+        className: "inline-flex h-12 items-center justify-center px-8 text-sm font-medium transition duration-150 cursor-pointer",
+        style: {
+          backgroundColor: "color-mix(in srgb, var(--widget-status-failed) 12%, transparent)",
+          border: "1px solid color-mix(in srgb, var(--widget-status-failed) 20%, transparent)",
+          color: "var(--widget-status-failed)",
+          borderRadius: "var(--widget-radius)"
+        },
+        onClick: cancel,
+        children: "Cancel"
+      }
+    )
+  ] });
+};
+var ReviewActionSignAndSubmitOrderRow_default = ReviewActionSignAndSubmitOrderRow;
+
+// src/components/states/ReviewActionTxRow.tsx
+import { useEffect as useEffect9 } from "react";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+var ComponentStep3 = "trackingTx";
+var statusConfig = {
+  pending: {
+    icon: /* @__PURE__ */ jsx8(LoadingSpinner_default, { size: "5" }),
+    buttonText: "Trade Pending",
+    showNewSwap: false,
+    statusVar: "var(--widget-status-pending)",
+    clickable: false
+  },
+  received: {
+    icon: /* @__PURE__ */ jsx8(LoadingSpinner_default, { size: "5" }),
+    buttonText: "Trade Received",
+    showNewSwap: false,
+    statusVar: "var(--widget-status-received)",
+    clickable: false
+  },
+  completed: {
+    icon: /* @__PURE__ */ jsx8(Checkmark, {}),
+    buttonText: "Continue Swapping",
+    showNewSwap: true,
+    statusVar: "var(--widget-status-completed)",
+    clickable: true
+  },
+  failed: {
+    icon: /* @__PURE__ */ jsx8(XAnimation, {}),
+    buttonText: "Retry Swap",
+    showNewSwap: true,
+    statusVar: "var(--widget-status-failed)",
+    clickable: true
+  },
+  cancelled: {
+    icon: /* @__PURE__ */ jsx8(XAnimation, {}),
+    buttonText: "Continue Swapping",
+    showNewSwap: true,
+    statusVar: "var(--widget-status-failed)",
+    clickable: true
+  }
+};
+var ReviewActionTxRow = ({
+  orderHash,
+  base,
+  quote,
+  baseAmount,
+  quoteAmount,
+  reviewState,
+  onNewSwap,
+  onRetry,
+  status
+}) => {
+  const hasSucceeded = isReviewStepPast(ComponentStep3, reviewState);
+  const config = statusConfig[status] || statusConfig.pending;
+  useEffect9(() => {
+    if (status === "completed") {
+      const timer = setTimeout(onNewSwap, 5e3);
+      return () => clearTimeout(timer);
+    }
+  }, [status, onNewSwap]);
+  const handleClick = () => {
+    if (status === "failed") onRetry();
+    else if (config.showNewSwap) onNewSwap();
+  };
+  const sv = config.statusVar;
+  return /* @__PURE__ */ jsx8("div", { className: "flex flex-row justify-between space-x-3 w-full", children: /* @__PURE__ */ jsx8(
+    "button",
+    {
+      type: "button",
+      className: `inline-flex h-12 w-full items-center justify-center text-sm font-medium transition duration-150 ${config.clickable ? "cursor-pointer" : "cursor-not-allowed"}`,
+      style: {
+        backgroundColor: `color-mix(in srgb, ${sv} 12%, transparent)`,
+        border: `1px solid color-mix(in srgb, ${sv} 20%, transparent)`,
+        color: sv,
+        borderRadius: "var(--widget-radius)"
+      },
+      onClick: config.showNewSwap ? handleClick : void 0,
+      children: /* @__PURE__ */ jsxs6("div", { className: "flex h-10 w-full flex-row items-center space-x-3 px-4", children: [
+        /* @__PURE__ */ jsx8("div", { className: "flex h-6 w-6 items-center justify-center rounded-full", children: config.icon }),
+        /* @__PURE__ */ jsx8("p", { className: "whitespace-nowrap", children: config.buttonText }),
+        /* @__PURE__ */ jsx8("div", { className: "flex flex-1 border-t", style: { borderColor: "var(--widget-border)" } }),
+        config.showNewSwap && /* @__PURE__ */ jsx8("div", { className: "flex h-6 w-6 items-center justify-center", children: /* @__PURE__ */ jsx8(RedoAnimation, {}) })
+      ] })
+    }
+  ) });
+};
+var ReviewActionTxRow_default = ReviewActionTxRow;
+
+// src/components/states/ReviewActionUnwrapGasToken.tsx
+import { useCallback as useCallback8, useEffect as useEffect10, useState as useState7, useRef as useRef9 } from "react";
+import { parseUnits as parseUnits2 } from "viem";
+import { useAccount as useAccount3, useWriteContract } from "wagmi";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+var WALLET_TIMEOUT_MS2 = 15e3;
+var ComponentStep4 = "unwrapping";
+var ReviewActionUnwrapGasToken = ({
+  needsToUnwrap,
+  amount,
+  chainId,
+  token,
+  reviewState,
+  setReviewState,
+  goToNextStep,
+  cancel,
+  delayedClose
+}) => {
+  const hasSucceeded = isReviewStepPast(ComponentStep4, reviewState);
+  const [unwrappingState, setUnwrappingState] = useState7("idle");
+  const unwrapMutation = useUnwrapToken();
+  const { writeContractAsync } = useWriteContract();
+  const { address } = useWalletState();
+  const emitBalanceEvent = useEmitBalanceEvent();
+  const isUnwrapping = useRef9(false);
+  const unwrapAttempted = useRef9(false);
+  const timeoutRef = useRef9(null);
+  const { status: wagmiStatus } = useAccount3();
+  const clearPendingTimeout = useCallback8(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  const handleUnwrap = useCallback8(async () => {
+    if (isUnwrapping.current || unwrapAttempted.current || !address || wagmiStatus !== "connected") return;
+    isUnwrapping.current = true;
+    unwrapAttempted.current = true;
+    setUnwrappingState("pending");
+    timeoutRef.current = setTimeout(() => {
+      if (isUnwrapping.current) {
+        setUnwrappingState("error");
+        isUnwrapping.current = false;
+      }
+    }, WALLET_TIMEOUT_MS2);
+    try {
+      const chainConfig = getChainConfig(chainId);
+      if (!chainConfig) throw new Error(`No config for chain ${chainId}`);
+      const wrappedDecimals = chainConfig.wrappedAsset.decimals ?? chainConfig.nativeAsset.decimals;
+      const amountRaw = parseUnits2(amount.toString(), wrappedDecimals);
+      await unwrapMutation.mutateAsync({
+        chainId,
+        accountAddress: address,
+        amountRaw,
+        writeContractAsync
+      });
+      const nativeAsset = {
+        symbol: chainConfig.nativeAsset.symbol,
+        name: chainConfig.nativeAsset.name,
+        address: NATIVE_ASSET_ADDRESS,
+        decimals: chainConfig.nativeAsset.decimals,
+        chainId
+      };
+      const wrappedAsset = {
+        symbol: chainConfig.wrappedAsset.symbol,
+        name: chainConfig.wrappedAsset.name,
+        address: chainConfig.wrappedAsset.address,
+        decimals: chainConfig.wrappedAsset.decimals,
+        chainId
+      };
+      emitBalanceEvent({
+        type: "unwrap",
+        tokens: [
+          { asset: nativeAsset, userAddress: address },
+          { asset: wrappedAsset, userAddress: address }
+        ]
+      });
+      clearPendingTimeout();
+      setUnwrappingState("success");
+      goToNextStep(ComponentStep4, reviewState);
+      await delayedClose();
+    } catch {
+      clearPendingTimeout();
+      setUnwrappingState("error");
+    } finally {
+      isUnwrapping.current = false;
+    }
+  }, [address, wagmiStatus, chainId, amount, unwrapMutation, writeContractAsync, emitBalanceEvent, goToNextStep, reviewState, delayedClose, clearPendingTimeout]);
+  useEffect10(() => {
+    if (isUnwrapping.current || unwrapAttempted.current) return;
+    if (reviewState === ComponentStep4 && unwrappingState === "idle" && wagmiStatus === "connected") {
+      if (needsToUnwrap) handleUnwrap();
+      else {
+        setUnwrappingState("success");
+        goToNextStep(ComponentStep4, reviewState);
+      }
+    }
+  }, [reviewState, unwrappingState, needsToUnwrap, wagmiStatus, handleUnwrap, goToNextStep]);
+  useEffect10(() => () => clearPendingTimeout(), [clearPendingTimeout]);
+  const handleRetry = () => {
+    if (unwrappingState === "error") {
+      unwrapAttempted.current = false;
+      setUnwrappingState("idle");
+    }
+  };
+  const isError = !hasSucceeded && unwrappingState === "error";
+  const showCancel = !hasSucceeded && (unwrappingState === "pending" || unwrappingState === "idle" || unwrappingState === "error");
+  const statusVar = isError ? "var(--widget-status-failed)" : "var(--widget-status-pending)";
+  return /* @__PURE__ */ jsxs7("div", { className: "flex w-full flex-row justify-between space-x-3", children: [
+    /* @__PURE__ */ jsx9(
+      "button",
+      {
+        type: "button",
+        className: `inline-flex h-12 w-full items-center justify-center text-sm font-medium transition duration-150 ${isError ? "cursor-pointer" : "cursor-not-allowed"}`,
+        style: {
+          backgroundColor: `color-mix(in srgb, ${statusVar} 12%, transparent)`,
+          border: `1px solid color-mix(in srgb, ${statusVar} 20%, transparent)`,
+          color: statusVar,
+          borderRadius: "var(--widget-radius)"
+        },
+        onClick: isError ? handleRetry : void 0,
+        children: /* @__PURE__ */ jsxs7("div", { className: "flex h-10 w-full flex-row items-center space-x-3 px-4", children: [
+          /* @__PURE__ */ jsx9("p", { className: "whitespace-nowrap", children: isError ? "Retry Unwrap" : token ? `Unwrap ${token.symbol}` : "Unwrap Native Token" }),
+          /* @__PURE__ */ jsx9("div", { className: "flex flex-1 border-t", style: { borderColor: "var(--widget-border)" } }),
+          /* @__PURE__ */ jsxs7("div", { className: "flex h-6 w-3 items-center justify-center rounded-full", children: [
+            !hasSucceeded && (unwrappingState === "pending" || unwrappingState === "idle") && /* @__PURE__ */ jsx9(LoadingSpinner_default, { size: "5" }),
+            (hasSucceeded || unwrappingState === "success") && /* @__PURE__ */ jsx9(Checkmark, { className: "h-8 w-8" }),
+            isError && /* @__PURE__ */ jsx9(RedoIcon, { className: "h-[12px] w-[12px]" })
+          ] })
+        ] })
+      }
+    ),
+    showCancel && /* @__PURE__ */ jsx9(
+      "button",
+      {
+        type: "button",
+        className: "inline-flex h-12 items-center justify-center px-8 text-sm font-medium transition duration-150 cursor-pointer",
+        style: {
+          backgroundColor: "color-mix(in srgb, var(--widget-status-failed) 12%, transparent)",
+          border: "1px solid color-mix(in srgb, var(--widget-status-failed) 20%, transparent)",
+          color: "var(--widget-status-failed)",
+          borderRadius: "var(--widget-radius)"
+        },
+        onClick: cancel,
+        children: "Cancel"
+      }
+    )
+  ] });
+};
+var ReviewActionUnwrapGasToken_default = ReviewActionUnwrapGasToken;
+
+// src/components/states/ReviewActionWrapGasToken.tsx
+import { useCallback as useCallback9, useEffect as useEffect11, useState as useState8, useRef as useRef10 } from "react";
+import { parseUnits as parseUnits3 } from "viem";
+import { useAccount as useAccount4, useWriteContract as useWriteContract2 } from "wagmi";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+var WALLET_TIMEOUT_MS3 = 15e3;
+var ComponentStep5 = "wrapping";
+var ReviewActionWrapGasToken = ({
+  needsToWrap,
+  amount,
+  chainId,
+  token,
+  reviewState,
+  setReviewState,
+  goToNextStep,
+  cancel,
+  delayedClose,
+  isWrappingPair
+}) => {
+  const hasSucceeded = isReviewStepPast(ComponentStep5, reviewState);
+  const [wrappingState, setWrappingState] = useState8("idle");
+  const wrapMutation = useWrapToken();
+  const { writeContractAsync } = useWriteContract2();
+  const { address } = useWalletState();
+  const emitBalanceEvent = useEmitBalanceEvent();
+  const isWrapping = useRef10(false);
+  const wrapAttempted = useRef10(false);
+  const timeoutRef = useRef10(null);
+  const { status: wagmiStatus } = useAccount4();
+  const clearPendingTimeout = useCallback9(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  const handleWrap = useCallback9(async () => {
+    if (isWrapping.current || wrapAttempted.current || !address || wagmiStatus !== "connected") return;
+    isWrapping.current = true;
+    wrapAttempted.current = true;
+    setWrappingState("pending");
+    timeoutRef.current = setTimeout(() => {
+      if (isWrapping.current) {
+        setWrappingState("error");
+        isWrapping.current = false;
+      }
+    }, WALLET_TIMEOUT_MS3);
+    try {
+      const chainConfig = getChainConfig(chainId);
+      if (!chainConfig) throw new Error(`No config for chain ${chainId}`);
+      const amountRaw = parseUnits3(amount.toString(), chainConfig.nativeAsset.decimals);
+      await wrapMutation.mutateAsync({
+        chainId,
+        accountAddress: address,
+        amountRaw,
+        writeContractAsync
+      });
+      const nativeAsset = {
+        symbol: chainConfig.nativeAsset.symbol,
+        name: chainConfig.nativeAsset.name,
+        address: NATIVE_ASSET_ADDRESS,
+        decimals: chainConfig.nativeAsset.decimals,
+        chainId
+      };
+      const wrappedAsset = {
+        symbol: chainConfig.wrappedAsset.symbol,
+        name: chainConfig.wrappedAsset.name,
+        address: chainConfig.wrappedAsset.address,
+        decimals: chainConfig.wrappedAsset.decimals,
+        chainId
+      };
+      emitBalanceEvent({
+        type: "wrap",
+        tokens: [
+          { asset: nativeAsset, userAddress: address },
+          { asset: wrappedAsset, userAddress: address }
+        ]
+      });
+      clearPendingTimeout();
+      setWrappingState("success");
+      goToNextStep(ComponentStep5, reviewState);
+      if (isWrappingPair) await delayedClose();
+    } catch {
+      clearPendingTimeout();
+      setWrappingState("error");
+    } finally {
+      isWrapping.current = false;
+    }
+  }, [address, wagmiStatus, chainId, amount, wrapMutation, writeContractAsync, emitBalanceEvent, goToNextStep, reviewState, delayedClose, isWrappingPair, clearPendingTimeout]);
+  useEffect11(() => {
+    if (isWrapping.current || wrapAttempted.current) return;
+    if (reviewState === ComponentStep5 && wrappingState === "idle" && wagmiStatus === "connected") {
+      if (needsToWrap) handleWrap();
+      else {
+        setWrappingState("success");
+        goToNextStep(ComponentStep5, reviewState);
+      }
+    }
+  }, [reviewState, wrappingState, needsToWrap, wagmiStatus, handleWrap, goToNextStep]);
+  useEffect11(() => () => clearPendingTimeout(), [clearPendingTimeout]);
+  const handleRetry = () => {
+    if (wrappingState === "error") {
+      wrapAttempted.current = false;
+      setWrappingState("idle");
+    }
+  };
+  const isError = !hasSucceeded && wrappingState === "error";
+  const showCancel = !hasSucceeded && (wrappingState === "pending" || wrappingState === "idle" || wrappingState === "error");
+  const statusVar = isError ? "var(--widget-status-failed)" : "var(--widget-status-pending)";
+  return /* @__PURE__ */ jsxs8("div", { className: "flex w-full flex-row justify-between space-x-3", children: [
+    /* @__PURE__ */ jsx10(
+      "button",
+      {
+        type: "button",
+        className: `inline-flex h-12 w-full items-center justify-center text-sm font-medium transition duration-150 ${isError ? "cursor-pointer" : "cursor-not-allowed"}`,
+        style: {
+          backgroundColor: `color-mix(in srgb, ${statusVar} 12%, transparent)`,
+          border: `1px solid color-mix(in srgb, ${statusVar} 20%, transparent)`,
+          color: statusVar,
+          borderRadius: "var(--widget-radius)"
+        },
+        onClick: isError ? handleRetry : void 0,
+        children: /* @__PURE__ */ jsxs8("div", { className: "flex h-10 w-full flex-row items-center space-x-3 px-4", children: [
+          /* @__PURE__ */ jsx10("p", { className: "whitespace-nowrap", children: isError ? "Retry Wrap" : token ? `Wrap ${token.symbol}` : "Wrap Native Token" }),
+          /* @__PURE__ */ jsx10("div", { className: "flex flex-1 border-t", style: { borderColor: "var(--widget-border)" } }),
+          /* @__PURE__ */ jsxs8("div", { className: "flex h-6 w-3 items-center justify-center rounded-full", children: [
+            !hasSucceeded && (wrappingState === "pending" || wrappingState === "idle") && /* @__PURE__ */ jsx10(LoadingSpinner_default, { size: "5" }),
+            (hasSucceeded || wrappingState === "success") && /* @__PURE__ */ jsx10(Checkmark, { className: "h-8 w-8" }),
+            isError && /* @__PURE__ */ jsx10(RedoIcon, { className: "h-[12px] w-[12px]" })
+          ] })
+        ] })
+      }
+    ),
+    showCancel && /* @__PURE__ */ jsx10(
+      "button",
+      {
+        type: "button",
+        className: "inline-flex h-12 items-center justify-center px-8 text-sm font-medium transition duration-150 cursor-pointer",
+        style: {
+          backgroundColor: "color-mix(in srgb, var(--widget-status-failed) 12%, transparent)",
+          border: "1px solid color-mix(in srgb, var(--widget-status-failed) 20%, transparent)",
+          color: "var(--widget-status-failed)",
+          borderRadius: "var(--widget-radius)"
+        },
+        onClick: cancel,
+        children: "Cancel"
+      }
+    )
+  ] });
+};
+var ReviewActionWrapGasToken_default = ReviewActionWrapGasToken;
+
+// src/components/states/SwapButton.tsx
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+var SwapButton = ({
+  base,
+  baseAmount,
+  quote,
+  quoteAmount,
+  userAddress,
+  isWrappingPair,
+  isUnwrappingPair,
+  isBaseGasToken,
+  isQuoteGasToken,
+  reviewActionProps,
+  reviewState,
+  setReviewState,
+  trackedOrderHash,
+  setTrackedOrderHash,
+  txStatus,
+  onSwapComplete,
+  onSwapInitiated,
+  onOrderSubmitted,
+  onStaleQuoteRestart,
+  setExitHandler,
+  setRetryHandler
+}) => {
+  const {
+    rfqQuote,
+    status: rfqStatus,
+    liquidityError,
+    routingError,
+    sizeCapError,
+    stop,
+    clear
+  } = useRfq();
+  const { clearForm } = useSwapFormContext();
+  const currentChainId = useChainId2();
+  const { swapButtonVariant, widgetType } = useWidgetConfig();
+  const isCompact = widgetType === "compact";
+  const { trackOrderTransaction, trackNativeTransaction } = useTransactionTracker();
+  const { startPolling } = useOrderStatusPolling((orderHash, status) => {
+    useWidgetSwapUIStore.getState().setTxStatus(status);
+    if (status === "completed") {
+      trackOrderTransaction(orderHash, `Swap ${base.symbol} \u2192 ${quote.symbol}`);
+    }
+  });
+  const [isRestarting, setIsRestarting] = useState9(false);
+  const awaitingAutoResumeRef = useRef11(false);
+  const restartTimerRef = useRef11(null);
+  const needsToWrap = isWrappingPair;
+  const needsToUnwrap = isUnwrappingPair;
+  const needsSignature = !isWrappingPair && !isUnwrappingPair;
+  const needsChainSwitch = currentChainId !== base?.chainId && (needsToWrap || needsToUnwrap || needsSignature);
+  const chainConfig = getChainConfig(base.chainId);
+  const requiredChain = {
+    chainId: base.chainId,
+    name: chainConfig?.displayName ?? `Chain ${base.chainId}`
+  };
+  const goToNextStep = useCallback10(
+    (componentStep, currentStep) => {
+      if (currentStep !== componentStep) return;
+      if (componentStep === "chain") {
+        if (needsToWrap) {
+          setReviewState("wrapping");
+          return;
+        }
+        if (needsToUnwrap) {
+          setReviewState("unwrapping");
+          return;
+        }
+        setReviewState("signingOrder");
+        return;
+      }
+      if (componentStep === "signingOrder") {
+        setReviewState("trackingTx");
+        return;
+      }
+      if (componentStep === "wrapping") {
+        if (!isWrappingPair) {
+          setReviewState("signingOrder");
+          return;
+        }
+        setReviewState("wrapSuccess");
+        return;
+      }
+      if (componentStep === "unwrapping") {
+        setReviewState("wrapSuccess");
+        return;
+      }
+      const nextStep = getNextReviewStep(componentStep);
+      if (nextStep) setReviewState(nextStep);
+    },
+    [
+      setReviewState,
+      isWrappingPair,
+      needsToWrap,
+      needsToUnwrap,
+      needsSignature
+    ]
+  );
+  const determineInitialStep = useCallback10(() => {
+    if (needsChainSwitch) return "chain";
+    if (needsToWrap) return "wrapping";
+    if (needsToUnwrap) return "unwrapping";
+    if (needsSignature) return "signingOrder";
+    return null;
+  }, [
+    needsChainSwitch,
+    needsToWrap,
+    needsToUnwrap,
+    needsSignature
+  ]);
+  const resetState = useCallback10(() => {
+    setReviewState(null);
+    clearForm();
+  }, [clearForm, setReviewState]);
+  const delayedClose = useCallback10(async () => {
+    setReviewState("wrapSuccess");
+    for (let i = 0; i < 3; i++) {
+      await sleep(700);
+    }
+    resetState();
+  }, [resetState, setReviewState]);
+  const cancel = useCallback10(async () => {
+    clear();
+    setReviewState("cancelled");
+    for (let i = 0; i < 3; i++) {
+      await sleep(500);
+    }
+    resetState();
+  }, [clear, resetState, setReviewState]);
+  const handleNewSwap = useCallback10(() => {
+    if (!trackedOrderHash) return;
+    useWidgetSwapUIStore.getState().stopTracking();
+    setReviewState(null);
+    setTrackedOrderHash(null);
+    clearForm();
+  }, [trackedOrderHash, setReviewState, setTrackedOrderHash, clearForm]);
+  const handleRetrySwap = useCallback10(() => {
+    setReviewState(null);
+    setTrackedOrderHash(null);
+    awaitingAutoResumeRef.current = true;
+    onStaleQuoteRestart?.();
+  }, [setReviewState, setTrackedOrderHash, onStaleQuoteRestart]);
+  const handleReview = useCallback10(() => {
+    if (reviewActionProps) {
+      setReviewState(determineInitialStep());
+    }
+  }, [determineInitialStep, reviewActionProps, setReviewState]);
+  const restartSigningFlow = useCallback10(
+    (isFromStaleState = false) => {
+      if (isFromStaleState) {
+        awaitingAutoResumeRef.current = true;
+        setReviewState(null);
+        onStaleQuoteRestart?.();
+      } else {
+        setReviewState(null);
+        restartTimerRef.current = setTimeout(() => {
+          if (reviewActionProps) {
+            setReviewState(determineInitialStep());
+            setIsRestarting(false);
+          }
+        }, 100);
+      }
+    },
+    [
+      setReviewState,
+      reviewActionProps,
+      determineInitialStep,
+      onStaleQuoteRestart
+    ]
+  );
+  useEffect12(() => {
+    if (reviewState !== null) stop();
+  }, [reviewState, stop]);
+  useEffect12(() => {
+    if (reviewState !== null && isRestarting) setIsRestarting(false);
+  }, [reviewState, isRestarting]);
+  useEffect12(() => {
+    setExitHandler?.(handleNewSwap);
+  }, [setExitHandler, handleNewSwap]);
+  useEffect12(() => {
+    setRetryHandler?.(handleRetrySwap);
+  }, [setRetryHandler, handleRetrySwap]);
+  useEffect12(() => {
+    return () => {
+      if (restartTimerRef.current) clearTimeout(restartTimerRef.current);
+    };
+  }, []);
+  useEffect12(() => {
+    if (awaitingAutoResumeRef.current && rfqStatus === "fresh" && rfqQuote?.id) {
+      awaitingAutoResumeRef.current = false;
+      setReviewState("signingOrder");
+    }
+  }, [rfqStatus, rfqQuote?.id, setReviewState]);
+  const getIdleButtonStyle = (active) => {
+    if (!active) {
+      return {
+        backgroundColor: swapButtonVariant === "default" ? "var(--widget-muted)" : "transparent",
+        color: "var(--widget-muted-foreground)",
+        border: swapButtonVariant !== "default" ? "1px solid var(--widget-border)" : "none",
+        borderRadius: "var(--widget-radius)"
+      };
+    }
+    switch (swapButtonVariant) {
+      case "outline":
+        return {
+          backgroundColor: "transparent",
+          color: "var(--widget-primary)",
+          border: "1px solid var(--widget-primary)",
+          borderRadius: "var(--widget-radius)"
+        };
+      case "ghost":
+        return {
+          backgroundColor: "transparent",
+          color: "var(--widget-primary)",
+          border: "none",
+          borderRadius: "var(--widget-radius)"
+        };
+      default:
+        return {
+          backgroundColor: "var(--widget-primary)",
+          color: "var(--widget-primary-foreground)",
+          borderRadius: "var(--widget-radius)"
+        };
+    }
+  };
+  const idleButtonClass = `w-full ${isCompact ? "py-2" : "py-3"} text-sm font-medium transition-colors cursor-pointer mt-1`;
+  if (reviewState === null && !isWrappingPair && !isUnwrappingPair) {
+    if (isRestarting) {
+      return /* @__PURE__ */ jsx11(
+        "button",
+        {
+          className: idleButtonClass,
+          disabled: true,
+          style: {
+            ...getIdleButtonStyle(false),
+            opacity: 0.6,
+            cursor: "not-allowed"
+          },
+          children: "Getting fresh quote..."
+        }
+      );
+    }
+    const getIdleText = () => {
+      if (liquidityError) return "Insufficient Liquidity";
+      if (routingError) return "Route Not Available";
+      if (sizeCapError) return "Size Cap Exceeded";
+      if (!rfqQuote && rfqStatus === "polling") return "Getting Quote...";
+      if (!rfqQuote) return "Enter Amount";
+      return "Swap";
+    };
+    const isActive = !!reviewActionProps;
+    return /* @__PURE__ */ jsx11(
+      "button",
+      {
+        onClick: isActive ? handleReview : void 0,
+        disabled: !isActive,
+        className: `${idleButtonClass} disabled:opacity-40 disabled:cursor-not-allowed`,
+        style: getIdleButtonStyle(isActive),
+        children: getIdleText()
+      }
+    );
+  }
+  if (reviewState === null && isUnwrappingPair) {
+    return /* @__PURE__ */ jsx11(
+      "button",
+      {
+        onClick: reviewActionProps ? handleReview : void 0,
+        disabled: !reviewActionProps,
+        className: `${idleButtonClass} disabled:opacity-40 disabled:cursor-not-allowed`,
+        style: getIdleButtonStyle(!!reviewActionProps),
+        children: "Unwrap"
+      }
+    );
+  }
+  if (reviewState === null && isWrappingPair) {
+    return /* @__PURE__ */ jsx11(
+      "button",
+      {
+        onClick: reviewActionProps ? handleReview : void 0,
+        disabled: !reviewActionProps,
+        className: `${idleButtonClass} disabled:opacity-40 disabled:cursor-not-allowed`,
+        style: getIdleButtonStyle(!!reviewActionProps),
+        children: "Wrap"
+      }
+    );
+  }
+  if (reviewState === "success") {
+    return /* @__PURE__ */ jsx11("div", { className: "flex flex-col gap-2 w-full", children: /* @__PURE__ */ jsx11(
+      "button",
+      {
+        className: `w-full ${isCompact ? "py-2" : "py-3"} text-sm font-medium cursor-default`,
+        style: {
+          backgroundColor: "color-mix(in srgb, var(--widget-status-completed) 15%, transparent)",
+          color: "var(--widget-status-completed)",
+          border: "1px solid color-mix(in srgb, var(--widget-status-completed) 20%, transparent)",
+          borderRadius: "var(--widget-radius)"
+        },
+        children: "Order Placed"
+      }
+    ) });
+  }
+  if (reviewState === "wrapSuccess") {
+    return /* @__PURE__ */ jsx11("div", { className: "flex flex-col gap-2 w-full", children: /* @__PURE__ */ jsx11(
+      "button",
+      {
+        className: `w-full ${isCompact ? "py-2" : "py-3"} text-sm font-medium cursor-default`,
+        style: {
+          backgroundColor: "color-mix(in srgb, var(--widget-status-completed) 15%, transparent)",
+          color: "var(--widget-status-completed)",
+          border: "1px solid color-mix(in srgb, var(--widget-status-completed) 20%, transparent)",
+          borderRadius: "var(--widget-radius)"
+        },
+        children: isWrappingPair ? "Wrapped Successfully" : "Unwrapped Successfully"
+      }
+    ) });
+  }
+  if (reviewState === "cancelled") {
+    return /* @__PURE__ */ jsx11("div", { className: "flex flex-col gap-2 w-full", children: /* @__PURE__ */ jsx11(
+      "button",
+      {
+        onClick: resetState,
+        className: `w-full ${isCompact ? "py-2" : "py-3"} text-sm font-medium cursor-pointer`,
+        style: {
+          backgroundColor: "color-mix(in srgb, var(--widget-status-failed) 15%, transparent)",
+          color: "var(--widget-status-failed)",
+          border: "1px solid color-mix(in srgb, var(--widget-status-failed) 20%, transparent)",
+          borderRadius: "var(--widget-radius)"
+        },
+        children: "Order Cancelled"
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsxs9("div", { className: "flex w-full", children: [
+    reviewState === "chain" && needsChainSwitch && /* @__PURE__ */ jsx11(
+      ReviewActionChainSwitchRow_default,
+      {
+        requiredChain,
+        needsChainSwitch: needsChainSwitch && currentChainId !== base.chainId,
+        reviewState,
+        goToNextStep,
+        cancel
+      }
+    ),
+    reviewState === "wrapping" && needsToWrap && /* @__PURE__ */ jsx11(
+      ReviewActionWrapGasToken_default,
+      {
+        needsToWrap,
+        amount: baseAmount,
+        chainId: base.chainId,
+        token: base,
+        reviewState,
+        setReviewState,
+        goToNextStep,
+        cancel,
+        delayedClose,
+        isWrappingPair
+      }
+    ),
+    reviewState === "unwrapping" && needsToUnwrap && /* @__PURE__ */ jsx11(
+      ReviewActionUnwrapGasToken_default,
+      {
+        needsToUnwrap,
+        amount: baseAmount,
+        chainId: base.chainId,
+        token: base,
+        reviewState,
+        setReviewState,
+        goToNextStep,
+        cancel,
+        delayedClose
+      }
+    ),
+    reviewState === "signingOrder" && needsSignature && /* @__PURE__ */ jsx11(
+      ReviewActionSignAndSubmitOrderRow_default,
+      {
+        base,
+        baseAmount,
+        quote,
+        quoteAmount,
+        userAddress,
+        reviewState,
+        goToNextStep,
+        cancel,
+        restartSigningFlow,
+        onSwapInitiated,
+        onOrderSubmitted,
+        isWrappingPair,
+        isUnwrappingPair,
+        onSwapComplete,
+        startPolling,
+        trackNativeTransaction
+      }
+    ),
+    reviewState === "trackingTx" && trackedOrderHash && /* @__PURE__ */ jsx11(
+      ReviewActionTxRow_default,
+      {
+        orderHash: trackedOrderHash,
+        base,
+        quote,
+        baseAmount,
+        quoteAmount,
+        reviewState,
+        status: txStatus,
+        onNewSwap: handleNewSwap,
+        onRetry: handleRetrySwap
+      }
+    ),
+    reviewState && ![
+      "chain",
+      "wrapping",
+      "unwrapping",
+      "approval",
+      "signingOrder",
+      "trackingTx",
+      "success",
+      "wrapSuccess",
+      "cancelled"
+    ].includes(reviewState) && /* @__PURE__ */ jsx11(
+      "button",
+      {
+        disabled: true,
+        className: `w-full ${isCompact ? "py-2" : "py-3"} text-sm font-medium`,
+        style: {
+          backgroundColor: "var(--widget-muted)",
+          color: "var(--widget-muted-foreground)",
+          borderRadius: "var(--widget-radius)"
+        },
+        children: "Processing..."
+      }
+    )
+  ] });
+};
+
+// src/components/states/TxStatusDisplay.tsx
+import { useState as useState10, useCallback as useCallback11, useRef as useRef12, useEffect as useEffect13 } from "react";
+import { useShallow } from "zustand/react/shallow";
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+var statusVarMap = {
+  pending: "var(--widget-status-pending)",
+  received: "var(--widget-status-received)",
+  completed: "var(--widget-status-completed)",
+  failed: "var(--widget-status-failed)",
+  cancelled: "var(--widget-status-failed)"
+};
+var statusLabels = {
+  pending: { title: "Trade Pending", subtitle: "Submitting to network" },
+  received: { title: "Trade Received", subtitle: "Processing settlement" },
+  completed: { title: "Trade Filled", subtitle: "Settlement complete" },
+  failed: { title: "Trade Failed", subtitle: "Settlement unsuccessful" },
+  cancelled: { title: "Trade Cancelled", subtitle: "Order was cancelled" }
+};
+function getStatusStyles(status) {
+  const v = statusVarMap[status] ?? statusVarMap.pending;
+  return {
+    textColor: v,
+    bgColor: `color-mix(in srgb, ${v} 15%, transparent)`,
+    borderColor: `color-mix(in srgb, ${v} 20%, transparent)`,
+    cardBgColor: `color-mix(in srgb, ${v} 8%, transparent)`,
+    cardBorderColor: `color-mix(in srgb, ${v} 15%, transparent)`,
+    iconBgColor: `color-mix(in srgb, ${v} 12%, transparent)`,
+    iconBorderColor: `color-mix(in srgb, ${v} 15%, transparent)`
+  };
+}
+var StatusIcon = ({ status }) => {
+  switch (status) {
+    case "completed":
+      return /* @__PURE__ */ jsx12(Checkmark, {});
+    case "failed":
+    case "cancelled":
+      return /* @__PURE__ */ jsx12(XAnimation, {});
+    default:
+      return /* @__PURE__ */ jsx12(LoadingSpinner_default, { size: "10" });
+  }
+};
+var TxStatusDisplay = ({
+  orderHash,
+  base,
+  quote,
+  baseAmount,
+  quoteAmount,
+  status
+}) => {
+  const [copied, setCopied] = useState10(false);
+  const receivedTimeRef = useRef12(null);
+  const submissionTimeRef = useRef12(Date.now());
+  const [transactionSpeed, setTransactionSpeed] = useState10(null);
+  const copyTimerRef = useRef12(null);
+  const { isRecipientInputOpen, recipient } = useWidgetSwapUIStore(
+    useShallow((state) => ({
+      isRecipientInputOpen: state.isRecipientInputOpen,
+      recipient: state.recipient
+    }))
+  );
+  useEffect13(() => {
+    if (status === "received") receivedTimeRef.current = Date.now();
+  }, [status]);
+  useEffect13(() => {
+    if (status === "completed" && !transactionSpeed) {
+      const startTime = receivedTimeRef.current || submissionTimeRef.current;
+      setTransactionSpeed((Date.now() - startTime) / 1e3);
+    }
+  }, [status, transactionSpeed]);
+  useEffect13(() => {
+    return () => {
+      if (copyTimerRef.current) clearTimeout(copyTimerRef.current);
+    };
+  }, []);
+  const handleCopyHash = useCallback11(() => {
+    if (!navigator.clipboard?.writeText) return;
+    navigator.clipboard.writeText(orderHash).then(() => {
+      setCopied(true);
+      if (copyTimerRef.current) clearTimeout(copyTimerRef.current);
+      copyTimerRef.current = setTimeout(() => setCopied(false), 2e3);
+    }).catch(() => {
+    });
+  }, [orderHash]);
+  const labels = statusLabels[status] ?? statusLabels.pending;
+  const config = getStatusStyles(status);
+  const formattedBaseAmount = formatNumber(baseAmount);
+  const formattedQuoteAmount = formatNumber(quoteAmount);
+  return /* @__PURE__ */ jsx12(
+    "div",
+    {
+      className: "relative w-full h-full overflow-hidden flex flex-col",
+      style: {
+        backgroundColor: config.bgColor,
+        border: `1px var(--widget-border-style) ${config.borderColor}`,
+        backdropFilter: "blur(8px)"
+      },
+      children: /* @__PURE__ */ jsxs10("div", { className: "relative z-10 px-3 pt-5 pb-3 flex-1 flex flex-col", children: [
+        /* @__PURE__ */ jsx12("div", { className: "flex items-center justify-center mb-2", children: /* @__PURE__ */ jsxs10("div", { className: "flex flex-col items-center gap-1 text-center", children: [
+          /* @__PURE__ */ jsx12(
+            "div",
+            {
+              className: "flex h-10 w-10 items-center justify-center rounded-full border",
+              style: {
+                backgroundColor: config.iconBgColor,
+                borderColor: config.iconBorderColor
+              },
+              children: /* @__PURE__ */ jsx12("div", { className: "h-7 w-7 flex items-center justify-center", children: /* @__PURE__ */ jsx12(StatusIcon, { status }) })
+            }
+          ),
+          /* @__PURE__ */ jsxs10("div", { children: [
+            /* @__PURE__ */ jsx12(
+              "h3",
+              {
+                className: "text-xl font-bold",
+                style: { color: config.textColor },
+                children: labels.title
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              "p",
+              {
+                className: "text-2xs uppercase tracking-wider",
+                style: { color: config.textColor, opacity: 0.6 },
+                children: labels.subtitle
+              }
+            )
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsx12("div", { className: "flex-1 flex flex-col justify-center", children: /* @__PURE__ */ jsxs10("div", { className: "space-y-1.5", children: [
+          /* @__PURE__ */ jsxs10(
+            "div",
+            {
+              className: "flex items-center justify-between backdrop-blur-sm p-2.5 border transition-all duration-300",
+              style: {
+                backgroundColor: config.cardBgColor,
+                borderColor: config.cardBorderColor
+              },
+              children: [
+                /* @__PURE__ */ jsxs10("div", { className: "flex items-center gap-2.5", children: [
+                  /* @__PURE__ */ jsx12(TokenImage_default, { asset: base, size: "sm" }),
+                  /* @__PURE__ */ jsxs10("div", { children: [
+                    /* @__PURE__ */ jsx12(
+                      "div",
+                      {
+                        className: "text-sm font-bold",
+                        style: { color: config.textColor },
+                        children: base.symbol
+                      }
+                    ),
+                    /* @__PURE__ */ jsx12(
+                      "div",
+                      {
+                        className: "text-2xs",
+                        style: { color: config.textColor, opacity: 0.5 },
+                        children: base.name
+                      }
+                    )
+                  ] })
+                ] }),
+                /* @__PURE__ */ jsxs10("div", { className: "text-right", children: [
+                  /* @__PURE__ */ jsx12(
+                    "div",
+                    {
+                      className: "text-lg font-bold mono",
+                      style: { color: config.textColor },
+                      children: formattedBaseAmount
+                    }
+                  ),
+                  base.price && /* @__PURE__ */ jsxs10(
+                    "div",
+                    {
+                      className: "text-2xs mono",
+                      style: { color: config.textColor, opacity: 0.5 },
+                      children: [
+                        "$",
+                        (base.price * baseAmount).toFixed(2)
+                      ]
+                    }
+                  )
+                ] })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx12("div", { className: "flex justify-center pb-0.5 pt-1", children: /* @__PURE__ */ jsx12(
+            "div",
+            {
+              className: "flex h-6 w-6 items-center justify-center rounded-full border",
+              style: {
+                backgroundColor: config.cardBgColor,
+                borderColor: config.cardBorderColor
+              },
+              children: /* @__PURE__ */ jsx12("span", { className: "text-base", style: { color: config.textColor }, children: "\u2193" })
+            }
+          ) }),
+          /* @__PURE__ */ jsxs10(
+            "div",
+            {
+              className: "flex items-center justify-between backdrop-blur-sm p-2.5 border transition-all duration-300",
+              style: {
+                backgroundColor: config.cardBgColor,
+                borderColor: config.cardBorderColor
+              },
+              children: [
+                /* @__PURE__ */ jsxs10("div", { className: "flex items-center gap-2.5", children: [
+                  /* @__PURE__ */ jsx12(TokenImage_default, { asset: quote, size: "sm" }),
+                  /* @__PURE__ */ jsxs10("div", { children: [
+                    /* @__PURE__ */ jsx12(
+                      "div",
+                      {
+                        className: "text-sm font-bold",
+                        style: { color: config.textColor },
+                        children: quote.symbol
+                      }
+                    ),
+                    /* @__PURE__ */ jsx12(
+                      "div",
+                      {
+                        className: "text-2xs",
+                        style: { color: config.textColor, opacity: 0.5 },
+                        children: quote.name
+                      }
+                    )
+                  ] })
+                ] }),
+                /* @__PURE__ */ jsxs10("div", { className: "text-right", children: [
+                  /* @__PURE__ */ jsx12(
+                    "div",
+                    {
+                      className: "text-lg font-bold mono",
+                      style: { color: config.textColor },
+                      children: formattedQuoteAmount
+                    }
+                  ),
+                  quote.price && /* @__PURE__ */ jsxs10(
+                    "div",
+                    {
+                      className: "text-2xs mono",
+                      style: { color: config.textColor, opacity: 0.5 },
+                      children: [
+                        "$",
+                        (quote.price * quoteAmount).toFixed(2)
+                      ]
+                    }
+                  )
+                ] })
+              ]
+            }
+          ),
+          isRecipientInputOpen && recipient && /* @__PURE__ */ jsxs10("div", { className: "mt-1.5", children: [
+            /* @__PURE__ */ jsx12(
+              "div",
+              {
+                className: "text-2xs mb-0.5 uppercase tracking-wider font-medium",
+                style: { color: config.textColor, opacity: 0.5 },
+                children: "Recipient"
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              "div",
+              {
+                className: "flex items-center backdrop-blur-sm p-2 border transition-all duration-300",
+                style: {
+                  backgroundColor: config.cardBgColor,
+                  borderColor: config.cardBorderColor
+                },
+                children: /* @__PURE__ */ jsxs10("div", { className: "flex items-center gap-2", children: [
+                  /* @__PURE__ */ jsx12(
+                    "div",
+                    {
+                      className: "flex h-5 w-5 items-center justify-center overflow-hidden rounded-full",
+                      style: { backgroundColor: config.iconBgColor },
+                      children: /* @__PURE__ */ jsx12("span", { className: "text-2xs", children: "\u{1F464}" })
+                    }
+                  ),
+                  /* @__PURE__ */ jsxs10("div", { className: "flex flex-col", children: [
+                    /* @__PURE__ */ jsx12(
+                      "div",
+                      {
+                        className: "text-2xs",
+                        style: { color: config.textColor, opacity: 0.5 },
+                        children: "To:"
+                      }
+                    ),
+                    /* @__PURE__ */ jsxs10(
+                      "div",
+                      {
+                        className: "text-xs mono",
+                        style: { color: config.textColor },
+                        children: [
+                          recipient.slice(0, 6),
+                          "...",
+                          recipient.slice(-4)
+                        ]
+                      }
+                    )
+                  ] })
+                ] })
+              }
+            )
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsxs10(
+          "div",
+          {
+            className: "mt-3 pt-2.5 space-y-1.5",
+            style: { borderTop: `1px solid ${config.cardBorderColor}` },
+            children: [
+              /* @__PURE__ */ jsxs10(
+                "div",
+                {
+                  role: "button",
+                  tabIndex: 0,
+                  onClick: handleCopyHash,
+                  onKeyDown: (e) => {
+                    if (e.key === "Enter" || e.key === " ") {
+                      e.preventDefault();
+                      handleCopyHash();
+                    }
+                  },
+                  className: "flex items-center justify-between cursor-pointer group hover:opacity-80 transition-opacity",
+                  children: [
+                    /* @__PURE__ */ jsx12(
+                      "div",
+                      {
+                        className: "text-xs uppercase tracking-wider font-medium",
+                        style: { color: config.textColor, opacity: 0.5 },
+                        children: copied ? "Copied!" : status === "completed" || status === "failed" || status === "cancelled" ? "Order Hash" : status === "received" ? "Received" : "Pending"
+                      }
+                    ),
+                    /* @__PURE__ */ jsxs10(
+                      "div",
+                      {
+                        className: "text-xs mono transition-colors",
+                        style: { color: config.textColor },
+                        children: [
+                          orderHash.slice(0, 6),
+                          "...",
+                          orderHash.slice(-4)
+                        ]
+                      }
+                    )
+                  ]
+                }
+              ),
+              status === "completed" && transactionSpeed ? /* @__PURE__ */ jsxs10("div", { className: "flex items-center justify-between", children: [
+                /* @__PURE__ */ jsx12(
+                  "div",
+                  {
+                    className: "text-xs uppercase tracking-wider font-medium",
+                    style: { color: config.textColor, opacity: 0.5 },
+                    children: "Speed"
+                  }
+                ),
+                /* @__PURE__ */ jsxs10(
+                  "div",
+                  {
+                    className: "text-base font-bold mono",
+                    style: { color: config.textColor },
+                    children: [
+                      transactionSpeed.toFixed(2),
+                      "s"
+                    ]
+                  }
+                )
+              ] }) : /* @__PURE__ */ jsx12("div", { className: "h-5" })
+            ]
+          }
+        )
+      ] })
+    }
+  );
+};
+var TxStatusDisplay_default = TxStatusDisplay;
+
+export {
+  useBalanceEventListener,
+  useEmitBalanceEvent,
+  useBalanceEventSubscription,
+  RfqProvider,
+  useRfq,
+  WalletModalContext,
+  useWalletModal,
+  AssetAmountInput_default,
+  AssetSelection_default,
+  RecipientForm_default,
+  pollOrderStatus,
+  useOrderStatusPolling,
+  useTransactionRegistry,
+  ChainSwitch,
+  SignSwap,
+  isQuoteFresh,
+  canSubmitOrder,
+  markOrderAsSubmitted,
+  cleanupOldSubmissions,
+  useUnwrapToken,
+  useWrapToken,
+  SwapButton,
+  TxStatusDisplay_default
+};
+//# sourceMappingURL=chunk-ARMW5POL.js.map