@swype-org/react-sdk 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,11 +1,11 @@
 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, 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 { createPublicClient, http as http$1 } from 'viem';
-import { arbitrum as arbitrum$1, base as base$1, mainnet as mainnet$1 } from 'viem/chains';
+import { recoverTypedDataAddress, walletActions, createClient, custom } from 'viem';
+import { parseAccount, getAddress } from 'viem/utils';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -143,6 +143,7 @@ __export(api_exports, {
   fetchProviders: () => fetchProviders,
   fetchTransfer: () => fetchTransfer,
   reportActionCompletion: () => reportActionCompletion,
+  signTransfer: () => signTransfer,
   updateUserConfig: () => updateUserConfig,
   updateUserConfigBySession: () => updateUserConfigBySession
 });
@@ -211,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}`
@@ -252,25 +265,302 @@ async function reportActionCompletion(apiBaseUrl, actionId, result) {
   if (!res.ok) await throwApiError(res);
   return await res.json();
 }
-var VIEM_CHAINS = {
-  1: mainnet$1,
-  8453: base$1,
-  42161: arbitrum$1
+
+// 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);
+  }
 };
-var chainClientCache = /* @__PURE__ */ new Map();
-function getPublicClientForChain(numericChainId) {
-  const existing = chainClientCache.get(numericChainId);
-  if (existing) return existing;
-  const viemChain = VIEM_CHAINS[numericChainId];
-  if (!viemChain) {
-    throw new Error(`Unsupported chain ID: ${numericChainId}`);
+_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"
+    });
   }
-  const client = createPublicClient({
-    chain: viemChain,
-    transport: http$1()
+};
+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 })
   });
-  chainClientCache.set(numericChainId, client);
-  return client;
+}
+
+// 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);
+}
+async function waitForWalletClient(wagmiConfig2, walletClientParams = {}, maxAttempts = 15, intervalMs = 200) {
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      return await getWalletClient(wagmiConfig2, walletClientParams);
+    } 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 parseSignTypedDataPayload(typedData) {
+  const domain = typedData.domain;
+  const types = typedData.types;
+  const primaryType = typedData.primaryType;
+  const message = typedData.message;
+  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 {
+    domain,
+    types,
+    primaryType,
+    message
+  };
 }
 function useTransferPolling(intervalMs = 3e3) {
   const { apiBaseUrl } = useSwypeConfig();
@@ -322,14 +612,13 @@ 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 { 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);
@@ -340,31 +629,28 @@ function useAuthorizationExecutor() {
       setPendingSelectSource(null);
     }
   }, []);
-  const [pendingAllowanceSelection, setPendingAllowanceSelection] = useState(null);
-  const allowanceSelectionResolverRef = useRef(null);
   const sessionIdRef = useRef(null);
-  const resolveAllowanceSelection = useCallback((selection) => {
-    if (allowanceSelectionResolverRef.current) {
-      allowanceSelectionResolverRef.current(selection);
-      allowanceSelectionResolverRef.current = null;
-      setPendingAllowanceSelection(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,
@@ -391,7 +677,7 @@ function useAuthorizationExecutor() {
         };
       }
     },
-    [isConnected, address, currentChainId, connectors, connectAsync]
+    [wagmiConfig2, connectors, connectAsync]
   );
   const executeSelectSource = useCallback(
     async (action) => {
@@ -439,6 +725,7 @@ function useAuthorizationExecutor() {
   const executeSwitchChain = useCallback(
     async (action) => {
       try {
+        const account = getAccount(wagmiConfig2);
         const targetChainIdHex = action.metadata?.targetChainId;
         if (!targetChainIdHex) {
           return {
@@ -450,7 +737,7 @@ function useAuthorizationExecutor() {
         }
         const targetChainIdNum = parseInt(targetChainIdHex, 16);
         const hexChainId = `0x${targetChainIdNum.toString(16)}`;
-        if (currentChainId === targetChainIdNum) {
+        if (account.chainId === targetChainIdNum) {
           return {
             actionId: action.id,
             type: action.type,
@@ -476,252 +763,253 @@ function useAuthorizationExecutor() {
         };
       }
     },
-    [currentChainId, switchChainAsync]
+    [wagmiConfig2, switchChainAsync]
   );
-  const executeApprovePermit2 = useCallback(
+  const executeRegisterPasskey = useCallback(
     async (action) => {
       try {
-        const tokenAddress = action.metadata?.tokenAddress;
-        const permit2Address = action.metadata?.permit2Address;
-        const metadataChainId = action.metadata?.chainId;
-        if (!tokenAddress || !permit2Address) {
+        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: "Missing tokenAddress or permit2Address in action metadata."
+            message: "Passkey creation was cancelled."
           };
         }
-        if (!address) {
+        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 executeCreateSmartAccount = useCallback(
+    async (action) => {
+      return {
+        actionId: action.id,
+        type: action.type,
+        status: "success",
+        message: "Smart account creation acknowledged. Server is deploying.",
+        data: {}
+      };
+    },
+    []
+  );
+  const executeApprovePermit2 = useCallback(
+    async (action) => {
+      try {
+        const walletClient = await waitForWalletClient(wagmiConfig2);
+        const account = getAccount(wagmiConfig2);
+        const sender = account.address ?? walletClient.account?.address;
+        const expectedWalletAddress = action.metadata?.walletAddress;
+        if (!sender) {
+          throw new Error("Wallet account not available. Please connect your wallet.");
+        }
+        if (expectedWalletAddress && sender.toLowerCase() !== expectedWalletAddress.toLowerCase()) {
           return {
             actionId: action.id,
             type: action.type,
             status: "error",
-            message: "Wallet not connected."
+            message: `Connected wallet ${sender} does not match the required source wallet ${expectedWalletAddress}. Please switch accounts in your wallet and retry.`
           };
         }
-        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" }
-            ],
-            outputs: [{ name: "", type: "bool" }]
-          }
-        ];
-        const targetChainIdNum = metadataChainId ? parseInt(metadataChainId, 16) : currentChainId;
-        const chainClient = targetChainIdNum ? getPublicClientForChain(targetChainIdNum) : void 0;
-        if (chainClient) {
-          try {
-            const currentAllowance = await chainClient.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() }
-              };
-            }
-          } catch {
-          }
-        }
-        if (!walletClient) {
+        const to = action.metadata?.to;
+        const data = action.metadata?.data;
+        const tokenSymbol = action.metadata?.tokenSymbol;
+        if (!to || !data) {
           return {
             actionId: action.id,
             type: action.type,
             status: "error",
-            message: "Wallet client not available."
+            message: "APPROVE_PERMIT2 metadata is missing transaction parameters (to, data)."
           };
         }
-        const MAX_UINT256 = 2n ** 256n - 1n;
-        const txHash = await walletClient.writeContract({
-          address: tokenAddress,
-          abi: ERC20_ABI,
-          functionName: "approve",
-          args: [permit2Address, MAX_UINT256]
+        const txHash = await walletClient.request({
+          method: "eth_sendTransaction",
+          params: [
+            {
+              from: sender,
+              to,
+              data,
+              value: "0x0"
+            }
+          ]
         });
-        if (chainClient) {
-          await chainClient.waitForTransactionReceipt({ hash: txHash });
-        }
+        console.info(
+          `[swype-sdk][approve-permit2] ERC-20 approve tx sent. token=${tokenSymbol ?? to}, txHash=${txHash}`
+        );
         return {
           actionId: action.id,
           type: action.type,
           status: "success",
-          message: `Permit2 approved. Tx: ${txHash}`,
-          data: { txHash, approved: true }
+          message: `Approved Permit2 to spend ${tokenSymbol ?? "tokens"}.`,
+          data: { txHash }
         };
       } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to approve Permit2";
+        const isRejected = message.includes("rejected") || message.includes("denied") || message.includes("user rejected");
         return {
           actionId: action.id,
           type: action.type,
           status: "error",
-          message: err instanceof Error ? err.message : "Failed to approve Permit2"
+          message: isRejected ? "You rejected the approval transaction. Please approve the Permit2 spending allowance in your wallet to continue." : message
         };
       }
     },
-    [address, currentChainId, walletClient]
+    [wagmiConfig2]
   );
   const executeSignPermit2 = 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 spenderAddress = action.metadata?.spenderAddress;
-        const tokenAddress = action.metadata?.tokenAddress;
-        const metadataChainId = action.metadata?.chainId;
-        const metadataAmount = action.metadata?.amount;
-        if (!spenderAddress || !tokenAddress) {
+        const expectedWalletAddress = action.metadata?.walletAddress;
+        const walletClient = await waitForWalletClient(
+          wagmiConfig2,
+          expectedWalletAddress ? { account: expectedWalletAddress } : {}
+        );
+        const account = getAccount(wagmiConfig2);
+        const connectedAddress = account.address ?? walletClient.account?.address;
+        const sender = expectedWalletAddress ?? connectedAddress;
+        if (!sender) {
+          throw new Error("Wallet account not available. Please connect your wallet.");
+        }
+        if (expectedWalletAddress && connectedAddress && connectedAddress.toLowerCase() !== expectedWalletAddress.toLowerCase()) {
           return {
             actionId: action.id,
             type: action.type,
             status: "error",
-            message: "Missing spenderAddress or tokenAddress in action metadata."
+            message: `Connected wallet ${sender} does not match the required source wallet ${expectedWalletAddress}. Please switch accounts in your wallet and retry.`
           };
         }
-        const permit2ChainId = metadataChainId ? parseInt(metadataChainId, 16) : currentChainId;
-        const chainClient = permit2ChainId ? getPublicClientForChain(permit2ChainId) : void 0;
-        let onChainNonce;
-        if (chainClient && address) {
-          try {
-            const [existingAmount, existingExpiration, chainNonce] = await chainClient.readContract({
-              address: PERMIT2_ADDRESS,
-              abi: PERMIT2_ALLOWANCE_ABI,
-              functionName: "allowance",
-              args: [address, tokenAddress, spenderAddress]
-            });
-            onChainNonce = chainNonce;
-            if (metadataAmount) {
-              const requiredSmallestUnit = BigInt(metadataAmount);
-              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 allowanceSelection = await new Promise((resolve) => {
-          allowanceSelectionResolverRef.current = resolve;
-          setPendingAllowanceSelection(action);
-        });
-        if (allowanceSelection.topUpAmount > 0 && sessionIdRef.current) {
-          try {
-            await updateUserConfigBySession(
+        let typedData = action.metadata?.typedData;
+        const tokenSymbol = action.metadata?.tokenSymbol;
+        if (!typedData && sessionIdRef.current) {
+          const POLL_INTERVAL_MS = 1e3;
+          const MAX_POLLS = 15;
+          for (let i = 0; i < MAX_POLLS; i++) {
+            await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+            const session = await fetchAuthorizationSession(
               apiBaseUrl,
-              sessionIdRef.current,
-              { defaultAllowance: allowanceSelection.topUpAmount }
+              sessionIdRef.current
             );
-          } catch {
+            const updatedAction = session.actions.find((a) => a.id === action.id);
+            typedData = updatedAction?.metadata?.typedData;
+            if (typedData) break;
           }
         }
-        const tokenDecimals = Number(action.metadata?.tokenDecimals ?? 6);
-        const topUpSmallestUnit = BigInt(
-          Math.round(allowanceSelection.topUpAmount * 10 ** tokenDecimals)
+        if (!typedData) {
+          return {
+            actionId: action.id,
+            type: action.type,
+            status: "error",
+            message: "SIGN_PERMIT2 metadata is missing typedData. The server may still be preparing the signing payload."
+          };
+        }
+        const parsedTypedData = parseSignTypedDataPayload(typedData);
+        console.info(
+          `[swype-sdk][sign-permit2] Signing typed data. expectedOwner=${expectedWalletAddress ?? "N/A"}, senderParam=${sender}, connectedAddress=${connectedAddress ?? "N/A"}, primaryType=${parsedTypedData.primaryType}, domainChainId=${String(parsedTypedData.domain.chainId ?? "N/A")}, verifyingContract=${String(parsedTypedData.domain.verifyingContract ?? "N/A")}`
         );
-        const baseAmount = metadataAmount ? BigInt(metadataAmount) : BigInt(0);
-        const permitAmount = baseAmount + topUpSmallestUnit;
-        const nonce = onChainNonce ?? 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.signTypedData({
+          account: sender,
+          domain: parsedTypedData.domain,
+          types: parsedTypedData.types,
+          primaryType: parsedTypedData.primaryType,
+          message: parsedTypedData.message
         });
+        const recoverInput = {
+          domain: parsedTypedData.domain,
+          types: parsedTypedData.types,
+          primaryType: parsedTypedData.primaryType,
+          message: parsedTypedData.message,
+          signature
+        };
+        const recoveredSigner = await recoverTypedDataAddress(recoverInput);
+        const expectedSigner = (expectedWalletAddress ?? sender).toLowerCase();
+        console.info(
+          `[swype-sdk][sign-permit2] Signature recovered. recoveredSigner=${recoveredSigner}, expectedSigner=${expectedSigner}`
+        );
+        if (recoveredSigner.toLowerCase() !== expectedSigner) {
+          return {
+            actionId: action.id,
+            type: action.type,
+            status: "error",
+            message: `Wallet signed with ${recoveredSigner}, but source wallet is ${expectedWalletAddress ?? 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 {
           actionId: action.id,
           type: action.type,
           status: "success",
-          message: "Permit2 allowance signature obtained.",
-          data: {
-            signature,
-            signer: address,
-            nonce: nonce.toString(),
-            sigDeadline: sigDeadline.toString(),
-            expiration: expiration.toString(),
-            amount: permitAmount.toString()
-          }
+          message: `Permit2 allowance signed for ${tokenSymbol ?? "tokens"}.`,
+          data: { signature }
         };
       } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to sign Permit2 allowance";
+        const isRejected = message.includes("rejected") || message.includes("denied") || message.includes("user rejected");
         return {
           actionId: action.id,
           type: action.type,
           status: "error",
-          message: err instanceof Error ? err.message : "Failed to sign Permit2"
+          message: isRejected ? "You rejected the Permit2 signature request. Please approve the signature in your wallet to allow fund transfers." : message
         };
       }
     },
-    [address, currentChainId, signTypedDataAsync, apiBaseUrl]
+    [wagmiConfig2, apiBaseUrl]
   );
   const executeAction = useCallback(
     async (action) => {
+      setCurrentAction(action);
       switch (action.type) {
         case "OPEN_PROVIDER":
           return executeOpenProvider(action);
@@ -729,7 +1017,11 @@ function useAuthorizationExecutor() {
           return executeSelectSource(action);
         case "SWITCH_CHAIN":
           return executeSwitchChain(action);
-        case "APPROVE_PERMIT_2":
+        case "REGISTER_PASSKEY":
+          return executeRegisterPasskey(action);
+        case "CREATE_SMART_ACCOUNT":
+          return executeCreateSmartAccount(action);
+        case "APPROVE_PERMIT2":
           return executeApprovePermit2(action);
         case "SIGN_PERMIT2":
           return executeSignPermit2(action);
@@ -742,16 +1034,15 @@ function useAuthorizationExecutor() {
           };
       }
     },
-    [executeOpenProvider, executeSelectSource, executeSwitchChain, executeApprovePermit2, executeSignPermit2]
+    [executeOpenProvider, executeSelectSource, executeSwitchChain, executeRegisterPasskey, executeCreateSmartAccount, executeApprovePermit2, executeSignPermit2]
   );
   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;
@@ -773,8 +1064,7 @@ function useAuthorizationExecutor() {
           actionPollRetries++;
         }
         if (pendingActions.length === 0 && currentSession.status !== "AUTHORIZED") {
-          setError("Authorization actions were not created in time. Please try again.");
-          return;
+          throw new Error("Authorization actions were not created in time. Please try again.");
         }
         while (pendingActions.length > 0) {
           const action = pendingActions[0];
@@ -783,8 +1073,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(
@@ -796,7 +1085,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);
@@ -804,9 +1092,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(
@@ -818,7 +1104,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;
@@ -827,8 +1112,11 @@ 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;
       }
@@ -839,13 +1127,99 @@ function useAuthorizationExecutor() {
     executing,
     results,
     error,
+    currentAction,
     pendingSelectSource,
     resolveSelectSource,
-    pendingAllowanceSelection,
-    resolveAllowanceSelection,
     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();
   return /* @__PURE__ */ jsxs(
@@ -1577,204 +1951,6 @@ function AdvancedSettings({
     )
   ] });
 }
-var TOP_UP_OPTIONS = [0, 25, 50, 100, 500];
-function AllowanceSelector({ action, onSelect }) {
-  const { tokens } = useSwypeConfig();
-  const metadataAmount = action.metadata?.amount;
-  const tokenDecimals = Number(action.metadata?.tokenDecimals ?? 6);
-  const currency = action.metadata?.currency ?? "USD";
-  const transferAmountRaw = metadataAmount ? Number(BigInt(metadataAmount)) / 10 ** tokenDecimals : 0;
-  const [selectedTopUp, setSelectedTopUp] = useState(0);
-  const totalAllowance = transferAmountRaw + selectedTopUp;
-  const formatAmount = (amount) => `$${amount.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      style: {
-        padding: "4px 0",
-        textAlign: "left"
-      },
-      children: [
-        /* @__PURE__ */ jsx(
-          "h3",
-          {
-            style: {
-              fontSize: "1rem",
-              fontWeight: 600,
-              color: tokens.text,
-              margin: "0 0 6px 0",
-              textAlign: "center"
-            },
-            children: "Set spending limit"
-          }
-        ),
-        /* @__PURE__ */ jsx(
-          "p",
-          {
-            style: {
-              fontSize: "0.8rem",
-              color: tokens.textMuted,
-              margin: "0 0 16px 0",
-              lineHeight: 1.5,
-              textAlign: "center"
-            },
-            children: "Pre-authorize a higher amount so future payments go through instantly without wallet prompts."
-          }
-        ),
-        /* @__PURE__ */ jsxs(
-          "div",
-          {
-            style: {
-              display: "flex",
-              justifyContent: "space-between",
-              alignItems: "center",
-              padding: "10px 14px",
-              background: tokens.bgInput,
-              borderRadius: tokens.radius,
-              marginBottom: "12px",
-              fontSize: "0.825rem"
-            },
-            children: [
-              /* @__PURE__ */ jsx("span", { style: { color: tokens.textSecondary }, children: "This payment" }),
-              /* @__PURE__ */ jsxs("span", { style: { fontWeight: 600, color: tokens.text }, children: [
-                formatAmount(transferAmountRaw),
-                " ",
-                currency
-              ] })
-            ]
-          }
-        ),
-        /* @__PURE__ */ jsx(
-          "div",
-          {
-            style: {
-              display: "flex",
-              flexDirection: "column",
-              gap: "6px",
-              marginBottom: "16px"
-            },
-            children: TOP_UP_OPTIONS.map((topUp) => {
-              const isSelected = selectedTopUp === topUp;
-              const total = transferAmountRaw + topUp;
-              const label = topUp === 0 ? "Just this payment" : `+${formatAmount(topUp)} for future payments`;
-              return /* @__PURE__ */ jsxs(
-                "button",
-                {
-                  onClick: () => setSelectedTopUp(topUp),
-                  style: {
-                    display: "flex",
-                    alignItems: "center",
-                    justifyContent: "space-between",
-                    width: "100%",
-                    padding: "12px 14px",
-                    background: isSelected ? tokens.accent + "14" : "transparent",
-                    border: `1.5px solid ${isSelected ? tokens.accent : tokens.border}`,
-                    borderRadius: tokens.radius,
-                    cursor: "pointer",
-                    color: tokens.text,
-                    fontFamily: "inherit",
-                    fontSize: "0.825rem",
-                    textAlign: "left",
-                    outline: "none",
-                    transition: "all 0.12s ease"
-                  },
-                  children: [
-                    /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: "8px" }, children: [
-                      /* @__PURE__ */ jsx(
-                        "div",
-                        {
-                          style: {
-                            width: 16,
-                            height: 16,
-                            borderRadius: "50%",
-                            border: `2px solid ${isSelected ? tokens.accent : tokens.border}`,
-                            display: "flex",
-                            alignItems: "center",
-                            justifyContent: "center",
-                            flexShrink: 0
-                          },
-                          children: isSelected && /* @__PURE__ */ jsx(
-                            "div",
-                            {
-                              style: {
-                                width: 8,
-                                height: 8,
-                                borderRadius: "50%",
-                                background: tokens.accent
-                              }
-                            }
-                          )
-                        }
-                      ),
-                      /* @__PURE__ */ jsx("span", { style: { fontWeight: isSelected ? 600 : 400 }, children: label })
-                    ] }),
-                    /* @__PURE__ */ jsx(
-                      "span",
-                      {
-                        style: {
-                          fontWeight: 600,
-                          color: isSelected ? tokens.accent : tokens.textMuted,
-                          fontSize: "0.8rem",
-                          flexShrink: 0,
-                          marginLeft: "8px"
-                        },
-                        children: formatAmount(total)
-                      }
-                    )
-                  ]
-                },
-                topUp
-              );
-            })
-          }
-        ),
-        /* @__PURE__ */ jsxs(
-          "div",
-          {
-            style: {
-              display: "flex",
-              justifyContent: "space-between",
-              alignItems: "center",
-              padding: "10px 14px",
-              background: tokens.bgInput,
-              borderRadius: tokens.radius,
-              marginBottom: "14px",
-              fontSize: "0.825rem"
-            },
-            children: [
-              /* @__PURE__ */ jsx("span", { style: { color: tokens.textSecondary }, children: "Total authorization" }),
-              /* @__PURE__ */ jsxs("span", { style: { fontWeight: 700, color: tokens.text, fontSize: "0.9rem" }, children: [
-                formatAmount(totalAllowance),
-                " ",
-                currency
-              ] })
-            ]
-          }
-        ),
-        /* @__PURE__ */ jsx(
-          "button",
-          {
-            onClick: () => onSelect({ topUpAmount: selectedTopUp }),
-            style: {
-              width: "100%",
-              padding: "14px",
-              background: tokens.accent,
-              color: tokens.accentText,
-              border: "none",
-              borderRadius: tokens.radius,
-              fontSize: "1rem",
-              fontWeight: 600,
-              cursor: "pointer",
-              transition: "background 0.15s ease",
-              fontFamily: "inherit"
-            },
-            children: "Authorize & Sign"
-          }
-        )
-      ]
-    }
-  );
-}
 function isMobile() {
   if (typeof navigator === "undefined") return false;
   return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
@@ -1785,11 +1961,11 @@ 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" && wallet.lastAuthorizedToken) {
-        const matchingSource = wallet.sources.find(
-          (s) => s.token.symbol === wallet.lastAuthorizedToken.symbol
+      if (wallet.status === "ACTIVE") {
+        const bestSource = wallet.sources.find(
+          (s) => s.balance.available.amount >= transferAmount
         );
-        if (matchingSource && matchingSource.balance.available.amount >= transferAmount) {
+        if (bestSource) {
           return { accountId: acct.id, walletId: wallet.id };
         }
       }
@@ -1846,6 +2022,7 @@ function SwypePayment({
   const pollingTransferIdRef = useRef(null);
   const authExecutor = useAuthorizationExecutor();
   const polling = useTransferPolling();
+  const transferSigning = useTransferSigning();
   const sourceType = connectingNewAccount ? "providerId" : selectedWalletId ? "walletId" : selectedAccountId ? "accountId" : "providerId";
   const sourceId = connectingNewAccount ? selectedProviderId ?? "" : selectedWalletId ? selectedWalletId : selectedAccountId ? selectedAccountId : selectedProviderId ?? "";
   useEffect(() => {
@@ -2025,9 +2202,11 @@ 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("ready");
@@ -2042,6 +2221,7 @@ function SwypePayment({
     apiBaseUrl,
     getAccessToken,
     authExecutor,
+    transferSigning,
     polling,
     onError
   ]);
@@ -2510,17 +2690,73 @@ function SwypePayment({
     ] });
   }
   if (step === "processing") {
-    if (authExecutor.pendingAllowanceSelection) {
-      return /* @__PURE__ */ jsx("div", { style: cardStyle, children: /* @__PURE__ */ jsx(
-        AllowanceSelector,
-        {
-          action: authExecutor.pendingAllowanceSelection,
-          onSelect: authExecutor.resolveAllowanceSelection
-        }
-      ) });
+    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 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...";
+    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 "CREATE_SMART_ACCOUNT":
+          return {
+            label: "Creating your smart account...",
+            description: "Setting up your smart account for gasless payments."
+          };
+        case "APPROVE_PERMIT2":
+          return {
+            label: "Approving token access...",
+            description: "Approve the prompt in your wallet to allow secure token transfers."
+          };
+        case "SIGN_PERMIT2":
+          return {
+            label: "Signing transfer permission...",
+            description: "Sign the permit to allow your smart account to transfer tokens on your behalf."
+          };
+        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(
@@ -2564,11 +2800,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
         }
       )
     ] }) });