@swype-org/react-sdk 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,9 +1,11 @@
-import { createContext, useRef, useMemo, useContext, useState, useCallback, useEffect } from 'react';
+import { createContext, useRef, useState, useCallback, useMemo, useContext, useEffect } from 'react';
 import { PrivyProvider, usePrivy } from '@privy-io/react-auth';
-import { createConfig, http, WagmiProvider, useAccount, useConnect, useSwitchChain, useSignTypedData, usePublicClient, useWalletClient } from 'wagmi';
+import { createConfig, http, WagmiProvider, useConfig, useConnect, useSwitchChain } from 'wagmi';
 import { mainnet, arbitrum, base } from 'wagmi/chains';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { walletActions, createClient, custom } from 'viem';
+import { parseAccount, getAddress } from 'viem/utils';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -82,13 +84,19 @@ function SwypeProvider({
   if (!queryClientRef.current) {
     queryClientRef.current = new QueryClient();
   }
+  const [depositAmount, setDepositAmountRaw] = useState(null);
+  const setDepositAmount = useCallback((amount) => {
+    setDepositAmountRaw(amount);
+  }, []);
   const value = useMemo(
     () => ({
       apiBaseUrl,
       theme,
-      tokens: getTheme(theme)
+      tokens: getTheme(theme),
+      depositAmount,
+      setDepositAmount
     }),
-    [apiBaseUrl, theme]
+    [apiBaseUrl, theme, depositAmount, setDepositAmount]
   );
   return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClientRef.current, children: /* @__PURE__ */ jsx(WagmiProvider, { config: wagmiConfig, children: /* @__PURE__ */ jsx(
     PrivyProvider,
@@ -110,6 +118,20 @@ function useSwypeConfig() {
   }
   return ctx;
 }
+function useSwypeDepositAmount() {
+  const ctx = useContext(SwypeContext);
+  if (!ctx) {
+    throw new Error(
+      "useSwypeDepositAmount must be used within a <SwypeProvider>"
+    );
+  }
+  return {
+    /** Current deposit amount, or null if not set */
+    amount: ctx.depositAmount,
+    /** Set the deposit amount (pass null to clear) */
+    setAmount: ctx.setDepositAmount
+  };
+}
 
 // src/api.ts
 var api_exports = {};
@@ -121,7 +143,9 @@ __export(api_exports, {
   fetchProviders: () => fetchProviders,
   fetchTransfer: () => fetchTransfer,
   reportActionCompletion: () => reportActionCompletion,
-  updateUserConfig: () => updateUserConfig
+  signTransfer: () => signTransfer,
+  updateUserConfig: () => updateUserConfig,
+  updateUserConfigBySession: () => updateUserConfigBySession
 });
 async function throwApiError(res) {
   const body = await res.json().catch(() => null);
@@ -188,6 +212,18 @@ async function fetchTransfer(apiBaseUrl, token, transferId) {
   if (!res.ok) await throwApiError(res);
   return await res.json();
 }
+async function signTransfer(apiBaseUrl, token, transferId, signedUserOp) {
+  const res = await fetch(`${apiBaseUrl}/v1/transfers/${transferId}`, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ signedUserOp })
+  });
+  if (!res.ok) await throwApiError(res);
+  return await res.json();
+}
 async function fetchAuthorizationSession(apiBaseUrl, sessionId) {
   const res = await fetch(
     `${apiBaseUrl}/v1/authorization-sessions/${sessionId}`
@@ -206,6 +242,17 @@ async function updateUserConfig(apiBaseUrl, token, config) {
   });
   if (!res.ok) await throwApiError(res);
 }
+async function updateUserConfigBySession(apiBaseUrl, sessionId, config) {
+  const res = await fetch(
+    `${apiBaseUrl}/v1/authorization-sessions/${sessionId}/user-config`,
+    {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ config })
+    }
+  );
+  if (!res.ok) await throwApiError(res);
+}
 async function reportActionCompletion(apiBaseUrl, actionId, result) {
   const res = await fetch(
     `${apiBaseUrl}/v1/authorization-actions/${actionId}`,
@@ -218,6 +265,443 @@ async function reportActionCompletion(apiBaseUrl, actionId, result) {
   if (!res.ok) await throwApiError(res);
   return await res.json();
 }
+
+// node_modules/@wagmi/core/dist/esm/version.js
+var version = "2.22.1";
+
+// node_modules/@wagmi/core/dist/esm/utils/getVersion.js
+var getVersion = () => `@wagmi/core@${version}`;
+
+// node_modules/@wagmi/core/dist/esm/errors/base.js
+var __classPrivateFieldGet = function(receiver, state, kind, f) {
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BaseError_instances;
+var _BaseError_walk;
+var BaseError = class _BaseError extends Error {
+  get docsBaseUrl() {
+    return "https://wagmi.sh/core";
+  }
+  get version() {
+    return getVersion();
+  }
+  constructor(shortMessage, options = {}) {
+    super();
+    _BaseError_instances.add(this);
+    Object.defineProperty(this, "details", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "docsPath", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "metaMessages", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "shortMessage", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "WagmiCoreError"
+    });
+    const details = options.cause instanceof _BaseError ? options.cause.details : options.cause?.message ? options.cause.message : options.details;
+    const docsPath = options.cause instanceof _BaseError ? options.cause.docsPath || options.docsPath : options.docsPath;
+    this.message = [
+      shortMessage || "An error occurred.",
+      "",
+      ...options.metaMessages ? [...options.metaMessages, ""] : [],
+      ...docsPath ? [
+        `Docs: ${this.docsBaseUrl}${docsPath}.html${options.docsSlug ? `#${options.docsSlug}` : ""}`
+      ] : [],
+      ...details ? [`Details: ${details}`] : [],
+      `Version: ${this.version}`
+    ].join("\n");
+    if (options.cause)
+      this.cause = options.cause;
+    this.details = details;
+    this.docsPath = docsPath;
+    this.metaMessages = options.metaMessages;
+    this.shortMessage = shortMessage;
+  }
+  walk(fn) {
+    return __classPrivateFieldGet(this, _BaseError_instances, "m", _BaseError_walk).call(this, this, fn);
+  }
+};
+_BaseError_instances = /* @__PURE__ */ new WeakSet(), _BaseError_walk = function _BaseError_walk2(err, fn) {
+  if (fn?.(err))
+    return err;
+  if (err.cause)
+    return __classPrivateFieldGet(this, _BaseError_instances, "m", _BaseError_walk2).call(this, err.cause, fn);
+  return err;
+};
+
+// node_modules/@wagmi/core/dist/esm/errors/config.js
+var ConnectorNotConnectedError = class extends BaseError {
+  constructor() {
+    super("Connector not connected.");
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "ConnectorNotConnectedError"
+    });
+  }
+};
+var ConnectorAccountNotFoundError = class extends BaseError {
+  constructor({ address, connector }) {
+    super(`Account "${address}" not found for connector "${connector.name}".`);
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "ConnectorAccountNotFoundError"
+    });
+  }
+};
+var ConnectorChainMismatchError = class extends BaseError {
+  constructor({ connectionChainId, connectorChainId }) {
+    super(`The current chain of the connector (id: ${connectorChainId}) does not match the connection's chain (id: ${connectionChainId}).`, {
+      metaMessages: [
+        `Current Chain ID:  ${connectorChainId}`,
+        `Expected Chain ID: ${connectionChainId}`
+      ]
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "ConnectorChainMismatchError"
+    });
+  }
+};
+var ConnectorUnavailableReconnectingError = class extends BaseError {
+  constructor({ connector }) {
+    super(`Connector "${connector.name}" unavailable while reconnecting.`, {
+      details: [
+        "During the reconnection step, the only connector methods guaranteed to be available are: `id`, `name`, `type`, `uid`.",
+        "All other methods are not guaranteed to be available until reconnection completes and connectors are fully restored.",
+        "This error commonly occurs for connectors that asynchronously inject after reconnection has already started."
+      ].join(" ")
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "ConnectorUnavailableReconnectingError"
+    });
+  }
+};
+async function getConnectorClient(config, parameters = {}) {
+  const { assertChainId = true } = parameters;
+  let connection;
+  if (parameters.connector) {
+    const { connector: connector2 } = parameters;
+    if (config.state.status === "reconnecting" && !connector2.getAccounts && !connector2.getChainId)
+      throw new ConnectorUnavailableReconnectingError({ connector: connector2 });
+    const [accounts, chainId2] = await Promise.all([
+      connector2.getAccounts().catch((e) => {
+        if (parameters.account === null)
+          return [];
+        throw e;
+      }),
+      connector2.getChainId()
+    ]);
+    connection = {
+      accounts,
+      chainId: chainId2,
+      connector: connector2
+    };
+  } else
+    connection = config.state.connections.get(config.state.current);
+  if (!connection)
+    throw new ConnectorNotConnectedError();
+  const chainId = parameters.chainId ?? connection.chainId;
+  const connectorChainId = await connection.connector.getChainId();
+  if (assertChainId && connectorChainId !== chainId)
+    throw new ConnectorChainMismatchError({
+      connectionChainId: chainId,
+      connectorChainId
+    });
+  const connector = connection.connector;
+  if (connector.getClient)
+    return connector.getClient({ chainId });
+  const account = parseAccount(parameters.account ?? connection.accounts[0]);
+  if (account)
+    account.address = getAddress(account.address);
+  if (parameters.account && !connection.accounts.some((x) => x.toLowerCase() === account.address.toLowerCase()))
+    throw new ConnectorAccountNotFoundError({
+      address: account.address,
+      connector
+    });
+  const chain = config.chains.find((chain2) => chain2.id === chainId);
+  const provider = await connection.connector.getProvider({ chainId });
+  return createClient({
+    account,
+    chain,
+    name: "Connector Client",
+    transport: (opts) => custom(provider)({ ...opts, retryCount: 0 })
+  });
+}
+
+// node_modules/@wagmi/core/dist/esm/actions/getAccount.js
+function getAccount(config) {
+  const uid = config.state.current;
+  const connection = config.state.connections.get(uid);
+  const addresses = connection?.accounts;
+  const address = addresses?.[0];
+  const chain = config.chains.find((chain2) => chain2.id === connection?.chainId);
+  const status = config.state.status;
+  switch (status) {
+    case "connected":
+      return {
+        address,
+        addresses,
+        chain,
+        chainId: connection?.chainId,
+        connector: connection?.connector,
+        isConnected: true,
+        isConnecting: false,
+        isDisconnected: false,
+        isReconnecting: false,
+        status
+      };
+    case "reconnecting":
+      return {
+        address,
+        addresses,
+        chain,
+        chainId: connection?.chainId,
+        connector: connection?.connector,
+        isConnected: !!address,
+        isConnecting: false,
+        isDisconnected: false,
+        isReconnecting: true,
+        status
+      };
+    case "connecting":
+      return {
+        address,
+        addresses,
+        chain,
+        chainId: connection?.chainId,
+        connector: connection?.connector,
+        isConnected: false,
+        isConnecting: true,
+        isDisconnected: false,
+        isReconnecting: false,
+        status
+      };
+    case "disconnected":
+      return {
+        address: void 0,
+        addresses: void 0,
+        chain: void 0,
+        chainId: void 0,
+        connector: void 0,
+        isConnected: false,
+        isConnecting: false,
+        isDisconnected: true,
+        isReconnecting: false,
+        status
+      };
+  }
+}
+async function getWalletClient(config, parameters = {}) {
+  const client = await getConnectorClient(config, parameters);
+  return client.extend(walletActions);
+}
+
+// src/authorization/upgrade.ts
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isValidChainId(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isRpcClient(value) {
+  return typeof value === "object" && value !== null && "request" in value && typeof value.request === "function";
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function pollCallsStatus(client, bundleId, label, timeoutMs = 12e4, intervalMs = 3e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const raw = await client.request({
+      method: "wallet_getCallsStatus",
+      params: [bundleId]
+    });
+    const result = raw;
+    const status = result.status;
+    console.info(`[swype-sdk][upgrade] ${label} status:`, status);
+    if (status === 200 || status === "CONFIRMED" || status === "confirmed") {
+      const txHash = result.receipts?.[0]?.transactionHash ?? "";
+      if (!txHash) {
+        console.warn(`[swype-sdk][upgrade] ${label}: confirmed but no receipt txHash.`);
+      }
+      return txHash;
+    }
+    if (typeof status === "number" && status >= 400) {
+      throw new Error(
+        `${label} failed with status ${status}. Receipts: ${JSON.stringify(result.receipts ?? [])}`
+      );
+    }
+    if (typeof status === "string" && (status.toLowerCase().includes("fail") || status.toLowerCase().includes("error"))) {
+      throw new Error(
+        `${label} failed: ${status}. Receipts: ${JSON.stringify(result.receipts ?? [])}`
+      );
+    }
+    await sleep(intervalMs);
+  }
+  throw new Error(`${label} timed out after ${timeoutMs / 1e3}s.`);
+}
+async function sendCalls(client, callsParams, label) {
+  try {
+    const result = await client.request({
+      method: "wallet_sendCalls",
+      params: [callsParams]
+    });
+    const bundleId = typeof result === "string" ? result : result?.id;
+    if (!bundleId) {
+      throw new Error(`${label}: wallet_sendCalls returned an unexpected result: ${JSON.stringify(result)}`);
+    }
+    return bundleId;
+  } catch (err) {
+    const msg = err.message ?? "";
+    if (msg.includes("Unauthorized") || msg.includes("-32006")) {
+      throw new Error(
+        "MetaMask smart accounts may not be enabled or may not be supported on this chain. Please ensure you are using a supported network and that smart accounts are enabled in MetaMask Settings \u2192 Experimental."
+      );
+    }
+    throw new Error(`${label} failed: ${msg}`);
+  }
+}
+async function submitUpgradeTransaction(params) {
+  const { walletClient, sender, metadata } = params;
+  const addKeyCalldata = metadata?.addKeyCalldata;
+  if (!isNonEmptyString(addKeyCalldata)) {
+    throw new Error("Incomplete upgrade metadata: missing addKeyCalldata.");
+  }
+  const resolvedSmartAccountAddress = metadata?.smartAccountAddress ?? sender;
+  if (!isNonEmptyString(resolvedSmartAccountAddress)) {
+    throw new Error("No connected account address found for smart account upgrade.");
+  }
+  const chainId = metadata?.upgradePayload?.authorization?.chainId;
+  if (!isValidChainId(chainId)) {
+    throw new Error("Invalid or missing chainId in upgrade metadata.");
+  }
+  if (!isRpcClient(walletClient)) {
+    throw new Error(
+      "Connected wallet client does not support request(). EIP-7702 upgrade requires a wallet client with raw RPC access."
+    );
+  }
+  const hexChainId = `0x${chainId.toString(16)}`;
+  console.info(
+    "[swype-sdk][upgrade] Step 1/2: Triggering EIP-7702 upgrade via wallet_sendCalls.",
+    { from: resolvedSmartAccountAddress, chainId: hexChainId }
+  );
+  const upgradeBundleId = await sendCalls(
+    walletClient,
+    {
+      version: "2.0.0",
+      from: resolvedSmartAccountAddress,
+      chainId: hexChainId,
+      atomicRequired: false,
+      calls: [{ to: resolvedSmartAccountAddress, value: "0x0" }]
+    },
+    "EIP-7702 upgrade"
+  );
+  console.info("[swype-sdk][upgrade] Upgrade bundle submitted. Polling for confirmation\u2026", {
+    bundleId: upgradeBundleId
+  });
+  const upgradeTxHash = await pollCallsStatus(
+    walletClient,
+    upgradeBundleId,
+    "EIP-7702 upgrade"
+  );
+  console.info("[swype-sdk][upgrade] Step 1/2 complete: account upgraded.", {
+    txHash: upgradeTxHash
+  });
+  console.info(
+    "[swype-sdk][upgrade] Step 2/2: Registering passkey via wallet_sendCalls (addKey)."
+  );
+  const addKeyBundleId = await sendCalls(
+    walletClient,
+    {
+      version: "2.0.0",
+      from: resolvedSmartAccountAddress,
+      chainId: hexChainId,
+      atomicRequired: false,
+      calls: [
+        {
+          to: resolvedSmartAccountAddress,
+          value: "0x0",
+          data: addKeyCalldata
+        }
+      ]
+    },
+    "Passkey registration (addKey)"
+  );
+  console.info("[swype-sdk][upgrade] addKey bundle submitted. Polling for confirmation\u2026", {
+    bundleId: addKeyBundleId
+  });
+  const addKeyTxHash = await pollCallsStatus(
+    walletClient,
+    addKeyBundleId,
+    "Passkey registration"
+  );
+  console.info("[swype-sdk][upgrade] Step 2/2 complete: passkey registered.", {
+    txHash: addKeyTxHash
+  });
+  return {
+    txHash: addKeyTxHash || upgradeTxHash,
+    smartAccountAddress: resolvedSmartAccountAddress
+  };
+}
+
+// src/hooks.ts
+async function waitForWalletClient(wagmiConfig2, maxAttempts = 15, intervalMs = 200) {
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      return await getWalletClient(wagmiConfig2);
+    } catch {
+      if (i === maxAttempts - 1) {
+        throw new Error("Wallet not ready. Please try again.");
+      }
+      await new Promise((r) => setTimeout(r, intervalMs));
+    }
+  }
+  throw new Error("Wallet not ready. Please try again.");
+}
+function extractErrorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  if (err && typeof err === "object") {
+    const maybeMessage = err.message;
+    if (typeof maybeMessage === "string") return maybeMessage;
+  }
+  return "Failed to upgrade account";
+}
+function isMetaMaskConnector(account) {
+  const connectorName = account.connector?.name?.toLowerCase() ?? "";
+  const connectorId = account.connector?.id?.toLowerCase() ?? "";
+  return connectorName.includes("metamask") || connectorId.includes("metamask");
+}
 function useTransferPolling(intervalMs = 3e3) {
   const { apiBaseUrl } = useSwypeConfig();
   const { getAccessToken } = usePrivy();
@@ -268,31 +752,45 @@ function useTransferPolling(intervalMs = 3e3) {
 }
 function useAuthorizationExecutor() {
   const { apiBaseUrl } = useSwypeConfig();
-  const { address, chainId: currentChainId, isConnected } = useAccount();
+  const wagmiConfig2 = useConfig();
   const { connectAsync, connectors } = useConnect();
   const { switchChainAsync } = useSwitchChain();
-  const { signTypedDataAsync } = useSignTypedData();
-  const publicClient = usePublicClient();
-  const { data: walletClient } = useWalletClient();
   const [executing, setExecuting] = useState(false);
   const [results, setResults] = useState([]);
   const [error, setError] = useState(null);
+  const [currentAction, setCurrentAction] = useState(null);
   const executingRef = useRef(false);
+  const [pendingSelectSource, setPendingSelectSource] = useState(null);
+  const selectSourceResolverRef = useRef(null);
+  const resolveSelectSource = useCallback((selection) => {
+    if (selectSourceResolverRef.current) {
+      selectSourceResolverRef.current(selection);
+      selectSourceResolverRef.current = null;
+      setPendingSelectSource(null);
+    }
+  }, []);
+  const sessionIdRef = useRef(null);
   const executeOpenProvider = useCallback(
     async (action) => {
       try {
-        if (isConnected && address) {
-          const hexChainId2 = currentChainId ? `0x${currentChainId.toString(16)}` : void 0;
+        const account = getAccount(wagmiConfig2);
+        if (account.isConnected && account.address) {
+          const hexChainId2 = account.chainId ? `0x${account.chainId.toString(16)}` : void 0;
           return {
             actionId: action.id,
             type: action.type,
             status: "success",
-            message: `Connected. Account: ${address}, Chain: ${hexChainId2}`,
-            data: { accounts: [address], chainId: hexChainId2 }
+            message: `Connected. Account: ${account.address}, Chain: ${hexChainId2}`,
+            data: { accounts: [account.address], chainId: hexChainId2 }
           };
         }
         const targetId = action.metadata?.wagmiConnectorId;
-        const connector = targetId ? connectors.find((c) => c.id === targetId) ?? connectors[0] : connectors[0];
+        const metaMaskConnector = connectors.find((c) => {
+          const id = c.id.toLowerCase();
+          const name = c.name.toLowerCase();
+          return id.includes("metamask") || name.includes("metamask");
+        });
+        const connector = targetId ? connectors.find((c) => c.id === targetId) ?? metaMaskConnector ?? connectors[0] : metaMaskConnector ?? connectors[0];
         if (!connector) {
           return {
             actionId: action.id,
@@ -319,243 +817,231 @@ function useAuthorizationExecutor() {
         };
       }
     },
-    [isConnected, address, currentChainId, connectors, connectAsync]
+    [wagmiConfig2, connectors, connectAsync]
   );
-  const executeSwitchChain = useCallback(
+  const executeSelectSource = useCallback(
     async (action) => {
       try {
-        const targetChainIdHex = action.metadata?.targetChainId;
-        if (!targetChainIdHex) {
+        const options = action.metadata?.options;
+        const recommended = action.metadata?.recommended;
+        if (!options || options.length <= 1) {
+          const selection2 = recommended ?? { chainName: "Base", tokenSymbol: "USDC" };
           return {
             actionId: action.id,
             type: action.type,
-            status: "error",
-            message: "No targetChainId in action metadata."
+            status: "success",
+            message: `Auto-selected ${selection2.tokenSymbol} on ${selection2.chainName}.`,
+            data: {
+              selectedChainName: selection2.chainName,
+              selectedTokenSymbol: selection2.tokenSymbol
+            }
           };
         }
-        const targetChainIdNum = parseInt(targetChainIdHex, 16);
-        await switchChainAsync({ chainId: targetChainIdNum });
-        const hexChainId = `0x${targetChainIdNum.toString(16)}`;
+        const selection = await new Promise((resolve) => {
+          selectSourceResolverRef.current = resolve;
+          setPendingSelectSource(action);
+        });
         return {
           actionId: action.id,
           type: action.type,
           status: "success",
-          message: `Switched to chain ${hexChainId}.`,
-          data: { chainId: hexChainId, switched: true }
+          message: `Selected ${selection.tokenSymbol} on ${selection.chainName}.`,
+          data: {
+            selectedChainName: selection.chainName,
+            selectedTokenSymbol: selection.tokenSymbol
+          }
         };
       } catch (err) {
         return {
           actionId: action.id,
           type: action.type,
           status: "error",
-          message: err instanceof Error ? err.message : "Failed to switch chain"
+          message: err instanceof Error ? err.message : "Failed to select source"
         };
       }
     },
-    [switchChainAsync]
+    []
   );
-  const executeApprovePermit2 = useCallback(
+  const executeSwitchChain = useCallback(
     async (action) => {
       try {
-        const tokenAddress = action.metadata?.tokenAddress;
-        const permit2Address = action.metadata?.permit2Address;
-        if (!tokenAddress || !permit2Address) {
+        const account = getAccount(wagmiConfig2);
+        const targetChainIdHex = action.metadata?.targetChainId;
+        if (!targetChainIdHex) {
           return {
             actionId: action.id,
             type: action.type,
             status: "error",
-            message: "Missing tokenAddress or permit2Address in action metadata."
+            message: "No targetChainId in action metadata."
           };
         }
-        if (!address) {
+        const targetChainIdNum = parseInt(targetChainIdHex, 16);
+        const hexChainId = `0x${targetChainIdNum.toString(16)}`;
+        if (account.chainId === targetChainIdNum) {
           return {
             actionId: action.id,
             type: action.type,
-            status: "error",
-            message: "Wallet not connected."
+            status: "success",
+            message: `Already on chain ${hexChainId}. Skipped.`,
+            data: { chainId: hexChainId, switched: false }
           };
         }
-        const ERC20_ABI = [
-          {
-            name: "allowance",
-            type: "function",
-            stateMutability: "view",
-            inputs: [
-              { name: "owner", type: "address" },
-              { name: "spender", type: "address" }
-            ],
-            outputs: [{ name: "", type: "uint256" }]
-          },
-          {
-            name: "approve",
-            type: "function",
-            stateMutability: "nonpayable",
-            inputs: [
-              { name: "spender", type: "address" },
-              { name: "amount", type: "uint256" }
+        await switchChainAsync({ chainId: targetChainIdNum });
+        return {
+          actionId: action.id,
+          type: action.type,
+          status: "success",
+          message: `Switched to chain ${hexChainId}.`,
+          data: { chainId: hexChainId, switched: true }
+        };
+      } catch (err) {
+        return {
+          actionId: action.id,
+          type: action.type,
+          status: "error",
+          message: err instanceof Error ? err.message : "Failed to switch chain"
+        };
+      }
+    },
+    [wagmiConfig2, switchChainAsync]
+  );
+  const executeRegisterPasskey = useCallback(
+    async (action) => {
+      try {
+        const account = getAccount(wagmiConfig2);
+        const challenge = new Uint8Array(32);
+        crypto.getRandomValues(challenge);
+        const credential = await navigator.credentials.create({
+          publicKey: {
+            challenge,
+            rp: {
+              name: "Swype",
+              id: window.location.hostname
+            },
+            user: {
+              id: new TextEncoder().encode(account.address ?? "user"),
+              name: account.address ?? "Swype User",
+              displayName: "Swype User"
+            },
+            pubKeyCredParams: [
+              { alg: -7, type: "public-key" },
+              // ES256 (P-256)
+              { alg: -257, type: "public-key" }
+              // RS256
             ],
-            outputs: [{ name: "", type: "bool" }]
-          }
-        ];
-        if (publicClient) {
-          const currentAllowance = await publicClient.readContract({
-            address: tokenAddress,
-            abi: ERC20_ABI,
-            functionName: "allowance",
-            args: [address, permit2Address]
-          });
-          if (currentAllowance > 0n) {
-            return {
-              actionId: action.id,
-              type: action.type,
-              status: "success",
-              message: `Permit2 already approved (allowance: ${currentAllowance.toString()}). Skipped.`,
-              data: { skipped: true, existingAllowance: currentAllowance.toString() }
-            };
+            authenticatorSelection: {
+              authenticatorAttachment: "platform",
+              residentKey: "preferred",
+              userVerification: "required"
+            },
+            timeout: 6e4
           }
-        }
-        if (!walletClient) {
+        });
+        if (!credential) {
           return {
             actionId: action.id,
             type: action.type,
             status: "error",
-            message: "Wallet client not available."
+            message: "Passkey creation was cancelled."
           };
         }
-        const MAX_UINT256 = 2n ** 256n - 1n;
-        const txHash = await walletClient.writeContract({
-          address: tokenAddress,
-          abi: ERC20_ABI,
-          functionName: "approve",
-          args: [permit2Address, MAX_UINT256]
-        });
-        if (publicClient) {
-          await publicClient.waitForTransactionReceipt({ hash: txHash });
-        }
+        const response = credential.response;
+        const publicKeyBytes = response.getPublicKey?.();
+        const credentialId = btoa(
+          String.fromCharCode(...new Uint8Array(credential.rawId))
+        );
+        const publicKey = publicKeyBytes ? btoa(String.fromCharCode(...new Uint8Array(publicKeyBytes))) : "";
         return {
           actionId: action.id,
           type: action.type,
           status: "success",
-          message: `Permit2 approved. Tx: ${txHash}`,
-          data: { txHash, approved: true }
+          message: "Passkey created successfully.",
+          data: {
+            credentialId,
+            publicKey
+          }
         };
       } catch (err) {
         return {
           actionId: action.id,
           type: action.type,
           status: "error",
-          message: err instanceof Error ? err.message : "Failed to approve Permit2"
+          message: err instanceof Error ? err.message : "Failed to create passkey"
         };
       }
     },
-    [address, publicClient, walletClient]
+    [wagmiConfig2]
   );
-  const executeSignPermit2 = useCallback(
+  const executeUpgradeSmartAccount = useCallback(
     async (action) => {
       try {
-        const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-        const PERMIT2_ALLOWANCE_ABI = [
-          {
-            name: "allowance",
-            type: "function",
-            stateMutability: "view",
-            inputs: [
-              { name: "owner", type: "address" },
-              { name: "token", type: "address" },
-              { name: "spender", type: "address" }
-            ],
-            outputs: [
-              { name: "amount", type: "uint160" },
-              { name: "expiration", type: "uint48" },
-              { name: "nonce", type: "uint48" }
-            ]
+        const account = getAccount(wagmiConfig2);
+        const walletClient = await waitForWalletClient(wagmiConfig2);
+        const sender = account.address ?? walletClient.account?.address;
+        if (!sender) {
+          throw new Error("Wallet account not available. Please connect your wallet.");
+        }
+        if (!isMetaMaskConnector(account)) {
+          throw new Error(
+            "EIP-7702 smart account upgrade requires a MetaMask-compatible wallet. Please reconnect using MetaMask and try again."
+          );
+        }
+        const metadata = action.metadata;
+        const { txHash, smartAccountAddress } = await submitUpgradeTransaction({
+          walletClient,
+          sender,
+          metadata
+        });
+        return {
+          actionId: action.id,
+          type: action.type,
+          status: "success",
+          message: "Account upgrade transaction submitted.",
+          data: {
+            txHash,
+            smartAccountAddress
           }
-        ];
-        const spenderAddress = action.metadata?.spenderAddress;
-        const tokenAddress = action.metadata?.tokenAddress;
-        const metadataChainId = action.metadata?.chainId;
-        const metadataAmount = action.metadata?.amount;
-        if (!spenderAddress || !tokenAddress) {
+        };
+      } catch (err) {
+        console.error("Failed to upgrade account", err);
+        const message = extractErrorMessage(err);
+        const isRejected = message.includes("rejected") || message.includes("denied") || message.includes("user rejected");
+        return {
+          actionId: action.id,
+          type: action.type,
+          status: "error",
+          message: isRejected ? "You rejected the upgrade transaction. Please approve the transaction prompt in your wallet to continue." : message
+        };
+      }
+    },
+    [wagmiConfig2]
+  );
+  const executeGrantPermissions = useCallback(
+    async (action) => {
+      try {
+        const walletClient = await waitForWalletClient(wagmiConfig2);
+        const signingPayload = action.metadata?.signingPayload;
+        const tokens = action.metadata?.tokens;
+        if (!signingPayload) {
           return {
             actionId: action.id,
             type: action.type,
             status: "error",
-            message: "Missing spenderAddress or tokenAddress in action metadata."
+            message: "No signing payload in action metadata."
           };
         }
-        if (publicClient && address && metadataAmount) {
-          try {
-            const [existingAmount, existingExpiration] = await publicClient.readContract({
-              address: PERMIT2_ADDRESS,
-              abi: PERMIT2_ALLOWANCE_ABI,
-              functionName: "allowance",
-              args: [address, tokenAddress, spenderAddress]
-            });
-            const requiredSmallestUnit = BigInt(
-              Math.ceil(metadataAmount * 1e6)
-            );
-            const now = Math.floor(Date.now() / 1e3);
-            if (existingAmount >= requiredSmallestUnit && existingExpiration > now) {
-              return {
-                actionId: action.id,
-                type: action.type,
-                status: "success",
-                message: `Permit2 allowance already sufficient (${existingAmount.toString()}). Skipped.`,
-                data: { skipped: true, existingAllowance: existingAmount.toString() }
-              };
-            }
-          } catch {
-          }
-        }
-        const metadataAllowance = action.metadata?.allowance;
-        const permitAmount = metadataAllowance ? BigInt(Math.ceil(metadataAllowance * 1e6)) : metadataAmount ? BigInt(Math.ceil(metadataAmount * 1e6)) : BigInt(5e6);
-        const permit2ChainId = metadataChainId ? parseInt(metadataChainId, 16) : currentChainId;
-        const nonce = Number(action.metadata?.nonce ?? 0);
-        const sigDeadline = BigInt(Math.floor(Date.now() / 1e3) + 3600);
-        const expiration = Math.floor(Date.now() / 1e3) + 30 * 24 * 60 * 60;
-        const signature = await signTypedDataAsync({
-          domain: {
-            name: "Permit2",
-            chainId: permit2ChainId,
-            verifyingContract: PERMIT2_ADDRESS
-          },
-          types: {
-            PermitSingle: [
-              { name: "details", type: "PermitDetails" },
-              { name: "spender", type: "address" },
-              { name: "sigDeadline", type: "uint256" }
-            ],
-            PermitDetails: [
-              { name: "token", type: "address" },
-              { name: "amount", type: "uint160" },
-              { name: "expiration", type: "uint48" },
-              { name: "nonce", type: "uint48" }
-            ]
-          },
-          primaryType: "PermitSingle",
-          message: {
-            details: {
-              token: tokenAddress,
-              amount: permitAmount,
-              expiration,
-              nonce
-            },
-            spender: spenderAddress,
-            sigDeadline
-          }
+        const signature = await walletClient.signMessage({
+          message: JSON.stringify(signingPayload)
         });
+        const tokenSummary = tokens?.map((t) => `${t.symbol} on ${t.chainName}`).join(", ") ?? "all tokens";
         return {
           actionId: action.id,
           type: action.type,
           status: "success",
-          message: "Permit2 allowance signature obtained.",
+          message: `Permissions granted for ${tokenSummary}.`,
           data: {
-            signature,
-            signer: address,
-            nonce: nonce.toString(),
-            sigDeadline: sigDeadline.toString(),
-            expiration: expiration.toString(),
-            amount: permitAmount.toString()
+            signedDelegation: signature,
+            tokens
           }
         };
       } catch (err) {
@@ -563,23 +1049,28 @@ function useAuthorizationExecutor() {
           actionId: action.id,
           type: action.type,
           status: "error",
-          message: err instanceof Error ? err.message : "Failed to sign Permit2"
+          message: err instanceof Error ? err.message : "Failed to grant permissions"
         };
       }
     },
-    [address, currentChainId, publicClient, signTypedDataAsync]
+    [wagmiConfig2]
   );
   const executeAction = useCallback(
     async (action) => {
+      setCurrentAction(action);
       switch (action.type) {
         case "OPEN_PROVIDER":
           return executeOpenProvider(action);
+        case "SELECT_SOURCE":
+          return executeSelectSource(action);
         case "SWITCH_CHAIN":
           return executeSwitchChain(action);
-        case "APPROVE_PERMIT_2":
-          return executeApprovePermit2(action);
-        case "SIGN_PERMIT2":
-          return executeSignPermit2(action);
+        case "REGISTER_PASSKEY":
+          return executeRegisterPasskey(action);
+        case "UPGRADE_SMART_ACCOUNT":
+          return executeUpgradeSmartAccount(action);
+        case "GRANT_PERMISSIONS":
+          return executeGrantPermissions(action);
         default:
           return {
             actionId: action.id,
@@ -589,18 +1080,18 @@ function useAuthorizationExecutor() {
           };
       }
     },
-    [executeOpenProvider, executeSwitchChain, executeApprovePermit2, executeSignPermit2]
+    [executeOpenProvider, executeSelectSource, executeSwitchChain, executeRegisterPasskey, executeUpgradeSmartAccount, executeGrantPermissions]
   );
   const executeSession = useCallback(
     async (transfer) => {
       if (executingRef.current) return;
       executingRef.current = true;
       if (!transfer.authorizationSessions || transfer.authorizationSessions.length === 0) {
-        setError("No authorization sessions available.");
         executingRef.current = false;
-        return;
+        throw new Error("No authorization sessions available.");
       }
       const sessionId = transfer.authorizationSessions[0].id;
+      sessionIdRef.current = sessionId;
       setExecuting(true);
       setError(null);
       setResults([]);
@@ -609,6 +1100,18 @@ function useAuthorizationExecutor() {
         const allResults = [];
         const completedActionIds = /* @__PURE__ */ new Set();
         let pendingActions = currentSession.actions.filter((a) => a.status === "PENDING").sort((a, b) => a.orderIndex - b.orderIndex);
+        const ACTION_POLL_INTERVAL_MS = 500;
+        const ACTION_POLL_MAX_RETRIES = 20;
+        let actionPollRetries = 0;
+        while (pendingActions.length === 0 && currentSession.status !== "AUTHORIZED" && actionPollRetries < ACTION_POLL_MAX_RETRIES) {
+          await new Promise((r) => setTimeout(r, ACTION_POLL_INTERVAL_MS));
+          currentSession = await fetchAuthorizationSession(apiBaseUrl, sessionId);
+          pendingActions = currentSession.actions.filter((a) => a.status === "PENDING").sort((a, b) => a.orderIndex - b.orderIndex);
+          actionPollRetries++;
+        }
+        if (pendingActions.length === 0 && currentSession.status !== "AUTHORIZED") {
+          throw new Error("Authorization actions were not created in time. Please try again.");
+        }
         while (pendingActions.length > 0) {
           const action = pendingActions[0];
           if (completedActionIds.has(action.id)) break;
@@ -616,8 +1119,7 @@ function useAuthorizationExecutor() {
           if (result.status === "error") {
             allResults.push(result);
             setResults([...allResults]);
-            setError(result.message);
-            break;
+            throw new Error(result.message);
           }
           completedActionIds.add(action.id);
           const updatedSession = await reportActionCompletion(
@@ -629,7 +1131,6 @@ function useAuthorizationExecutor() {
           pendingActions = currentSession.actions.filter((a) => a.status === "PENDING" && !completedActionIds.has(a.id)).sort((a, b) => a.orderIndex - b.orderIndex);
           if (action.type === "OPEN_PROVIDER" && pendingActions.length > 0) {
             const chainResults = [result];
-            let chainBroken = false;
             while (pendingActions.length > 0) {
               const nextAction = pendingActions[0];
               const nextResult = await executeAction(nextAction);
@@ -637,9 +1138,7 @@ function useAuthorizationExecutor() {
                 chainResults.push(nextResult);
                 allResults.push(...chainResults);
                 setResults([...allResults]);
-                setError(nextResult.message);
-                chainBroken = true;
-                break;
+                throw new Error(nextResult.message);
               }
               completedActionIds.add(nextAction.id);
               const nextSession = await reportActionCompletion(
@@ -651,7 +1150,6 @@ function useAuthorizationExecutor() {
               chainResults.push(nextResult);
               pendingActions = currentSession.actions.filter((a) => a.status === "PENDING" && !completedActionIds.has(a.id)).sort((a, b) => a.orderIndex - b.orderIndex);
             }
-            if (chainBroken) break;
             allResults.push(...chainResults);
             setResults([...allResults]);
             continue;
@@ -660,15 +1158,113 @@ function useAuthorizationExecutor() {
           setResults([...allResults]);
         }
       } catch (err) {
-        setError(err instanceof Error ? err.message : "Authorization failed");
+        const msg = err instanceof Error ? err.message : "Authorization failed";
+        setError(msg);
+        throw err;
       } finally {
+        setCurrentAction(null);
         setExecuting(false);
         executingRef.current = false;
       }
     },
     [apiBaseUrl, executeAction]
   );
-  return { executing, results, error, executeSession };
+  return {
+    executing,
+    results,
+    error,
+    currentAction,
+    pendingSelectSource,
+    resolveSelectSource,
+    executeSession
+  };
+}
+function useTransferSigning(pollIntervalMs = 2e3) {
+  const { apiBaseUrl } = useSwypeConfig();
+  const { getAccessToken } = usePrivy();
+  const [signing, setSigning] = useState(false);
+  const [signPayload, setSignPayload] = useState(null);
+  const [error, setError] = useState(null);
+  const signTransfer2 = useCallback(
+    async (transferId) => {
+      setSigning(true);
+      setError(null);
+      setSignPayload(null);
+      try {
+        const token = await getAccessToken();
+        if (!token) {
+          throw new Error("Could not get access token");
+        }
+        const MAX_POLLS = 60;
+        let payload = null;
+        for (let i = 0; i < MAX_POLLS; i++) {
+          const transfer = await fetchTransfer(apiBaseUrl, token, transferId);
+          if (transfer.signPayload) {
+            payload = transfer.signPayload;
+            setSignPayload(payload);
+            break;
+          }
+          if (transfer.status !== "AUTHORIZED" && transfer.status !== "CREATED") {
+            throw new Error(`Unexpected transfer status: ${transfer.status}`);
+          }
+          await new Promise((r) => setTimeout(r, pollIntervalMs));
+        }
+        if (!payload) {
+          throw new Error("Timed out waiting for sign payload. Please try again.");
+        }
+        const userOpHashHex = payload.userOpHash;
+        const hashBytes = new Uint8Array(
+          (userOpHashHex.startsWith("0x") ? userOpHashHex.slice(2) : userOpHashHex).match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
+        );
+        const assertion = await navigator.credentials.get({
+          publicKey: {
+            challenge: hashBytes,
+            rpId: window.location.hostname,
+            userVerification: "required",
+            timeout: 6e4
+          }
+        });
+        if (!assertion) {
+          throw new Error("Passkey authentication was cancelled.");
+        }
+        const response = assertion.response;
+        const signature = btoa(
+          String.fromCharCode(...new Uint8Array(response.signature))
+        );
+        const authenticatorData = btoa(
+          String.fromCharCode(
+            ...new Uint8Array(response.authenticatorData)
+          )
+        );
+        const clientDataJSON = btoa(
+          String.fromCharCode(
+            ...new Uint8Array(response.clientDataJSON)
+          )
+        );
+        const signedUserOp = {
+          ...payload.userOp,
+          signature,
+          authenticatorData,
+          clientDataJSON
+        };
+        const updatedTransfer = await signTransfer(
+          apiBaseUrl,
+          token,
+          transferId,
+          signedUserOp
+        );
+        return updatedTransfer;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Failed to sign transfer";
+        setError(msg);
+        throw err;
+      } finally {
+        setSigning(false);
+      }
+    },
+    [apiBaseUrl, getAccessToken, pollIntervalMs]
+  );
+  return { signing, signPayload, error, signTransfer: signTransfer2 };
 }
 function Spinner({ size = 40, label }) {
   const { tokens } = useSwypeConfig();
@@ -786,163 +1382,232 @@ function ProviderCard({ provider, selected, onClick }) {
     }
   );
 }
-function AccountWalletSelector({
+function AccountDropdown({
   accounts,
-  selection,
-  onSelect
+  selectedAccountId,
+  onSelect,
+  selectedWalletId,
+  onWalletSelect
 }) {
   const { tokens } = useSwypeConfig();
-  const [expandedAccountId, setExpandedAccountId] = useState(null);
-  const activeAccounts = accounts.filter(
-    (a) => a.wallets.some((w) => w.status === "ACTIVE")
+  const [open, setOpen] = useState(false);
+  const containerRef = useRef(null);
+  const selected = accounts.find((a) => a.id === selectedAccountId);
+  const selectedWallet = selected?.wallets.find(
+    (w) => w.id === selectedWalletId
   );
-  if (activeAccounts.length === 0) return null;
-  const handleAccountClick = (accountId) => {
-    if (expandedAccountId === accountId) {
-      setExpandedAccountId(null);
-    } else {
-      setExpandedAccountId(accountId);
-    }
-  };
-  const handleWalletClick = (account, wallet) => {
-    const isAlreadySelected = selection?.accountId === account.id && selection?.walletId === wallet.id;
-    if (isAlreadySelected) {
-      onSelect(null);
-    } else {
-      onSelect({
-        accountId: account.id,
-        walletId: wallet.id,
-        accountName: account.name,
-        walletName: wallet.name,
-        chainName: wallet.chain.name
-      });
-    }
-  };
-  const formatBalance = (wallet) => {
-    const parts = [];
-    for (const src of wallet.sources) {
-      if (src.token.status === "ACTIVE") {
-        parts.push(
-          `${src.balance.available.amount.toFixed(2)} ${src.balance.available.currency} (${src.token.symbol})`
-        );
+  useEffect(() => {
+    if (!open) return;
+    const handleClick = (e) => {
+      if (containerRef.current && !containerRef.current.contains(e.target)) {
+        setOpen(false);
       }
-    }
-    if (parts.length === 0 && wallet.balance) {
-      return `${wallet.balance.available.amount.toFixed(2)} ${wallet.balance.available.currency}`;
-    }
-    return parts.join(", ") || "No balance";
-  };
-  return /* @__PURE__ */ jsxs("div", { style: { width: "100%" }, children: [
-    /* @__PURE__ */ jsx(
-      "label",
+    };
+    document.addEventListener("mousedown", handleClick);
+    return () => document.removeEventListener("mousedown", handleClick);
+  }, [open]);
+  if (accounts.length === 0) return null;
+  const hasMultipleChoices = accounts.length > 1 || accounts.length === 1 && onWalletSelect && accounts[0].wallets.filter((w) => w.balance.available.amount > 0).length > 1;
+  if (!hasMultipleChoices) {
+    return /* @__PURE__ */ jsxs(
+      "div",
       {
         style: {
-          display: "block",
-          fontSize: "0.8rem",
-          color: tokens.textMuted,
-          marginBottom: "8px",
-          fontWeight: 500,
-          textTransform: "uppercase",
-          letterSpacing: "0.05em"
+          display: "flex",
+          alignItems: "center",
+          gap: "6px",
+          fontSize: "0.85rem",
+          color: tokens.textSecondary
         },
-        children: "Or use a connected account"
+        children: [
+          /* @__PURE__ */ jsx("span", { style: { fontWeight: 500 }, children: accounts[0].name }),
+          (selectedWallet ?? accounts[0].wallets[0]) && /* @__PURE__ */ jsx(
+            "span",
+            {
+              style: {
+                fontSize: "0.75rem",
+                color: tokens.textMuted,
+                fontFamily: '"SF Mono", "Fira Code", monospace'
+              },
+              children: selectedWallet ? `${selectedWallet.chain.name} \xB7 ${selectedWallet.name}` : accounts[0].wallets[0]?.name
+            }
+          )
+        ]
       }
-    ),
-    /* @__PURE__ */ jsx("div", { style: { display: "flex", flexDirection: "column", gap: "6px" }, children: activeAccounts.map((account) => {
-      const isExpanded = expandedAccountId === account.id;
-      const activeWallets = account.wallets.filter((w) => w.status === "ACTIVE");
-      const hasSelection = selection?.accountId === account.id;
-      return /* @__PURE__ */ jsxs(
-        "div",
-        {
-          style: {
-            border: `1px solid ${hasSelection ? tokens.accent : tokens.border}`,
-            borderRadius: tokens.radius,
-            overflow: "hidden",
-            transition: "border-color 0.15s ease"
-          },
-          children: [
+    );
+  }
+  const getAccountBalance = (account) => {
+    let total = 0;
+    for (const w of account.wallets) {
+      total += w.balance.available.amount;
+    }
+    return total > 0 ? `$${total.toFixed(2)}` : "";
+  };
+  const hasActiveWallet = (account) => account.wallets.some((w) => w.status === "ACTIVE");
+  return /* @__PURE__ */ jsxs("div", { ref: containerRef, style: { position: "relative" }, children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        onClick: () => setOpen(!open),
+        style: {
+          display: "flex",
+          alignItems: "center",
+          gap: "6px",
+          background: "transparent",
+          border: "none",
+          cursor: "pointer",
+          padding: "4px 0",
+          color: tokens.textSecondary,
+          fontFamily: "inherit",
+          fontSize: "0.85rem",
+          outline: "none"
+        },
+        children: [
+          /* @__PURE__ */ jsx("span", { style: { fontWeight: 500, color: tokens.text }, children: selected?.name ?? "Select account" }),
+          (selectedWallet ?? selected?.wallets?.[0]) && /* @__PURE__ */ jsx(
+            "span",
+            {
+              style: {
+                fontSize: "0.75rem",
+                color: tokens.textMuted,
+                fontFamily: '"SF Mono", "Fira Code", monospace'
+              },
+              children: selectedWallet ? `${selectedWallet.chain.name} \xB7 ${selectedWallet.name}` : selected.wallets[0].name
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "svg",
+            {
+              width: "12",
+              height: "12",
+              viewBox: "0 0 24 24",
+              fill: "none",
+              style: {
+                transform: open ? "rotate(180deg)" : "rotate(0deg)",
+                transition: "transform 0.15s ease",
+                flexShrink: 0
+              },
+              children: /* @__PURE__ */ jsx(
+                "path",
+                {
+                  d: "M7 10l5 5 5-5",
+                  stroke: tokens.textMuted,
+                  strokeWidth: "2",
+                  strokeLinecap: "round",
+                  strokeLinejoin: "round"
+                }
+              )
+            }
+          )
+        ]
+      }
+    ),
+    open && /* @__PURE__ */ jsx(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          top: "100%",
+          left: 0,
+          right: 0,
+          marginTop: "4px",
+          background: tokens.bgCard,
+          border: `1px solid ${tokens.border}`,
+          borderRadius: tokens.radius,
+          boxShadow: tokens.shadowLg,
+          zIndex: 50,
+          overflow: "hidden",
+          minWidth: "220px"
+        },
+        children: accounts.map((account) => {
+          const isAcctSelected = account.id === selectedAccountId;
+          const balance = getAccountBalance(account);
+          const active = hasActiveWallet(account);
+          const walletsWithBalance = account.wallets.filter(
+            (w) => w.balance.available.amount > 0
+          );
+          const showWallets = onWalletSelect && walletsWithBalance.length > 0;
+          return /* @__PURE__ */ jsxs("div", { children: [
             /* @__PURE__ */ jsxs(
               "button",
               {
-                onClick: () => handleAccountClick(account.id),
+                onClick: () => {
+                  onSelect(account.id);
+                  if (!showWallets) setOpen(false);
+                },
                 style: {
-                  width: "100%",
                   display: "flex",
                   alignItems: "center",
                   justifyContent: "space-between",
-                  padding: "12px 14px",
-                  background: hasSelection ? tokens.accent + "10" : tokens.bgInput,
+                  width: "100%",
+                  padding: "10px 14px",
+                  background: isAcctSelected && !selectedWalletId ? tokens.accent + "12" : "transparent",
                   border: "none",
+                  borderBottom: showWallets ? "none" : `1px solid ${tokens.border}`,
                   cursor: "pointer",
                   color: tokens.text,
                   fontFamily: "inherit",
-                  fontSize: "0.9rem",
-                  fontWeight: 500,
+                  fontSize: "0.85rem",
                   textAlign: "left",
                   outline: "none",
-                  transition: "background 0.15s ease"
+                  transition: "background 0.1s ease"
                 },
                 children: [
-                  /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: "10px" }, children: [
-                    /* @__PURE__ */ jsx(
+                  /* @__PURE__ */ jsxs("div", { style: { minWidth: 0, flex: 1 }, children: [
+                    /* @__PURE__ */ jsxs(
                       "div",
                       {
                         style: {
-                          width: 28,
-                          height: 28,
-                          borderRadius: "6px",
-                          background: tokens.accent + "25",
                           display: "flex",
                           alignItems: "center",
-                          justifyContent: "center",
-                          fontSize: "0.75rem",
-                          fontWeight: 700,
-                          color: tokens.accent,
-                          flexShrink: 0
+                          gap: "6px"
                         },
-                        children: account.name.charAt(0).toUpperCase()
+                        children: [
+                          /* @__PURE__ */ jsx("span", { style: { fontWeight: 500 }, children: account.name }),
+                          active && /* @__PURE__ */ jsx(
+                            "span",
+                            {
+                              style: {
+                                fontSize: "0.6rem",
+                                fontWeight: 600,
+                                color: tokens.success,
+                                background: tokens.successBg,
+                                padding: "1px 5px",
+                                borderRadius: "3px",
+                                textTransform: "uppercase",
+                                letterSpacing: "0.03em"
+                              },
+                              children: "Active"
+                            }
+                          )
+                        ]
                       }
                     ),
-                    /* @__PURE__ */ jsxs("div", { children: [
-                      /* @__PURE__ */ jsx("div", { children: account.name }),
-                      /* @__PURE__ */ jsxs(
-                        "div",
-                        {
-                          style: {
-                            fontSize: "0.75rem",
-                            color: tokens.textMuted,
-                            marginTop: "2px"
-                          },
-                          children: [
-                            activeWallets.length,
-                            " wallet",
-                            activeWallets.length !== 1 ? "s" : ""
-                          ]
-                        }
-                      )
-                    ] })
+                    balance && /* @__PURE__ */ jsx(
+                      "div",
+                      {
+                        style: {
+                          fontSize: "0.75rem",
+                          color: tokens.textMuted,
+                          marginTop: "2px"
+                        },
+                        children: balance
+                      }
+                    )
                   ] }),
-                  /* @__PURE__ */ jsx(
+                  isAcctSelected && !selectedWalletId && /* @__PURE__ */ jsx(
                     "svg",
                     {
                       width: "14",
                       height: "14",
                       viewBox: "0 0 24 24",
                       fill: "none",
-                      style: {
-                        transform: isExpanded ? "rotate(180deg)" : "rotate(0deg)",
-                        transition: "transform 0.2s ease",
-                        flexShrink: 0
-                      },
+                      style: { flexShrink: 0, marginLeft: "8px" },
                       children: /* @__PURE__ */ jsx(
                         "path",
                         {
-                          d: "M7 10l5 5 5-5",
-                          stroke: tokens.textMuted,
-                          strokeWidth: "2",
-                          strokeLinecap: "round",
-                          strokeLinejoin: "round"
+                          d: "M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41L9 16.17z",
+                          fill: tokens.accent
                         }
                       )
                     }
@@ -950,128 +1615,383 @@ function AccountWalletSelector({
                 ]
               }
             ),
-            isExpanded && /* @__PURE__ */ jsx(
-              "div",
-              {
-                style: {
-                  borderTop: `1px solid ${tokens.border}`,
-                  background: tokens.bgCard
-                },
-                children: activeWallets.map((wallet) => {
-                  const isSelected = selection?.walletId === wallet.id;
-                  return /* @__PURE__ */ jsxs(
-                    "button",
-                    {
-                      onClick: () => handleWalletClick(account, wallet),
-                      style: {
-                        width: "100%",
-                        display: "flex",
-                        alignItems: "center",
-                        justifyContent: "space-between",
-                        padding: "10px 14px 10px 24px",
-                        background: isSelected ? tokens.accent + "12" : "transparent",
-                        border: "none",
-                        borderBottom: `1px solid ${tokens.border}`,
-                        cursor: "pointer",
-                        color: tokens.text,
-                        fontFamily: "inherit",
-                        fontSize: "0.85rem",
-                        textAlign: "left",
-                        outline: "none",
-                        transition: "background 0.1s ease"
-                      },
-                      children: [
-                        /* @__PURE__ */ jsxs("div", { style: { minWidth: 0, flex: 1 }, children: [
-                          /* @__PURE__ */ jsxs(
-                            "div",
+            showWallets && walletsWithBalance.map((wallet, wIdx) => {
+              const isWalletSelected = isAcctSelected && wallet.id === selectedWalletId;
+              const walletBal = wallet.balance.available.amount > 0 ? `$${wallet.balance.available.amount.toFixed(2)}` : "";
+              const isLastWallet = wIdx === walletsWithBalance.length - 1;
+              return /* @__PURE__ */ jsxs(
+                "button",
+                {
+                  onClick: () => {
+                    onWalletSelect(account.id, wallet.id);
+                    setOpen(false);
+                  },
+                  style: {
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: "space-between",
+                    width: "100%",
+                    padding: "8px 14px 8px 28px",
+                    background: isWalletSelected ? tokens.accent + "12" : "transparent",
+                    border: "none",
+                    borderBottom: isLastWallet ? `1px solid ${tokens.border}` : "none",
+                    cursor: "pointer",
+                    color: tokens.text,
+                    fontFamily: "inherit",
+                    fontSize: "0.8rem",
+                    textAlign: "left",
+                    outline: "none",
+                    transition: "background 0.1s ease"
+                  },
+                  children: [
+                    /* @__PURE__ */ jsxs(
+                      "div",
+                      {
+                        style: {
+                          display: "flex",
+                          alignItems: "center",
+                          gap: "6px",
+                          minWidth: 0,
+                          flex: 1
+                        },
+                        children: [
+                          /* @__PURE__ */ jsx(
+                            "span",
                             {
                               style: {
-                                display: "flex",
-                                alignItems: "center",
-                                gap: "6px"
+                                fontWeight: 500,
+                                fontSize: "0.8rem"
                               },
-                              children: [
-                                /* @__PURE__ */ jsx("span", { style: { fontWeight: 500 }, children: wallet.name }),
-                                /* @__PURE__ */ jsx(
-                                  "span",
-                                  {
-                                    style: {
-                                      fontSize: "0.7rem",
-                                      color: tokens.textMuted,
-                                      background: tokens.bgHover,
-                                      padding: "1px 6px",
-                                      borderRadius: "4px"
-                                    },
-                                    children: wallet.chain.name
-                                  }
-                                )
-                              ]
+                              children: wallet.chain.name
                             }
                           ),
                           /* @__PURE__ */ jsx(
-                            "div",
+                            "span",
+                            {
+                              style: {
+                                fontSize: "0.7rem",
+                                color: tokens.textMuted,
+                                fontFamily: '"SF Mono", "Fira Code", monospace'
+                              },
+                              children: wallet.name
+                            }
+                          ),
+                          walletBal && /* @__PURE__ */ jsx(
+                            "span",
                             {
                               style: {
-                                fontSize: "0.75rem",
-                                color: tokens.textSecondary,
-                                marginTop: "3px"
+                                fontSize: "0.7rem",
+                                color: tokens.textMuted,
+                                marginLeft: "auto"
                               },
-                              children: formatBalance(wallet)
+                              children: walletBal
                             }
                           )
-                        ] }),
-                        isSelected && /* @__PURE__ */ jsx(
-                          "svg",
+                        ]
+                      }
+                    ),
+                    isWalletSelected && /* @__PURE__ */ jsx(
+                      "svg",
+                      {
+                        width: "12",
+                        height: "12",
+                        viewBox: "0 0 24 24",
+                        fill: "none",
+                        style: {
+                          flexShrink: 0,
+                          marginLeft: "8px"
+                        },
+                        children: /* @__PURE__ */ jsx(
+                          "path",
                           {
-                            width: "16",
-                            height: "16",
-                            viewBox: "0 0 24 24",
-                            fill: "none",
-                            style: { flexShrink: 0, marginLeft: "8px" },
-                            children: /* @__PURE__ */ jsx(
-                              "path",
-                              {
-                                d: "M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41L9 16.17z",
-                                fill: tokens.accent
-                              }
-                            )
+                            d: "M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41L9 16.17z",
+                            fill: tokens.accent
                           }
                         )
-                      ]
-                    },
-                    wallet.id
-                  );
-                })
-              }
-            )
-          ]
-        },
-        account.id
-      );
-    }) }),
-    selection && /* @__PURE__ */ jsxs(
-      "div",
+                      }
+                    )
+                  ]
+                },
+                wallet.id
+              );
+            })
+          ] }, account.id);
+        })
+      }
+    )
+  ] });
+}
+var ASSETS = ["USDC", "USDT"];
+function AdvancedSettings({
+  settings,
+  onChange,
+  chains,
+  providers,
+  onConnectNewAccount,
+  connectingNewAccount
+}) {
+  const { tokens } = useSwypeConfig();
+  const [open, setOpen] = useState(false);
+  const [showProviders, setShowProviders] = useState(false);
+  return /* @__PURE__ */ jsxs("div", { style: { marginTop: "12px" }, children: [
+    /* @__PURE__ */ jsxs(
+      "button",
       {
+        onClick: () => setOpen(!open),
         style: {
-          marginTop: "8px",
-          fontSize: "0.8rem",
-          color: tokens.accent,
           display: "flex",
           alignItems: "center",
-          gap: "6px"
+          gap: "6px",
+          background: "transparent",
+          border: "none",
+          cursor: "pointer",
+          padding: "4px 0",
+          color: tokens.textMuted,
+          fontFamily: "inherit",
+          fontSize: "0.8rem",
+          fontWeight: 500,
+          outline: "none",
+          letterSpacing: "0.02em"
         },
         children: [
-          /* @__PURE__ */ jsx("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", children: /* @__PURE__ */ jsx(
-            "path",
+          /* @__PURE__ */ jsx(
+            "svg",
             {
-              d: "M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41L9 16.17z",
-              fill: tokens.accent
+              width: "10",
+              height: "10",
+              viewBox: "0 0 24 24",
+              fill: "none",
+              style: {
+                transform: open ? "rotate(180deg)" : "rotate(0deg)",
+                transition: "transform 0.15s ease"
+              },
+              children: /* @__PURE__ */ jsx(
+                "path",
+                {
+                  d: "M7 10l5 5 5-5",
+                  stroke: tokens.textMuted,
+                  strokeWidth: "2.5",
+                  strokeLinecap: "round",
+                  strokeLinejoin: "round"
+                }
+              )
+            }
+          ),
+          "Advanced options"
+        ]
+      }
+    ),
+    open && /* @__PURE__ */ jsxs(
+      "div",
+      {
+        style: {
+          marginTop: "10px",
+          padding: "14px",
+          background: tokens.bgInput,
+          borderRadius: tokens.radius,
+          border: `1px solid ${tokens.border}`
+        },
+        children: [
+          /* @__PURE__ */ jsxs("div", { style: { marginBottom: "14px" }, children: [
+            /* @__PURE__ */ jsx(
+              "label",
+              {
+                style: {
+                  display: "block",
+                  fontSize: "0.7rem",
+                  fontWeight: 600,
+                  color: tokens.textMuted,
+                  textTransform: "uppercase",
+                  letterSpacing: "0.05em",
+                  marginBottom: "6px"
+                },
+                children: "Asset"
+              }
+            ),
+            /* @__PURE__ */ jsx("div", { style: { display: "flex", gap: "6px" }, children: ASSETS.map((asset) => {
+              const isSelected = settings.asset === asset;
+              return /* @__PURE__ */ jsx(
+                "button",
+                {
+                  onClick: () => onChange({
+                    ...settings,
+                    asset: isSelected ? null : asset
+                  }),
+                  style: {
+                    padding: "6px 14px",
+                    fontSize: "0.8rem",
+                    fontWeight: 600,
+                    fontFamily: "inherit",
+                    borderRadius: "6px",
+                    border: `1.5px solid ${isSelected ? tokens.accent : tokens.border}`,
+                    background: isSelected ? tokens.accent + "18" : "transparent",
+                    color: isSelected ? tokens.accent : tokens.text,
+                    cursor: "pointer",
+                    outline: "none",
+                    transition: "all 0.12s ease"
+                  },
+                  children: asset
+                },
+                asset
+              );
+            }) })
+          ] }),
+          chains.length > 0 && /* @__PURE__ */ jsxs("div", { style: { marginBottom: "14px" }, children: [
+            /* @__PURE__ */ jsx(
+              "label",
+              {
+                style: {
+                  display: "block",
+                  fontSize: "0.7rem",
+                  fontWeight: 600,
+                  color: tokens.textMuted,
+                  textTransform: "uppercase",
+                  letterSpacing: "0.05em",
+                  marginBottom: "6px"
+                },
+                children: "Chain"
+              }
+            ),
+            /* @__PURE__ */ jsx("div", { style: { display: "flex", flexWrap: "wrap", gap: "6px" }, children: chains.map((chain) => {
+              const isSelected = settings.chain === chain.name;
+              return /* @__PURE__ */ jsx(
+                "button",
+                {
+                  onClick: () => onChange({
+                    ...settings,
+                    chain: isSelected ? null : chain.name
+                  }),
+                  style: {
+                    padding: "6px 14px",
+                    fontSize: "0.8rem",
+                    fontWeight: 600,
+                    fontFamily: "inherit",
+                    borderRadius: "6px",
+                    border: `1.5px solid ${isSelected ? tokens.accent : tokens.border}`,
+                    background: isSelected ? tokens.accent + "18" : "transparent",
+                    color: isSelected ? tokens.accent : tokens.text,
+                    cursor: "pointer",
+                    outline: "none",
+                    transition: "all 0.12s ease"
+                  },
+                  children: chain.name
+                },
+                chain.id
+              );
+            }) })
+          ] }),
+          /* @__PURE__ */ jsx("div", { children: !showProviders ? /* @__PURE__ */ jsxs(
+            "button",
+            {
+              onClick: () => setShowProviders(true),
+              disabled: connectingNewAccount,
+              style: {
+                display: "flex",
+                alignItems: "center",
+                gap: "6px",
+                background: "transparent",
+                border: `1px dashed ${tokens.border}`,
+                borderRadius: tokens.radius,
+                padding: "10px 14px",
+                width: "100%",
+                cursor: connectingNewAccount ? "not-allowed" : "pointer",
+                color: tokens.textSecondary,
+                fontFamily: "inherit",
+                fontSize: "0.825rem",
+                fontWeight: 500,
+                outline: "none",
+                opacity: connectingNewAccount ? 0.5 : 1,
+                transition: "opacity 0.1s ease"
+              },
+              children: [
+                /* @__PURE__ */ jsx(
+                  "svg",
+                  {
+                    width: "14",
+                    height: "14",
+                    viewBox: "0 0 24 24",
+                    fill: "none",
+                    children: /* @__PURE__ */ jsx(
+                      "path",
+                      {
+                        d: "M12 5v14M5 12h14",
+                        stroke: tokens.textMuted,
+                        strokeWidth: "2",
+                        strokeLinecap: "round"
+                      }
+                    )
+                  }
+                ),
+                "Connect new account"
+              ]
             }
-          ) }),
-          "Using ",
-          selection.walletName,
-          " on ",
-          selection.chainName
+          ) : /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsxs(
+              "div",
+              {
+                style: {
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "space-between",
+                  marginBottom: "8px"
+                },
+                children: [
+                  /* @__PURE__ */ jsx(
+                    "label",
+                    {
+                      style: {
+                        fontSize: "0.7rem",
+                        fontWeight: 600,
+                        color: tokens.textMuted,
+                        textTransform: "uppercase",
+                        letterSpacing: "0.05em"
+                      },
+                      children: "Select provider"
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      onClick: () => setShowProviders(false),
+                      style: {
+                        background: "transparent",
+                        border: "none",
+                        cursor: "pointer",
+                        color: tokens.textMuted,
+                        fontSize: "0.75rem",
+                        fontFamily: "inherit",
+                        outline: "none",
+                        padding: "2px 4px"
+                      },
+                      children: "Cancel"
+                    }
+                  )
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "div",
+              {
+                style: {
+                  display: "flex",
+                  flexDirection: "column",
+                  gap: "6px"
+                },
+                children: providers.map((p) => /* @__PURE__ */ jsx(
+                  ProviderCard,
+                  {
+                    provider: p,
+                    selected: false,
+                    onClick: () => {
+                      onConnectNewAccount(p.id);
+                      setShowProviders(false);
+                    }
+                  },
+                  p.id
+                ))
+              }
+            )
+          ] }) })
         ]
       }
     )
@@ -1083,69 +2003,135 @@ function isMobile() {
     navigator.userAgent
   );
 }
+function computeSmartDefaults(accts, transferAmount) {
+  if (accts.length === 0) return null;
+  for (const acct of accts) {
+    for (const wallet of acct.wallets) {
+      if (wallet.status === "ACTIVE") {
+        const bestSource = wallet.sources.find(
+          (s) => s.balance.available.amount >= transferAmount
+        );
+        if (bestSource) {
+          return { accountId: acct.id, walletId: wallet.id };
+        }
+      }
+    }
+  }
+  let bestAccount = null;
+  let bestWallet = null;
+  let bestBalance = -1;
+  for (const acct of accts) {
+    for (const wallet of acct.wallets) {
+      const walletBal = wallet.balance.available.amount;
+      if (walletBal > bestBalance) {
+        bestBalance = walletBal;
+        bestAccount = acct;
+        bestWallet = wallet;
+      }
+    }
+  }
+  if (bestAccount) {
+    return {
+      accountId: bestAccount.id,
+      walletId: bestWallet?.id ?? null
+    };
+  }
+  return { accountId: accts[0].id, walletId: null };
+}
 function SwypePayment({
   destination,
   onComplete,
   onError
 }) {
-  const { apiBaseUrl, tokens } = useSwypeConfig();
+  const { apiBaseUrl, tokens, depositAmount } = useSwypeConfig();
   const { ready, authenticated, login, getAccessToken } = usePrivy();
   const [step, setStep] = useState("login");
   const [error, setError] = useState(null);
   const [providers, setProviders] = useState([]);
   const [accounts, setAccounts] = useState([]);
+  const [chains, setChains] = useState([]);
   const [loadingData, setLoadingData] = useState(false);
-  const [selectedProviderId, setSelectedProviderId] = useState(
-    null
+  const [selectedAccountId, setSelectedAccountId] = useState(null);
+  const [selectedWalletId, setSelectedWalletId] = useState(null);
+  const [selectedProviderId, setSelectedProviderId] = useState(null);
+  const [connectingNewAccount, setConnectingNewAccount] = useState(false);
+  const [amount, setAmount] = useState(
+    depositAmount != null ? depositAmount.toString() : ""
   );
-  const [walletSelection, setWalletSelection] = useState(null);
-  const [amount, setAmount] = useState("0.10");
-  const [topUpBalance, setTopUpBalance] = useState("");
+  const [advancedSettings, setAdvancedSettings] = useState({
+    asset: null,
+    chain: null
+  });
   const [transfer, setTransfer] = useState(null);
   const [creatingTransfer, setCreatingTransfer] = useState(false);
   const [mobileFlow, setMobileFlow] = useState(false);
   const pollingTransferIdRef = useRef(null);
   const authExecutor = useAuthorizationExecutor();
   const polling = useTransferPolling();
-  const sourceType = walletSelection ? "walletId" : "providerId";
-  const sourceId = walletSelection?.walletId ?? selectedProviderId ?? "";
+  const transferSigning = useTransferSigning();
+  const sourceType = connectingNewAccount ? "providerId" : selectedWalletId ? "walletId" : selectedAccountId ? "accountId" : "providerId";
+  const sourceId = connectingNewAccount ? selectedProviderId ?? "" : selectedWalletId ? selectedWalletId : selectedAccountId ? selectedAccountId : selectedProviderId ?? "";
+  useEffect(() => {
+    if (depositAmount != null) {
+      setAmount(depositAmount.toString());
+    }
+  }, [depositAmount]);
   useEffect(() => {
     if (ready && authenticated && step === "login") {
-      setStep("select-source");
+      if (depositAmount != null && depositAmount > 0) {
+        setStep("ready");
+      } else {
+        setStep("enter-amount");
+      }
     }
-  }, [ready, authenticated, step]);
+  }, [ready, authenticated, step, depositAmount]);
+  const loadingDataRef = useRef(false);
   useEffect(() => {
-    if (step !== "select-source") return;
-    if (providers.length > 0) return;
+    if (!authenticated) return;
+    if (accounts.length > 0 || loadingDataRef.current) return;
     let cancelled = false;
+    loadingDataRef.current = true;
     const load = async () => {
       setLoadingData(true);
       setError(null);
       try {
         const token = await getAccessToken();
         if (!token) throw new Error("Not authenticated");
-        const [prov, accts] = await Promise.all([
+        const [prov, accts, chn] = await Promise.all([
           fetchProviders(apiBaseUrl, token),
-          fetchAccounts(apiBaseUrl, token)
+          fetchAccounts(apiBaseUrl, token),
+          fetchChains(apiBaseUrl, token)
         ]);
         if (cancelled) return;
         setProviders(prov);
         setAccounts(accts);
-        if (prov.length > 0) setSelectedProviderId(prov[0].id);
+        setChains(chn);
+        const parsedAmt = depositAmount != null ? depositAmount : 0;
+        const defaults = computeSmartDefaults(accts, parsedAmt);
+        if (defaults) {
+          setSelectedAccountId(defaults.accountId);
+          setSelectedWalletId(defaults.walletId);
+        } else if (prov.length > 0) {
+          setSelectedProviderId(prov[0].id);
+        }
       } catch (err) {
         if (!cancelled) {
           const msg = err instanceof Error ? err.message : "Failed to load data";
           setError(msg);
         }
       } finally {
-        if (!cancelled) setLoadingData(false);
+        if (!cancelled) {
+          setLoadingData(false);
+          loadingDataRef.current = false;
+        }
       }
     };
     load();
     return () => {
       cancelled = true;
+      loadingDataRef.current = false;
     };
-  }, [step, providers.length, apiBaseUrl, getAccessToken]);
+  }, [authenticated, accounts.length, apiBaseUrl, getAccessToken]);
   useEffect(() => {
     if (!polling.transfer) return;
     if (polling.transfer.status === "COMPLETED") {
@@ -1172,6 +2158,61 @@ function SwypePayment({
       document.removeEventListener("visibilitychange", handleVisibility);
     };
   }, [mobileFlow, polling]);
+  useEffect(() => {
+    if (!authExecutor.pendingSelectSource) return;
+    const action = authExecutor.pendingSelectSource;
+    const hasAdvancedOverride = advancedSettings.asset !== null || advancedSettings.chain !== null;
+    if (hasAdvancedOverride) {
+      const options = action.metadata?.options ?? [];
+      const recommended = action.metadata?.recommended;
+      const match = options.find(
+        (opt) => (advancedSettings.chain === null || opt.chainName === advancedSettings.chain) && (advancedSettings.asset === null || opt.tokenSymbol === advancedSettings.asset)
+      );
+      if (match) {
+        authExecutor.resolveSelectSource({
+          chainName: match.chainName,
+          tokenSymbol: match.tokenSymbol
+        });
+      } else if (recommended) {
+        authExecutor.resolveSelectSource({
+          chainName: recommended.chainName,
+          tokenSymbol: recommended.tokenSymbol
+        });
+      }
+    } else {
+      const options = action.metadata?.options ?? [];
+      const recommended = action.metadata?.recommended;
+      const selWallet = selectedWalletId ? accounts.find((a) => a.id === selectedAccountId)?.wallets.find((w) => w.id === selectedWalletId) : null;
+      if (selWallet) {
+        const walletMatch = options.find(
+          (opt) => opt.chainName === selWallet.chain.name
+        );
+        if (walletMatch) {
+          authExecutor.resolveSelectSource({
+            chainName: walletMatch.chainName,
+            tokenSymbol: walletMatch.tokenSymbol
+          });
+          return;
+        }
+      }
+      if (recommended) {
+        authExecutor.resolveSelectSource({
+          chainName: recommended.chainName,
+          tokenSymbol: recommended.tokenSymbol
+        });
+      } else if (options.length > 0) {
+        authExecutor.resolveSelectSource({
+          chainName: options[0].chainName,
+          tokenSymbol: options[0].tokenSymbol
+        });
+      } else {
+        authExecutor.resolveSelectSource({
+          chainName: "Base",
+          tokenSymbol: "USDC"
+        });
+      }
+    }
+  }, [authExecutor, authExecutor.pendingSelectSource, advancedSettings, selectedWalletId, selectedAccountId, accounts]);
   const handlePay = useCallback(async () => {
     const parsedAmount = parseFloat(amount);
     if (isNaN(parsedAmount) || parsedAmount <= 0) {
@@ -1179,7 +2220,7 @@ function SwypePayment({
       return;
     }
     if (!sourceId) {
-      setError("Select a source.");
+      setError("No account or provider selected.");
       return;
     }
     setStep("processing");
@@ -1189,12 +2230,6 @@ function SwypePayment({
     try {
       const token = await getAccessToken();
       if (!token) throw new Error("Not authenticated");
-      const parsedTopUp = parseFloat(topUpBalance);
-      if (!isNaN(parsedTopUp) && parsedTopUp > 0) {
-        await updateUserConfig(apiBaseUrl, token, {
-          defaultAllowance: parsedTopUp
-        });
-      }
       const t = await createTransfer(apiBaseUrl, token, {
         sourceType,
         sourceId,
@@ -1213,12 +2248,14 @@ function SwypePayment({
           await authExecutor.executeSession(t);
         }
       }
+      const signedTransfer = await transferSigning.signTransfer(t.id);
+      setTransfer(signedTransfer);
       polling.startPolling(t.id);
     } catch (err) {
-      const msg = err instanceof Error ? err.message : "Transfer creation failed";
+      const msg = err instanceof Error ? err.message : "Transfer failed";
       setError(msg);
       onError?.(msg);
-      setStep("enter-amount");
+      setStep("ready");
     } finally {
       setCreatingTransfer(false);
     }
@@ -1230,20 +2267,26 @@ function SwypePayment({
     apiBaseUrl,
     getAccessToken,
     authExecutor,
+    transferSigning,
     polling,
-    onError,
-    topUpBalance
+    onError
   ]);
   const handleNewPayment = () => {
-    setStep("select-source");
+    setStep("ready");
     setTransfer(null);
     setError(null);
-    setAmount("0.10");
-    setTopUpBalance("");
+    setAmount(depositAmount != null ? depositAmount.toString() : "");
     setMobileFlow(false);
     pollingTransferIdRef.current = null;
-    setWalletSelection(null);
-    if (providers.length > 0) setSelectedProviderId(providers[0].id);
+    setConnectingNewAccount(false);
+    setSelectedWalletId(null);
+    setAdvancedSettings({ asset: null, chain: null });
+    if (accounts.length > 0) setSelectedAccountId(accounts[0].id);
+  };
+  const handleConnectNewAccount = (providerId) => {
+    setSelectedProviderId(providerId);
+    setSelectedAccountId(null);
+    setConnectingNewAccount(true);
   };
   const cardStyle = {
     background: tokens.bgCard,
@@ -1281,15 +2324,10 @@ function SwypePayment({
     opacity: 0.5,
     cursor: "not-allowed"
   };
-  const btnSecondary = {
+  ({
     ...btnPrimary,
-    background: "transparent",
     color: tokens.textSecondary,
-    border: `1px solid ${tokens.border}`,
-    width: "auto",
-    flex: "0 0 auto",
-    padding: "14px 20px"
-  };
+    border: `1px solid ${tokens.border}`});
   const errorStyle = {
     background: tokens.errorBg,
     border: `1px solid ${tokens.error}`,
@@ -1380,62 +2418,20 @@ function SwypePayment({
       /* @__PURE__ */ jsx("button", { style: btnPrimary, onClick: login, children: "Connect to Swype" })
     ] }) });
   }
-  if (step === "select-source") {
-    return /* @__PURE__ */ jsxs("div", { style: cardStyle, children: [
-      stepBadge("Select payment source"),
-      /* @__PURE__ */ jsx("h2", { style: headingStyle, children: "Choose a provider" }),
-      error && /* @__PURE__ */ jsx("div", { style: errorStyle, children: error }),
-      loadingData ? /* @__PURE__ */ jsx("div", { style: { padding: "24px 0", textAlign: "center" }, children: /* @__PURE__ */ jsx(Spinner, { label: "Loading providers..." }) }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-        accounts.length > 0 && /* @__PURE__ */ jsx("div", { style: { marginBottom: "16px" }, children: /* @__PURE__ */ jsx(
-          AccountWalletSelector,
-          {
-            accounts,
-            selection: walletSelection,
-            onSelect: (sel) => {
-              setWalletSelection(sel);
-              if (sel) setSelectedProviderId(null);
-            }
-          }
-        ) }),
-        !walletSelection && /* @__PURE__ */ jsx(
-          "div",
-          {
-            style: {
-              display: "flex",
-              flexDirection: "column",
-              gap: "8px",
-              marginBottom: "20px"
-            },
-            children: providers.map((p) => /* @__PURE__ */ jsx(
-              ProviderCard,
-              {
-                provider: p,
-                selected: selectedProviderId === p.id,
-                onClick: () => {
-                  setSelectedProviderId(p.id);
-                  setWalletSelection(null);
-                }
-              },
-              p.id
-            ))
-          }
-        ),
-        /* @__PURE__ */ jsx(
-          "button",
-          {
-            style: sourceId ? btnPrimary : btnDisabled,
-            disabled: !sourceId,
-            onClick: () => {
-              setError(null);
-              setStep("enter-amount");
-            },
-            children: "Continue"
-          }
-        )
-      ] })
-    ] });
-  }
   if (step === "enter-amount") {
+    const parsedAmount = parseFloat(amount);
+    const canContinue = !isNaN(parsedAmount) && parsedAmount > 0;
+    let maxSourceBalance = null;
+    for (const acct of accounts) {
+      for (const wallet of acct.wallets) {
+        for (const source of wallet.sources) {
+          const bal = source.balance.available.amount;
+          if (maxSourceBalance === null || bal > maxSourceBalance) {
+            maxSourceBalance = bal;
+          }
+        }
+      }
+    }
     return /* @__PURE__ */ jsxs("div", { style: cardStyle, children: [
       stepBadge("Enter amount"),
       /* @__PURE__ */ jsx("h2", { style: headingStyle, children: "How much?" }),
@@ -1451,7 +2447,7 @@ function SwypePayment({
             border: `1px solid ${tokens.border}`,
             borderRadius: tokens.radius,
             padding: "4px 14px 4px 4px",
-            marginBottom: "20px"
+            marginBottom: "8px"
           },
           children: [
             /* @__PURE__ */ jsx(
@@ -1475,6 +2471,7 @@ function SwypePayment({
                 step: "0.01",
                 value: amount,
                 onChange: (e) => setAmount(e.target.value),
+                placeholder: "0.00",
                 style: {
                   flex: 1,
                   background: "transparent",
@@ -1506,156 +2503,301 @@ function SwypePayment({
           ]
         }
       ),
-      /* @__PURE__ */ jsxs(
+      /* @__PURE__ */ jsx(
         "div",
         {
           style: {
-            display: "flex",
-            alignItems: "center",
-            gap: "8px",
-            background: tokens.bgInput,
-            border: `1px solid ${tokens.border}`,
-            borderRadius: tokens.radius,
-            padding: "4px 14px 4px 4px",
-            marginBottom: "20px"
+            fontSize: "0.8rem",
+            color: tokens.textMuted,
+            marginBottom: "20px",
+            paddingLeft: "2px"
           },
-          children: [
-            /* @__PURE__ */ jsx(
-              "span",
-              {
-                style: {
-                  fontSize: "1rem",
-                  fontWeight: 600,
-                  color: tokens.textMuted,
-                  paddingLeft: "10px",
-                  userSelect: "none"
-                },
-                children: "$"
-              }
-            ),
-            /* @__PURE__ */ jsx(
-              "input",
-              {
-                type: "number",
-                min: "0",
-                step: "1",
-                placeholder: "Top up balance (optional)",
-                value: topUpBalance,
-                onChange: (e) => setTopUpBalance(e.target.value),
-                style: {
-                  flex: 1,
-                  background: "transparent",
-                  border: "none",
-                  outline: "none",
-                  color: tokens.text,
-                  fontSize: "1rem",
-                  fontWeight: 600,
-                  fontFamily: "inherit",
-                  padding: "10px 0"
-                }
-              }
-            ),
-            /* @__PURE__ */ jsx(
-              "span",
-              {
-                style: {
-                  fontSize: "0.75rem",
-                  fontWeight: 600,
-                  color: tokens.textMuted,
-                  background: tokens.bgHover,
-                  padding: "4px 10px",
-                  borderRadius: "6px",
-                  whiteSpace: "nowrap"
-                },
-                children: "USD"
-              }
-            )
-          ]
+          children: loadingData ? /* @__PURE__ */ jsx("span", { children: "Loading balance..." }) : maxSourceBalance !== null && maxSourceBalance > 0 ? /* @__PURE__ */ jsxs("span", { children: [
+            "Available: ",
+            /* @__PURE__ */ jsxs("span", { style: { fontWeight: 600, color: tokens.textSecondary }, children: [
+              "$",
+              maxSourceBalance.toFixed(2)
+            ] })
+          ] }) : null
         }
       ),
       /* @__PURE__ */ jsx(
-        "p",
+        "button",
         {
-          style: {
-            fontSize: "0.75rem",
-            color: tokens.textMuted,
-            margin: "-12px 0 16px 0",
-            lineHeight: 1.4
+          style: canContinue ? btnPrimary : btnDisabled,
+          disabled: !canContinue,
+          onClick: () => {
+            setError(null);
+            setStep("ready");
           },
-          children: "Set a higher allowance to skip wallet prompts on future payments under this amount."
+          children: "Continue"
         }
-      ),
-      /* @__PURE__ */ jsxs(
-        "div",
-        {
-          style: {
-            fontSize: "0.825rem",
-            color: tokens.textSecondary,
-            marginBottom: "20px",
-            padding: "12px 14px",
-            background: tokens.bgInput,
-            borderRadius: tokens.radius,
-            lineHeight: 1.7
-          },
-          children: [
-            /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between" }, children: [
-              /* @__PURE__ */ jsx("span", { children: "To" }),
+      )
+    ] });
+  }
+  if (step === "ready") {
+    const parsedAmount = parseFloat(amount);
+    const canPay = !isNaN(parsedAmount) && parsedAmount > 0 && !!sourceId && !loadingData;
+    const noAccounts = !loadingData && accounts.length === 0;
+    return /* @__PURE__ */ jsxs("div", { style: cardStyle, children: [
+      stepBadge("Review & pay"),
+      error && /* @__PURE__ */ jsx("div", { style: errorStyle, children: error }),
+      loadingData ? /* @__PURE__ */ jsx("div", { style: { padding: "24px 0", textAlign: "center" }, children: /* @__PURE__ */ jsx(Spinner, { label: "Loading..." }) }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              textAlign: "center",
+              marginBottom: "20px"
+            },
+            children: [
               /* @__PURE__ */ jsxs(
-                "span",
+                "div",
                 {
                   style: {
-                    fontFamily: '"SF Mono", "Fira Code", monospace',
-                    fontSize: "0.8rem"
+                    fontSize: "2rem",
+                    fontWeight: 700,
+                    color: tokens.text,
+                    lineHeight: 1.2
                   },
                   children: [
-                    destination.address.slice(0, 6),
-                    "...",
-                    destination.address.slice(-4)
+                    "$",
+                    parsedAmount > 0 ? parsedAmount.toFixed(2) : "0.00"
                   ]
                 }
+              ),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  onClick: () => setStep("enter-amount"),
+                  style: {
+                    background: "transparent",
+                    border: "none",
+                    cursor: "pointer",
+                    color: tokens.textMuted,
+                    fontSize: "0.75rem",
+                    fontFamily: "inherit",
+                    outline: "none",
+                    padding: "4px 8px",
+                    marginTop: "4px"
+                  },
+                  children: "Change amount"
+                }
               )
-            ] }),
-            /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between" }, children: [
-              /* @__PURE__ */ jsx("span", { children: "Token" }),
-              /* @__PURE__ */ jsx("span", { style: { fontWeight: 600 }, children: destination.token.symbol })
-            ] }),
-            /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between" }, children: [
-              /* @__PURE__ */ jsx("span", { children: "Source" }),
-              /* @__PURE__ */ jsx("span", { style: { fontWeight: 600 }, children: walletSelection ? `${walletSelection.walletName} (${walletSelection.chainName})` : providers.find((p) => p.id === selectedProviderId)?.name ?? "Provider" })
-            ] })
-          ]
-        }
-      ),
-      /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "10px" }, children: [
-        /* @__PURE__ */ jsx(
-          "button",
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "div",
           {
-            style: btnSecondary,
-            onClick: () => {
-              setError(null);
-              setStep("select-source");
+            style: {
+              fontSize: "0.825rem",
+              color: tokens.textSecondary,
+              marginBottom: "16px",
+              padding: "12px 14px",
+              background: tokens.bgInput,
+              borderRadius: tokens.radius,
+              lineHeight: 1.7
             },
-            children: "Back"
+            children: [
+              /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: { display: "flex", justifyContent: "space-between" },
+                  children: [
+                    /* @__PURE__ */ jsx("span", { children: "To" }),
+                    /* @__PURE__ */ jsxs(
+                      "span",
+                      {
+                        style: {
+                          fontFamily: '"SF Mono", "Fira Code", monospace',
+                          fontSize: "0.8rem"
+                        },
+                        children: [
+                          destination.address.slice(0, 6),
+                          "...",
+                          destination.address.slice(-4)
+                        ]
+                      }
+                    )
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: { display: "flex", justifyContent: "space-between" },
+                  children: [
+                    /* @__PURE__ */ jsx("span", { children: "Token" }),
+                    /* @__PURE__ */ jsx("span", { style: { fontWeight: 600 }, children: destination.token.symbol })
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    justifyContent: "space-between",
+                    alignItems: "center"
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx("span", { children: "From" }),
+                    noAccounts ? /* @__PURE__ */ jsx("span", { style: { fontWeight: 500, color: tokens.textMuted }, children: "New account" }) : /* @__PURE__ */ jsx(
+                      AccountDropdown,
+                      {
+                        accounts,
+                        selectedAccountId,
+                        selectedWalletId,
+                        onSelect: (id) => {
+                          setSelectedAccountId(id);
+                          setSelectedWalletId(null);
+                          setConnectingNewAccount(false);
+                          setSelectedProviderId(null);
+                        },
+                        onWalletSelect: (accountId, walletId) => {
+                          setSelectedAccountId(accountId);
+                          setSelectedWalletId(walletId);
+                          setConnectingNewAccount(false);
+                          setSelectedProviderId(null);
+                        }
+                      }
+                    )
+                  ]
+                }
+              )
+            ]
           }
         ),
+        noAccounts && /* @__PURE__ */ jsxs("div", { style: { marginBottom: "16px" }, children: [
+          /* @__PURE__ */ jsx(
+            "label",
+            {
+              style: {
+                display: "block",
+                fontSize: "0.8rem",
+                color: tokens.textMuted,
+                marginBottom: "8px",
+                fontWeight: 500,
+                textTransform: "uppercase",
+                letterSpacing: "0.05em"
+              },
+              children: "Connect a wallet"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              style: {
+                display: "flex",
+                flexDirection: "column",
+                gap: "8px"
+              },
+              children: providers.map((p) => /* @__PURE__ */ jsx(
+                ProviderCard,
+                {
+                  provider: p,
+                  selected: selectedProviderId === p.id,
+                  onClick: () => {
+                    setSelectedProviderId(p.id);
+                    setSelectedAccountId(null);
+                    setConnectingNewAccount(false);
+                  }
+                },
+                p.id
+              ))
+            }
+          )
+        ] }),
         /* @__PURE__ */ jsxs(
           "button",
           {
-            style: parseFloat(amount) > 0 ? btnPrimary : btnDisabled,
-            disabled: !(parseFloat(amount) > 0),
+            style: canPay ? btnPrimary : btnDisabled,
+            disabled: !canPay,
             onClick: handlePay,
             children: [
               "Pay $",
-              parseFloat(amount || "0").toFixed(2)
+              parsedAmount > 0 ? parsedAmount.toFixed(2) : "0.00"
             ]
           }
+        ),
+        !noAccounts && /* @__PURE__ */ jsx(
+          AdvancedSettings,
+          {
+            settings: advancedSettings,
+            onChange: setAdvancedSettings,
+            chains,
+            providers,
+            onConnectNewAccount: handleConnectNewAccount,
+            connectingNewAccount
+          }
         )
       ] })
     ] });
   }
   if (step === "processing") {
-    const statusLabel = creatingTransfer ? "Creating transfer..." : mobileFlow ? "Waiting for authorization..." : authExecutor.executing ? "Authorizing..." : polling.isPolling ? "Processing payment..." : "Please wait...";
-    const statusDescription = creatingTransfer ? "Setting up your transfer..." : mobileFlow ? "Complete the authorization in your wallet app, then return here." : authExecutor.executing ? "Complete the wallet prompts to authorize this payment." : polling.isPolling ? "Your payment is being processed. This usually takes a few moments." : "Hang tight...";
+    if (transferSigning.signing && transferSigning.signPayload) {
+      const payload = transferSigning.signPayload;
+      return /* @__PURE__ */ jsx("div", { style: cardStyle, children: /* @__PURE__ */ jsxs("div", { style: { textAlign: "center", padding: "16px 0" }, children: [
+        /* @__PURE__ */ jsxs("svg", { width: "48", height: "48", viewBox: "0 0 48 48", fill: "none", style: { margin: "0 auto 16px" }, children: [
+          /* @__PURE__ */ jsx("rect", { width: "48", height: "48", rx: "12", fill: tokens.accent + "20" }),
+          /* @__PURE__ */ jsx("path", { d: "M24 14v8M20 18h8M24 26v2M24 32v2", stroke: tokens.accent, strokeWidth: "2", strokeLinecap: "round" })
+        ] }),
+        /* @__PURE__ */ jsx("h2", { style: { ...headingStyle, marginBottom: "8px" }, children: "Authorize Transfer" }),
+        /* @__PURE__ */ jsx("p", { style: { fontSize: "0.85rem", color: tokens.textSecondary, margin: "0 0 16px 0", lineHeight: 1.5 }, children: "Use your passkey to confirm this payment." }),
+        /* @__PURE__ */ jsxs("div", { style: { fontSize: "0.825rem", color: tokens.textSecondary, padding: "12px 14px", background: tokens.bgInput, borderRadius: tokens.radius, textAlign: "left", lineHeight: 1.7, marginBottom: "16px" }, children: [
+          payload.amount && payload.tokenSymbol && /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between" }, children: [
+            /* @__PURE__ */ jsx("span", { children: "Amount" }),
+            /* @__PURE__ */ jsxs("span", { style: { fontWeight: 600, color: tokens.text }, children: [
+              payload.amount,
+              " ",
+              payload.tokenSymbol
+            ] })
+          ] }),
+          payload.bridgeRelayAddress && /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between" }, children: [
+            /* @__PURE__ */ jsx("span", { children: "Bridge relay" }),
+            /* @__PURE__ */ jsxs("span", { style: { fontFamily: '"SF Mono", "Fira Code", monospace', fontSize: "0.75rem" }, children: [
+              payload.bridgeRelayAddress.slice(0, 6),
+              "...",
+              payload.bridgeRelayAddress.slice(-4)
+            ] })
+          ] }),
+          payload.estimatedFeeUsd && /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between" }, children: [
+            /* @__PURE__ */ jsx("span", { children: "Est. fee" }),
+            /* @__PURE__ */ jsxs("span", { style: { fontWeight: 600 }, children: [
+              "$",
+              payload.estimatedFeeUsd
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx(Spinner, { label: "Waiting for passkey..." })
+      ] }) });
+    }
+    const currentActionType = authExecutor.currentAction?.type;
+    const getRegistrationMessage = () => {
+      switch (currentActionType) {
+        case "REGISTER_PASSKEY":
+          return {
+            label: "Creating your passkey...",
+            description: "Set up a passkey for secure, one-touch payments."
+          };
+        case "UPGRADE_SMART_ACCOUNT":
+          return {
+            label: "Upgrading your account...",
+            description: "Approve the prompts in MetaMask to upgrade your account to a smart account and register your passkey. You may see two prompts."
+          };
+        case "GRANT_PERMISSIONS":
+          return {
+            label: "Setting up permissions...",
+            description: "Signing delegation permissions. Transfer routing and gas sponsorship are handled by Swype backend."
+          };
+        default:
+          return { label: "", description: "" };
+      }
+    };
+    const regMsg = getRegistrationMessage();
+    const statusLabel = creatingTransfer ? "Creating transfer..." : mobileFlow ? "Waiting for authorization..." : authExecutor.executing && regMsg.label ? regMsg.label : authExecutor.executing ? "Authorizing..." : transferSigning.signing ? "Preparing transfer..." : polling.isPolling ? "Processing payment..." : "Please wait...";
+    const statusDescription = creatingTransfer ? "Setting up your transfer..." : mobileFlow ? "Complete the authorization in your wallet app, then return here." : authExecutor.executing && regMsg.description ? regMsg.description : authExecutor.executing ? "Complete the wallet prompts to authorize this payment." : transferSigning.signing ? "Waiting for backend to prepare your transfer payload..." : polling.isPolling ? "Your payment is being processed. This usually takes a few moments." : "Hang tight...";
     return /* @__PURE__ */ jsx("div", { style: cardStyle, children: /* @__PURE__ */ jsxs("div", { style: { textAlign: "center", padding: "16px 0" }, children: [
       /* @__PURE__ */ jsx(Spinner, { size: 48 }),
       /* @__PURE__ */ jsx(
@@ -1699,11 +2841,11 @@ function SwypePayment({
         },
         r.actionId
       )) }),
-      (error || authExecutor.error || polling.error) && /* @__PURE__ */ jsx(
+      (error || authExecutor.error || transferSigning.error || polling.error) && /* @__PURE__ */ jsx(
         "div",
         {
           style: { ...errorStyle, marginTop: "16px", textAlign: "left" },
-          children: error || authExecutor.error || polling.error
+          children: error || authExecutor.error || transferSigning.error || polling.error
         }
       )
     ] }) });
@@ -1830,6 +2972,6 @@ function SwypePayment({
   return null;
 }
 
-export { SwypePayment, SwypeProvider, darkTheme, getTheme, lightTheme, api_exports as swypeApi, useAuthorizationExecutor, useSwypeConfig, useTransferPolling };
+export { SwypePayment, SwypeProvider, darkTheme, getTheme, lightTheme, api_exports as swypeApi, useAuthorizationExecutor, useSwypeConfig, useSwypeDepositAmount, useTransferPolling };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map