@swype-org/react-sdk 0.1.3 → 0.1.5

package/dist/index.js

@@ -4,7 +4,7 @@ import { createConfig, http, WagmiProvider, useConfig, useConnect, useSwitchChai
 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 { recoverTypedDataAddress, walletActions, createClient, custom } from 'viem';
 import { parseAccount, getAddress } from 'viem/utils';
 
 var __defProp = Object.defineProperty;
@@ -118,6 +118,9 @@ function useSwypeConfig() {
   }
   return ctx;
 }
+function useOptionalSwypeConfig() {
+  return useContext(SwypeContext);
+}
 function useSwypeDepositAmount() {
   const ctx = useContext(SwypeContext);
   if (!ctx) {
@@ -142,6 +145,8 @@ __export(api_exports, {
   fetchChains: () => fetchChains,
   fetchProviders: () => fetchProviders,
   fetchTransfer: () => fetchTransfer,
+  fetchUserConfig: () => fetchUserConfig,
+  registerPasskey: () => registerPasskey,
   reportActionCompletion: () => reportActionCompletion,
   signTransfer: () => signTransfer,
   updateUserConfig: () => updateUserConfig,
@@ -205,19 +210,29 @@ async function createTransfer(apiBaseUrl, token, params) {
   if (!res.ok) await throwApiError(res);
   return await res.json();
 }
-async function fetchTransfer(apiBaseUrl, token, transferId) {
+async function fetchTransfer(apiBaseUrl, token, transferId, authorizationSessionToken) {
+  if (!token && !authorizationSessionToken) {
+    throw new Error("Missing auth credentials for transfer fetch.");
+  }
   const res = await fetch(`${apiBaseUrl}/v1/transfers/${transferId}`, {
-    headers: { Authorization: `Bearer ${token}` }
+    headers: {
+      ...token ? { Authorization: `Bearer ${token}` } : {},
+      ...authorizationSessionToken ? { "x-authorization-session-token": authorizationSessionToken } : {}
+    }
   });
   if (!res.ok) await throwApiError(res);
   return await res.json();
 }
-async function signTransfer(apiBaseUrl, token, transferId, signedUserOp) {
+async function signTransfer(apiBaseUrl, token, transferId, signedUserOp, authorizationSessionToken) {
+  if (!token && !authorizationSessionToken) {
+    throw new Error("Missing auth credentials for transfer signing.");
+  }
   const res = await fetch(`${apiBaseUrl}/v1/transfers/${transferId}`, {
     method: "PATCH",
     headers: {
       "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
+      ...token ? { Authorization: `Bearer ${token}` } : {},
+      ...authorizationSessionToken ? { "x-authorization-session-token": authorizationSessionToken } : {}
     },
     body: JSON.stringify({ signedUserOp })
   });
@@ -231,6 +246,24 @@ async function fetchAuthorizationSession(apiBaseUrl, sessionId) {
   if (!res.ok) await throwApiError(res);
   return await res.json();
 }
+async function registerPasskey(apiBaseUrl, token, credentialId, publicKey) {
+  const res = await fetch(`${apiBaseUrl}/v1/users/config/passkey`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ credentialId, publicKey })
+  });
+  if (!res.ok) await throwApiError(res);
+}
+async function fetchUserConfig(apiBaseUrl, token) {
+  const res = await fetch(`${apiBaseUrl}/v1/users/config`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) await throwApiError(res);
+  return await res.json();
+}
 async function updateUserConfig(apiBaseUrl, token, config) {
   const res = await fetch(`${apiBaseUrl}/v1/users`, {
     method: "PATCH",
@@ -525,182 +558,136 @@ 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;
+var WALLET_CLIENT_MAX_ATTEMPTS = 15;
+var WALLET_CLIENT_POLL_MS = 200;
+var ACTION_POLL_INTERVAL_MS = 500;
+var ACTION_POLL_MAX_RETRIES = 20;
+var SIGN_PERMIT2_POLL_MS = 1e3;
+var SIGN_PERMIT2_MAX_POLLS = 15;
+var TRANSFER_SIGN_MAX_POLLS = 60;
+function actionSuccess(action, message, data) {
+  return { actionId: action.id, type: action.type, status: "success", message, data };
 }
-function isValidChainId(value) {
-  return typeof value === "number" && Number.isInteger(value) && value > 0;
+function actionError(action, message) {
+  return { actionId: action.id, type: action.type, status: "error", message };
 }
-function isRpcClient(value) {
-  return typeof value === "object" && value !== null && "request" in value && typeof value.request === "function";
+function isUserRejection(msg) {
+  const lower = msg.toLowerCase();
+  return lower.includes("rejected") || lower.includes("denied");
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = clean.match(/.{1,2}/g).map((b) => parseInt(b, 16));
+  return new Uint8Array(bytes);
 }
-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.`);
+function toBase64(buffer) {
+  return btoa(String.fromCharCode(...new Uint8Array(buffer)));
 }
-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}`);
+function base64ToBytes(value) {
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+  const raw = atob(padded);
+  const bytes = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) {
+    bytes[i] = raw.charCodeAt(i);
   }
+  return bytes;
 }
-async function submitUpgradeTransaction(params) {
-  const { walletClient, sender, metadata } = params;
-  const addKeyCalldata = metadata?.addKeyCalldata;
-  if (!isNonEmptyString(addKeyCalldata)) {
-    throw new Error("Incomplete upgrade metadata: missing addKeyCalldata.");
+function readEnvValue(name) {
+  const meta = import.meta;
+  const metaValue = meta.env?.[name];
+  if (typeof metaValue === "string" && metaValue.trim().length > 0) {
+    return metaValue.trim();
   }
-  const resolvedSmartAccountAddress = metadata?.smartAccountAddress ?? sender;
-  if (!isNonEmptyString(resolvedSmartAccountAddress)) {
-    throw new Error("No connected account address found for smart account upgrade.");
+  const processValue = globalThis.process?.env?.[name];
+  if (typeof processValue === "string" && processValue.trim().length > 0) {
+    return processValue.trim();
   }
-  const chainId = metadata?.upgradePayload?.authorization?.chainId;
-  if (!isValidChainId(chainId)) {
-    throw new Error("Invalid or missing chainId in upgrade metadata.");
+  return void 0;
+}
+function resolvePasskeyRpId() {
+  const configuredDomain = readEnvValue("VITE_DOMAIN") ?? readEnvValue("SWYPE_DOMAIN");
+  if (configuredDomain) {
+    return configuredDomain.replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/^\./, "").trim();
   }
-  if (!isRpcClient(walletClient)) {
-    throw new Error(
-      "Connected wallet client does not support request(). EIP-7702 upgrade requires a wallet client with raw RPC access."
-    );
+  if (typeof window !== "undefined") {
+    return window.location.hostname;
   }
-  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
-  };
+  return "localhost";
 }
-
-// src/hooks.ts
-async function waitForWalletClient(wagmiConfig2, maxAttempts = 15, intervalMs = 200) {
-  for (let i = 0; i < maxAttempts; i++) {
+async function waitForWalletClient(wagmiConfig2, params = {}) {
+  for (let i = 0; i < WALLET_CLIENT_MAX_ATTEMPTS; i++) {
     try {
-      return await getWalletClient(wagmiConfig2);
+      return await getWalletClient(wagmiConfig2, params);
     } catch {
-      if (i === maxAttempts - 1) {
+      if (i === WALLET_CLIENT_MAX_ATTEMPTS - 1) {
         throw new Error("Wallet not ready. Please try again.");
       }
-      await new Promise((r) => setTimeout(r, intervalMs));
+      await new Promise((r) => setTimeout(r, WALLET_CLIENT_POLL_MS));
     }
   }
   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;
+function parseSignTypedDataPayload(typedData) {
+  const { domain, types, primaryType, message } = typedData;
+  if (!domain || typeof domain !== "object" || Array.isArray(domain)) {
+    throw new Error("SIGN_PERMIT2 typedData is missing a valid domain object.");
+  }
+  if (!types || typeof types !== "object" || Array.isArray(types)) {
+    throw new Error("SIGN_PERMIT2 typedData is missing a valid types object.");
+  }
+  if (typeof primaryType !== "string") {
+    throw new Error("SIGN_PERMIT2 typedData is missing primaryType.");
+  }
+  if (!message || typeof message !== "object" || Array.isArray(message)) {
+    throw new Error("SIGN_PERMIT2 typedData is missing a valid message object.");
   }
-  return "Failed to upgrade account";
+  return {
+    domain,
+    types,
+    primaryType,
+    message
+  };
 }
-function isMetaMaskConnector(account) {
-  const connectorName = account.connector?.name?.toLowerCase() ?? "";
-  const connectorId = account.connector?.id?.toLowerCase() ?? "";
-  return connectorName.includes("metamask") || connectorId.includes("metamask");
+function getPendingActions(session, completedIds) {
+  return session.actions.filter((a) => a.status === "PENDING" && !completedIds.has(a.id)).sort((a, b) => a.orderIndex - b.orderIndex);
+}
+async function createPasskeyCredential(userIdentifier) {
+  const challenge = new Uint8Array(32);
+  crypto.getRandomValues(challenge);
+  const rpId = resolvePasskeyRpId();
+  const credential = await navigator.credentials.create({
+    publicKey: {
+      challenge,
+      rp: { name: "Swype", id: rpId },
+      user: {
+        id: new TextEncoder().encode(userIdentifier),
+        name: userIdentifier,
+        displayName: "Swype User"
+      },
+      pubKeyCredParams: [
+        { alg: -7, type: "public-key" },
+        // ES256 (P-256)
+        { alg: -257, type: "public-key" }
+        // RS256
+      ],
+      authenticatorSelection: {
+        authenticatorAttachment: "platform",
+        residentKey: "preferred",
+        userVerification: "required"
+      },
+      timeout: 6e4
+    }
+  });
+  if (!credential) {
+    throw new Error("Passkey creation was cancelled.");
+  }
+  const response = credential.response;
+  const publicKeyBytes = response.getPublicKey?.();
+  return {
+    credentialId: toBase64(credential.rawId),
+    publicKey: publicKeyBytes ? toBase64(publicKeyBytes) : ""
+  };
 }
 function useTransferPolling(intervalMs = 3e3) {
   const { apiBaseUrl } = useSwypeConfig();
@@ -750,8 +737,247 @@ function useTransferPolling(intervalMs = 3e3) {
   useEffect(() => () => stopPolling(), [stopPolling]);
   return { transfer, error, isPolling, startPolling, stopPolling };
 }
-function useAuthorizationExecutor() {
-  const { apiBaseUrl } = useSwypeConfig();
+async function executeOpenProvider(action, wagmiConfig2, connectors, connectAsync) {
+  try {
+    const account = getAccount(wagmiConfig2);
+    if (account.isConnected && account.address) {
+      const hexChainId2 = account.chainId ? `0x${account.chainId.toString(16)}` : void 0;
+      return actionSuccess(
+        action,
+        `Connected. Account: ${account.address}, Chain: ${hexChainId2}`,
+        { accounts: [account.address], chainId: hexChainId2 }
+      );
+    }
+    const targetId = action.metadata?.wagmiConnectorId;
+    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 actionError(action, "No wallet connector found. Please install a supported wallet.");
+    }
+    const result = await connectAsync({ connector });
+    const hexChainId = `0x${result.chainId.toString(16)}`;
+    return actionSuccess(
+      action,
+      `Connected to ${connector.name}. Account: ${result.accounts[0]}, Chain: ${hexChainId}`,
+      { accounts: [...result.accounts], chainId: hexChainId }
+    );
+  } catch (err) {
+    return actionError(
+      action,
+      err instanceof Error ? err.message : "Failed to connect wallet"
+    );
+  }
+}
+async function executeSelectSource(action, waitForSelection) {
+  try {
+    const options = action.metadata?.options;
+    const recommended = action.metadata?.recommended;
+    if (!options || options.length === 0) {
+      return actionError(
+        action,
+        "No selectable source options returned by backend."
+      );
+    }
+    const selection = await waitForSelection(action);
+    const isValidSelection = options.some(
+      (option) => option.chainName === selection.chainName && option.tokenSymbol === selection.tokenSymbol
+    );
+    if (!isValidSelection) {
+      return actionError(
+        action,
+        "Invalid source selection. Please choose one of the provided options."
+      );
+    }
+    return actionSuccess(
+      action,
+      `Selected ${selection.tokenSymbol} on ${selection.chainName}.`,
+      { selectedChainName: selection.chainName, selectedTokenSymbol: selection.tokenSymbol }
+    );
+  } catch (err) {
+    return actionError(
+      action,
+      err instanceof Error ? err.message : "Failed to select source"
+    );
+  }
+}
+async function executeSwitchChain(action, wagmiConfig2, switchChainAsync) {
+  try {
+    const account = getAccount(wagmiConfig2);
+    const targetChainIdHex = action.metadata?.targetChainId;
+    if (!targetChainIdHex) {
+      return actionError(action, "No targetChainId in action metadata.");
+    }
+    if (!/^0x[0-9a-fA-F]+$/.test(targetChainIdHex)) {
+      return actionError(
+        action,
+        `Invalid targetChainId in action metadata: ${targetChainIdHex}`
+      );
+    }
+    const targetChainIdNum = parseInt(targetChainIdHex, 16);
+    if (Number.isNaN(targetChainIdNum)) {
+      return actionError(
+        action,
+        `Invalid targetChainId in action metadata: ${targetChainIdHex}`
+      );
+    }
+    const hexChainId = `0x${targetChainIdNum.toString(16)}`;
+    if (account.chainId === targetChainIdNum) {
+      return actionSuccess(
+        action,
+        `Already on chain ${hexChainId}. Skipped.`,
+        { chainId: hexChainId, switched: false }
+      );
+    }
+    await switchChainAsync({ chainId: targetChainIdNum });
+    return actionSuccess(
+      action,
+      `Switched to chain ${hexChainId}.`,
+      { chainId: hexChainId, switched: true }
+    );
+  } catch (err) {
+    return actionError(
+      action,
+      err instanceof Error ? err.message : "Failed to switch chain"
+    );
+  }
+}
+async function executeApprovePermit2(action, wagmiConfig2) {
+  try {
+    const walletClient = await waitForWalletClient(wagmiConfig2);
+    const account = getAccount(wagmiConfig2);
+    const sender = account.address ?? walletClient.account?.address;
+    const expectedWallet = action.metadata?.walletAddress;
+    if (!sender) {
+      throw new Error("Wallet account not available. Please connect your wallet.");
+    }
+    if (expectedWallet && sender.toLowerCase() !== expectedWallet.toLowerCase()) {
+      return actionError(
+        action,
+        `Connected wallet ${sender} does not match the required source wallet ${expectedWallet}. Please switch accounts in your wallet and retry.`
+      );
+    }
+    const to = action.metadata?.to;
+    const data = action.metadata?.data;
+    const tokenSymbol = action.metadata?.tokenSymbol;
+    if (!to || !data) {
+      return actionError(
+        action,
+        "APPROVE_PERMIT2 metadata is missing transaction parameters (to, data)."
+      );
+    }
+    const txHash = await walletClient.request({
+      method: "eth_sendTransaction",
+      params: [{
+        from: sender,
+        to,
+        data,
+        value: "0x0"
+      }]
+    });
+    console.info(
+      `[swype-sdk][approve-permit2] ERC-20 approve tx sent. token=${tokenSymbol ?? to}, txHash=${txHash}`
+    );
+    return actionSuccess(
+      action,
+      `Approved Permit2 to spend ${tokenSymbol ?? "tokens"}.`,
+      { txHash }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Failed to approve Permit2";
+    return actionError(
+      action,
+      isUserRejection(msg) ? "You rejected the approval transaction. Please approve the Permit2 spending allowance in your wallet to continue." : msg
+    );
+  }
+}
+async function executeSignPermit2(action, wagmiConfig2, apiBaseUrl, sessionId) {
+  try {
+    const expectedWallet = action.metadata?.walletAddress;
+    const walletClient = await waitForWalletClient(
+      wagmiConfig2,
+      expectedWallet ? { account: expectedWallet } : {}
+    );
+    const account = getAccount(wagmiConfig2);
+    const connectedAddress = account.address ?? walletClient.account?.address;
+    const sender = expectedWallet ?? connectedAddress;
+    if (!sender) {
+      throw new Error("Wallet account not available. Please connect your wallet.");
+    }
+    if (expectedWallet && connectedAddress && connectedAddress.toLowerCase() !== expectedWallet.toLowerCase()) {
+      return actionError(
+        action,
+        `Connected wallet ${connectedAddress} does not match the required source wallet ${expectedWallet}. Please switch accounts in your wallet and retry.`
+      );
+    }
+    let typedData = action.metadata?.typedData;
+    const tokenSymbol = action.metadata?.tokenSymbol;
+    if (!typedData && sessionId) {
+      for (let i = 0; i < SIGN_PERMIT2_MAX_POLLS; i++) {
+        await new Promise((r) => setTimeout(r, SIGN_PERMIT2_POLL_MS));
+        const session = await fetchAuthorizationSession(apiBaseUrl, sessionId);
+        const updated = session.actions.find((a) => a.id === action.id);
+        typedData = updated?.metadata?.typedData;
+        if (typedData) break;
+      }
+    }
+    if (!typedData) {
+      return actionError(
+        action,
+        "SIGN_PERMIT2 metadata is missing typedData. The server may still be preparing the signing payload."
+      );
+    }
+    const parsed = parseSignTypedDataPayload(typedData);
+    console.info(
+      `[swype-sdk][sign-permit2] Signing typed data. expectedOwner=${expectedWallet ?? "N/A"}, senderParam=${sender}, connectedAddress=${connectedAddress ?? "N/A"}, primaryType=${parsed.primaryType}, domainChainId=${String(parsed.domain.chainId ?? "N/A")}, verifyingContract=${String(parsed.domain.verifyingContract ?? "N/A")}`
+    );
+    const signature = await walletClient.signTypedData({
+      account: sender,
+      domain: parsed.domain,
+      types: parsed.types,
+      primaryType: parsed.primaryType,
+      message: parsed.message
+    });
+    const recoverInput = {
+      domain: parsed.domain,
+      types: parsed.types,
+      primaryType: parsed.primaryType,
+      message: parsed.message,
+      signature
+    };
+    const recoveredSigner = await recoverTypedDataAddress(recoverInput);
+    const expectedSigner = (expectedWallet ?? sender).toLowerCase();
+    console.info(
+      `[swype-sdk][sign-permit2] Signature recovered. recoveredSigner=${recoveredSigner}, expectedSigner=${expectedSigner}`
+    );
+    if (recoveredSigner.toLowerCase() !== expectedSigner) {
+      return actionError(
+        action,
+        `Wallet signed with ${recoveredSigner}, but source wallet is ${expectedWallet ?? sender}. Please switch to the source wallet in MetaMask and retry.`
+      );
+    }
+    console.info(
+      `[swype-sdk][sign-permit2] Permit2 EIP-712 signature obtained. token=${tokenSymbol ?? "unknown"}`
+    );
+    return actionSuccess(
+      action,
+      `Permit2 allowance signed for ${tokenSymbol ?? "tokens"}.`,
+      { signature }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Failed to sign Permit2 allowance";
+    return actionError(
+      action,
+      isUserRejection(msg) ? "You rejected the Permit2 signature request. Please approve the signature in your wallet to allow fund transfers." : msg
+    );
+  }
+}
+function useAuthorizationExecutor(options) {
+  const swypeConfig = useOptionalSwypeConfig();
+  const apiBaseUrl = options?.apiBaseUrl ?? swypeConfig?.apiBaseUrl;
   const wagmiConfig2 = useConfig();
   const { connectAsync, connectors } = useConnect();
   const { switchChainAsync } = useSwitchChain();
@@ -762,6 +988,7 @@ function useAuthorizationExecutor() {
   const executingRef = useRef(false);
   const [pendingSelectSource, setPendingSelectSource] = useState(null);
   const selectSourceResolverRef = useRef(null);
+  const sessionIdRef = useRef(null);
   const resolveSelectSource = useCallback((selection) => {
     if (selectSourceResolverRef.current) {
       selectSourceResolverRef.current(selection);
@@ -769,393 +996,82 @@ function useAuthorizationExecutor() {
       setPendingSelectSource(null);
     }
   }, []);
-  const sessionIdRef = useRef(null);
-  const executeOpenProvider = useCallback(
-    async (action) => {
-      try {
-        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: ${account.address}, Chain: ${hexChainId2}`,
-            data: { accounts: [account.address], chainId: hexChainId2 }
-          };
-        }
-        const targetId = action.metadata?.wagmiConnectorId;
-        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,
-            type: action.type,
-            status: "error",
-            message: "No wallet connector found. Please install a supported wallet."
-          };
-        }
-        const result = await connectAsync({ connector });
-        const hexChainId = `0x${result.chainId.toString(16)}`;
-        return {
-          actionId: action.id,
-          type: action.type,
-          status: "success",
-          message: `Connected to ${connector.name}. Account: ${result.accounts[0]}, Chain: ${hexChainId}`,
-          data: { accounts: [...result.accounts], chainId: hexChainId }
-        };
-      } catch (err) {
-        return {
-          actionId: action.id,
-          type: action.type,
-          status: "error",
-          message: err instanceof Error ? err.message : "Failed to connect wallet"
-        };
-      }
-    },
-    [wagmiConfig2, connectors, connectAsync]
-  );
-  const executeSelectSource = useCallback(
-    async (action) => {
-      try {
-        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: "success",
-            message: `Auto-selected ${selection2.tokenSymbol} on ${selection2.chainName}.`,
-            data: {
-              selectedChainName: selection2.chainName,
-              selectedTokenSymbol: selection2.tokenSymbol
-            }
-          };
-        }
-        const selection = await new Promise((resolve) => {
-          selectSourceResolverRef.current = resolve;
-          setPendingSelectSource(action);
-        });
-        return {
-          actionId: action.id,
-          type: action.type,
-          status: "success",
-          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 select source"
-        };
-      }
-    },
+  const waitForSelection = useCallback(
+    (action) => new Promise((resolve) => {
+      selectSourceResolverRef.current = resolve;
+      setPendingSelectSource(action);
+    }),
     []
   );
-  const executeSwitchChain = useCallback(
-    async (action) => {
-      try {
-        const account = getAccount(wagmiConfig2);
-        const targetChainIdHex = action.metadata?.targetChainId;
-        if (!targetChainIdHex) {
-          return {
-            actionId: action.id,
-            type: action.type,
-            status: "error",
-            message: "No targetChainId in action metadata."
-          };
-        }
-        const targetChainIdNum = parseInt(targetChainIdHex, 16);
-        const hexChainId = `0x${targetChainIdNum.toString(16)}`;
-        if (account.chainId === targetChainIdNum) {
-          return {
-            actionId: action.id,
-            type: action.type,
-            status: "success",
-            message: `Already on chain ${hexChainId}. Skipped.`,
-            data: { chainId: hexChainId, switched: false }
-          };
-        }
-        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
-            ],
-            authenticatorSelection: {
-              authenticatorAttachment: "platform",
-              residentKey: "preferred",
-              userVerification: "required"
-            },
-            timeout: 6e4
-          }
-        });
-        if (!credential) {
-          return {
-            actionId: action.id,
-            type: action.type,
-            status: "error",
-            message: "Passkey creation was cancelled."
-          };
-        }
-        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: "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 create passkey"
-        };
-      }
-    },
-    [wagmiConfig2]
-  );
-  const executeUpgradeSmartAccount = useCallback(
-    async (action) => {
-      try {
-        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
-          }
-        };
-      } 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: "No signing payload in action metadata."
-          };
-        }
-        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: `Permissions granted for ${tokenSummary}.`,
-          data: {
-            signedDelegation: signature,
-            tokens
-          }
-        };
-      } catch (err) {
-        return {
-          actionId: action.id,
-          type: action.type,
-          status: "error",
-          message: err instanceof Error ? err.message : "Failed to grant permissions"
-        };
-      }
-    },
-    [wagmiConfig2]
-  );
-  const executeAction = useCallback(
+  const dispatchAction = useCallback(
     async (action) => {
       setCurrentAction(action);
       switch (action.type) {
         case "OPEN_PROVIDER":
-          return executeOpenProvider(action);
+          return executeOpenProvider(action, wagmiConfig2, connectors, connectAsync);
         case "SELECT_SOURCE":
-          return executeSelectSource(action);
+          return executeSelectSource(action, waitForSelection);
         case "SWITCH_CHAIN":
-          return executeSwitchChain(action);
-        case "REGISTER_PASSKEY":
-          return executeRegisterPasskey(action);
-        case "UPGRADE_SMART_ACCOUNT":
-          return executeUpgradeSmartAccount(action);
-        case "GRANT_PERMISSIONS":
-          return executeGrantPermissions(action);
+          return executeSwitchChain(action, wagmiConfig2, switchChainAsync);
+        case "APPROVE_PERMIT2":
+          return executeApprovePermit2(action, wagmiConfig2);
+        case "SIGN_PERMIT2":
+          return executeSignPermit2(action, wagmiConfig2, apiBaseUrl ?? "", sessionIdRef.current);
         default:
-          return {
-            actionId: action.id,
-            type: action.type,
-            status: "error",
-            message: `Unsupported action type: ${action.type}`
-          };
+          return actionError(action, `Unsupported action type: ${action.type}`);
       }
     },
-    [executeOpenProvider, executeSelectSource, executeSwitchChain, executeRegisterPasskey, executeUpgradeSmartAccount, executeGrantPermissions]
+    [wagmiConfig2, connectors, connectAsync, switchChainAsync, apiBaseUrl, waitForSelection]
   );
-  const executeSession = useCallback(
-    async (transfer) => {
+  const executeSessionById = useCallback(
+    async (sessionId) => {
       if (executingRef.current) return;
       executingRef.current = true;
-      if (!transfer.authorizationSessions || transfer.authorizationSessions.length === 0) {
+      if (!sessionId) {
         executingRef.current = false;
-        throw new Error("No authorization sessions available.");
+        throw new Error("No authorization session id provided.");
+      }
+      if (!apiBaseUrl) {
+        executingRef.current = false;
+        throw new Error("Missing apiBaseUrl. Provide useAuthorizationExecutor({ apiBaseUrl }) or wrap in <SwypeProvider>.");
       }
-      const sessionId = transfer.authorizationSessions[0].id;
       sessionIdRef.current = sessionId;
       setExecuting(true);
       setError(null);
       setResults([]);
       try {
-        let currentSession = await fetchAuthorizationSession(apiBaseUrl, sessionId);
+        let session = await fetchAuthorizationSession(apiBaseUrl, sessionId);
         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) {
+        const completedIds = /* @__PURE__ */ new Set();
+        let pending = getPendingActions(session, completedIds);
+        let retries = 0;
+        while (pending.length === 0 && session.status !== "AUTHORIZED" && retries < 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++;
+          session = await fetchAuthorizationSession(apiBaseUrl, sessionId);
+          pending = getPendingActions(session, completedIds);
+          retries++;
         }
-        if (pendingActions.length === 0 && currentSession.status !== "AUTHORIZED") {
+        if (pending.length === 0 && session.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;
-          const result = await executeAction(action);
+        while (pending.length > 0) {
+          const action = pending[0];
+          if (completedIds.has(action.id)) break;
+          const result = await dispatchAction(action);
           if (result.status === "error") {
             allResults.push(result);
             setResults([...allResults]);
             throw new Error(result.message);
           }
-          completedActionIds.add(action.id);
-          const updatedSession = await reportActionCompletion(
+          completedIds.add(action.id);
+          allResults.push(result);
+          session = await reportActionCompletion(
             apiBaseUrl,
             action.id,
             result.data ?? {}
           );
-          currentSession = updatedSession;
-          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];
-            while (pendingActions.length > 0) {
-              const nextAction = pendingActions[0];
-              const nextResult = await executeAction(nextAction);
-              if (nextResult.status === "error") {
-                chainResults.push(nextResult);
-                allResults.push(...chainResults);
-                setResults([...allResults]);
-                throw new Error(nextResult.message);
-              }
-              completedActionIds.add(nextAction.id);
-              const nextSession = await reportActionCompletion(
-                apiBaseUrl,
-                nextAction.id,
-                nextResult.data ?? {}
-              );
-              currentSession = nextSession;
-              chainResults.push(nextResult);
-              pendingActions = currentSession.actions.filter((a) => a.status === "PENDING" && !completedActionIds.has(a.id)).sort((a, b) => a.orderIndex - b.orderIndex);
-            }
-            allResults.push(...chainResults);
-            setResults([...allResults]);
-            continue;
-          }
-          allResults.push(result);
           setResults([...allResults]);
+          pending = getPendingActions(session, completedIds);
         }
       } catch (err) {
         const msg = err instanceof Error ? err.message : "Authorization failed";
@@ -1167,7 +1083,16 @@ function useAuthorizationExecutor() {
         executingRef.current = false;
       }
     },
-    [apiBaseUrl, executeAction]
+    [apiBaseUrl, dispatchAction]
+  );
+  const executeSession = useCallback(
+    async (transfer) => {
+      if (!transfer.authorizationSessions?.length) {
+        throw new Error("No authorization sessions available.");
+      }
+      await executeSessionById(transfer.authorizationSessions[0].id);
+    },
+    [executeSessionById]
   );
   return {
     executing,
@@ -1176,12 +1101,21 @@ function useAuthorizationExecutor() {
     currentAction,
     pendingSelectSource,
     resolveSelectSource,
+    executeSessionById,
     executeSession
   };
 }
-function useTransferSigning(pollIntervalMs = 2e3) {
-  const { apiBaseUrl } = useSwypeConfig();
-  const { getAccessToken } = usePrivy();
+function useTransferSigning(pollIntervalMs = 2e3, options) {
+  const swypeConfig = useOptionalSwypeConfig();
+  const apiBaseUrl = options?.apiBaseUrl ?? swypeConfig?.apiBaseUrl;
+  const authorizationSessionToken = options?.authorizationSessionToken;
+  let privyGetAccessToken;
+  try {
+    ({ getAccessToken: privyGetAccessToken } = usePrivy());
+  } catch {
+    privyGetAccessToken = void 0;
+  }
+  const getAccessToken = options?.getAccessToken ?? privyGetAccessToken;
   const [signing, setSigning] = useState(false);
   const [signPayload, setSignPayload] = useState(null);
   const [error, setError] = useState(null);
@@ -1191,14 +1125,24 @@ function useTransferSigning(pollIntervalMs = 2e3) {
       setError(null);
       setSignPayload(null);
       try {
-        const token = await getAccessToken();
-        if (!token) {
+        if (!apiBaseUrl) {
+          throw new Error("Missing apiBaseUrl. Provide useTransferSigning(_, { apiBaseUrl }) or wrap in <SwypeProvider>.");
+        }
+        if (!getAccessToken && !authorizationSessionToken) {
+          throw new Error("Missing getAccessToken provider. Provide useTransferSigning(_, { getAccessToken }).");
+        }
+        const token = getAccessToken ? await getAccessToken() : null;
+        if (!token && !authorizationSessionToken) {
           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);
+        for (let i = 0; i < TRANSFER_SIGN_MAX_POLLS; i++) {
+          const transfer = await fetchTransfer(
+            apiBaseUrl,
+            token ?? "",
+            transferId,
+            authorizationSessionToken
+          );
           if (transfer.signPayload) {
             payload = transfer.signPayload;
             setSignPayload(payload);
@@ -1212,14 +1156,16 @@ function useTransferSigning(pollIntervalMs = 2e3) {
         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 hashBytes = hexToBytes(payload.userOpHash);
+        const allowCredentials = payload.passkeyCredentialId ? [{
+          type: "public-key",
+          id: base64ToBytes(payload.passkeyCredentialId)
+        }] : void 0;
         const assertion = await navigator.credentials.get({
           publicKey: {
             challenge: hashBytes,
-            rpId: window.location.hostname,
+            rpId: resolvePasskeyRpId(),
+            allowCredentials,
             userVerification: "required",
             timeout: 6e4
           }
@@ -1228,32 +1174,20 @@ function useTransferSigning(pollIntervalMs = 2e3) {
           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
+          credentialId: toBase64(assertion.rawId),
+          signature: toBase64(response.signature),
+          authenticatorData: toBase64(response.authenticatorData),
+          clientDataJSON: toBase64(response.clientDataJSON)
         };
-        const updatedTransfer = await signTransfer(
+        return await signTransfer(
           apiBaseUrl,
-          token,
+          token ?? "",
           transferId,
-          signedUserOp
+          signedUserOp,
+          authorizationSessionToken
         );
-        return updatedTransfer;
       } catch (err) {
         const msg = err instanceof Error ? err.message : "Failed to sign transfer";
         setError(msg);
@@ -1262,7 +1196,7 @@ function useTransferSigning(pollIntervalMs = 2e3) {
         setSigning(false);
       }
     },
-    [apiBaseUrl, getAccessToken, pollIntervalMs]
+    [apiBaseUrl, getAccessToken, pollIntervalMs, authorizationSessionToken]
   );
   return { signing, signPayload, error, signTransfer: signTransfer2 };
 }
@@ -2038,6 +1972,37 @@ function computeSmartDefaults(accts, transferAmount) {
   }
   return { accountId: accts[0].id, walletId: null };
 }
+function parseRawBalance(rawBalance, decimals) {
+  const parsed = Number(rawBalance);
+  if (!Number.isFinite(parsed)) return 0;
+  return parsed / 10 ** decimals;
+}
+function buildSelectSourceChoices(options) {
+  const chainChoices = [];
+  const chainIndexByName = /* @__PURE__ */ new Map();
+  for (const option of options) {
+    const chainName = option.chainName;
+    const tokenSymbol = option.tokenSymbol;
+    const balance = parseRawBalance(option.rawBalance, option.decimals);
+    let chainChoice;
+    const existingChainIdx = chainIndexByName.get(chainName);
+    if (existingChainIdx === void 0) {
+      chainChoice = { chainName, balance: 0, tokens: [] };
+      chainIndexByName.set(chainName, chainChoices.length);
+      chainChoices.push(chainChoice);
+    } else {
+      chainChoice = chainChoices[existingChainIdx];
+    }
+    chainChoice.balance += balance;
+    const existingToken = chainChoice.tokens.find((token) => token.tokenSymbol === tokenSymbol);
+    if (existingToken) {
+      existingToken.balance += balance;
+    } else {
+      chainChoice.tokens.push({ tokenSymbol, balance });
+    }
+  }
+  return chainChoices;
+}
 function SwypePayment({
   destination,
   onComplete,
@@ -2064,8 +2029,12 @@ function SwypePayment({
   });
   const [transfer, setTransfer] = useState(null);
   const [creatingTransfer, setCreatingTransfer] = useState(false);
+  const [registeringPasskey, setRegisteringPasskey] = useState(false);
   const [mobileFlow, setMobileFlow] = useState(false);
   const pollingTransferIdRef = useRef(null);
+  const [selectSourceChainName, setSelectSourceChainName] = useState("");
+  const [selectSourceTokenSymbol, setSelectSourceTokenSymbol] = useState("");
+  const initializedSelectSourceActionRef = useRef(null);
   const authExecutor = useAuthorizationExecutor();
   const polling = useTransferPolling();
   const transferSigning = useTransferSigning();
@@ -2077,14 +2046,36 @@ function SwypePayment({
     }
   }, [depositAmount]);
   useEffect(() => {
-    if (ready && authenticated && step === "login") {
-      if (depositAmount != null && depositAmount > 0) {
-        setStep("ready");
-      } else {
-        setStep("enter-amount");
+    if (!ready || !authenticated || step !== "login") return;
+    let cancelled = false;
+    const checkPasskey = async () => {
+      try {
+        const token = await getAccessToken();
+        if (!token || cancelled) return;
+        const { config } = await fetchUserConfig(apiBaseUrl, token);
+        if (cancelled) return;
+        if (!config.passkey) {
+          setStep("register-passkey");
+        } else if (depositAmount != null && depositAmount > 0) {
+          setStep("ready");
+        } else {
+          setStep("enter-amount");
+        }
+      } catch {
+        if (!cancelled) {
+          if (depositAmount != null && depositAmount > 0) {
+            setStep("ready");
+          } else {
+            setStep("enter-amount");
+          }
+        }
       }
-    }
-  }, [ready, authenticated, step, depositAmount]);
+    };
+    checkPasskey();
+    return () => {
+      cancelled = true;
+    };
+  }, [ready, authenticated, step, depositAmount, apiBaseUrl, getAccessToken]);
   const loadingDataRef = useRef(false);
   useEffect(() => {
     if (!authenticated) return;
@@ -2158,61 +2149,43 @@ function SwypePayment({
       document.removeEventListener("visibilitychange", handleVisibility);
     };
   }, [mobileFlow, polling]);
+  const pendingSelectSourceAction = authExecutor.pendingSelectSource;
+  const selectSourceChoices = useMemo(() => {
+    if (!pendingSelectSourceAction) return [];
+    const options = pendingSelectSourceAction.metadata?.options ?? [];
+    return buildSelectSourceChoices(options);
+  }, [pendingSelectSourceAction]);
+  const selectSourceRecommended = useMemo(() => {
+    if (!pendingSelectSourceAction) return null;
+    return pendingSelectSourceAction.metadata?.recommended ?? null;
+  }, [pendingSelectSourceAction]);
   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
-        });
-      }
+    if (!pendingSelectSourceAction) {
+      initializedSelectSourceActionRef.current = null;
+      setSelectSourceChainName("");
+      setSelectSourceTokenSymbol("");
+      return;
+    }
+    if (initializedSelectSourceActionRef.current === pendingSelectSourceAction.id) {
+      return;
+    }
+    const hasRecommendedOption = !!selectSourceRecommended && selectSourceChoices.some(
+      (chain) => chain.chainName === selectSourceRecommended.chainName && chain.tokens.some(
+        (token) => token.tokenSymbol === selectSourceRecommended.tokenSymbol
+      )
+    );
+    if (hasRecommendedOption && selectSourceRecommended) {
+      setSelectSourceChainName(selectSourceRecommended.chainName);
+      setSelectSourceTokenSymbol(selectSourceRecommended.tokenSymbol);
+    } else if (selectSourceChoices.length > 0 && selectSourceChoices[0].tokens.length > 0) {
+      setSelectSourceChainName(selectSourceChoices[0].chainName);
+      setSelectSourceTokenSymbol(selectSourceChoices[0].tokens[0].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"
-        });
-      }
+      setSelectSourceChainName("Base");
+      setSelectSourceTokenSymbol("USDC");
     }
-  }, [authExecutor, authExecutor.pendingSelectSource, advancedSettings, selectedWalletId, selectedAccountId, accounts]);
+    initializedSelectSourceActionRef.current = pendingSelectSourceAction.id;
+  }, [pendingSelectSourceAction, selectSourceChoices, selectSourceRecommended]);
   const handlePay = useCallback(async () => {
     const parsedAmount = parseFloat(amount);
     if (isNaN(parsedAmount) || parsedAmount <= 0) {
@@ -2375,6 +2348,37 @@ function SwypePayment({
       ]
     }
   );
+  const displayedSelectSourceChoices = selectSourceChoices.length > 0 ? selectSourceChoices : [
+    {
+      chainName: "Base",
+      balance: 0,
+      tokens: [{ tokenSymbol: "USDC", balance: 0 }]
+    }
+  ];
+  const selectedChainChoice = displayedSelectSourceChoices.find(
+    (choice) => choice.chainName === selectSourceChainName
+  ) ?? displayedSelectSourceChoices[0];
+  const selectSourceTokenChoices = selectedChainChoice?.tokens ?? [];
+  const resolvedSelectSourceChainName = selectedChainChoice?.chainName ?? selectSourceChainName;
+  const resolvedSelectSourceTokenSymbol = selectSourceTokenChoices.find(
+    (token) => token.tokenSymbol === selectSourceTokenSymbol
+  )?.tokenSymbol ?? selectSourceTokenChoices[0]?.tokenSymbol ?? "";
+  const canConfirmSelectSource = !!resolvedSelectSourceChainName && !!resolvedSelectSourceTokenSymbol;
+  const handleSelectSourceChainChange = (chainName) => {
+    setSelectSourceChainName(chainName);
+    const nextChain = displayedSelectSourceChoices.find(
+      (choice) => choice.chainName === chainName
+    );
+    if (!nextChain || nextChain.tokens.length === 0) {
+      setSelectSourceTokenSymbol("");
+      return;
+    }
+    const recommendedTokenForChain = selectSourceRecommended?.chainName === chainName ? selectSourceRecommended.tokenSymbol : null;
+    const hasRecommendedToken = !!recommendedTokenForChain && nextChain.tokens.some((token) => token.tokenSymbol === recommendedTokenForChain);
+    setSelectSourceTokenSymbol(
+      hasRecommendedToken && recommendedTokenForChain ? recommendedTokenForChain : nextChain.tokens[0].tokenSymbol
+    );
+  };
   if (!ready) {
     return /* @__PURE__ */ jsx("div", { style: cardStyle, children: /* @__PURE__ */ jsx("div", { style: { textAlign: "center", padding: "24px 0" }, children: /* @__PURE__ */ jsx(Spinner, { label: "Initializing..." }) }) });
   }
@@ -2418,6 +2422,73 @@ function SwypePayment({
       /* @__PURE__ */ jsx("button", { style: btnPrimary, onClick: login, children: "Connect to Swype" })
     ] }) });
   }
+  if (step === "register-passkey") {
+    const handleRegisterPasskey = async () => {
+      setRegisteringPasskey(true);
+      setError(null);
+      try {
+        const token = await getAccessToken();
+        if (!token) throw new Error("Not authenticated");
+        const { credentialId, publicKey } = await createPasskeyCredential("Swype User");
+        await registerPasskey(apiBaseUrl, token, credentialId, publicKey);
+        if (depositAmount != null && depositAmount > 0) {
+          setStep("ready");
+        } else {
+          setStep("enter-amount");
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Failed to register passkey";
+        setError(msg);
+      } finally {
+        setRegisteringPasskey(false);
+      }
+    };
+    return /* @__PURE__ */ jsx("div", { style: cardStyle, children: /* @__PURE__ */ jsxs("div", { style: { textAlign: "center" }, 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 16c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 10c-4.42 0-8 1.79-8 4v2h16v-2c0-2.21-3.58-4-8-4z",
+                fill: tokens.accent
+              }
+            )
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx("h2", { style: { ...headingStyle, marginBottom: "8px" }, children: "Set Up Passkey" }),
+      /* @__PURE__ */ jsx(
+        "p",
+        {
+          style: {
+            fontSize: "0.875rem",
+            color: tokens.textSecondary,
+            margin: "0 0 24px 0",
+            lineHeight: 1.5
+          },
+          children: "Create a passkey for secure, one-touch payments. This only needs to be done once."
+        }
+      ),
+      error && /* @__PURE__ */ jsx("div", { style: errorStyle, children: error }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          style: registeringPasskey ? btnDisabled : btnPrimary,
+          disabled: registeringPasskey,
+          onClick: handleRegisterPasskey,
+          children: registeringPasskey ? "Creating passkey..." : "Create Passkey"
+        }
+      )
+    ] }) });
+  }
   if (step === "enter-amount") {
     const parsedAmount = parseFloat(amount);
     const canContinue = !isNaN(parsedAmount) && parsedAmount > 0;
@@ -2736,6 +2807,142 @@ function SwypePayment({
     ] });
   }
   if (step === "processing") {
+    if (pendingSelectSourceAction) {
+      const chainValue = resolvedSelectSourceChainName;
+      const tokenValue = resolvedSelectSourceTokenSymbol;
+      return /* @__PURE__ */ jsxs("div", { style: cardStyle, children: [
+        stepBadge("Select source"),
+        /* @__PURE__ */ jsxs("div", { style: { textAlign: "center", marginBottom: "16px" }, children: [
+          /* @__PURE__ */ jsx("h2", { style: { ...headingStyle, marginBottom: "8px" }, children: "Select payment source" }),
+          /* @__PURE__ */ jsx(
+            "p",
+            {
+              style: {
+                fontSize: "0.85rem",
+                color: tokens.textSecondary,
+                margin: 0,
+                lineHeight: 1.5
+              },
+              children: "Confirm the chain and token to use for this transfer."
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              fontSize: "0.825rem",
+              color: tokens.textSecondary,
+              marginBottom: "16px",
+              padding: "14px",
+              background: tokens.bgInput,
+              borderRadius: tokens.radius,
+              border: `1px solid ${tokens.border}`
+            },
+            children: [
+              /* @__PURE__ */ jsx(
+                "label",
+                {
+                  htmlFor: "swype-select-source-chain",
+                  style: {
+                    display: "block",
+                    fontSize: "0.75rem",
+                    fontWeight: 600,
+                    marginBottom: "6px",
+                    color: tokens.textMuted,
+                    textTransform: "uppercase",
+                    letterSpacing: "0.04em"
+                  },
+                  children: "Chain"
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "select",
+                {
+                  id: "swype-select-source-chain",
+                  value: chainValue,
+                  onChange: (event) => handleSelectSourceChainChange(event.target.value),
+                  style: {
+                    width: "100%",
+                    marginBottom: "12px",
+                    padding: "10px 12px",
+                    borderRadius: tokens.radius,
+                    border: `1px solid ${tokens.border}`,
+                    background: tokens.bgCard,
+                    color: tokens.text,
+                    fontFamily: "inherit",
+                    fontSize: "0.875rem",
+                    outline: "none"
+                  },
+                  children: displayedSelectSourceChoices.map((chainChoice) => /* @__PURE__ */ jsxs("option", { value: chainChoice.chainName, children: [
+                    chainChoice.chainName,
+                    " ($",
+                    chainChoice.balance.toFixed(2),
+                    ")"
+                  ] }, chainChoice.chainName))
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "label",
+                {
+                  htmlFor: "swype-select-source-token",
+                  style: {
+                    display: "block",
+                    fontSize: "0.75rem",
+                    fontWeight: 600,
+                    marginBottom: "6px",
+                    color: tokens.textMuted,
+                    textTransform: "uppercase",
+                    letterSpacing: "0.04em"
+                  },
+                  children: "Token"
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "select",
+                {
+                  id: "swype-select-source-token",
+                  value: tokenValue,
+                  onChange: (event) => setSelectSourceTokenSymbol(event.target.value),
+                  style: {
+                    width: "100%",
+                    padding: "10px 12px",
+                    borderRadius: tokens.radius,
+                    border: `1px solid ${tokens.border}`,
+                    background: tokens.bgCard,
+                    color: tokens.text,
+                    fontFamily: "inherit",
+                    fontSize: "0.875rem",
+                    outline: "none"
+                  },
+                  children: selectSourceTokenChoices.map((tokenChoice) => /* @__PURE__ */ jsxs("option", { value: tokenChoice.tokenSymbol, children: [
+                    tokenChoice.tokenSymbol,
+                    " ($",
+                    tokenChoice.balance.toFixed(2),
+                    ")"
+                  ] }, tokenChoice.tokenSymbol))
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            style: canConfirmSelectSource ? btnPrimary : btnDisabled,
+            disabled: !canConfirmSelectSource,
+            onClick: () => {
+              if (!canConfirmSelectSource) return;
+              authExecutor.resolveSelectSource({
+                chainName: resolvedSelectSourceChainName,
+                tokenSymbol: resolvedSelectSourceTokenSymbol
+              });
+            },
+            children: "Confirm source"
+          }
+        )
+      ] });
+    }
     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: [
@@ -2776,20 +2983,20 @@ function SwypePayment({
     const currentActionType = authExecutor.currentAction?.type;
     const getRegistrationMessage = () => {
       switch (currentActionType) {
-        case "REGISTER_PASSKEY":
+        case "CREATE_SMART_ACCOUNT":
           return {
-            label: "Creating your passkey...",
-            description: "Set up a passkey for secure, one-touch payments."
+            label: "Creating your smart account...",
+            description: "Setting up your smart account for gasless payments."
           };
-        case "UPGRADE_SMART_ACCOUNT":
+        case "APPROVE_PERMIT2":
           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."
+            label: "Approving token access...",
+            description: "Approve the prompt in your wallet to allow secure token transfers."
           };
-        case "GRANT_PERMISSIONS":
+        case "SIGN_PERMIT2":
           return {
-            label: "Setting up permissions...",
-            description: "Signing delegation permissions. Transfer routing and gas sponsorship are handled by Swype backend."
+            label: "Signing transfer permission...",
+            description: "Sign the permit to allow your smart account to transfer tokens on your behalf."
           };
         default:
           return { label: "", description: "" };
@@ -2972,6 +3179,6 @@ function SwypePayment({
   return null;
 }
 
-export { SwypePayment, SwypeProvider, darkTheme, getTheme, lightTheme, api_exports as swypeApi, useAuthorizationExecutor, useSwypeConfig, useSwypeDepositAmount, useTransferPolling };
+export { SwypePayment, SwypeProvider, createPasskeyCredential, darkTheme, getTheme, lightTheme, api_exports as swypeApi, useAuthorizationExecutor, useSwypeConfig, useSwypeDepositAmount, useTransferPolling, useTransferSigning };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map