@rhinestone/deposit-modal 0.1.20 → 0.1.22

package/dist/chunk-J7UK4L5T.mjs

@@ -0,0 +1,1524 @@
+import {
+  Button,
+  ConnectStep,
+  Modal,
+  PoweredBy,
+  ProcessingStep,
+  accountFromPrivateKey,
+  applyTheme,
+  createDepositService,
+  createSessionOwnerKey,
+  createSmartAccount,
+  createViewOnlyAccount,
+  currencyFormatter,
+  formatUserError,
+  getAccountAddress,
+  getAccountInitData,
+  getAssetId,
+  getPublicClient,
+  getSessionDetails,
+  isNativeAsset,
+  loadSessionOwnerFromStorage,
+  saveSessionOwnerToStorage
+} from "./chunk-JBT2ZV3Q.mjs";
+import {
+  CHAIN_BY_ID,
+  DEFAULT_BACKEND_URL,
+  DEFAULT_SIGNER_ADDRESS,
+  NATIVE_TOKEN_ADDRESS,
+  SOURCE_CHAINS,
+  getChainIcon,
+  getChainId,
+  getChainName,
+  getSupportedTargetTokens,
+  getTokenDecimalsByAddress,
+  getTokenIcon,
+  getTokenSymbol
+} from "./chunk-A6QLADED.mjs";
+
+// src/WithdrawModal.tsx
+import {
+  useCallback as useCallback3,
+  useEffect as useEffect3,
+  useMemo as useMemo3,
+  useRef as useRef2,
+  useState as useState3,
+  lazy,
+  Suspense
+} from "react";
+
+// src/WithdrawFlow.tsx
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useState as useState2 } from "react";
+
+// src/components/steps/WithdrawFormStep.tsx
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { erc20Abi, formatUnits, parseUnits } from "viem";
+import { jsx, jsxs } from "react/jsx-runtime";
+function useClickOutside(ref, onClose) {
+  useEffect(() => {
+    function handleClick(e) {
+      if (ref.current && !ref.current.contains(e.target)) {
+        onClose();
+      }
+    }
+    document.addEventListener("mousedown", handleClick);
+    return () => document.removeEventListener("mousedown", handleClick);
+  }, [ref, onClose]);
+}
+function WithdrawFormStep({
+  walletClient,
+  publicClient,
+  address,
+  safeAddress,
+  asset,
+  defaultRecipient,
+  defaultAmount,
+  targetChain,
+  targetToken,
+  targetChains,
+  targetTokenOptions,
+  onTargetChainChange,
+  onTargetTokenChange,
+  switchChain,
+  submitting = false,
+  onSubmit,
+  onBalanceUsdChange
+}) {
+  const [recipient, setRecipient] = useState(
+    defaultRecipient ?? address ?? ""
+  );
+  const [amount, setAmount] = useState(defaultAmount ?? "");
+  const [balance, setBalance] = useState(null);
+  const [error, setError] = useState(null);
+  const [isSwitching, setIsSwitching] = useState(false);
+  const [showChainDropdown, setShowChainDropdown] = useState(false);
+  const [showTokenDropdown, setShowTokenDropdown] = useState(false);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const hasAttemptedSwitch = useRef(false);
+  const chainDropdownRef = useRef(null);
+  const tokenDropdownRef = useRef(null);
+  const publicClientChainId = publicClient.chain?.id;
+  useClickOutside(chainDropdownRef, () => setShowChainDropdown(false));
+  useClickOutside(tokenDropdownRef, () => setShowTokenDropdown(false));
+  const isRecipientConnected = Boolean(
+    address && recipient && recipient.toLowerCase() === address.toLowerCase()
+  );
+  const chainMismatch = Boolean(
+    walletClient?.chain?.id && walletClient.chain.id !== asset.chainId
+  );
+  const targetSymbol = getTokenSymbol(targetToken, targetChain);
+  const targetChainName = getChainName(targetChain);
+  const isBusy = submitting || isSubmitting;
+  useEffect(() => {
+    if (chainMismatch && switchChain && !hasAttemptedSwitch.current) {
+      hasAttemptedSwitch.current = true;
+      setIsSwitching(true);
+      switchChain(asset.chainId).catch((err) => {
+        const raw = err instanceof Error ? err.message : "Failed to switch chain";
+        setError(formatUserError(raw));
+      }).finally(() => {
+        setIsSwitching(false);
+      });
+    }
+  }, [chainMismatch, switchChain, asset.chainId]);
+  useEffect(() => {
+    hasAttemptedSwitch.current = false;
+  }, [asset.chainId]);
+  useEffect(() => {
+    let active = true;
+    async function fetchBalance() {
+      if (!safeAddress || !publicClient) return;
+      if (publicClientChainId && publicClientChainId !== asset.chainId) {
+        return;
+      }
+      try {
+        const bal = isNativeAsset(asset) ? await publicClient.getBalance({ address: safeAddress }) : await publicClient.readContract({
+          address: asset.token,
+          abi: erc20Abi,
+          functionName: "balanceOf",
+          args: [safeAddress]
+        });
+        if (active) {
+          setBalance(bal);
+        }
+      } catch {
+        if (active) {
+          setBalance(null);
+        }
+      }
+    }
+    void fetchBalance();
+    const unwatch = publicClient.watchBlockNumber({
+      emitOnBegin: false,
+      onBlockNumber() {
+        void fetchBalance();
+      }
+    });
+    return () => {
+      active = false;
+      unwatch();
+    };
+  }, [safeAddress, publicClient, publicClientChainId, asset]);
+  const formattedBalance = useMemo(() => {
+    if (balance === null) return "...";
+    try {
+      const raw = formatUnits(balance, asset.decimals);
+      const numeric = Number(raw);
+      if (!Number.isFinite(numeric)) return raw;
+      return new Intl.NumberFormat("en-US", {
+        maximumFractionDigits: 2
+      }).format(numeric);
+    } catch {
+      return "...";
+    }
+  }, [balance, asset.decimals]);
+  useEffect(() => {
+    if (balance === null) return;
+    const sym = asset.symbol.toUpperCase();
+    if (sym !== "USDC" && sym !== "USDT") return;
+    try {
+      const raw = formatUnits(balance, asset.decimals);
+      const numeric = Number(raw);
+      if (!Number.isFinite(numeric)) return;
+      onBalanceUsdChange?.(numeric);
+    } catch {
+      return;
+    }
+  }, [balance, asset.decimals, asset.symbol, onBalanceUsdChange]);
+  const amountUsd = useMemo(() => {
+    if (!amount) return null;
+    const parsed = Number(amount);
+    if (!Number.isFinite(parsed) || parsed <= 0) return null;
+    const sym = asset.symbol.toUpperCase();
+    if (sym === "USDC" || sym === "USDT") {
+      return parsed;
+    }
+    return null;
+  }, [amount, asset.symbol]);
+  const handleMaxClick = useCallback(() => {
+    if (balance === null) return;
+    const maxAmount = formatUnits(balance, asset.decimals);
+    setAmount(maxAmount);
+    setError(null);
+  }, [balance, asset.decimals]);
+  const handleUseConnected = useCallback(() => {
+    if (!address) return;
+    setRecipient(address);
+    setError(null);
+  }, [address]);
+  const handleWithdraw = useCallback(async () => {
+    if (!recipient || !/^0x[a-fA-F0-9]{40}$/.test(recipient)) {
+      setError("Enter a valid recipient address");
+      return;
+    }
+    const parsed = Number(amount);
+    if (!amount || !Number.isFinite(parsed) || parsed <= 0) {
+      setError("Enter a valid amount");
+      return;
+    }
+    if (balance !== null) {
+      try {
+        const amountInUnits = parseUnits(amount, asset.decimals);
+        if (amountInUnits > balance) {
+          setError("Insufficient balance");
+          return;
+        }
+      } catch {
+        setError("Invalid amount");
+        return;
+      }
+    }
+    setError(null);
+    setIsSubmitting(true);
+    try {
+      await onSubmit(recipient, amount);
+    } catch (err) {
+      const raw = err instanceof Error ? err.message : "Withdrawal failed";
+      setError(formatUserError(raw));
+    } finally {
+      setIsSubmitting(false);
+    }
+  }, [recipient, amount, balance, asset.decimals, onSubmit]);
+  const handleSwitch = async () => {
+    if (!asset.chainId || !switchChain) return;
+    setIsSwitching(true);
+    try {
+      await switchChain(asset.chainId);
+    } catch (err) {
+      const raw = err instanceof Error ? err.message : "Failed to switch chain";
+      setError(formatUserError(raw));
+    } finally {
+      setIsSwitching(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "rs-step", children: [
+    /* @__PURE__ */ jsxs("div", { className: "rs-step-body rs-withdraw-form", children: [
+      /* @__PURE__ */ jsxs("div", { className: "rs-withdraw-section", children: [
+        /* @__PURE__ */ jsx("label", { className: "rs-withdraw-label", children: "Recipient" }),
+        /* @__PURE__ */ jsxs("div", { className: "rs-withdraw-input-row", children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: "text",
+              className: "rs-withdraw-input rs-withdraw-input--address",
+              placeholder: "0x...",
+              value: recipient,
+              onChange: (e) => {
+                setRecipient(e.target.value.trim());
+                if (error) setError(null);
+              }
+            }
+          ),
+          address && /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              className: `rs-withdraw-use-connected ${isRecipientConnected ? "rs-withdraw-use-connected--active" : ""}`,
+              onClick: handleUseConnected,
+              title: isRecipientConnected ? "Using connected wallet" : "Use connected wallet",
+              children: [
+                /* @__PURE__ */ jsx(
+                  "svg",
+                  {
+                    viewBox: "0 0 24 24",
+                    fill: "none",
+                    stroke: "currentColor",
+                    strokeWidth: "2",
+                    className: "rs-withdraw-use-connected-icon",
+                    children: /* @__PURE__ */ jsx(
+                      "path",
+                      {
+                        strokeLinecap: "round",
+                        strokeLinejoin: "round",
+                        d: "M21 12a2.25 2.25 0 00-2.25-2.25H15a3 3 0 11-6 0H5.25A2.25 2.25 0 003 12m18 0v6a2.25 2.25 0 01-2.25 2.25H5.25A2.25 2.25 0 013 18v-6m18 0V9M3 12V9m18 0a2.25 2.25 0 00-2.25-2.25H5.25A2.25 2.25 0 003 9m18 0V6a2.25 2.25 0 00-2.25-2.25H5.25A2.25 2.25 0 003 6v3"
+                      }
+                    )
+                  }
+                ),
+                isRecipientConnected ? null : "Wallet"
+              ]
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "rs-withdraw-section", children: [
+        /* @__PURE__ */ jsx("label", { className: "rs-withdraw-label", children: "Amount" }),
+        /* @__PURE__ */ jsxs("div", { className: "rs-withdraw-input-row", children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: "text",
+              inputMode: "decimal",
+              className: "rs-withdraw-input rs-withdraw-input--amount",
+              placeholder: "0",
+              value: amount,
+              onChange: (e) => {
+                const value = e.target.value.replace(/[^0-9.]/g, "");
+                const parts = value.split(".");
+                if (parts.length > 2) return;
+                setAmount(value);
+                if (error) setError(null);
+              }
+            }
+          ),
+          /* @__PURE__ */ jsxs("div", { className: "rs-withdraw-amount-right", children: [
+            /* @__PURE__ */ jsx("span", { className: "rs-withdraw-token-label", children: asset.symbol }),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                className: "rs-withdraw-max-btn",
+                onClick: handleMaxClick,
+                disabled: balance === null,
+                children: "Max"
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "rs-withdraw-amount-info", children: [
+          /* @__PURE__ */ jsx("span", { className: "rs-withdraw-usd", children: amountUsd !== null ? currencyFormatter.format(amountUsd) : "$0.00" }),
+          /* @__PURE__ */ jsxs("span", { className: "rs-withdraw-balance", children: [
+            formattedBalance,
+            " ",
+            asset.symbol
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "rs-withdraw-receive-row", children: [
+        /* @__PURE__ */ jsxs("div", { className: "rs-withdraw-receive-col", children: [
+          /* @__PURE__ */ jsx("label", { className: "rs-withdraw-label", children: "Receive" }),
+          /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: "rs-withdraw-dropdown-container",
+              ref: tokenDropdownRef,
+              children: [
+                /* @__PURE__ */ jsxs(
+                  "button",
+                  {
+                    type: "button",
+                    className: "rs-withdraw-dropdown",
+                    onClick: () => {
+                      setShowTokenDropdown(!showTokenDropdown);
+                      setShowChainDropdown(false);
+                    },
+                    children: [
+                      /* @__PURE__ */ jsxs("div", { className: "rs-withdraw-dropdown-value", children: [
+                        getTokenIcon(targetSymbol) && /* @__PURE__ */ jsx(
+                          "img",
+                          {
+                            src: getTokenIcon(targetSymbol),
+                            alt: targetSymbol,
+                            className: "rs-withdraw-dropdown-icon"
+                          }
+                        ),
+                        /* @__PURE__ */ jsx("span", { children: targetSymbol })
+                      ] }),
+                      /* @__PURE__ */ jsx(
+                        "svg",
+                        {
+                          viewBox: "0 0 24 24",
+                          fill: "none",
+                          stroke: "currentColor",
+                          strokeWidth: "2",
+                          className: "rs-withdraw-dropdown-arrow",
+                          style: {
+                            transform: showTokenDropdown ? "rotate(180deg)" : void 0
+                          },
+                          children: /* @__PURE__ */ jsx(
+                            "path",
+                            {
+                              strokeLinecap: "round",
+                              strokeLinejoin: "round",
+                              d: "M19 9l-7 7-7-7"
+                            }
+                          )
+                        }
+                      )
+                    ]
+                  }
+                ),
+                showTokenDropdown && /* @__PURE__ */ jsx("div", { className: "rs-withdraw-dropdown-menu", children: targetTokenOptions.map((option) => /* @__PURE__ */ jsxs(
+                  "button",
+                  {
+                    type: "button",
+                    className: "rs-withdraw-dropdown-item",
+                    onClick: () => {
+                      onTargetTokenChange(option.address);
+                      setShowTokenDropdown(false);
+                    },
+                    children: [
+                      getTokenIcon(option.symbol) && /* @__PURE__ */ jsx(
+                        "img",
+                        {
+                          src: getTokenIcon(option.symbol),
+                          alt: option.symbol,
+                          className: "rs-withdraw-dropdown-icon"
+                        }
+                      ),
+                      /* @__PURE__ */ jsx("span", { children: option.symbol })
+                    ]
+                  },
+                  option.address
+                )) })
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "rs-withdraw-receive-col", children: [
+          /* @__PURE__ */ jsx("label", { className: "rs-withdraw-label", children: "Chain" }),
+          /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: "rs-withdraw-dropdown-container",
+              ref: chainDropdownRef,
+              children: [
+                /* @__PURE__ */ jsxs(
+                  "button",
+                  {
+                    type: "button",
+                    className: "rs-withdraw-dropdown",
+                    onClick: () => {
+                      setShowChainDropdown(!showChainDropdown);
+                      setShowTokenDropdown(false);
+                    },
+                    children: [
+                      /* @__PURE__ */ jsxs("div", { className: "rs-withdraw-dropdown-value", children: [
+                        getChainIcon(targetChain) && /* @__PURE__ */ jsx(
+                          "img",
+                          {
+                            src: getChainIcon(targetChain),
+                            alt: targetChainName,
+                            className: "rs-withdraw-dropdown-icon"
+                          }
+                        ),
+                        /* @__PURE__ */ jsx("span", { children: targetChainName })
+                      ] }),
+                      /* @__PURE__ */ jsx(
+                        "svg",
+                        {
+                          viewBox: "0 0 24 24",
+                          fill: "none",
+                          stroke: "currentColor",
+                          strokeWidth: "2",
+                          className: "rs-withdraw-dropdown-arrow",
+                          style: {
+                            transform: showChainDropdown ? "rotate(180deg)" : void 0
+                          },
+                          children: /* @__PURE__ */ jsx(
+                            "path",
+                            {
+                              strokeLinecap: "round",
+                              strokeLinejoin: "round",
+                              d: "M19 9l-7 7-7-7"
+                            }
+                          )
+                        }
+                      )
+                    ]
+                  }
+                ),
+                showChainDropdown && /* @__PURE__ */ jsx("div", { className: "rs-withdraw-dropdown-menu", children: targetChains.map((chain) => /* @__PURE__ */ jsxs(
+                  "button",
+                  {
+                    type: "button",
+                    className: "rs-withdraw-dropdown-item",
+                    onClick: () => {
+                      onTargetChainChange(chain.id);
+                      setShowChainDropdown(false);
+                    },
+                    children: [
+                      getChainIcon(chain.id) && /* @__PURE__ */ jsx(
+                        "img",
+                        {
+                          src: getChainIcon(chain.id),
+                          alt: chain.name,
+                          className: "rs-withdraw-dropdown-icon"
+                        }
+                      ),
+                      /* @__PURE__ */ jsx("span", { children: chain.name })
+                    ]
+                  },
+                  chain.id
+                )) })
+              ]
+            }
+          )
+        ] })
+      ] }),
+      chainMismatch && /* @__PURE__ */ jsxs("div", { className: "rs-chain-switch", children: [
+        /* @__PURE__ */ jsxs("div", { className: "rs-chain-switch-text", children: [
+          "Switch to ",
+          getChainName(asset.chainId),
+          " to continue."
+        ] }),
+        switchChain && /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "outline",
+            size: "small",
+            loading: isSwitching,
+            onClick: handleSwitch,
+            children: "Switch"
+          }
+        )
+      ] }),
+      error && /* @__PURE__ */ jsxs("div", { className: "rs-withdraw-error", children: [
+        /* @__PURE__ */ jsx(
+          "svg",
+          {
+            viewBox: "0 0 24 24",
+            fill: "none",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            children: /* @__PURE__ */ jsx(
+              "path",
+              {
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                d: "M12 9v3.75m9-.75a9 9 0 11-18 0 9 9 0 0118 0zm-9 3.75h.008v.008H12v-.008z"
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { children: error })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "rs-step-footer", children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        onClick: handleWithdraw,
+        fullWidth: true,
+        loading: isBusy,
+        disabled: !recipient || !amount || chainMismatch || isBusy,
+        children: isBusy ? "Preparing..." : "Withdraw"
+      }
+    ) }),
+    /* @__PURE__ */ jsx(PoweredBy, {})
+  ] });
+}
+WithdrawFormStep.displayName = "WithdrawFormStep";
+
+// src/WithdrawFlow.tsx
+import { walletClientToAccount } from "@rhinestone/sdk";
+
+// src/core/safe.ts
+import {
+  concat,
+  encodeFunctionData,
+  erc20Abi as erc20Abi2,
+  hashTypedData,
+  pad,
+  parseEventLogs,
+  toHex,
+  zeroAddress
+} from "viem";
+var SAFE_ABI = [
+  {
+    type: "function",
+    name: "isOwner",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "nonce",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "execTransaction",
+    stateMutability: "payable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "data", type: "bytes" },
+      { name: "operation", type: "uint8" },
+      { name: "safeTxGas", type: "uint256" },
+      { name: "baseGas", type: "uint256" },
+      { name: "gasPrice", type: "uint256" },
+      { name: "gasToken", type: "address" },
+      { name: "refundReceiver", type: "address" },
+      { name: "signatures", type: "bytes" }
+    ],
+    outputs: [{ name: "success", type: "bool" }]
+  },
+  {
+    type: "event",
+    name: "ExecutionSuccess",
+    inputs: [
+      { name: "txHash", type: "bytes32", indexed: true },
+      { name: "payment", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "ExecutionFailure",
+    inputs: [
+      { name: "txHash", type: "bytes32", indexed: true },
+      { name: "payment", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  }
+];
+async function executeSafeEthTransfer(params) {
+  const {
+    walletClient,
+    publicClient,
+    safeAddress,
+    recipient,
+    amount,
+    chainId
+  } = params;
+  const account = walletClient.account;
+  const chain = walletClient.chain;
+  if (!account || !chain) {
+    throw new Error("Wallet not connected");
+  }
+  if (chain.id !== chainId) {
+    throw new Error(`Switch to ${getChainName(chainId)} to sign`);
+  }
+  const isOwner = await publicClient.readContract({
+    address: safeAddress,
+    abi: SAFE_ABI,
+    functionName: "isOwner",
+    args: [account.address]
+  });
+  if (!isOwner) {
+    throw new Error("Connected wallet is not a Safe owner");
+  }
+  const safeTx = {
+    to: recipient,
+    value: amount,
+    data: "0x",
+    operation: 0,
+    safeTxGas: 0n,
+    baseGas: 0n,
+    gasPrice: 0n,
+    gasToken: zeroAddress,
+    refundReceiver: zeroAddress
+  };
+  const signature = concat([
+    pad(account.address, { size: 32 }),
+    pad(toHex(0), { size: 32 }),
+    toHex(1, { size: 1 })
+  ]);
+  const txHash = await walletClient.writeContract({
+    account,
+    chain,
+    address: safeAddress,
+    abi: SAFE_ABI,
+    functionName: "execTransaction",
+    args: [
+      safeTx.to,
+      safeTx.value,
+      safeTx.data,
+      safeTx.operation,
+      safeTx.safeTxGas,
+      safeTx.baseGas,
+      safeTx.gasPrice,
+      safeTx.gasToken,
+      safeTx.refundReceiver,
+      signature
+    ]
+  });
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash: txHash
+  });
+  const safeLogs = receipt.logs.filter(
+    (log) => log.address.toLowerCase() === safeAddress.toLowerCase()
+  );
+  const parsed = parseEventLogs({
+    abi: SAFE_ABI,
+    logs: safeLogs,
+    strict: false
+  });
+  const failed = parsed.find((log) => log.eventName === "ExecutionFailure");
+  if (failed) {
+    throw new Error("Safe transaction failed");
+  }
+  const succeeded = parsed.find((log) => log.eventName === "ExecutionSuccess");
+  if (!succeeded) {
+    throw new Error("Safe transaction status unavailable");
+  }
+  return { txHash };
+}
+async function executeSafeErc20Transfer(params) {
+  const {
+    walletClient,
+    publicClient,
+    safeAddress,
+    tokenAddress,
+    recipient,
+    amount,
+    chainId
+  } = params;
+  const account = walletClient.account;
+  const chain = walletClient.chain;
+  if (!account || !chain) {
+    throw new Error("Wallet not connected");
+  }
+  if (chain.id !== chainId) {
+    throw new Error(`Switch to ${getChainName(chainId)} to sign`);
+  }
+  const isOwner = await publicClient.readContract({
+    address: safeAddress,
+    abi: SAFE_ABI,
+    functionName: "isOwner",
+    args: [account.address]
+  });
+  if (!isOwner) {
+    throw new Error("Connected wallet is not a Safe owner");
+  }
+  const data = encodeFunctionData({
+    abi: erc20Abi2,
+    functionName: "transfer",
+    args: [recipient, amount]
+  });
+  const safeTx = {
+    to: tokenAddress,
+    value: 0n,
+    data,
+    operation: 0,
+    safeTxGas: 0n,
+    baseGas: 0n,
+    gasPrice: 0n,
+    gasToken: zeroAddress,
+    refundReceiver: zeroAddress
+  };
+  const signature = concat([
+    pad(account.address, { size: 32 }),
+    pad(toHex(0), { size: 32 }),
+    toHex(1, { size: 1 })
+  ]);
+  const txHash = await walletClient.writeContract({
+    account,
+    chain,
+    address: safeAddress,
+    abi: SAFE_ABI,
+    functionName: "execTransaction",
+    args: [
+      safeTx.to,
+      safeTx.value,
+      safeTx.data,
+      safeTx.operation,
+      safeTx.safeTxGas,
+      safeTx.baseGas,
+      safeTx.gasPrice,
+      safeTx.gasToken,
+      safeTx.refundReceiver,
+      signature
+    ]
+  });
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash: txHash
+  });
+  const safeLogs = receipt.logs.filter(
+    (log) => log.address.toLowerCase() === safeAddress.toLowerCase()
+  );
+  const parsed = parseEventLogs({
+    abi: SAFE_ABI,
+    logs: safeLogs,
+    strict: false
+  });
+  const failed = parsed.find((log) => log.eventName === "ExecutionFailure");
+  if (failed) {
+    throw new Error("Safe transaction failed");
+  }
+  const succeeded = parsed.find((log) => log.eventName === "ExecutionSuccess");
+  if (!succeeded) {
+    throw new Error("Safe transaction status unavailable");
+  }
+  return { txHash };
+}
+var SAFE_TX_TYPES = {
+  SafeTx: [
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "data", type: "bytes" },
+    { name: "operation", type: "uint8" },
+    { name: "safeTxGas", type: "uint256" },
+    { name: "baseGas", type: "uint256" },
+    { name: "gasPrice", type: "uint256" },
+    { name: "gasToken", type: "address" },
+    { name: "refundReceiver", type: "address" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+async function buildSafeTransaction(params) {
+  const { publicClient, safeAddress, to, value, data, chainId } = params;
+  const nonce = await publicClient.readContract({
+    address: safeAddress,
+    abi: SAFE_ABI,
+    functionName: "nonce"
+  });
+  const message = {
+    to,
+    value,
+    data,
+    operation: 0,
+    safeTxGas: 0n,
+    baseGas: 0n,
+    gasPrice: 0n,
+    gasToken: zeroAddress,
+    refundReceiver: zeroAddress,
+    nonce
+  };
+  const safeTxHash = hashTypedData({
+    domain: { chainId, verifyingContract: safeAddress },
+    types: SAFE_TX_TYPES,
+    primaryType: "SafeTx",
+    message
+  });
+  return {
+    chainId,
+    safeAddress,
+    safeTxHash,
+    typedData: {
+      domain: { chainId, verifyingContract: safeAddress },
+      types: SAFE_TX_TYPES,
+      primaryType: "SafeTx",
+      message
+    }
+  };
+}
+
+// src/WithdrawFlow.tsx
+import { encodeFunctionData as encodeFunctionData2, erc20Abi as erc20Abi3, parseUnits as parseUnits2 } from "viem";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function WithdrawFlow({
+  dappWalletClient,
+  dappPublicClient,
+  dappAddress,
+  safeAddress,
+  sourceChain,
+  sourceToken,
+  targetChain: targetChainProp,
+  targetToken: targetTokenProp,
+  recipient: defaultRecipient,
+  amount: defaultAmount,
+  service,
+  rhinestoneApiKey,
+  signerAddress = DEFAULT_SIGNER_ADDRESS,
+  sessionChainIds,
+  forceRegister = false,
+  waitForFinalTx = true,
+  reownWallet,
+  onConnect,
+  onRelayTransaction,
+  onRequestConnect,
+  connectButtonLabel,
+  onStepChange,
+  onTotalBalanceChange,
+  onClose,
+  onConnected,
+  onWithdrawSubmitted,
+  onWithdrawComplete,
+  onWithdrawFailed,
+  onError,
+  debug
+}) {
+  const [step, setStep] = useState2({ type: "form" });
+  const [isSubmitting, setIsSubmitting] = useState2(false);
+  const [totalBalanceUsd, setTotalBalanceUsd] = useState2(0);
+  const [isConnectSelectionConfirmed, setIsConnectSelectionConfirmed] = useState2(false);
+  const [targetChain, setTargetChain] = useState2(targetChainProp);
+  const [targetToken, setTargetToken] = useState2(targetTokenProp);
+  useEffect2(() => {
+    setTargetChain(targetChainProp);
+    setTargetToken(targetTokenProp);
+  }, [targetChainProp, targetTokenProp]);
+  const targetChainObj = useMemo2(() => CHAIN_BY_ID[targetChain], [targetChain]);
+  const hasCustomSigner = Boolean(dappAddress && onRelayTransaction);
+  const dappSwitchChain = useMemo2(() => {
+    if (!dappWalletClient?.switchChain) return void 0;
+    return async (chainId) => {
+      await dappWalletClient.switchChain?.({ id: chainId });
+    };
+  }, [dappWalletClient]);
+  const walletOptions = useMemo2(() => {
+    const options = [];
+    const seen = /* @__PURE__ */ new Set();
+    if (dappWalletClient?.account && dappAddress) {
+      options.push({
+        address: dappWalletClient.account.address,
+        label: "Connected Wallet",
+        kind: "connected"
+      });
+      seen.add(dappWalletClient.account.address.toLowerCase());
+    }
+    if (reownWallet?.address && reownWallet.isConnected && !seen.has(reownWallet.address.toLowerCase())) {
+      options.push({
+        address: reownWallet.address,
+        label: "External Wallet",
+        kind: "external"
+      });
+    }
+    return options;
+  }, [
+    dappWalletClient,
+    dappAddress,
+    reownWallet?.address,
+    reownWallet?.isConnected
+  ]);
+  const canAutoLock = (dappWalletClient?.account && dappAddress || hasCustomSigner) && !reownWallet;
+  const [selectedConnectAddress, setSelectedConnectAddress] = useState2(null);
+  const signerContext = useMemo2(() => {
+    if (canAutoLock) {
+      if (hasCustomSigner) {
+        return {
+          ownerAddress: dappAddress,
+          walletClient: dappWalletClient ?? void 0,
+          publicClient: dappPublicClient ?? getPublicClient(sourceChain),
+          switchChain: dappSwitchChain
+        };
+      }
+      return {
+        ownerAddress: dappWalletClient.account.address,
+        walletClient: dappWalletClient,
+        publicClient: dappPublicClient ?? getPublicClient(sourceChain),
+        switchChain: dappSwitchChain
+      };
+    }
+    if (!isConnectSelectionConfirmed || !selectedConnectAddress) return null;
+    if (dappWalletClient?.account && dappWalletClient.account.address.toLowerCase() === selectedConnectAddress.toLowerCase()) {
+      return {
+        ownerAddress: dappWalletClient.account.address,
+        walletClient: dappWalletClient,
+        publicClient: dappPublicClient ?? getPublicClient(sourceChain),
+        switchChain: dappSwitchChain
+      };
+    }
+    if (reownWallet?.address?.toLowerCase() === selectedConnectAddress.toLowerCase() && reownWallet.walletClient && reownWallet.publicClient) {
+      return {
+        ownerAddress: reownWallet.address,
+        walletClient: reownWallet.walletClient,
+        publicClient: reownWallet.publicClient,
+        switchChain: reownWallet.switchChain
+      };
+    }
+    return null;
+  }, [
+    canAutoLock,
+    hasCustomSigner,
+    isConnectSelectionConfirmed,
+    selectedConnectAddress,
+    dappWalletClient,
+    dappPublicClient,
+    dappSwitchChain,
+    dappAddress,
+    reownWallet,
+    sourceChain
+  ]);
+  const asset = useMemo2(() => {
+    const symbol = getTokenSymbol(sourceToken, sourceChain);
+    const decimals = getTokenDecimalsByAddress(sourceToken, sourceChain);
+    return {
+      id: getAssetId({ chainId: sourceChain, token: sourceToken }),
+      chainId: sourceChain,
+      token: sourceToken,
+      symbol,
+      name: symbol,
+      decimals
+    };
+  }, [sourceChain, sourceToken]);
+  const isSourceNative = sourceToken.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase();
+  const stepIndex = step.type === "form" ? 0 : 1;
+  const currentBackHandler = void 0;
+  useEffect2(() => {
+    onStepChange?.(stepIndex, currentBackHandler);
+  }, [stepIndex, currentBackHandler, onStepChange]);
+  useEffect2(() => {
+    onTotalBalanceChange?.(totalBalanceUsd);
+  }, [totalBalanceUsd, onTotalBalanceChange]);
+  const handleConnected = useCallback2(
+    (addr, smartAccount) => {
+      onConnected?.({ address: addr, smartAccount });
+    },
+    [onConnected]
+  );
+  const handleError = useCallback2(
+    (message, code) => {
+      onError?.({ message, code });
+    },
+    [onError]
+  );
+  const resolveSessionOwner = useCallback2(async (eoaAddress) => {
+    const localOwner = loadSessionOwnerFromStorage(eoaAddress);
+    if (localOwner) {
+      return {
+        account: accountFromPrivateKey(localOwner.privateKey),
+        address: localOwner.address
+      };
+    }
+    const created = createSessionOwnerKey();
+    saveSessionOwnerToStorage(eoaAddress, created.privateKey, created.address);
+    return {
+      account: created.account,
+      address: created.address
+    };
+  }, []);
+  const handleFormSubmit = useCallback2(
+    async (recipient, amountValue) => {
+      const ownerAddress2 = signerContext?.ownerAddress;
+      if (!ownerAddress2) {
+        throw new Error("Wallet not connected");
+      }
+      if (!onRelayTransaction && !signerContext?.walletClient) {
+        throw new Error("Wallet not connected");
+      }
+      if (!targetChainObj) {
+        throw new Error("Unsupported target chain");
+      }
+      setIsSubmitting(true);
+      try {
+        const signerAccount = signerContext?.walletClient ? walletClientToAccount(signerContext.walletClient) : createViewOnlyAccount(ownerAddress2);
+        const sessionOwner = await resolveSessionOwner(ownerAddress2);
+        const account = await createSmartAccount(
+          signerAccount,
+          sessionOwner.account,
+          rhinestoneApiKey
+        );
+        const smartAccount = getAccountAddress(account);
+        const checkResult = await service.checkAccount(smartAccount);
+        const targetMatches = checkResult.targetChain === targetChain && checkResult.targetToken?.toLowerCase() === targetToken.toLowerCase();
+        if (!checkResult.isRegistered || forceRegister || !targetMatches) {
+          const initData = getAccountInitData(account);
+          const sessionDetails = await getSessionDetails(
+            account,
+            targetChainObj,
+            signerAddress,
+            sessionOwner.account,
+            targetToken,
+            sessionChainIds
+          );
+          await service.registerAccount({
+            address: smartAccount,
+            accountParams: {
+              factory: initData.factory,
+              factoryData: initData.factoryData,
+              sessionDetails
+            },
+            eoaAddress: ownerAddress2,
+            sessionOwner: sessionOwner.address,
+            target: {
+              chain: targetChain,
+              token: targetToken,
+              recipient
+            }
+          });
+        }
+        handleConnected(ownerAddress2, smartAccount);
+        const amountUnits = parseUnits2(amountValue, asset.decimals);
+        const pc = signerContext?.publicClient ?? getPublicClient(sourceChain);
+        let result;
+        if (onRelayTransaction) {
+          const transferData = isSourceNative ? { to: smartAccount, value: amountUnits, data: "0x" } : {
+            to: sourceToken,
+            value: 0n,
+            data: encodeFunctionData2({
+              abi: erc20Abi3,
+              functionName: "transfer",
+              args: [smartAccount, amountUnits]
+            })
+          };
+          const request = await buildSafeTransaction({
+            publicClient: pc,
+            safeAddress,
+            to: transferData.to,
+            value: transferData.value,
+            data: transferData.data,
+            chainId: sourceChain
+          });
+          result = await onRelayTransaction(request);
+        } else if (isSourceNative) {
+          result = await executeSafeEthTransfer({
+            walletClient: signerContext.walletClient,
+            publicClient: pc,
+            safeAddress,
+            recipient: smartAccount,
+            amount: amountUnits,
+            chainId: sourceChain
+          });
+        } else {
+          result = await executeSafeErc20Transfer({
+            walletClient: signerContext.walletClient,
+            publicClient: pc,
+            safeAddress,
+            tokenAddress: sourceToken,
+            recipient: smartAccount,
+            amount: amountUnits,
+            chainId: sourceChain
+          });
+        }
+        onWithdrawSubmitted?.({
+          txHash: result.txHash,
+          sourceChain,
+          amount: amountUnits.toString(),
+          safeAddress
+        });
+        setStep({
+          type: "processing",
+          smartAccount,
+          txHash: result.txHash,
+          sourceChain,
+          sourceToken,
+          amount: amountUnits.toString()
+        });
+      } catch (err) {
+        const raw = err instanceof Error ? err.message : "Withdraw failed";
+        handleError(formatUserError(raw), "WITHDRAW_FLOW_ERROR");
+        throw err;
+      } finally {
+        setIsSubmitting(false);
+      }
+    },
+    [
+      signerContext,
+      targetChainObj,
+      resolveSessionOwner,
+      signerAddress,
+      sessionChainIds,
+      forceRegister,
+      targetChain,
+      targetToken,
+      service,
+      rhinestoneApiKey,
+      handleConnected,
+      asset.decimals,
+      safeAddress,
+      sourceToken,
+      sourceChain,
+      onWithdrawSubmitted,
+      onRelayTransaction,
+      isSourceNative,
+      handleError
+    ]
+  );
+  const handleWithdrawComplete = useCallback2(
+    (txHash, destinationTxHash) => {
+      onWithdrawComplete?.({ txHash, destinationTxHash });
+    },
+    [onWithdrawComplete]
+  );
+  const handleWithdrawFailed = useCallback2(
+    (txHash, error) => {
+      onWithdrawFailed?.({ txHash, error });
+    },
+    [onWithdrawFailed]
+  );
+  const targetChainOptions = useMemo2(() => {
+    return SOURCE_CHAINS.filter(
+      (chain) => getSupportedTargetTokens(chain.id).length > 0
+    );
+  }, []);
+  const targetTokenOptions = useMemo2(
+    () => getSupportedTargetTokens(targetChain),
+    [targetChain]
+  );
+  useEffect2(() => {
+    if (targetTokenOptions.length === 0) return;
+    const matches = targetTokenOptions.some(
+      (option) => option.address.toLowerCase() === targetToken.toLowerCase()
+    );
+    if (!matches) {
+      setTargetToken(targetTokenOptions[0].address);
+    }
+  }, [targetToken, targetTokenOptions]);
+  const handleTargetChainChange = useCallback2(
+    (chainId) => {
+      setTargetChain(chainId);
+      const options = getSupportedTargetTokens(chainId);
+      if (options.length === 0) {
+        return;
+      }
+      const currentlySupported = options.some(
+        (option) => option.address.toLowerCase() === targetToken.toLowerCase()
+      );
+      setTargetToken(
+        currentlySupported ? targetToken : options[0].address
+      );
+    },
+    [targetToken]
+  );
+  const handleTargetTokenChange = useCallback2((token) => {
+    setTargetToken(token);
+  }, []);
+  const selectedConnectAddressEffective = useMemo2(() => {
+    if (selectedConnectAddress) return selectedConnectAddress;
+    if (walletOptions.length === 1) {
+      return walletOptions[0].address;
+    }
+    return null;
+  }, [selectedConnectAddress, walletOptions]);
+  const walletOptionsKey = useMemo2(
+    () => walletOptions.map((option) => option.address.toLowerCase()).join(","),
+    [walletOptions]
+  );
+  const showConnectStep = !canAutoLock && !isConnectSelectionConfirmed;
+  useEffect2(() => {
+    setIsConnectSelectionConfirmed(false);
+  }, [walletOptionsKey, selectedConnectAddressEffective]);
+  if (showConnectStep) {
+    return /* @__PURE__ */ jsx2("div", { className: "rs-modal-body", children: /* @__PURE__ */ jsx2(
+      ConnectStep,
+      {
+        walletOptions,
+        selectedAddress: selectedConnectAddressEffective,
+        onSelectAddress: setSelectedConnectAddress,
+        onRequestConnect,
+        onConnect,
+        onContinue: () => {
+          if (selectedConnectAddressEffective) {
+            setSelectedConnectAddress(selectedConnectAddressEffective);
+          }
+          setIsConnectSelectionConfirmed(true);
+        },
+        connectButtonLabel
+      }
+    ) });
+  }
+  if (!signerContext) return null;
+  if (!onRelayTransaction && !signerContext.walletClient) return null;
+  const ownerAddress = signerContext.ownerAddress;
+  const formPublicClient = signerContext.publicClient ?? getPublicClient(sourceChain);
+  return /* @__PURE__ */ jsxs2("div", { className: "rs-modal-body", children: [
+    step.type === "form" && /* @__PURE__ */ jsx2(
+      WithdrawFormStep,
+      {
+        walletClient: signerContext.walletClient,
+        publicClient: formPublicClient,
+        address: ownerAddress,
+        safeAddress,
+        asset,
+        defaultRecipient: defaultRecipient ?? ownerAddress,
+        defaultAmount,
+        targetChain,
+        targetToken,
+        targetChains: targetChainOptions,
+        targetTokenOptions,
+        onTargetChainChange: handleTargetChainChange,
+        onTargetTokenChange: handleTargetTokenChange,
+        switchChain: signerContext.switchChain,
+        submitting: isSubmitting,
+        onSubmit: handleFormSubmit,
+        onBalanceUsdChange: setTotalBalanceUsd
+      }
+    ),
+    step.type === "processing" && /* @__PURE__ */ jsx2(
+      ProcessingStep,
+      {
+        smartAccount: step.smartAccount,
+        txHash: step.txHash,
+        sourceChain: step.sourceChain,
+        sourceToken: step.sourceToken,
+        targetChain,
+        targetToken,
+        amount: step.amount,
+        waitForFinalTx,
+        service,
+        flowLabel: "withdraw",
+        onClose,
+        onNewDeposit: () => setStep({ type: "form" }),
+        onDepositComplete: handleWithdrawComplete,
+        onDepositFailed: handleWithdrawFailed,
+        onError: handleError,
+        debug
+      }
+    )
+  ] });
+}
+
+// src/WithdrawModal.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var ReownWithdrawInner = lazy(
+  () => import("./WithdrawModalReown-ICP3DH6Q.mjs").then((m) => ({
+    default: m.WithdrawModalReown
+  }))
+);
+function WithdrawModal(props) {
+  const needsReown = !!props.reownAppId;
+  if (needsReown) {
+    return /* @__PURE__ */ jsx3(Suspense, { fallback: null, children: /* @__PURE__ */ jsx3(ReownWithdrawInner, { ...props }) });
+  }
+  return /* @__PURE__ */ jsx3(WithdrawModalInner, { ...props });
+}
+WithdrawModal.displayName = "WithdrawModal";
+function WithdrawModalInner({
+  dappWalletClient,
+  dappPublicClient,
+  dappAddress,
+  safeAddress,
+  sourceChain: sourceChainProp,
+  sourceToken,
+  targetChain: targetChainProp,
+  targetToken,
+  recipient,
+  defaultAmount,
+  isOpen,
+  onClose,
+  inline,
+  backendUrl = DEFAULT_BACKEND_URL,
+  rhinestoneApiKey,
+  signerAddress = DEFAULT_SIGNER_ADDRESS,
+  sessionChainIds,
+  forceRegister = false,
+  waitForFinalTx = true,
+  reownWallet,
+  onConnect,
+  onRelayTransaction,
+  onRequestConnect,
+  connectButtonLabel,
+  theme,
+  branding,
+  uiConfig,
+  className,
+  onReady,
+  onConnected,
+  onWithdrawSubmitted,
+  onWithdrawComplete,
+  onWithdrawFailed,
+  onError,
+  debug
+}) {
+  const modalRef = useRef2(null);
+  const [currentStepIndex, setCurrentStepIndex] = useState3(0);
+  const [totalBalanceUsd, setTotalBalanceUsd] = useState3(null);
+  const backHandlerRef = useRef2(void 0);
+  const targetChain = getChainId(targetChainProp);
+  const sourceChain = getChainId(sourceChainProp);
+  const service = useMemo3(() => createDepositService(backendUrl), [backendUrl]);
+  useEffect3(() => {
+    if (isOpen && modalRef.current) {
+      applyTheme(modalRef.current, theme);
+    }
+  }, [isOpen, theme]);
+  const hasCalledReady = useRef2(false);
+  useEffect3(() => {
+    if (isOpen && !hasCalledReady.current) {
+      hasCalledReady.current = true;
+      onReady?.();
+    }
+  }, [isOpen, onReady]);
+  useEffect3(() => {
+    if (!isOpen) {
+      setCurrentStepIndex(0);
+    }
+  }, [isOpen]);
+  const handleStepChange = useCallback3(
+    (stepIndex, onBack) => {
+      setCurrentStepIndex(stepIndex);
+      backHandlerRef.current = onBack;
+    },
+    []
+  );
+  const handleTotalBalanceChange = useCallback3((balance) => {
+    setTotalBalanceUsd(balance);
+  }, []);
+  const handleBack = useCallback3(() => {
+    backHandlerRef.current?.();
+  }, []);
+  const showLogo = uiConfig?.showLogo ?? false;
+  const showStepper = uiConfig?.showStepper ?? false;
+  const showBackButton = uiConfig?.showBackButton ?? true;
+  const balanceTitle = uiConfig?.balanceTitle;
+  const logoUrl = branding?.logoUrl ?? "https://github.com/rhinestonewtf.png";
+  const title = branding?.title ?? "Withdraw";
+  const canGoBack = currentStepIndex > 0 && currentStepIndex < 3 && backHandlerRef.current;
+  return /* @__PURE__ */ jsx3(
+    Modal,
+    {
+      isOpen,
+      onClose,
+      className,
+      inline,
+      children: /* @__PURE__ */ jsxs3("div", { ref: modalRef, className: "rs-modal", children: [
+        /* @__PURE__ */ jsxs3("div", { className: "rs-modal-header--redesigned", children: [
+          /* @__PURE__ */ jsx3("div", { className: "rs-modal-header-nav-left", children: showBackButton && canGoBack && /* @__PURE__ */ jsx3(
+            "button",
+            {
+              type: "button",
+              className: "rs-modal-header-back",
+              "aria-label": "Go back",
+              onClick: handleBack,
+              children: /* @__PURE__ */ jsx3(
+                "svg",
+                {
+                  viewBox: "0 0 24 24",
+                  fill: "none",
+                  stroke: "currentColor",
+                  strokeWidth: "2",
+                  children: /* @__PURE__ */ jsx3(
+                    "path",
+                    {
+                      strokeLinecap: "round",
+                      strokeLinejoin: "round",
+                      d: "M15.75 19.5L8.25 12l7.5-7.5"
+                    }
+                  )
+                }
+              )
+            }
+          ) }),
+          /* @__PURE__ */ jsxs3("div", { className: "rs-modal-header-nav-center", children: [
+            /* @__PURE__ */ jsxs3("div", { className: "rs-modal-header-title-row", children: [
+              showLogo && logoUrl && /* @__PURE__ */ jsx3(
+                "img",
+                {
+                  src: logoUrl,
+                  alt: "",
+                  className: "rs-modal-logo",
+                  onError: (e) => {
+                    e.target.style.display = "none";
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsx3("span", { className: "rs-modal-header-title", children: title }),
+              showStepper && /* @__PURE__ */ jsx3("div", { className: "rs-modal-progress", style: { marginLeft: 8 }, children: [0, 1].map((i) => /* @__PURE__ */ jsx3(
+                "div",
+                {
+                  className: `rs-modal-progress-dot ${i <= currentStepIndex ? "rs-modal-progress-dot--active" : "rs-modal-progress-dot--inactive"}`
+                },
+                i
+              )) })
+            ] }),
+            balanceTitle && totalBalanceUsd !== null && /* @__PURE__ */ jsxs3("div", { className: "rs-modal-header-balance", children: [
+              /* @__PURE__ */ jsx3("span", { className: "rs-modal-header-balance-label", children: balanceTitle }),
+              /* @__PURE__ */ jsx3("span", { className: "rs-modal-header-balance-value", children: currencyFormatter.format(totalBalanceUsd) })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx3("div", { className: "rs-modal-header-nav-right", children: /* @__PURE__ */ jsx3(
+            "button",
+            {
+              type: "button",
+              onClick: onClose,
+              className: "rs-modal-close",
+              "aria-label": "Close",
+              children: /* @__PURE__ */ jsx3(
+                "svg",
+                {
+                  viewBox: "0 0 24 24",
+                  fill: "none",
+                  stroke: "currentColor",
+                  strokeWidth: "2",
+                  children: /* @__PURE__ */ jsx3(
+                    "path",
+                    {
+                      strokeLinecap: "round",
+                      strokeLinejoin: "round",
+                      d: "M6 18L18 6M6 6l12 12"
+                    }
+                  )
+                }
+              )
+            }
+          ) })
+        ] }),
+        /* @__PURE__ */ jsx3(
+          WithdrawFlow,
+          {
+            dappWalletClient,
+            dappPublicClient,
+            dappAddress,
+            safeAddress,
+            sourceChain,
+            sourceToken,
+            targetChain,
+            targetToken,
+            recipient,
+            amount: defaultAmount,
+            service,
+            rhinestoneApiKey,
+            signerAddress,
+            sessionChainIds,
+            forceRegister,
+            waitForFinalTx,
+            reownWallet,
+            onConnect,
+            onRelayTransaction,
+            onRequestConnect,
+            connectButtonLabel,
+            onStepChange: handleStepChange,
+            onTotalBalanceChange: handleTotalBalanceChange,
+            onClose,
+            onConnected,
+            onWithdrawSubmitted,
+            onWithdrawComplete,
+            onWithdrawFailed,
+            onError,
+            debug
+          }
+        )
+      ] })
+    }
+  );
+}
+
+export {
+  WithdrawModal,
+  WithdrawModalInner
+};