@swype-org/react-sdk 0.1.132 → 0.1.142

package/dist/index.cjs

@@ -156,261 +156,6 @@ function useSwypeDepositAmount() {
   };
 }
 
-// src/api.ts
-var api_exports = {};
-__export(api_exports, {
-  createAccount: () => createAccount,
-  createAccountAuthorizationSession: () => createAccountAuthorizationSession,
-  createTransfer: () => createTransfer,
-  fetchAccount: () => fetchAccount,
-  fetchAccounts: () => fetchAccounts,
-  fetchAuthorizationSession: () => fetchAuthorizationSession,
-  fetchChains: () => fetchChains,
-  fetchMerchantPublicKey: () => fetchMerchantPublicKey,
-  fetchProviders: () => fetchProviders,
-  fetchTransfer: () => fetchTransfer,
-  fetchUserConfig: () => fetchUserConfig,
-  registerPasskey: () => registerPasskey,
-  reportActionCompletion: () => reportActionCompletion,
-  reportPasskeyActivity: () => reportPasskeyActivity,
-  signTransfer: () => signTransfer,
-  updateUserConfig: () => updateUserConfig,
-  updateUserConfigBySession: () => updateUserConfigBySession
-});
-async function throwApiError(res) {
-  const body = await res.json().catch(() => null);
-  const detail = body?.error ?? body;
-  const msg = detail?.message ?? res.statusText;
-  const code = detail?.code ?? String(res.status);
-  throw new Error(`${res.status} \u2014 ${code}: ${msg}`);
-}
-async function fetchProviders(apiBaseUrl, token) {
-  const res = await fetch(`${apiBaseUrl}/v1/providers`, {
-    headers: { Authorization: `Bearer ${token}` }
-  });
-  if (!res.ok) await throwApiError(res);
-  const data = await res.json();
-  return data.items;
-}
-async function fetchChains(apiBaseUrl, token) {
-  const res = await fetch(`${apiBaseUrl}/v1/chains`, {
-    headers: { Authorization: `Bearer ${token}` }
-  });
-  if (!res.ok) await throwApiError(res);
-  const data = await res.json();
-  return data.items;
-}
-async function fetchAccounts(apiBaseUrl, token, credentialId) {
-  const params = new URLSearchParams({ credentialId });
-  const res = await fetch(`${apiBaseUrl}/v1/accounts?${params.toString()}`, {
-    headers: { Authorization: `Bearer ${token}` }
-  });
-  if (!res.ok) await throwApiError(res);
-  const data = await res.json();
-  return data.items;
-}
-async function fetchAccount(apiBaseUrl, token, accountId, credentialId) {
-  const params = new URLSearchParams({ credentialId });
-  const res = await fetch(`${apiBaseUrl}/v1/accounts/${accountId}?${params.toString()}`, {
-    headers: { Authorization: `Bearer ${token}` }
-  });
-  if (!res.ok) await throwApiError(res);
-  return await res.json();
-}
-async function createAccount(apiBaseUrl, token, params) {
-  const body = {
-    id: params.id ?? crypto.randomUUID(),
-    name: params.name,
-    credentialId: params.credentialId,
-    providerId: params.providerId
-  };
-  if (params.nickname) {
-    body.nickname = params.nickname;
-  }
-  const res = await fetch(`${apiBaseUrl}/v1/accounts`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify(body)
-  });
-  if (!res.ok) await throwApiError(res);
-  return await res.json();
-}
-async function createAccountAuthorizationSession(apiBaseUrl, token, accountId, credentialId, options) {
-  const body = { credentialId };
-  if (options?.tokenAddress) body.tokenAddress = options.tokenAddress;
-  if (options?.chainId != null) body.chainId = options.chainId;
-  const res = await fetch(
-    `${apiBaseUrl}/v1/accounts/${accountId}/authorization-sessions`,
-    {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify(body)
-    }
-  );
-  if (!res.ok) await throwApiError(res);
-  return await res.json();
-}
-async function createTransfer(apiBaseUrl, token, params) {
-  if (!params.merchantAuthorization) {
-    throw new Error("merchantAuthorization is required for transfer creation.");
-  }
-  const body = {
-    id: params.id ?? crypto.randomUUID(),
-    credentialId: params.credentialId,
-    merchantAuthorization: params.merchantAuthorization,
-    sources: [{ [params.sourceType]: params.sourceId }],
-    destinations: [
-      {
-        chainId: params.destination.chainId,
-        token: { address: params.destination.token.address },
-        address: params.destination.address
-      }
-    ],
-    amount: {
-      amount: params.amount,
-      currency: params.currency ?? "USD"
-    }
-  };
-  const res = await fetch(`${apiBaseUrl}/v1/transfers`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify(body)
-  });
-  if (!res.ok) await throwApiError(res);
-  return await res.json();
-}
-async function fetchMerchantPublicKey(apiBaseUrl, merchantId) {
-  const res = await fetch(
-    `${apiBaseUrl}/v1/merchants/${encodeURIComponent(merchantId)}/public-key`
-  );
-  if (!res.ok) await throwApiError(res);
-  return await res.json();
-}
-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: {
-      ...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, 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",
-      ...token ? { Authorization: `Bearer ${token}` } : {},
-      ...authorizationSessionToken ? { "x-authorization-session-token": authorizationSessionToken } : {}
-    },
-    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}`
-  );
-  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 reportPasskeyActivity(apiBaseUrl, token, credentialId) {
-  const res = await fetch(`${apiBaseUrl}/v1/users/config/passkey`, {
-    method: "PATCH",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify({ credentialId })
-  });
-  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",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify({ config })
-  });
-  if (!res.ok) await throwApiError(res);
-}
-async function updateUserConfigBySession(apiBaseUrl, sessionId, config) {
-  const res = await fetch(
-    `${apiBaseUrl}/v1/authorization-sessions/${sessionId}/user-config`,
-    {
-      method: "PATCH",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ config })
-    }
-  );
-  if (!res.ok) await throwApiError(res);
-}
-async function reportActionCompletion(apiBaseUrl, actionId, result) {
-  const res = await fetch(
-    `${apiBaseUrl}/v1/authorization-actions/${actionId}`,
-    {
-      method: "PATCH",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ status: "COMPLETED", result })
-    }
-  );
-  if (!res.ok) await throwApiError(res);
-  return await res.json();
-}
-
-// src/sentry.ts
-var _mod;
-function captureException(error) {
-  if (_mod === null) return;
-  if (_mod) {
-    _mod.captureException(error);
-    return;
-  }
-  import('@sentry/react').then((m) => {
-    _mod = m;
-    m.captureException(error);
-  }).catch(() => {
-    _mod = null;
-  });
-}
-
 // node_modules/@wagmi/core/dist/esm/version.js
 var version = "2.22.1";
 
@@ -671,8 +416,250 @@ async function getWalletClient(config, parameters = {}) {
   return client.extend(viem.walletActions);
 }
 
-// src/passkeyRpId.ts
-function normalizeConfiguredDomain(value) {
+// src/api.ts
+var api_exports = {};
+__export(api_exports, {
+  createAccount: () => createAccount,
+  createAccountAuthorizationSession: () => createAccountAuthorizationSession,
+  createTransfer: () => createTransfer,
+  fetchAccount: () => fetchAccount,
+  fetchAccounts: () => fetchAccounts,
+  fetchAuthorizationSession: () => fetchAuthorizationSession,
+  fetchChains: () => fetchChains,
+  fetchMerchantPublicKey: () => fetchMerchantPublicKey,
+  fetchProviders: () => fetchProviders,
+  fetchTransfer: () => fetchTransfer,
+  fetchUserConfig: () => fetchUserConfig,
+  registerPasskey: () => registerPasskey,
+  reportActionCompletion: () => reportActionCompletion,
+  reportPasskeyActivity: () => reportPasskeyActivity,
+  signTransfer: () => signTransfer,
+  updateUserConfig: () => updateUserConfig,
+  updateUserConfigBySession: () => updateUserConfigBySession
+});
+async function throwApiError(res) {
+  const body = await res.json().catch(() => null);
+  const detail = body?.error ?? body;
+  const msg = detail?.message ?? res.statusText;
+  const code = detail?.code ?? String(res.status);
+  throw new Error(`${res.status} \u2014 ${code}: ${msg}`);
+}
+async function fetchProviders(apiBaseUrl, token) {
+  const res = await fetch(`${apiBaseUrl}/v1/providers`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) await throwApiError(res);
+  const data = await res.json();
+  return data.items;
+}
+async function fetchChains(apiBaseUrl, token) {
+  const res = await fetch(`${apiBaseUrl}/v1/chains`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) await throwApiError(res);
+  const data = await res.json();
+  return data.items;
+}
+async function fetchAccounts(apiBaseUrl, token, credentialId) {
+  const params = new URLSearchParams({ credentialId });
+  const res = await fetch(`${apiBaseUrl}/v1/accounts?${params.toString()}`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) await throwApiError(res);
+  const data = await res.json();
+  return data.items;
+}
+async function fetchAccount(apiBaseUrl, token, accountId, credentialId) {
+  const params = new URLSearchParams({ credentialId });
+  const res = await fetch(`${apiBaseUrl}/v1/accounts/${accountId}?${params.toString()}`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) await throwApiError(res);
+  return await res.json();
+}
+async function createAccount(apiBaseUrl, token, params) {
+  const body = {
+    id: params.id ?? crypto.randomUUID(),
+    name: params.name,
+    credentialId: params.credentialId,
+    providerId: params.providerId
+  };
+  if (params.nickname) {
+    body.nickname = params.nickname;
+  }
+  const res = await fetch(`${apiBaseUrl}/v1/accounts`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) await throwApiError(res);
+  return await res.json();
+}
+async function createAccountAuthorizationSession(apiBaseUrl, token, accountId, credentialId, options) {
+  const body = { credentialId };
+  if (options?.tokenAddress) body.tokenAddress = options.tokenAddress;
+  if (options?.chainId != null) body.chainId = options.chainId;
+  const res = await fetch(
+    `${apiBaseUrl}/v1/accounts/${accountId}/authorization-sessions`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify(body)
+    }
+  );
+  if (!res.ok) await throwApiError(res);
+  return await res.json();
+}
+async function createTransfer(apiBaseUrl, token, params) {
+  if (!params.merchantAuthorization) {
+    throw new Error("merchantAuthorization is required for transfer creation.");
+  }
+  const body = {
+    id: params.id ?? crypto.randomUUID(),
+    credentialId: params.credentialId,
+    merchantAuthorization: params.merchantAuthorization,
+    sources: [{
+      [params.sourceType]: params.sourceId,
+      ...params.sourceTokenAddress ? { tokenAddress: params.sourceTokenAddress } : {}
+    }],
+    destinations: [
+      {
+        chainId: params.destination.chainId,
+        token: { address: params.destination.token.address },
+        address: params.destination.address
+      }
+    ],
+    amount: {
+      amount: params.amount,
+      currency: params.currency ?? "USD"
+    }
+  };
+  const res = await fetch(`${apiBaseUrl}/v1/transfers`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) await throwApiError(res);
+  return await res.json();
+}
+async function fetchMerchantPublicKey(apiBaseUrl, merchantId) {
+  const res = await fetch(
+    `${apiBaseUrl}/v1/merchants/${encodeURIComponent(merchantId)}/public-key`
+  );
+  if (!res.ok) await throwApiError(res);
+  return await res.json();
+}
+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: {
+      ...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, 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",
+      ...token ? { Authorization: `Bearer ${token}` } : {},
+      ...authorizationSessionToken ? { "x-authorization-session-token": authorizationSessionToken } : {}
+    },
+    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}`
+  );
+  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 reportPasskeyActivity(apiBaseUrl, token, credentialId) {
+  const res = await fetch(`${apiBaseUrl}/v1/users/config/passkey`, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ credentialId })
+  });
+  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",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ config })
+  });
+  if (!res.ok) await throwApiError(res);
+}
+async function updateUserConfigBySession(apiBaseUrl, sessionId, config) {
+  const res = await fetch(
+    `${apiBaseUrl}/v1/authorization-sessions/${sessionId}/user-config`,
+    {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ config })
+    }
+  );
+  if (!res.ok) await throwApiError(res);
+}
+async function reportActionCompletion(apiBaseUrl, actionId, result) {
+  const res = await fetch(
+    `${apiBaseUrl}/v1/authorization-actions/${actionId}`,
+    {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ status: "COMPLETED", result })
+    }
+  );
+  if (!res.ok) await throwApiError(res);
+  return await res.json();
+}
+
+// src/passkeyRpId.ts
+function normalizeConfiguredDomain(value) {
   return value.replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/^\./, "").trim();
 }
 function resolveRootDomainFromHostname(hostname) {
@@ -1656,170 +1643,6 @@ function useTransferSigning(pollIntervalMs = 2e3, options) {
   return { signing, signPayload, error, signTransfer: signTransfer2 };
 }
 
-// src/auth.ts
-var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-var PHONE_DIGIT_PATTERN = /^\d{7,15}$/;
-function normalizePhoneNumber(rawValue) {
-  const trimmed = rawValue.trim();
-  if (!trimmed) return null;
-  const hasExplicitCountryCode = trimmed.startsWith("+");
-  const digits = trimmed.replace(/\D/g, "");
-  if (!PHONE_DIGIT_PATTERN.test(digits)) return null;
-  return hasExplicitCountryCode ? `+${digits}` : digits;
-}
-function normalizeAuthIdentifier(rawValue) {
-  const trimmed = rawValue.trim();
-  if (!trimmed) return null;
-  if (EMAIL_PATTERN.test(trimmed)) {
-    return {
-      kind: "email",
-      value: trimmed.toLowerCase()
-    };
-  }
-  const normalizedPhoneNumber = normalizePhoneNumber(trimmed);
-  if (normalizedPhoneNumber) {
-    return {
-      kind: "phone",
-      value: normalizedPhoneNumber
-    };
-  }
-  return null;
-}
-function maskAuthIdentifier(identifier) {
-  if (identifier.kind === "email") {
-    const [localPart, domain = ""] = identifier.value.split("@");
-    const localPrefix = localPart.slice(0, 2);
-    return `${localPrefix}${"*".repeat(Math.max(localPart.length - 2, 0))}@${domain}`;
-  }
-  const digits = identifier.value.replace(/\D/g, "");
-  const visibleSuffix = digits.slice(-4);
-  return `***-***-${visibleSuffix}`;
-}
-
-// src/processingStatus.ts
-var PROCESSING_TIMEOUT_MS = 18e4;
-function resolvePreferredTransfer(polledTransfer, localTransfer) {
-  return polledTransfer ?? localTransfer;
-}
-function getTransferStatus(polledTransfer, localTransfer) {
-  const transfer = resolvePreferredTransfer(polledTransfer, localTransfer);
-  return transfer?.status ?? "UNKNOWN";
-}
-function hasProcessingTimedOut(processingStartedAtMs, nowMs) {
-  if (!processingStartedAtMs) return false;
-  return nowMs - processingStartedAtMs >= PROCESSING_TIMEOUT_MS;
-}
-var STATUS_DISPLAY_LABELS = {
-  CREATED: "created",
-  AUTHORIZED: "authorized",
-  SENDING: "sending",
-  SENT: "confirming delivery",
-  COMPLETED: "completed",
-  FAILED: "failed"
-};
-function getStatusDisplayLabel(status) {
-  return STATUS_DISPLAY_LABELS[status] ?? status;
-}
-function buildProcessingTimeoutMessage(status) {
-  const label = getStatusDisplayLabel(status);
-  return `Payment is taking longer than expected (status: ${label}). Please try again.`;
-}
-
-// src/walletFlow.ts
-var MOBILE_USER_AGENT_PATTERN = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i;
-function isMobileUserAgent(userAgent) {
-  if (!userAgent) {
-    return false;
-  }
-  return MOBILE_USER_AGENT_PATTERN.test(userAgent);
-}
-function shouldUseWalletConnector(options) {
-  return options.useWalletConnector ?? !isMobileUserAgent(options.userAgent);
-}
-
-// src/deeplink.ts
-var IFRAME_CLEANUP_DELAY_MS = 3e3;
-var LOCATION_FALLBACK_DELAY_MS = 100;
-function triggerDeeplink(uri) {
-  try {
-    const iframe = document.createElement("iframe");
-    iframe.style.display = "none";
-    iframe.src = uri;
-    document.body.appendChild(iframe);
-    setTimeout(() => {
-      try {
-        document.body.removeChild(iframe);
-      } catch {
-      }
-    }, IFRAME_CLEANUP_DELAY_MS);
-  } catch {
-  }
-  setTimeout(() => {
-    window.location.href = uri;
-  }, LOCATION_FALLBACK_DELAY_MS);
-}
-
-// src/mobileFlow.ts
-function hasActiveWallet(accounts) {
-  return accounts.some((account) => account.wallets.some((wallet) => wallet.status === "ACTIVE"));
-}
-function resolvePostAuthStep(state) {
-  if (!state.hasPasskey) {
-    return { step: "create-passkey", clearPersistedFlow: false };
-  }
-  if (state.persistedMobileFlow) {
-    if (state.persistedMobileFlow.isReauthorization) {
-      return { step: "open-wallet", clearPersistedFlow: false };
-    }
-    if (state.persistedMobileFlow.isSetup && hasActiveWallet(state.accounts)) {
-      return { step: "deposit", clearPersistedFlow: true };
-    }
-    return { step: "open-wallet", clearPersistedFlow: false };
-  }
-  if (state.mobileSetupInProgress && !hasActiveWallet(state.accounts)) {
-    return { step: "open-wallet", clearPersistedFlow: false };
-  }
-  if ((state.accounts.length === 0 || !hasActiveWallet(state.accounts)) && !state.connectingNewAccount) {
-    return { step: "wallet-picker", clearPersistedFlow: false };
-  }
-  return { step: "deposit", clearPersistedFlow: false };
-}
-function resolveRestoredMobileFlow(transferStatus, isSetup) {
-  if (transferStatus === "AUTHORIZED") {
-    return isSetup ? { kind: "resume-setup-deposit", step: "deposit", clearPersistedFlow: true } : { kind: "resume-confirm-sign", step: "confirm-sign", clearPersistedFlow: true };
-  }
-  if (transferStatus === "COMPLETED") {
-    return { kind: "resume-success", step: "success", clearPersistedFlow: true };
-  }
-  if (transferStatus === "FAILED") {
-    return { kind: "resume-failed", step: "success", clearPersistedFlow: true };
-  }
-  if (transferStatus === "SENDING" || transferStatus === "SENT") {
-    return { kind: "resume-processing", step: "processing", clearPersistedFlow: true };
-  }
-  if (isSetup) {
-    return { kind: "resume-stale-setup", step: "wallet-picker", clearPersistedFlow: true };
-  }
-  return { kind: "resume-open-wallet", step: "open-wallet", clearPersistedFlow: false };
-}
-
-// src/dataLoading.ts
-function resolveDataLoadAction({
-  authenticated,
-  step,
-  accountsCount,
-  hasActiveCredential,
-  loading
-}) {
-  if (!authenticated || step === "login" || step === "otp-verify" || accountsCount > 0 || !hasActiveCredential) {
-    return "reset";
-  }
-  if (loading) {
-    return "wait";
-  }
-  return "load";
-}
-
 // src/paymentHelpers.ts
 var ACTIVE_CREDENTIAL_STORAGE_KEY = "swype_active_credential_id";
 var MOBILE_FLOW_STORAGE_KEY = "swype_mobile_flow";
@@ -2235,6 +2058,46 @@ function paymentReducer(state, action) {
       return state;
   }
 }
+
+// src/auth.ts
+var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var PHONE_DIGIT_PATTERN = /^\d{7,15}$/;
+function normalizePhoneNumber(rawValue) {
+  const trimmed = rawValue.trim();
+  if (!trimmed) return null;
+  const hasExplicitCountryCode = trimmed.startsWith("+");
+  const digits = trimmed.replace(/\D/g, "");
+  if (!PHONE_DIGIT_PATTERN.test(digits)) return null;
+  return hasExplicitCountryCode ? `+${digits}` : digits;
+}
+function normalizeAuthIdentifier(rawValue) {
+  const trimmed = rawValue.trim();
+  if (!trimmed) return null;
+  if (EMAIL_PATTERN.test(trimmed)) {
+    return {
+      kind: "email",
+      value: trimmed.toLowerCase()
+    };
+  }
+  const normalizedPhoneNumber = normalizePhoneNumber(trimmed);
+  if (normalizedPhoneNumber) {
+    return {
+      kind: "phone",
+      value: normalizedPhoneNumber
+    };
+  }
+  return null;
+}
+function maskAuthIdentifier(identifier) {
+  if (identifier.kind === "email") {
+    const [localPart, domain = ""] = identifier.value.split("@");
+    const localPrefix = localPart.slice(0, 2);
+    return `${localPrefix}${"*".repeat(Math.max(localPart.length - 2, 0))}@${domain}`;
+  }
+  const digits = identifier.value.replace(/\D/g, "");
+  const visibleSuffix = digits.slice(-4);
+  return `***-***-${visibleSuffix}`;
+}
 var ACCENT = "#28b67a";
 var BG_RING = "#d2e4ea";
 function SwypeLoadingScreen() {
@@ -3860,7 +3723,7 @@ var dividerTextStyle = (color) => ({
   color,
   whiteSpace: "nowrap"
 });
-var DEFAULT_MAX = 500;
+var DEFAULT_MAX = 1e7;
 var ABSOLUTE_MIN = 0.01;
 function SetupScreen({
   availableBalance,
@@ -3875,7 +3738,7 @@ function SetupScreen({
   error
 }) {
   const { tokens } = useSwypeConfig();
-  const effectiveMax = Math.min(DEFAULT_MAX, availableBalance);
+  const effectiveMax = DEFAULT_MAX;
   const effectiveMin = Math.min(ABSOLUTE_MIN, effectiveMax);
   const [limit, setLimit] = react.useState(() => Math.min(availableBalance, effectiveMax));
   const [editing, setEditing] = react.useState(false);
@@ -4251,7 +4114,8 @@ function DepositScreen({
   onSelectAccount,
   onAuthorizeAccount,
   onAddProvider,
-  onSelectToken
+  onSelectToken,
+  selectedSourceLabel
 }) {
   const { tokens } = useSwypeConfig();
   const amount = initialAmount;
@@ -4296,7 +4160,7 @@ function DepositScreen({
                 /* @__PURE__ */ jsxRuntime.jsx("text", { x: "12", y: "16", textAnchor: "middle", fontSize: "12", fill: "#fff", fontWeight: "700", children: "$" })
               ] }) }),
               /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
-                /* @__PURE__ */ jsxRuntime.jsx("div", { style: balanceLabelStyle2(tokens.textMuted), children: "Available" }),
+                /* @__PURE__ */ jsxRuntime.jsx("div", { style: balanceLabelStyle2(tokens.textMuted), children: selectedSourceLabel ?? "Available" }),
                 /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { ...balanceAmountStyle, color: tokens.warning }, children: [
                   "$",
                   availableBalance.toFixed(2)
@@ -4371,10 +4235,7 @@ function DepositScreen({
               /* @__PURE__ */ jsxRuntime.jsx("text", { x: "12", y: "16", textAnchor: "middle", fontSize: "12", fill: "#fff", fontWeight: "700", children: "$" })
             ] }) }),
             /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
-              /* @__PURE__ */ jsxRuntime.jsxs("div", { style: balanceLabelStyle2(tokens.textMuted), children: [
-                "Paying from ",
-                sourceName
-              ] }),
+              /* @__PURE__ */ jsxRuntime.jsx("div", { style: balanceLabelStyle2(tokens.textMuted), children: selectedSourceLabel ?? `Paying from ${sourceName}` }),
               /* @__PURE__ */ jsxRuntime.jsxs("div", { style: balanceAmountStyle, children: [
                 "$",
                 availableBalance.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })
@@ -4728,6 +4589,7 @@ function SelectSourceScreen({
   onChainChange,
   onTokenChange,
   onConfirm,
+  onBack,
   onLogout
 }) {
   const { tokens } = useSwypeConfig();
@@ -4746,6 +4608,7 @@ function SelectSourceScreen({
           ScreenHeader,
           {
             title: "Select Source",
+            onBack,
             right: /* @__PURE__ */ jsxRuntime.jsx(SettingsMenu, { onLogout })
           }
         ),
@@ -5168,6 +5031,28 @@ var waitHintStyle2 = (color) => ({
   color,
   margin: 0
 });
+
+// src/deeplink.ts
+var IFRAME_CLEANUP_DELAY_MS = 3e3;
+var LOCATION_FALLBACK_DELAY_MS = 100;
+function triggerDeeplink(uri) {
+  try {
+    const iframe = document.createElement("iframe");
+    iframe.style.display = "none";
+    iframe.src = uri;
+    document.body.appendChild(iframe);
+    setTimeout(() => {
+      try {
+        document.body.removeChild(iframe);
+      } catch {
+      }
+    }, IFRAME_CLEANUP_DELAY_MS);
+  } catch {
+  }
+  setTimeout(() => {
+    window.location.href = uri;
+  }, LOCATION_FALLBACK_DELAY_MS);
+}
 function OpenWalletScreen({
   walletName,
   deeplinkUri,
@@ -5613,6 +5498,7 @@ function StepRenderer({
   selectedSource,
   selectSourceChoices,
   selectSourceRecommended,
+  selectSourceAvailableBalance,
   authInput,
   otpCode,
   selectSourceChainName,
@@ -5734,17 +5620,23 @@ function StepRenderer({
     );
   }
   if (step === "setup") {
+    const selectSourceTokenCount = selectSourceChoices.reduce(
+      (sum, chain) => sum + chain.tokens.length,
+      0
+    );
+    const effectiveTokenCount = tokenCount > 0 ? tokenCount : selectSourceTokenCount;
+    const effectiveSourceLabel = selectedSourceLabel ?? (selectSourceChainName && selectSourceTokenSymbol ? `${selectSourceTokenSymbol} on ${selectSourceChainName}` : void 0);
     return /* @__PURE__ */ jsxRuntime.jsx(
       SetupScreen,
       {
-        availableBalance: selectedSource ? selectedSource.balance.available.amount : selectedAccount ? selectedAccount.wallets.reduce((sum, w) => sum + w.balance.available.amount, 0) : maxSourceBalance,
-        tokenCount,
+        availableBalance: selectedSource ? selectedSource.balance.available.amount : selectedAccount ? selectedAccount.wallets.reduce((sum, w) => sum + w.balance.available.amount, 0) : selectSourceAvailableBalance > 0 ? selectSourceAvailableBalance : maxSourceBalance,
+        tokenCount: effectiveTokenCount,
         sourceName,
         onSetupOneTap: handlers.onSetupOneTap,
         onBack: () => handlers.onNavigate("deposit"),
         onLogout: handlers.onLogout,
         onAdvanced: handlers.onSelectToken,
-        selectedSourceLabel,
+        selectedSourceLabel: effectiveSourceLabel,
         loading: savingOneTapLimit,
         error: state.error
       }
@@ -5792,7 +5684,8 @@ function StepRenderer({
         onSelectAccount: handlers.onSelectAccount,
         onAuthorizeAccount: handlers.onContinueConnection,
         onAddProvider: () => handlers.onNavigate("wallet-picker"),
-        onSelectToken: handlers.onSelectToken
+        onSelectToken: handlers.onSelectToken,
+        selectedSourceLabel
       }
     );
   }
@@ -5824,6 +5717,7 @@ function StepRenderer({
     );
   }
   if (step === "select-source") {
+    const cameFromSetup = state.previousStep === "setup";
     return /* @__PURE__ */ jsxRuntime.jsx(
       SelectSourceScreen,
       {
@@ -5833,7 +5727,8 @@ function StepRenderer({
         recommended: selectSourceRecommended,
         onChainChange: handlers.onSelectSourceChainChange,
         onTokenChange: handlers.onSetSelectSourceTokenSymbol,
-        onConfirm: handlers.onConfirmSelectSource,
+        onConfirm: cameFromSetup ? () => handlers.onNavigate("setup") : handlers.onConfirmSelectSource,
+        onBack: cameFromSetup ? () => handlers.onNavigate("setup") : void 0,
         onLogout: handlers.onLogout
       }
     );
@@ -5883,12 +5778,29 @@ function StepRenderer({
         selectedAccountId: state.selectedAccountId,
         onSelectAccount: handlers.onSelectAccount,
         onAuthorizeAccount: handlers.onContinueConnection,
-        onAddProvider: () => handlers.onNavigate("wallet-picker")
+        onAddProvider: () => handlers.onNavigate("wallet-picker"),
+        selectedSourceLabel
       }
     );
   }
   return null;
 }
+
+// src/sentry.ts
+var _mod;
+function captureException(error) {
+  if (_mod === null) return;
+  if (_mod) {
+    _mod.captureException(error);
+    return;
+  }
+  import('@sentry/react').then((m) => {
+    _mod = m;
+    m.captureException(error);
+  }).catch(() => {
+    _mod = null;
+  });
+}
 var PaymentErrorBoundary = class extends react.Component {
   constructor(props) {
     super(props);
@@ -5957,78 +5869,7 @@ var buttonStyle3 = {
   fontFamily: "inherit",
   cursor: "pointer"
 };
-function SwypePayment(props) {
-  const resetKey = react.useRef(0);
-  const handleBoundaryReset = react.useCallback(() => {
-    resetKey.current += 1;
-  }, []);
-  return /* @__PURE__ */ jsxRuntime.jsx(PaymentErrorBoundary, { onReset: handleBoundaryReset, children: /* @__PURE__ */ jsxRuntime.jsx(SwypePaymentInner, { ...props }) }, resetKey.current);
-}
-function SwypePaymentInner({
-  destination,
-  onComplete,
-  onError,
-  useWalletConnector: useWalletConnectorProp,
-  idempotencyKey,
-  merchantAuthorization,
-  merchantName,
-  onBack,
-  onDismiss,
-  autoCloseSeconds
-}) {
-  const { apiBaseUrl, depositAmount } = useSwypeConfig();
-  const { ready, authenticated, user, logout, getAccessToken } = reactAuth.usePrivy();
-  const {
-    sendCode: sendEmailCode,
-    loginWithCode: loginWithEmailCode,
-    state: emailLoginState
-  } = reactAuth.useLoginWithEmail();
-  const {
-    sendCode: sendSmsCode,
-    loginWithCode: loginWithSmsCode,
-    state: smsLoginState
-  } = reactAuth.useLoginWithSms();
-  reactAuth.useLoginWithOAuth();
-  const [state, dispatch] = react.useReducer(
-    paymentReducer,
-    {
-      depositAmount,
-      passkeyPopupNeeded: isSafari() && isInCrossOriginIframe(),
-      activeCredentialId: typeof window === "undefined" ? null : window.localStorage.getItem(ACTIVE_CREDENTIAL_STORAGE_KEY)
-    },
-    createInitialState
-  );
-  const loadingDataRef = react.useRef(false);
-  const pollingTransferIdRef = react.useRef(null);
-  const setupAccountIdRef = react.useRef(null);
-  const mobileSetupFlowRef = react.useRef(false);
-  const handlingMobileReturnRef = react.useRef(false);
-  const processingStartedAtRef = react.useRef(null);
-  const initializedSelectSourceActionRef = react.useRef(null);
-  const preSelectSourceStepRef = react.useRef(null);
-  const pendingTokenAuthRef = react.useRef(null);
-  const pendingTokenSelectionRef = react.useRef(null);
-  const pendingTokenAuthSessionRef = react.useRef(null);
-  const reauthSessionIdRef = react.useRef(null);
-  const reauthTokenRef = react.useRef(null);
-  const checkingPasskeyRef = react.useRef(false);
-  const onCompleteRef = react.useRef(onComplete);
-  onCompleteRef.current = onComplete;
-  const pollingRef = react.useRef(null);
-  const getAccessTokenRef = react.useRef(getAccessToken);
-  getAccessTokenRef.current = getAccessToken;
-  const handleAuthorizedMobileReturnRef = react.useRef(
-    null
-  );
-  const [authInput, setAuthInput] = react.useState("");
-  const [otpCode, setOtpCode] = react.useState("");
-  const [selectSourceChainName, setSelectSourceChainName] = react.useState("");
-  const [selectSourceTokenSymbol, setSelectSourceTokenSymbol] = react.useState("");
-  const [savingOneTapLimit, setSavingOneTapLimit] = react.useState(false);
-  const authExecutor = useAuthorizationExecutor();
-  const polling = useTransferPolling();
-  pollingRef.current = polling;
-  const transferSigning = useTransferSigning();
+function useDerivedState(state) {
   const { sourceType, sourceId } = deriveSourceTypeAndId(state);
   const selectedAccount = state.accounts.find((a) => a.id === state.selectedAccountId);
   const selectedWallet = selectedAccount?.wallets.find(
@@ -6078,8 +5919,36 @@ function SwypePaymentInner({
     }
     return count;
   }, [state.accounts]);
-  const activeOtpStatus = state.verificationTarget?.kind === "email" ? emailLoginState.status : state.verificationTarget?.kind === "phone" ? smsLoginState.status : "initial";
-  const activeOtpErrorMessage = state.verificationTarget?.kind === "email" && emailLoginState.status === "error" ? emailLoginState.error?.message ?? "Failed to continue with email." : state.verificationTarget?.kind === "phone" && smsLoginState.status === "error" ? smsLoginState.error?.message ?? "Failed to continue with phone number." : null;
+  return {
+    sourceType,
+    sourceId,
+    selectedAccount,
+    selectedWallet,
+    selectedSource,
+    sourceName,
+    sourceAddress,
+    sourceVerified,
+    pendingConnections,
+    depositEligibleAccounts,
+    maxSourceBalance,
+    tokenCount
+  };
+}
+function useAuthHandlers(dispatch, verificationTarget) {
+  const {
+    sendCode: sendEmailCode,
+    loginWithCode: loginWithEmailCode,
+    state: emailLoginState
+  } = reactAuth.useLoginWithEmail();
+  const {
+    sendCode: sendSmsCode,
+    loginWithCode: loginWithSmsCode,
+    state: smsLoginState
+  } = reactAuth.useLoginWithSms();
+  const [authInput, setAuthInput] = react.useState("");
+  const [otpCode, setOtpCode] = react.useState("");
+  const activeOtpStatus = verificationTarget?.kind === "email" ? emailLoginState.status : verificationTarget?.kind === "phone" ? smsLoginState.status : "initial";
+  const activeOtpErrorMessage = verificationTarget?.kind === "email" && emailLoginState.status === "error" ? emailLoginState.error?.message ?? "Failed to continue with email." : verificationTarget?.kind === "phone" && smsLoginState.status === "error" ? smsLoginState.error?.message ?? "Failed to continue with phone number." : null;
   const handleSendLoginCode = react.useCallback(async () => {
     const normalizedIdentifier = normalizeAuthIdentifier(authInput);
     if (!normalizedIdentifier) {
@@ -6101,9 +5970,9 @@ function SwypePaymentInner({
         error: err instanceof Error ? err.message : "Failed to send verification code"
       });
     }
-  }, [authInput, sendEmailCode, sendSmsCode]);
+  }, [authInput, sendEmailCode, sendSmsCode, dispatch]);
   const handleVerifyLoginCode = react.useCallback(async () => {
-    if (!state.verificationTarget) return;
+    if (!verificationTarget) return;
     const trimmedCode = otpCode.trim();
     if (!/^\d{6}$/.test(trimmedCode)) {
       dispatch({ type: "SET_ERROR", error: "Enter the 6-digit verification code." });
@@ -6111,7 +5980,7 @@ function SwypePaymentInner({
     }
     dispatch({ type: "SET_ERROR", error: null });
     try {
-      if (state.verificationTarget.kind === "email") {
+      if (verificationTarget.kind === "email") {
         await loginWithEmailCode({ code: trimmedCode });
       } else {
         await loginWithSmsCode({ code: trimmedCode });
@@ -6123,15 +5992,15 @@ function SwypePaymentInner({
         error: err instanceof Error ? err.message : "Failed to verify code"
       });
     }
-  }, [state.verificationTarget, otpCode, loginWithEmailCode, loginWithSmsCode]);
+  }, [verificationTarget, otpCode, loginWithEmailCode, loginWithSmsCode, dispatch]);
   const handleResendLoginCode = react.useCallback(async () => {
-    if (!state.verificationTarget) return;
+    if (!verificationTarget) return;
     dispatch({ type: "SET_ERROR", error: null });
     try {
-      if (state.verificationTarget.kind === "email") {
-        await sendEmailCode({ email: state.verificationTarget.value });
+      if (verificationTarget.kind === "email") {
+        await sendEmailCode({ email: verificationTarget.value });
       } else {
-        await sendSmsCode({ phoneNumber: state.verificationTarget.value });
+        await sendSmsCode({ phoneNumber: verificationTarget.value });
       }
     } catch (err) {
       captureException(err);
@@ -6140,7 +6009,68 @@ function SwypePaymentInner({
         error: err instanceof Error ? err.message : "Failed to resend code"
       });
     }
-  }, [state.verificationTarget, sendEmailCode, sendSmsCode]);
+  }, [verificationTarget, sendEmailCode, sendSmsCode, dispatch]);
+  return {
+    authInput,
+    otpCode,
+    activeOtpStatus,
+    activeOtpErrorMessage,
+    setAuthInput,
+    setOtpCode,
+    handleSendLoginCode,
+    handleVerifyLoginCode,
+    handleResendLoginCode
+  };
+}
+
+// src/mobileFlow.ts
+function hasActiveWallet(accounts) {
+  return accounts.some((account) => account.wallets.some((wallet) => wallet.status === "ACTIVE"));
+}
+function resolvePostAuthStep(state) {
+  if (!state.hasPasskey) {
+    return { step: "create-passkey", clearPersistedFlow: false };
+  }
+  if (state.persistedMobileFlow) {
+    if (state.persistedMobileFlow.isReauthorization) {
+      return { step: "open-wallet", clearPersistedFlow: false };
+    }
+    if (state.persistedMobileFlow.isSetup && hasActiveWallet(state.accounts)) {
+      return { step: "deposit", clearPersistedFlow: true };
+    }
+    return { step: "open-wallet", clearPersistedFlow: false };
+  }
+  if (state.mobileSetupInProgress && !hasActiveWallet(state.accounts)) {
+    return { step: "open-wallet", clearPersistedFlow: false };
+  }
+  if ((state.accounts.length === 0 || !hasActiveWallet(state.accounts)) && !state.connectingNewAccount) {
+    return { step: "wallet-picker", clearPersistedFlow: false };
+  }
+  return { step: "deposit", clearPersistedFlow: false };
+}
+function resolveRestoredMobileFlow(transferStatus, isSetup) {
+  if (transferStatus === "AUTHORIZED") {
+    return isSetup ? { kind: "resume-setup-deposit", step: "deposit", clearPersistedFlow: true } : { kind: "resume-confirm-sign", step: "confirm-sign", clearPersistedFlow: true };
+  }
+  if (transferStatus === "COMPLETED") {
+    return { kind: "resume-success", step: "success", clearPersistedFlow: true };
+  }
+  if (transferStatus === "FAILED") {
+    return { kind: "resume-failed", step: "success", clearPersistedFlow: true };
+  }
+  if (transferStatus === "SENDING" || transferStatus === "SENT") {
+    return { kind: "resume-processing", step: "processing", clearPersistedFlow: true };
+  }
+  if (isSetup) {
+    return { kind: "resume-stale-setup", step: "wallet-picker", clearPersistedFlow: true };
+  }
+  return { kind: "resume-open-wallet", step: "open-wallet", clearPersistedFlow: false };
+}
+
+// src/hooks/usePasskeyHandlers.ts
+function usePasskeyHandlers(dispatch, apiBaseUrl, accounts, knownCredentialIds, mobileSetupFlowRef) {
+  const { user, getAccessToken } = reactAuth.usePrivy();
+  const checkingPasskeyRef = react.useRef(false);
   const completePasskeyRegistration = react.useCallback(async (credentialId, publicKey) => {
     const token = await getAccessToken();
     if (!token) throw new Error("Not authenticated");
@@ -6149,14 +6079,14 @@ function SwypePaymentInner({
     window.localStorage.setItem(ACTIVE_CREDENTIAL_STORAGE_KEY, credentialId);
     const resolved = resolvePostAuthStep({
       hasPasskey: true,
-      accounts: state.accounts,
+      accounts,
       persistedMobileFlow: loadMobileFlowState(),
       mobileSetupInProgress: mobileSetupFlowRef.current,
       connectingNewAccount: false
     });
     if (resolved.clearPersistedFlow) clearMobileFlowState();
     dispatch({ type: "NAVIGATE", step: resolved.step });
-  }, [getAccessToken, apiBaseUrl, state.accounts]);
+  }, [getAccessToken, apiBaseUrl, accounts, mobileSetupFlowRef, dispatch]);
   const handleRegisterPasskey = react.useCallback(async () => {
     dispatch({ type: "SET_REGISTERING_PASSKEY", value: true });
     dispatch({ type: "SET_ERROR", error: null });
@@ -6180,7 +6110,7 @@ function SwypePaymentInner({
     } finally {
       dispatch({ type: "SET_REGISTERING_PASSKEY", value: false });
     }
-  }, [user, completePasskeyRegistration]);
+  }, [user, completePasskeyRegistration, dispatch]);
   const handleCreatePasskeyViaPopup = react.useCallback(async () => {
     dispatch({ type: "SET_REGISTERING_PASSKEY", value: true });
     dispatch({ type: "SET_ERROR", error: null });
@@ -6198,7 +6128,7 @@ function SwypePaymentInner({
       localStorage.setItem(ACTIVE_CREDENTIAL_STORAGE_KEY, credentialId);
       const resolved = resolvePostAuthStep({
         hasPasskey: true,
-        accounts: state.accounts,
+        accounts,
         persistedMobileFlow: loadMobileFlowState(),
         mobileSetupInProgress: mobileSetupFlowRef.current,
         connectingNewAccount: false
@@ -6214,14 +6144,14 @@ function SwypePaymentInner({
     } finally {
       dispatch({ type: "SET_REGISTERING_PASSKEY", value: false });
     }
-  }, [user, getAccessToken, apiBaseUrl, state.accounts]);
+  }, [user, getAccessToken, apiBaseUrl, accounts, mobileSetupFlowRef, dispatch]);
   const handleVerifyPasskeyViaPopup = react.useCallback(async () => {
     dispatch({ type: "SET_VERIFYING_PASSKEY", value: true });
     dispatch({ type: "SET_ERROR", error: null });
     try {
       const token = await getAccessToken();
       const matched = await findDevicePasskeyViaPopup({
-        credentialIds: state.knownCredentialIds,
+        credentialIds: knownCredentialIds,
         rpId: resolvePasskeyRpId(),
         authToken: token ?? void 0,
         apiBaseUrl
@@ -6235,7 +6165,7 @@ function SwypePaymentInner({
         }
         const resolved = resolvePostAuthStep({
           hasPasskey: true,
-          accounts: state.accounts,
+          accounts,
           persistedMobileFlow: loadMobileFlowState(),
           mobileSetupInProgress: mobileSetupFlowRef.current,
           connectingNewAccount: false
@@ -6257,44 +6187,48 @@ function SwypePaymentInner({
     } finally {
       dispatch({ type: "SET_VERIFYING_PASSKEY", value: false });
     }
-  }, [state.knownCredentialIds, getAccessToken, apiBaseUrl, state.accounts]);
+  }, [knownCredentialIds, getAccessToken, apiBaseUrl, accounts, mobileSetupFlowRef, dispatch]);
+  return {
+    handleRegisterPasskey,
+    handleCreatePasskeyViaPopup,
+    handleVerifyPasskeyViaPopup,
+    checkingPasskeyRef
+  };
+}
+function useTransferHandlers(deps) {
+  const {
+    dispatch,
+    getAccessToken,
+    apiBaseUrl,
+    depositAmount,
+    destination,
+    idempotencyKey,
+    merchantAuthorization,
+    onComplete,
+    onError,
+    polling,
+    transferSigning,
+    sourceType,
+    sourceId,
+    sourceTokenAddress,
+    activeCredentialId,
+    selectedAccountId,
+    transfer,
+    accounts
+  } = deps;
+  const processingStartedAtRef = react.useRef(null);
+  const pollingTransferIdRef = react.useRef(null);
   const reloadAccounts = react.useCallback(async () => {
     const token = await getAccessToken();
-    if (!token || !state.activeCredentialId) return;
+    if (!token || !activeCredentialId) return;
     const [accts, prov] = await Promise.all([
-      fetchAccounts(apiBaseUrl, token, state.activeCredentialId),
+      fetchAccounts(apiBaseUrl, token, activeCredentialId),
       fetchProviders(apiBaseUrl, token)
     ]);
     const parsedAmt = depositAmount != null ? depositAmount : 0;
-    const defaults = resolveDepositSelection(accts, parsedAmt, state.selectedAccountId);
+    const defaults = resolveDepositSelection(accts, parsedAmt, selectedAccountId);
     dispatch({ type: "ACCOUNTS_RELOADED", accounts: accts, providers: prov, defaults });
-  }, [getAccessToken, state.activeCredentialId, state.selectedAccountId, apiBaseUrl, depositAmount]);
-  const handleAuthorizedMobileReturn = react.useCallback(async (authorizedTransfer, isSetup) => {
-    if (handlingMobileReturnRef.current) return;
-    handlingMobileReturnRef.current = true;
-    polling.stopPolling();
-    if (isSetup) {
-      mobileSetupFlowRef.current = false;
-      clearMobileFlowState();
-      try {
-        await reloadAccounts();
-        loadingDataRef.current = false;
-        dispatch({ type: "MOBILE_SETUP_COMPLETE", transfer: authorizedTransfer });
-      } catch (err) {
-        handlingMobileReturnRef.current = false;
-        dispatch({
-          type: "SET_ERROR",
-          error: err instanceof Error ? err.message : "Wallet authorized, but we could not refresh your account yet."
-        });
-        dispatch({ type: "NAVIGATE", step: "open-wallet" });
-      }
-      return;
-    }
-    mobileSetupFlowRef.current = false;
-    clearMobileFlowState();
-    dispatch({ type: "MOBILE_SIGN_READY", transfer: authorizedTransfer });
-  }, [polling.stopPolling, reloadAccounts]);
-  handleAuthorizedMobileReturnRef.current = handleAuthorizedMobileReturn;
+  }, [getAccessToken, activeCredentialId, selectedAccountId, apiBaseUrl, depositAmount, dispatch]);
   const handlePay = react.useCallback(async (payAmount, sourceOverrides) => {
     if (isNaN(payAmount) || payAmount < MIN_SEND_AMOUNT_USD) {
       dispatch({ type: "SET_ERROR", error: `Minimum amount is $${MIN_SEND_AMOUNT_USD.toFixed(2)}.` });
@@ -6304,7 +6238,7 @@ function SwypePaymentInner({
       dispatch({ type: "SET_ERROR", error: "No account or provider selected." });
       return;
     }
-    if (!state.activeCredentialId) {
+    if (!activeCredentialId) {
       dispatch({ type: "SET_ERROR", error: "Create or verify a passkey on this device before continuing." });
       dispatch({ type: "NAVIGATE", step: "create-passkey" });
       return;
@@ -6312,10 +6246,10 @@ function SwypePaymentInner({
     dispatch({ type: "PAY_STARTED", isSetupRedirect: false });
     processingStartedAtRef.current = Date.now();
     try {
-      if (state.transfer?.status === "AUTHORIZED") {
-        const signedTransfer2 = await transferSigning.signTransfer(state.transfer.id);
+      if (transfer?.status === "AUTHORIZED") {
+        const signedTransfer2 = await transferSigning.signTransfer(transfer.id);
         dispatch({ type: "TRANSFER_SIGNED", transfer: signedTransfer2 });
-        polling.startPolling(state.transfer.id);
+        polling.startPolling(transfer.id);
         return;
       }
       const token = await getAccessToken();
@@ -6323,7 +6257,7 @@ function SwypePaymentInner({
       let effectiveSourceType = sourceOverrides?.sourceType ?? sourceType;
       let effectiveSourceId = sourceOverrides?.sourceId ?? sourceId;
       if (effectiveSourceType === "accountId") {
-        const acct = state.accounts.find((a) => a.id === effectiveSourceId);
+        const acct = accounts.find((a) => a.id === effectiveSourceId);
         const preferredWallet = acct ? getPreferredDepositWallet(acct, payAmount) : null;
         if (preferredWallet?.status === "ACTIVE") {
           effectiveSourceType = "walletId";
@@ -6332,10 +6266,11 @@ function SwypePaymentInner({
       }
       const t = await createTransfer(apiBaseUrl, token, {
         id: idempotencyKey,
-        credentialId: state.activeCredentialId,
+        credentialId: activeCredentialId,
         merchantAuthorization,
         sourceType: effectiveSourceType,
         sourceId: effectiveSourceId,
+        sourceTokenAddress,
         destination,
         amount: payAmount
       });
@@ -6355,11 +6290,7 @@ function SwypePaymentInner({
     } catch (err) {
       captureException(err);
       const msg = err instanceof Error ? err.message : "Transfer failed";
-      dispatch({
-        type: "PAY_ERROR",
-        error: msg,
-        fallbackStep: "deposit"
-      });
+      dispatch({ type: "PAY_ERROR", error: msg, fallbackStep: "deposit" });
       onError?.(msg);
     } finally {
       dispatch({ type: "PAY_ENDED" });
@@ -6367,9 +6298,10 @@ function SwypePaymentInner({
   }, [
     sourceId,
     sourceType,
-    state.activeCredentialId,
-    state.transfer,
-    state.accounts,
+    sourceTokenAddress,
+    activeCredentialId,
+    transfer,
+    accounts,
     destination,
     apiBaseUrl,
     getAccessToken,
@@ -6378,51 +6310,222 @@ function SwypePaymentInner({
     onError,
     onComplete,
     idempotencyKey,
-    merchantAuthorization
+    merchantAuthorization,
+    dispatch
   ]);
-  const handleIncreaseLimit = react.useCallback(async () => {
-    if (!state.selectedAccountId) {
-      dispatch({ type: "SET_ERROR", error: "No account selected." });
+  const handleConfirmSign = react.useCallback(async () => {
+    const t = transfer ?? polling.transfer;
+    if (!t) return;
+    try {
+      const signedTransfer = await transferSigning.signTransfer(t.id);
+      clearMobileFlowState();
+      dispatch({ type: "CONFIRM_SIGN_SUCCESS", transfer: signedTransfer });
+      polling.startPolling(t.id);
+    } catch (err) {
+      captureException(err);
+      const msg = err instanceof Error ? err.message : "Failed to sign transfer";
+      dispatch({ type: "SET_ERROR", error: msg });
+      onError?.(msg);
+    }
+  }, [transfer, polling.transfer, polling.startPolling, transferSigning, onError, dispatch]);
+  return {
+    reloadAccounts,
+    handlePay,
+    handleConfirmSign,
+    processingStartedAtRef,
+    pollingTransferIdRef
+  };
+}
+function useSourceSelectionHandlers(dispatch, authExecutor) {
+  const [selectSourceChainName, setSelectSourceChainName] = react.useState("");
+  const [selectSourceTokenSymbol, setSelectSourceTokenSymbol] = react.useState("");
+  const initializedSelectSourceActionRef = react.useRef(null);
+  const preSelectSourceStepRef = react.useRef(null);
+  const pendingSelectSourceAction = authExecutor.pendingSelectSource;
+  const selectSourceChoices = react.useMemo(() => {
+    if (!pendingSelectSourceAction) return [];
+    const options = pendingSelectSourceAction.metadata?.options ?? [];
+    return buildSelectSourceChoices(options);
+  }, [pendingSelectSourceAction]);
+  const selectSourceRecommended = react.useMemo(() => {
+    if (!pendingSelectSourceAction) return null;
+    return pendingSelectSourceAction.metadata?.recommended ?? null;
+  }, [pendingSelectSourceAction]);
+  const selectSourceAvailableBalance = react.useMemo(() => {
+    if (!pendingSelectSourceAction) return 0;
+    const options = pendingSelectSourceAction.metadata?.options ?? [];
+    const recommended = selectSourceRecommended;
+    if (recommended) {
+      const match = options.find(
+        (opt) => opt.chainName === recommended.chainName && opt.tokenSymbol === recommended.tokenSymbol
+      );
+      if (match) return Number(match.rawBalance) / Math.pow(10, match.decimals);
+    }
+    let max = 0;
+    for (const opt of options) {
+      const bal = Number(opt.rawBalance) / Math.pow(10, opt.decimals);
+      if (bal > max) max = bal;
+    }
+    return max;
+  }, [pendingSelectSourceAction, selectSourceRecommended]);
+  const handleSelectSourceChainChange = react.useCallback(
+    (chainName) => {
+      setSelectSourceChainName(chainName);
+      const chain = selectSourceChoices.find((c) => c.chainName === chainName);
+      if (!chain || chain.tokens.length === 0) return;
+      const recommendedToken = selectSourceRecommended?.chainName === chainName ? selectSourceRecommended.tokenSymbol : null;
+      const hasRecommended = !!recommendedToken && chain.tokens.some((t) => t.tokenSymbol === recommendedToken);
+      setSelectSourceTokenSymbol(
+        hasRecommended ? recommendedToken : chain.tokens[0].tokenSymbol
+      );
+    },
+    [selectSourceChoices, selectSourceRecommended]
+  );
+  const handleConfirmSelectSource = react.useCallback(() => {
+    authExecutor.resolveSelectSource({
+      chainName: selectSourceChainName,
+      tokenSymbol: selectSourceTokenSymbol
+    });
+  }, [authExecutor, selectSourceChainName, selectSourceTokenSymbol]);
+  return {
+    selectSourceChainName,
+    selectSourceTokenSymbol,
+    setSelectSourceChainName,
+    setSelectSourceTokenSymbol,
+    selectSourceChoices,
+    selectSourceRecommended,
+    selectSourceAvailableBalance,
+    handleSelectSourceChainChange,
+    handleConfirmSelectSource,
+    pendingSelectSourceAction,
+    initializedSelectSourceActionRef,
+    preSelectSourceStepRef
+  };
+}
+function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransferIdRef, stateTransfer, refs) {
+  const {
+    mobileSetupFlowRef,
+    handlingMobileReturnRef,
+    loadingDataRef
+  } = refs;
+  const handleAuthorizedMobileReturn = react.useCallback(async (authorizedTransfer, isSetup) => {
+    if (handlingMobileReturnRef.current) return;
+    handlingMobileReturnRef.current = true;
+    polling.stopPolling();
+    if (isSetup) {
+      mobileSetupFlowRef.current = false;
+      clearMobileFlowState();
+      try {
+        await reloadAccounts();
+        loadingDataRef.current = false;
+        dispatch({ type: "MOBILE_SETUP_COMPLETE", transfer: authorizedTransfer });
+      } catch (err) {
+        handlingMobileReturnRef.current = false;
+        dispatch({
+          type: "SET_ERROR",
+          error: err instanceof Error ? err.message : "Wallet authorized, but we could not refresh your account yet."
+        });
+        dispatch({ type: "NAVIGATE", step: "open-wallet" });
+      }
+      return;
+    }
+    mobileSetupFlowRef.current = false;
+    clearMobileFlowState();
+    dispatch({ type: "MOBILE_SIGN_READY", transfer: authorizedTransfer });
+  }, [polling.stopPolling, reloadAccounts, dispatch]);
+  const handleRetryMobileStatus = react.useCallback(() => {
+    dispatch({ type: "SET_ERROR", error: null });
+    handlingMobileReturnRef.current = false;
+    const currentTransfer = polling.transfer ?? stateTransfer;
+    if (currentTransfer?.status === "AUTHORIZED") {
+      void handleAuthorizedMobileReturn(currentTransfer, mobileSetupFlowRef.current);
       return;
     }
-    if (!state.activeCredentialId) {
+    const transferIdToResume = pollingTransferIdRef.current ?? currentTransfer?.id;
+    if (transferIdToResume) {
+      polling.startPolling(transferIdToResume);
+    }
+  }, [handleAuthorizedMobileReturn, polling, stateTransfer, pollingTransferIdRef, dispatch]);
+  return {
+    handleAuthorizedMobileReturn,
+    handleRetryMobileStatus
+  };
+}
+
+// src/walletFlow.ts
+var MOBILE_USER_AGENT_PATTERN = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i;
+function isMobileUserAgent(userAgent) {
+  if (!userAgent) {
+    return false;
+  }
+  return MOBILE_USER_AGENT_PATTERN.test(userAgent);
+}
+function shouldUseWalletConnector(options) {
+  return options.useWalletConnector ?? !isMobileUserAgent(options.userAgent);
+}
+
+// src/hooks/useProviderHandlers.ts
+function useProviderHandlers(deps) {
+  const {
+    dispatch,
+    getAccessToken,
+    apiBaseUrl,
+    depositAmount,
+    useWalletConnectorProp,
+    activeCredentialId,
+    selectedAccountId,
+    accounts,
+    providers,
+    authExecutor,
+    reloadAccounts,
+    onError,
+    mobileSetupFlowRef,
+    handlingMobileReturnRef,
+    setupAccountIdRef,
+    reauthSessionIdRef,
+    reauthTokenRef
+  } = deps;
+  const handleSelectProvider = react.useCallback(async (providerId) => {
+    dispatch({ type: "SELECT_PROVIDER", providerId });
+    if (!activeCredentialId) {
       dispatch({ type: "SET_ERROR", error: "Create or verify a passkey on this device before continuing." });
       dispatch({ type: "NAVIGATE", step: "create-passkey" });
       return;
     }
-    const acct = state.accounts.find((a) => a.id === state.selectedAccountId);
-    const matchedProvider = acct ? state.providers.find((p) => p.name === acct.name) : void 0;
-    if (matchedProvider) {
-      dispatch({ type: "SELECT_PROVIDER", providerId: matchedProvider.id });
+    const provider = providers.find((p) => p.id === providerId);
+    const providerName = provider?.name ?? "Wallet";
+    const isMobile = !shouldUseWalletConnector({
+      useWalletConnector: useWalletConnectorProp,
+      userAgent: typeof navigator === "undefined" ? void 0 : navigator.userAgent
+    });
+    if (isMobile) {
+      dispatch({ type: "PAY_STARTED", isSetupRedirect: true });
+    } else {
+      dispatch({ type: "PAY_STARTED", isSetupRedirect: false });
+      dispatch({ type: "NAVIGATE", step: "setup-status" });
     }
-    dispatch({ type: "SET_ERROR", error: null });
-    dispatch({ type: "SET_INCREASING_LIMIT", value: true });
     try {
       const token = await getAccessToken();
       if (!token) throw new Error("Not authenticated");
-      const session = await createAccountAuthorizationSession(
-        apiBaseUrl,
-        token,
-        state.selectedAccountId,
-        state.activeCredentialId
-      );
-      const isMobile = !shouldUseWalletConnector({
-        useWalletConnector: useWalletConnectorProp,
-        userAgent: typeof navigator === "undefined" ? void 0 : navigator.userAgent
+      const accountId = crypto.randomUUID();
+      const account = await createAccount(apiBaseUrl, token, {
+        id: accountId,
+        name: providerName,
+        credentialId: activeCredentialId,
+        providerId
       });
+      const session = account.authorizationSessions?.[0];
+      if (!session) throw new Error("No authorization session returned.");
       if (isMobile) {
         handlingMobileReturnRef.current = false;
         mobileSetupFlowRef.current = true;
-        setupAccountIdRef.current = state.selectedAccountId;
-        reauthSessionIdRef.current = session.id;
-        reauthTokenRef.current = null;
+        setupAccountIdRef.current = account.id;
         persistMobileFlowState({
-          accountId: state.selectedAccountId,
+          accountId: account.id,
           sessionId: session.id,
           deeplinkUri: session.uri,
-          providerId: matchedProvider?.id ?? null,
-          isSetup: true,
-          isReauthorization: true
+          providerId,
+          isSetup: true
         });
         dispatch({ type: "MOBILE_DEEPLINK_READY", deeplinkUri: session.uri });
         triggerDeeplink(session.uri);
@@ -6433,57 +6536,75 @@ function SwypePaymentInner({
       }
     } catch (err) {
       captureException(err);
-      const msg = err instanceof Error ? err.message : "Failed to increase limit";
-      dispatch({ type: "SET_ERROR", error: msg });
+      const msg = err instanceof Error ? err.message : "Failed to set up wallet";
+      dispatch({ type: "PAY_ERROR", error: msg, fallbackStep: "wallet-picker" });
       onError?.(msg);
     } finally {
-      dispatch({ type: "SET_INCREASING_LIMIT", value: false });
+      dispatch({ type: "PAY_ENDED" });
     }
   }, [
-    state.selectedAccountId,
-    state.activeCredentialId,
-    state.accounts,
-    state.providers,
+    activeCredentialId,
+    providers,
     apiBaseUrl,
     getAccessToken,
     authExecutor,
     useWalletConnectorProp,
     reloadAccounts,
-    onError
+    onError,
+    dispatch,
+    mobileSetupFlowRef,
+    handlingMobileReturnRef,
+    setupAccountIdRef
   ]);
-  const handleNavigateToTokenPicker = react.useCallback(() => {
-    dispatch({ type: "NAVIGATE", step: "token-picker" });
-  }, []);
-  const handleSelectAuthorizedToken = react.useCallback((walletId, tokenSymbol) => {
-    dispatch({ type: "SELECT_TOKEN", walletId, tokenSymbol });
-  }, []);
-  const handleAuthorizeToken = react.useCallback(async (_walletId, tokenAddress, chainId, tokenSymbol) => {
-    if (!state.selectedAccountId) {
+  const handleContinueConnection = react.useCallback(
+    (accountId) => {
+      const acct = accounts.find((a) => a.id === accountId);
+      if (!acct) return;
+      const matchedProvider = providers.find((p) => p.name === acct.name);
+      if (matchedProvider) {
+        handleSelectProvider(matchedProvider.id);
+      }
+    },
+    [accounts, providers, handleSelectProvider]
+  );
+  const handleSelectAccount = react.useCallback(
+    (accountId) => {
+      const acct = accounts.find((a) => a.id === accountId);
+      if (!acct) return;
+      const activeWallet = getPreferredDepositWallet(acct, depositAmount ?? 0);
+      dispatch({
+        type: "SELECT_ACCOUNT",
+        accountId,
+        walletId: activeWallet?.id ?? null
+      });
+    },
+    [accounts, depositAmount, dispatch]
+  );
+  const handleIncreaseLimit = react.useCallback(async () => {
+    if (!selectedAccountId) {
       dispatch({ type: "SET_ERROR", error: "No account selected." });
       return;
     }
-    if (!state.activeCredentialId) {
+    if (!activeCredentialId) {
       dispatch({ type: "SET_ERROR", error: "Create or verify a passkey on this device before continuing." });
       dispatch({ type: "NAVIGATE", step: "create-passkey" });
       return;
     }
-    const acct = state.accounts.find((a) => a.id === state.selectedAccountId);
-    const matchedProvider = acct ? state.providers.find((p) => p.name === acct.name) : void 0;
+    const acct = accounts.find((a) => a.id === selectedAccountId);
+    const matchedProvider = acct ? providers.find((p) => p.name === acct.name) : void 0;
     if (matchedProvider) {
       dispatch({ type: "SELECT_PROVIDER", providerId: matchedProvider.id });
     }
     dispatch({ type: "SET_ERROR", error: null });
     dispatch({ type: "SET_INCREASING_LIMIT", value: true });
-    pendingTokenAuthRef.current = { tokenAddress, chainId, tokenSymbol, walletId: _walletId };
     try {
       const token = await getAccessToken();
       if (!token) throw new Error("Not authenticated");
       const session = await createAccountAuthorizationSession(
         apiBaseUrl,
         token,
-        state.selectedAccountId,
-        state.activeCredentialId,
-        { tokenAddress, chainId }
+        selectedAccountId,
+        activeCredentialId
       );
       const isMobile = !shouldUseWalletConnector({
         useWalletConnector: useWalletConnectorProp,
@@ -6492,205 +6613,187 @@ function SwypePaymentInner({
       if (isMobile) {
         handlingMobileReturnRef.current = false;
         mobileSetupFlowRef.current = true;
-        setupAccountIdRef.current = state.selectedAccountId;
+        setupAccountIdRef.current = selectedAccountId;
         reauthSessionIdRef.current = session.id;
-        reauthTokenRef.current = { walletId: _walletId, tokenSymbol };
+        reauthTokenRef.current = null;
         persistMobileFlowState({
-          accountId: state.selectedAccountId,
+          accountId: selectedAccountId,
           sessionId: session.id,
           deeplinkUri: session.uri,
           providerId: matchedProvider?.id ?? null,
           isSetup: true,
-          isReauthorization: true,
-          reauthorizationToken: { walletId: _walletId, tokenSymbol }
+          isReauthorization: true
         });
         dispatch({ type: "MOBILE_DEEPLINK_READY", deeplinkUri: session.uri });
         triggerDeeplink(session.uri);
       } else {
-        pendingTokenAuthSessionRef.current = {
-          sessionId: session.id,
-          walletId: _walletId,
-          tokenSymbol,
-          tokenAddress,
-          chainId
-        };
-        dispatch({ type: "SELECT_TOKEN", walletId: _walletId, tokenSymbol });
-        dispatch({ type: "NAVIGATE", step: "setup" });
+        dispatch({ type: "NAVIGATE", step: "setup-status" });
+        await authExecutor.executeSessionById(session.id);
+        await reloadAccounts();
+        dispatch({ type: "NAVIGATE", step: "deposit" });
       }
     } catch (err) {
       captureException(err);
-      const msg = err instanceof Error ? err.message : "Failed to authorize token";
+      const msg = err instanceof Error ? err.message : "Failed to increase limit";
       dispatch({ type: "SET_ERROR", error: msg });
       onError?.(msg);
     } finally {
-      pendingTokenAuthRef.current = null;
       dispatch({ type: "SET_INCREASING_LIMIT", value: false });
     }
   }, [
-    state.selectedAccountId,
-    state.activeCredentialId,
-    state.accounts,
-    state.providers,
+    selectedAccountId,
+    activeCredentialId,
+    accounts,
+    providers,
     apiBaseUrl,
     getAccessToken,
     authExecutor,
     useWalletConnectorProp,
     reloadAccounts,
-    onError
+    onError,
+    dispatch,
+    mobileSetupFlowRef,
+    handlingMobileReturnRef,
+    setupAccountIdRef,
+    reauthSessionIdRef,
+    reauthTokenRef
   ]);
-  const handleConfirmSign = react.useCallback(async () => {
-    const t = state.transfer ?? polling.transfer;
-    if (!t) return;
-    try {
-      const signedTransfer = await transferSigning.signTransfer(t.id);
-      clearMobileFlowState();
-      dispatch({ type: "CONFIRM_SIGN_SUCCESS", transfer: signedTransfer });
-      polling.startPolling(t.id);
-    } catch (err) {
-      captureException(err);
-      const msg = err instanceof Error ? err.message : "Failed to sign transfer";
-      dispatch({ type: "SET_ERROR", error: msg });
-      onError?.(msg);
+  const handleNavigateToTokenPicker = react.useCallback(() => {
+    if (authExecutor.pendingSelectSource) {
+      dispatch({ type: "NAVIGATE", step: "select-source" });
+    } else {
+      dispatch({ type: "NAVIGATE", step: "token-picker" });
     }
-  }, [state.transfer, polling.transfer, polling.startPolling, transferSigning, onError]);
-  const handleRetryMobileStatus = react.useCallback(() => {
-    dispatch({ type: "SET_ERROR", error: null });
-    handlingMobileReturnRef.current = false;
-    const currentTransfer = polling.transfer ?? state.transfer;
-    if (currentTransfer?.status === "AUTHORIZED") {
-      void handleAuthorizedMobileReturn(currentTransfer, mobileSetupFlowRef.current);
+  }, [dispatch, authExecutor.pendingSelectSource]);
+  const handleSelectAuthorizedToken = react.useCallback((walletId, tokenSymbol) => {
+    dispatch({ type: "SELECT_TOKEN", walletId, tokenSymbol });
+  }, [dispatch]);
+  const handleAuthorizeToken = react.useCallback(async (_walletId, tokenAddress, chainId, tokenSymbol) => {
+    if (!selectedAccountId) {
+      dispatch({ type: "SET_ERROR", error: "No account selected." });
       return;
     }
-    const transferIdToResume = pollingTransferIdRef.current ?? currentTransfer?.id;
-    if (transferIdToResume) {
-      polling.startPolling(transferIdToResume);
-    }
-  }, [handleAuthorizedMobileReturn, polling, state.transfer]);
-  const handleSelectProvider = react.useCallback(async (providerId) => {
-    dispatch({ type: "SELECT_PROVIDER", providerId });
-    if (!state.activeCredentialId) {
+    if (!activeCredentialId) {
       dispatch({ type: "SET_ERROR", error: "Create or verify a passkey on this device before continuing." });
       dispatch({ type: "NAVIGATE", step: "create-passkey" });
       return;
     }
-    const provider = state.providers.find((p) => p.id === providerId);
-    const providerName = provider?.name ?? "Wallet";
-    const isMobile = !shouldUseWalletConnector({
-      useWalletConnector: useWalletConnectorProp,
-      userAgent: typeof navigator === "undefined" ? void 0 : navigator.userAgent
-    });
-    if (isMobile) {
-      dispatch({ type: "PAY_STARTED", isSetupRedirect: true });
-    } else {
-      dispatch({ type: "PAY_STARTED", isSetupRedirect: false });
-      dispatch({ type: "NAVIGATE", step: "setup-status" });
+    const acct = accounts.find((a) => a.id === selectedAccountId);
+    const matchedProvider = acct ? providers.find((p) => p.name === acct.name) : void 0;
+    if (matchedProvider) {
+      dispatch({ type: "SELECT_PROVIDER", providerId: matchedProvider.id });
     }
+    dispatch({ type: "SET_ERROR", error: null });
+    dispatch({ type: "SET_INCREASING_LIMIT", value: true });
     try {
       const token = await getAccessToken();
       if (!token) throw new Error("Not authenticated");
-      const accountId = crypto.randomUUID();
-      const account = await createAccount(apiBaseUrl, token, {
-        id: accountId,
-        name: providerName,
-        credentialId: state.activeCredentialId,
-        providerId
+      const session = await createAccountAuthorizationSession(
+        apiBaseUrl,
+        token,
+        selectedAccountId,
+        activeCredentialId,
+        { tokenAddress, chainId }
+      );
+      const isMobile = !shouldUseWalletConnector({
+        useWalletConnector: useWalletConnectorProp,
+        userAgent: typeof navigator === "undefined" ? void 0 : navigator.userAgent
       });
-      const session = account.authorizationSessions?.[0];
-      if (!session) throw new Error("No authorization session returned.");
       if (isMobile) {
         handlingMobileReturnRef.current = false;
         mobileSetupFlowRef.current = true;
-        setupAccountIdRef.current = account.id;
+        setupAccountIdRef.current = selectedAccountId;
+        reauthSessionIdRef.current = session.id;
+        reauthTokenRef.current = { walletId: _walletId, tokenSymbol };
         persistMobileFlowState({
-          accountId: account.id,
+          accountId: selectedAccountId,
           sessionId: session.id,
           deeplinkUri: session.uri,
-          providerId,
-          isSetup: true
+          providerId: matchedProvider?.id ?? null,
+          isSetup: true,
+          isReauthorization: true,
+          reauthorizationToken: { walletId: _walletId, tokenSymbol }
         });
         dispatch({ type: "MOBILE_DEEPLINK_READY", deeplinkUri: session.uri });
         triggerDeeplink(session.uri);
       } else {
+        dispatch({ type: "NAVIGATE", step: "setup-status" });
         await authExecutor.executeSessionById(session.id);
         await reloadAccounts();
-        dispatch({ type: "NAVIGATE", step: "deposit" });
+        dispatch({ type: "SELECT_TOKEN", walletId: _walletId, tokenSymbol });
       }
     } catch (err) {
       captureException(err);
-      const msg = err instanceof Error ? err.message : "Failed to set up wallet";
-      dispatch({ type: "PAY_ERROR", error: msg, fallbackStep: "wallet-picker" });
+      const msg = err instanceof Error ? err.message : "Failed to authorize token";
+      dispatch({ type: "SET_ERROR", error: msg });
       onError?.(msg);
     } finally {
-      dispatch({ type: "PAY_ENDED" });
+      dispatch({ type: "SET_INCREASING_LIMIT", value: false });
     }
   }, [
-    state.activeCredentialId,
-    state.providers,
+    selectedAccountId,
+    activeCredentialId,
+    accounts,
+    providers,
     apiBaseUrl,
     getAccessToken,
     authExecutor,
     useWalletConnectorProp,
     reloadAccounts,
-    onError
+    onError,
+    dispatch,
+    mobileSetupFlowRef,
+    handlingMobileReturnRef,
+    setupAccountIdRef,
+    reauthSessionIdRef,
+    reauthTokenRef
   ]);
-  const handleContinueConnection = react.useCallback(
-    (accountId) => {
-      const acct = state.accounts.find((a) => a.id === accountId);
-      if (!acct) return;
-      const matchedProvider = state.providers.find((p) => p.name === acct.name);
-      if (matchedProvider) {
-        handleSelectProvider(matchedProvider.id);
-      }
-    },
-    [state.accounts, state.providers, handleSelectProvider]
-  );
-  const handleSelectAccount = react.useCallback(
-    (accountId) => {
-      const acct = state.accounts.find((a) => a.id === accountId);
-      if (!acct) return;
-      const activeWallet = getPreferredDepositWallet(acct, depositAmount ?? 0);
-      dispatch({
-        type: "SELECT_ACCOUNT",
-        accountId,
-        walletId: activeWallet?.id ?? null
-      });
-    },
-    [state.accounts, depositAmount]
-  );
+  return {
+    handleSelectProvider,
+    handleContinueConnection,
+    handleSelectAccount,
+    handleIncreaseLimit,
+    handleNavigateToTokenPicker,
+    handleSelectAuthorizedToken,
+    handleAuthorizeToken
+  };
+}
+function useOneTapSetupHandlers(deps) {
+  const {
+    dispatch,
+    getAccessToken,
+    apiBaseUrl,
+    authExecutor,
+    selectSourceChainName,
+    selectSourceTokenSymbol
+  } = deps;
+  const [savingOneTapLimit, setSavingOneTapLimit] = react.useState(false);
+  const oneTapLimitSavedDuringSetupRef = react.useRef(false);
   const handleSetupOneTap = react.useCallback(async (limit) => {
     setSavingOneTapLimit(true);
     try {
       const token = await getAccessToken();
       if (!token) throw new Error("Not authenticated");
       await updateUserConfig(apiBaseUrl, token, { defaultAllowance: limit });
-      if (authExecutor.pendingOneTapSetup) {
-        authExecutor.resolveOneTapSetup();
-      } else if (pendingTokenAuthSessionRef.current) {
-        const pending = pendingTokenAuthSessionRef.current;
-        pendingTokenAuthSessionRef.current = null;
-        pendingTokenAuthRef.current = {
-          tokenAddress: pending.tokenAddress,
-          chainId: pending.chainId,
-          tokenSymbol: pending.tokenSymbol,
-          walletId: pending.walletId
-        };
-        dispatch({ type: "SET_INCREASING_LIMIT", value: true });
-        dispatch({ type: "NAVIGATE", step: "setup-status" });
-        try {
-          await authExecutor.executeSessionById(pending.sessionId);
-          await reloadAccounts();
-          dispatch({ type: "SELECT_TOKEN", walletId: pending.walletId, tokenSymbol: pending.tokenSymbol });
-        } catch (authErr) {
-          captureException(authErr);
-          dispatch({
-            type: "SET_ERROR",
-            error: authErr instanceof Error ? authErr.message : "Failed to authorize token"
-          });
-          dispatch({ type: "NAVIGATE", step: "deposit" });
-        } finally {
-          pendingTokenAuthRef.current = null;
-          dispatch({ type: "SET_INCREASING_LIMIT", value: false });
+      if (authExecutor.pendingSelectSource) {
+        const action = authExecutor.pendingSelectSource;
+        const recommended = action.metadata?.recommended;
+        let chainName;
+        let tokenSymbol;
+        if (selectSourceChainName && selectSourceTokenSymbol) {
+          chainName = selectSourceChainName;
+          tokenSymbol = selectSourceTokenSymbol;
+        } else {
+          const options = action.metadata?.options ?? [];
+          const choices = buildSelectSourceChoices(options);
+          chainName = recommended?.chainName ?? choices[0]?.chainName ?? "Base";
+          tokenSymbol = recommended?.tokenSymbol ?? choices[0]?.tokens[0]?.tokenSymbol ?? "USDC";
         }
+        oneTapLimitSavedDuringSetupRef.current = true;
+        authExecutor.resolveSelectSource({ chainName, tokenSymbol });
+        dispatch({ type: "NAVIGATE", step: "setup-status" });
+      } else if (authExecutor.pendingOneTapSetup) {
+        authExecutor.resolveOneTapSetup();
       } else {
         dispatch({ type: "NAVIGATE", step: "deposit" });
       }
@@ -6703,76 +6806,118 @@ function SwypePaymentInner({
     } finally {
       setSavingOneTapLimit(false);
     }
-  }, [getAccessToken, apiBaseUrl, authExecutor, reloadAccounts, onError]);
-  const handleNewPayment = react.useCallback(() => {
-    clearMobileFlowState();
-    processingStartedAtRef.current = null;
-    pollingTransferIdRef.current = null;
-    preSelectSourceStepRef.current = null;
-    pendingTokenSelectionRef.current = null;
-    pendingTokenAuthSessionRef.current = null;
-    dispatch({
-      type: "NEW_PAYMENT",
-      depositAmount,
-      firstAccountId: state.accounts.length > 0 ? state.accounts[0].id : null
-    });
-  }, [depositAmount, state.accounts]);
-  const handleLogout = react.useCallback(async () => {
-    try {
-      await logout();
-    } catch {
-    }
-    clearMobileFlowState();
-    if (typeof window !== "undefined") {
-      window.localStorage.removeItem(ACTIVE_CREDENTIAL_STORAGE_KEY);
-    }
-    polling.stopPolling();
-    preSelectSourceStepRef.current = null;
-    pendingTokenSelectionRef.current = null;
-    pendingTokenAuthSessionRef.current = null;
-    checkingPasskeyRef.current = false;
-    setAuthInput("");
-    setOtpCode("");
-    dispatch({ type: "LOGOUT", depositAmount });
-  }, [logout, polling, depositAmount]);
-  const pendingSelectSourceAction = authExecutor.pendingSelectSource;
-  const selectSourceChoices = react.useMemo(() => {
-    if (!pendingSelectSourceAction) return [];
-    const options = pendingSelectSourceAction.metadata?.options ?? [];
-    return buildSelectSourceChoices(options);
-  }, [pendingSelectSourceAction]);
-  const selectSourceRecommended = react.useMemo(() => {
-    if (!pendingSelectSourceAction) return null;
-    return pendingSelectSourceAction.metadata?.recommended ?? null;
-  }, [pendingSelectSourceAction]);
-  const handleSelectSourceChainChange = react.useCallback(
-    (chainName) => {
-      setSelectSourceChainName(chainName);
-      const chain = selectSourceChoices.find((c) => c.chainName === chainName);
-      if (!chain || chain.tokens.length === 0) return;
-      const recommendedToken = selectSourceRecommended?.chainName === chainName ? selectSourceRecommended.tokenSymbol : null;
-      const hasRecommended = !!recommendedToken && chain.tokens.some((t) => t.tokenSymbol === recommendedToken);
-      setSelectSourceTokenSymbol(
-        hasRecommended ? recommendedToken : chain.tokens[0].tokenSymbol
-      );
-    },
-    [selectSourceChoices, selectSourceRecommended]
-  );
-  const handleConfirmSelectSource = react.useCallback(() => {
-    authExecutor.resolveSelectSource({
-      chainName: selectSourceChainName,
-      tokenSymbol: selectSourceTokenSymbol
-    });
-  }, [authExecutor, selectSourceChainName, selectSourceTokenSymbol]);
+  }, [getAccessToken, apiBaseUrl, authExecutor, dispatch, selectSourceChainName, selectSourceTokenSymbol]);
+  return {
+    handleSetupOneTap,
+    savingOneTapLimit,
+    oneTapLimitSavedDuringSetupRef
+  };
+}
+
+// src/dataLoading.ts
+function resolveDataLoadAction({
+  authenticated,
+  step,
+  accountsCount,
+  hasActiveCredential,
+  loading
+}) {
+  if (!authenticated || step === "login" || step === "otp-verify" || accountsCount > 0 || !hasActiveCredential) {
+    return "reset";
+  }
+  if (loading) {
+    return "wait";
+  }
+  return "load";
+}
+
+// src/processingStatus.ts
+var PROCESSING_TIMEOUT_MS = 18e4;
+function resolvePreferredTransfer(polledTransfer, localTransfer) {
+  return polledTransfer ?? localTransfer;
+}
+function getTransferStatus(polledTransfer, localTransfer) {
+  const transfer = resolvePreferredTransfer(polledTransfer, localTransfer);
+  return transfer?.status ?? "UNKNOWN";
+}
+function hasProcessingTimedOut(processingStartedAtMs, nowMs) {
+  if (!processingStartedAtMs) return false;
+  return nowMs - processingStartedAtMs >= PROCESSING_TIMEOUT_MS;
+}
+var STATUS_DISPLAY_LABELS = {
+  CREATED: "created",
+  AUTHORIZED: "authorized",
+  SENDING: "sending",
+  SENT: "confirming delivery",
+  COMPLETED: "completed",
+  FAILED: "failed"
+};
+function getStatusDisplayLabel(status) {
+  return STATUS_DISPLAY_LABELS[status] ?? status;
+}
+function buildProcessingTimeoutMessage(status) {
+  const label = getStatusDisplayLabel(status);
+  return `Payment is taking longer than expected (status: ${label}). Please try again.`;
+}
+
+// src/hooks/usePaymentEffects.ts
+function usePaymentEffects(deps) {
+  const {
+    state,
+    dispatch,
+    ready,
+    authenticated,
+    apiBaseUrl,
+    depositAmount,
+    useWalletConnectorProp,
+    onComplete,
+    onError,
+    polling,
+    authExecutor,
+    reloadAccounts,
+    activeOtpStatus,
+    activeOtpErrorMessage,
+    otpCode,
+    handleVerifyLoginCode,
+    setAuthInput,
+    setOtpCode,
+    mobileSetupFlowRef,
+    handlingMobileReturnRef,
+    setupAccountIdRef,
+    reauthSessionIdRef,
+    reauthTokenRef,
+    loadingDataRef,
+    pollingTransferIdRef,
+    processingStartedAtRef,
+    checkingPasskeyRef,
+    pendingSelectSourceAction,
+    selectSourceChoices,
+    selectSourceRecommended,
+    setSelectSourceChainName,
+    setSelectSourceTokenSymbol,
+    initializedSelectSourceActionRef,
+    preSelectSourceStepRef,
+    oneTapLimitSavedDuringSetupRef,
+    handleAuthorizedMobileReturn
+  } = deps;
+  const { getAccessToken } = reactAuth.usePrivy();
+  const onCompleteRef = react.useRef(onComplete);
+  onCompleteRef.current = onComplete;
+  const getAccessTokenRef = react.useRef(getAccessToken);
+  getAccessTokenRef.current = getAccessToken;
+  const pollingRef = react.useRef(polling);
+  pollingRef.current = polling;
+  const handleAuthorizedMobileReturnRef = react.useRef(handleAuthorizedMobileReturn);
+  handleAuthorizedMobileReturnRef.current = handleAuthorizedMobileReturn;
   react.useEffect(() => {
     if (depositAmount != null) {
       dispatch({ type: "SYNC_AMOUNT", amount: depositAmount.toString() });
     }
-  }, [depositAmount]);
+  }, [depositAmount, dispatch]);
   react.useEffect(() => {
     if (authenticated || state.step !== "otp-verify") return;
     if (activeOtpErrorMessage) dispatch({ type: "SET_ERROR", error: activeOtpErrorMessage });
-  }, [activeOtpErrorMessage, authenticated, state.step]);
+  }, [activeOtpErrorMessage, authenticated, state.step, dispatch]);
   react.useEffect(() => {
     if (state.step === "otp-verify" && /^\d{6}$/.test(otpCode.trim()) && activeOtpStatus === "awaiting-code-input") {
       handleVerifyLoginCode();
@@ -6999,7 +7144,7 @@ function SwypePaymentInner({
     const load = async () => {
       dispatch({ type: "DATA_LOAD_START" });
       try {
-        const token = await getAccessToken();
+        const token = await getAccessTokenRef.current();
         if (!token) throw new Error("Not authenticated");
         const [prov, accts, chn] = await Promise.all([
           fetchProviders(apiBaseUrl, token),
@@ -7053,7 +7198,6 @@ function SwypePaymentInner({
     state.step,
     state.accounts.length,
     apiBaseUrl,
-    getAccessToken,
     state.activeCredentialId,
     state.selectedAccountId,
     depositAmount
@@ -7068,7 +7212,7 @@ function SwypePaymentInner({
       clearMobileFlowState();
       dispatch({ type: "TRANSFER_FAILED", transfer: polling.transfer, error: "Transfer failed." });
     }
-  }, [polling.transfer, onComplete]);
+  }, [polling.transfer, onComplete, dispatch]);
   react.useEffect(() => {
     if (state.step !== "processing") {
       processingStartedAtRef.current = null;
@@ -7094,7 +7238,7 @@ function SwypePaymentInner({
     }
     const timeoutId = window.setTimeout(handleTimeout, remainingMs);
     return () => window.clearTimeout(timeoutId);
-  }, [state.step, polling.transfer, state.transfer, polling.stopPolling, onError]);
+  }, [state.step, polling.transfer, state.transfer, polling.stopPolling, onError, dispatch, processingStartedAtRef]);
   react.useEffect(() => {
     if (!state.mobileFlow) {
       handlingMobileReturnRef.current = false;
@@ -7104,7 +7248,7 @@ function SwypePaymentInner({
     const polledTransfer = polling.transfer;
     if (!polledTransfer || polledTransfer.status !== "AUTHORIZED") return;
     void handleAuthorizedMobileReturn(polledTransfer, mobileSetupFlowRef.current);
-  }, [state.mobileFlow, polling.transfer, handleAuthorizedMobileReturn]);
+  }, [state.mobileFlow, polling.transfer, handleAuthorizedMobileReturn, handlingMobileReturnRef, mobileSetupFlowRef]);
   react.useEffect(() => {
     if (!state.mobileFlow || !mobileSetupFlowRef.current) return;
     if (state.step !== "open-wallet") return;
@@ -7175,7 +7319,18 @@ function SwypePaymentInner({
       window.clearInterval(intervalId);
       document.removeEventListener("visibilitychange", handleVisibility);
     };
-  }, [state.mobileFlow, state.step, state.activeCredentialId, apiBaseUrl, reloadAccounts]);
+  }, [
+    state.mobileFlow,
+    state.step,
+    state.activeCredentialId,
+    apiBaseUrl,
+    reloadAccounts,
+    dispatch,
+    mobileSetupFlowRef,
+    setupAccountIdRef,
+    reauthSessionIdRef,
+    reauthTokenRef
+  ]);
   react.useEffect(() => {
     if (!state.mobileFlow) return;
     if (handlingMobileReturnRef.current) return;
@@ -7189,7 +7344,14 @@ function SwypePaymentInner({
     };
     document.addEventListener("visibilitychange", handleVisibility);
     return () => document.removeEventListener("visibilitychange", handleVisibility);
-  }, [state.mobileFlow, state.transfer?.id, polling.isPolling, polling.startPolling]);
+  }, [
+    state.mobileFlow,
+    state.transfer?.id,
+    polling.isPolling,
+    polling.startPolling,
+    handlingMobileReturnRef,
+    pollingTransferIdRef
+  ]);
   react.useEffect(() => {
     if (!pendingSelectSourceAction) {
       initializedSelectSourceActionRef.current = null;
@@ -7198,20 +7360,6 @@ function SwypePaymentInner({
       return;
     }
     if (initializedSelectSourceActionRef.current === pendingSelectSourceAction.id) return;
-    const options = pendingSelectSourceAction.metadata?.options ?? [];
-    if (pendingTokenAuthRef.current) {
-      const { tokenAddress, chainId } = pendingTokenAuthRef.current;
-      const chainIdHex = `0x${chainId.toString(16)}`;
-      const match = options.find(
-        (opt) => opt.tokenAddress.toLowerCase() === tokenAddress.toLowerCase() && opt.chainId.toLowerCase() === chainIdHex.toLowerCase()
-      );
-      if (match) {
-        setSelectSourceChainName(match.chainName);
-        setSelectSourceTokenSymbol(match.tokenSymbol);
-        initializedSelectSourceActionRef.current = pendingSelectSourceAction.id;
-        return;
-      }
-    }
     const hasRecommended = !!selectSourceRecommended && selectSourceChoices.some(
       (chain) => chain.chainName === selectSourceRecommended.chainName && chain.tokens.some((t) => t.tokenSymbol === selectSourceRecommended.tokenSymbol)
     );
@@ -7226,7 +7374,14 @@ function SwypePaymentInner({
       setSelectSourceTokenSymbol("USDC");
     }
     initializedSelectSourceActionRef.current = pendingSelectSourceAction.id;
-  }, [pendingSelectSourceAction, selectSourceChoices, selectSourceRecommended]);
+  }, [
+    pendingSelectSourceAction,
+    selectSourceChoices,
+    selectSourceRecommended,
+    setSelectSourceChainName,
+    setSelectSourceTokenSymbol,
+    initializedSelectSourceActionRef
+  ]);
   react.useEffect(() => {
     if (pendingSelectSourceAction && (state.step === "processing" || state.step === "open-wallet" || state.step === "setup-status")) {
       const isDesktop = shouldUseWalletConnector({
@@ -7234,24 +7389,8 @@ function SwypePaymentInner({
         userAgent: typeof navigator === "undefined" ? void 0 : navigator.userAgent
       });
       if (isDesktop && state.step === "setup-status") {
-        const recommended = pendingSelectSourceAction.metadata?.recommended;
-        const options = pendingSelectSourceAction.metadata?.options ?? [];
-        let chainName;
-        let tokenSymbol;
-        if (pendingTokenAuthRef.current) {
-          const { tokenAddress, chainId } = pendingTokenAuthRef.current;
-          const chainIdHex = `0x${chainId.toString(16)}`;
-          const match = options.find(
-            (opt) => opt.tokenAddress.toLowerCase() === tokenAddress.toLowerCase() && opt.chainId.toLowerCase() === chainIdHex.toLowerCase()
-          );
-          chainName = match?.chainName ?? recommended?.chainName ?? "Base";
-          tokenSymbol = match?.tokenSymbol ?? recommended?.tokenSymbol ?? "USDC";
-        } else {
-          const choices = buildSelectSourceChoices(options);
-          chainName = recommended?.chainName ?? choices[0]?.chainName ?? "Base";
-          tokenSymbol = recommended?.tokenSymbol ?? choices[0]?.tokens[0]?.tokenSymbol ?? "USDC";
-        }
-        authExecutor.resolveSelectSource({ chainName, tokenSymbol });
+        preSelectSourceStepRef.current = state.step;
+        dispatch({ type: "NAVIGATE", step: "setup" });
         return;
       }
       preSelectSourceStepRef.current = state.step;
@@ -7260,75 +7399,243 @@ function SwypePaymentInner({
       dispatch({ type: "NAVIGATE", step: preSelectSourceStepRef.current ?? "processing" });
       preSelectSourceStepRef.current = null;
     }
-  }, [pendingSelectSourceAction, state.step, authExecutor, useWalletConnectorProp]);
+  }, [pendingSelectSourceAction, state.step, useWalletConnectorProp, dispatch, preSelectSourceStepRef, authExecutor]);
   const pendingOneTapSetupAction = authExecutor.pendingOneTapSetup;
   const preOneTapSetupStepRef = react.useRef(null);
   react.useEffect(() => {
     if (pendingOneTapSetupAction && state.step === "setup-status") {
-      preOneTapSetupStepRef.current = state.step;
-      reloadAccounts().then(() => {
-        dispatch({ type: "NAVIGATE", step: "setup" });
-      });
+      if (oneTapLimitSavedDuringSetupRef.current) {
+        oneTapLimitSavedDuringSetupRef.current = false;
+        authExecutor.resolveOneTapSetup();
+      } else {
+        preOneTapSetupStepRef.current = state.step;
+        reloadAccounts().then(() => {
+          dispatch({ type: "NAVIGATE", step: "setup" });
+        });
+      }
     } else if (!pendingOneTapSetupAction && state.step === "setup" && preOneTapSetupStepRef.current) {
       dispatch({ type: "NAVIGATE", step: preOneTapSetupStepRef.current });
       preOneTapSetupStepRef.current = null;
     }
-  }, [pendingOneTapSetupAction, state.step, reloadAccounts]);
+  }, [pendingOneTapSetupAction, state.step, reloadAccounts, authExecutor, dispatch, oneTapLimitSavedDuringSetupRef]);
+}
+function SwypePayment(props) {
+  const resetKey = react.useRef(0);
+  const handleBoundaryReset = react.useCallback(() => {
+    resetKey.current += 1;
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(PaymentErrorBoundary, { onReset: handleBoundaryReset, children: /* @__PURE__ */ jsxRuntime.jsx(SwypePaymentInner, { ...props }) }, resetKey.current);
+}
+function SwypePaymentInner({
+  destination,
+  onComplete,
+  onError,
+  useWalletConnector: useWalletConnectorProp,
+  idempotencyKey,
+  merchantAuthorization,
+  merchantName,
+  onBack,
+  onDismiss,
+  autoCloseSeconds
+}) {
+  const { apiBaseUrl, depositAmount } = useSwypeConfig();
+  const { ready, authenticated, logout, getAccessToken } = reactAuth.usePrivy();
+  reactAuth.useLoginWithOAuth();
+  const [state, dispatch] = react.useReducer(
+    paymentReducer,
+    {
+      depositAmount,
+      passkeyPopupNeeded: isSafari() && isInCrossOriginIframe(),
+      activeCredentialId: typeof window === "undefined" ? null : window.localStorage.getItem(ACTIVE_CREDENTIAL_STORAGE_KEY)
+    },
+    createInitialState
+  );
+  const authExecutor = useAuthorizationExecutor();
+  const polling = useTransferPolling();
+  const transferSigning = useTransferSigning();
+  const mobileFlowRefs = {
+    mobileSetupFlowRef: react.useRef(false),
+    handlingMobileReturnRef: react.useRef(false),
+    setupAccountIdRef: react.useRef(null),
+    reauthSessionIdRef: react.useRef(null),
+    reauthTokenRef: react.useRef(null),
+    loadingDataRef: react.useRef(false)
+  };
+  const derived = useDerivedState(state);
+  const auth = useAuthHandlers(dispatch, state.verificationTarget);
+  const passkey = usePasskeyHandlers(
+    dispatch,
+    apiBaseUrl,
+    state.accounts,
+    state.knownCredentialIds,
+    mobileFlowRefs.mobileSetupFlowRef
+  );
+  const transfer = useTransferHandlers({
+    dispatch,
+    getAccessToken,
+    apiBaseUrl,
+    depositAmount,
+    destination,
+    idempotencyKey,
+    merchantAuthorization,
+    onComplete,
+    onError,
+    polling,
+    transferSigning,
+    sourceType: derived.sourceType,
+    sourceId: derived.sourceId,
+    sourceTokenAddress: derived.selectedSource?.address,
+    activeCredentialId: state.activeCredentialId,
+    selectedAccountId: state.selectedAccountId,
+    transfer: state.transfer,
+    accounts: state.accounts
+  });
+  const mobileFlow = useMobileFlowHandlers(
+    dispatch,
+    polling,
+    transfer.reloadAccounts,
+    transfer.pollingTransferIdRef,
+    state.transfer,
+    mobileFlowRefs
+  );
+  const sourceSelection = useSourceSelectionHandlers(dispatch, authExecutor);
+  const provider = useProviderHandlers({
+    dispatch,
+    getAccessToken,
+    apiBaseUrl,
+    depositAmount,
+    useWalletConnectorProp,
+    activeCredentialId: state.activeCredentialId,
+    selectedAccountId: state.selectedAccountId,
+    accounts: state.accounts,
+    providers: state.providers,
+    authExecutor,
+    reloadAccounts: transfer.reloadAccounts,
+    onError,
+    mobileSetupFlowRef: mobileFlowRefs.mobileSetupFlowRef,
+    handlingMobileReturnRef: mobileFlowRefs.handlingMobileReturnRef,
+    setupAccountIdRef: mobileFlowRefs.setupAccountIdRef,
+    reauthSessionIdRef: mobileFlowRefs.reauthSessionIdRef,
+    reauthTokenRef: mobileFlowRefs.reauthTokenRef
+  });
+  const oneTapSetup = useOneTapSetupHandlers({
+    dispatch,
+    getAccessToken,
+    apiBaseUrl,
+    authExecutor,
+    selectSourceChainName: sourceSelection.selectSourceChainName,
+    selectSourceTokenSymbol: sourceSelection.selectSourceTokenSymbol
+  });
+  const handleNewPayment = react.useCallback(() => {
+    clearMobileFlowState();
+    transfer.processingStartedAtRef.current = null;
+    transfer.pollingTransferIdRef.current = null;
+    sourceSelection.preSelectSourceStepRef.current = null;
+    oneTapSetup.oneTapLimitSavedDuringSetupRef.current = false;
+    dispatch({
+      type: "NEW_PAYMENT",
+      depositAmount,
+      firstAccountId: state.accounts.length > 0 ? state.accounts[0].id : null
+    });
+  }, [depositAmount, state.accounts, transfer, sourceSelection, provider, oneTapSetup]);
+  const handleLogout = react.useCallback(async () => {
+    try {
+      await logout();
+    } catch {
+    }
+    clearMobileFlowState();
+    if (typeof window !== "undefined") {
+      window.localStorage.removeItem(ACTIVE_CREDENTIAL_STORAGE_KEY);
+    }
+    polling.stopPolling();
+    sourceSelection.preSelectSourceStepRef.current = null;
+    passkey.checkingPasskeyRef.current = false;
+    oneTapSetup.oneTapLimitSavedDuringSetupRef.current = false;
+    auth.setAuthInput("");
+    auth.setOtpCode("");
+    dispatch({ type: "LOGOUT", depositAmount });
+  }, [logout, polling, depositAmount, auth, sourceSelection, provider, passkey, oneTapSetup]);
+  usePaymentEffects({
+    state,
+    dispatch,
+    ready,
+    authenticated,
+    apiBaseUrl,
+    depositAmount,
+    useWalletConnectorProp,
+    onComplete,
+    onError,
+    polling,
+    authExecutor,
+    reloadAccounts: transfer.reloadAccounts,
+    activeOtpStatus: auth.activeOtpStatus,
+    activeOtpErrorMessage: auth.activeOtpErrorMessage,
+    otpCode: auth.otpCode,
+    handleVerifyLoginCode: auth.handleVerifyLoginCode,
+    setAuthInput: auth.setAuthInput,
+    setOtpCode: auth.setOtpCode,
+    mobileSetupFlowRef: mobileFlowRefs.mobileSetupFlowRef,
+    handlingMobileReturnRef: mobileFlowRefs.handlingMobileReturnRef,
+    setupAccountIdRef: mobileFlowRefs.setupAccountIdRef,
+    reauthSessionIdRef: mobileFlowRefs.reauthSessionIdRef,
+    reauthTokenRef: mobileFlowRefs.reauthTokenRef,
+    loadingDataRef: mobileFlowRefs.loadingDataRef,
+    pollingTransferIdRef: transfer.pollingTransferIdRef,
+    processingStartedAtRef: transfer.processingStartedAtRef,
+    checkingPasskeyRef: passkey.checkingPasskeyRef,
+    pendingSelectSourceAction: sourceSelection.pendingSelectSourceAction,
+    selectSourceChoices: sourceSelection.selectSourceChoices,
+    selectSourceRecommended: sourceSelection.selectSourceRecommended,
+    setSelectSourceChainName: sourceSelection.setSelectSourceChainName,
+    setSelectSourceTokenSymbol: sourceSelection.setSelectSourceTokenSymbol,
+    initializedSelectSourceActionRef: sourceSelection.initializedSelectSourceActionRef,
+    preSelectSourceStepRef: sourceSelection.preSelectSourceStepRef,
+    oneTapLimitSavedDuringSetupRef: oneTapSetup.oneTapLimitSavedDuringSetupRef,
+    handleAuthorizedMobileReturn: mobileFlow.handleAuthorizedMobileReturn
+  });
   const handlers = react.useMemo(() => ({
-    onSendLoginCode: handleSendLoginCode,
-    onVerifyLoginCode: handleVerifyLoginCode,
-    onResendLoginCode: handleResendLoginCode,
+    onSendLoginCode: auth.handleSendLoginCode,
+    onVerifyLoginCode: auth.handleVerifyLoginCode,
+    onResendLoginCode: auth.handleResendLoginCode,
     onBackFromOtp: () => {
-      setOtpCode("");
+      auth.setOtpCode("");
       dispatch({ type: "BACK_TO_LOGIN" });
     },
-    onRegisterPasskey: handleRegisterPasskey,
-    onCreatePasskeyViaPopup: handleCreatePasskeyViaPopup,
-    onVerifyPasskeyViaPopup: handleVerifyPasskeyViaPopup,
-    onSelectProvider: handleSelectProvider,
-    onContinueConnection: handleContinueConnection,
-    onSelectAccount: handleSelectAccount,
-    onPay: handlePay,
-    onIncreaseLimit: handleIncreaseLimit,
-    onConfirmSign: handleConfirmSign,
-    onRetryMobileStatus: handleRetryMobileStatus,
+    onRegisterPasskey: passkey.handleRegisterPasskey,
+    onCreatePasskeyViaPopup: passkey.handleCreatePasskeyViaPopup,
+    onVerifyPasskeyViaPopup: passkey.handleVerifyPasskeyViaPopup,
+    onSelectProvider: provider.handleSelectProvider,
+    onContinueConnection: provider.handleContinueConnection,
+    onSelectAccount: provider.handleSelectAccount,
+    onPay: transfer.handlePay,
+    onIncreaseLimit: provider.handleIncreaseLimit,
+    onConfirmSign: transfer.handleConfirmSign,
+    onRetryMobileStatus: mobileFlow.handleRetryMobileStatus,
     onLogout: handleLogout,
     onNewPayment: handleNewPayment,
     onNavigate: (step) => dispatch({ type: "NAVIGATE", step }),
-    onSetAuthInput: setAuthInput,
+    onSetAuthInput: auth.setAuthInput,
     onSetOtpCode: (code) => {
-      setOtpCode(code);
+      auth.setOtpCode(code);
       dispatch({ type: "SET_ERROR", error: null });
     },
-    onSelectSourceChainChange: handleSelectSourceChainChange,
-    onSetSelectSourceTokenSymbol: setSelectSourceTokenSymbol,
-    onConfirmSelectSource: handleConfirmSelectSource,
-    onSetupOneTap: handleSetupOneTap,
-    onSelectToken: handleNavigateToTokenPicker,
-    onSelectAuthorizedToken: handleSelectAuthorizedToken,
-    onAuthorizeToken: handleAuthorizeToken
+    onSelectSourceChainChange: sourceSelection.handleSelectSourceChainChange,
+    onSetSelectSourceTokenSymbol: sourceSelection.setSelectSourceTokenSymbol,
+    onConfirmSelectSource: sourceSelection.handleConfirmSelectSource,
+    onSetupOneTap: oneTapSetup.handleSetupOneTap,
+    onSelectToken: provider.handleNavigateToTokenPicker,
+    onSelectAuthorizedToken: provider.handleSelectAuthorizedToken,
+    onAuthorizeToken: provider.handleAuthorizeToken
   }), [
-    handleSendLoginCode,
-    handleVerifyLoginCode,
-    handleResendLoginCode,
-    handleRegisterPasskey,
-    handleCreatePasskeyViaPopup,
-    handleVerifyPasskeyViaPopup,
-    handleSelectProvider,
-    handleContinueConnection,
-    handleSelectAccount,
-    handlePay,
-    handleIncreaseLimit,
-    handleConfirmSign,
-    handleRetryMobileStatus,
+    auth,
+    passkey,
+    provider,
+    transfer,
+    mobileFlow,
+    sourceSelection,
+    oneTapSetup,
     handleLogout,
-    handleNewPayment,
-    handleSelectSourceChainChange,
-    handleConfirmSelectSource,
-    handleSetupOneTap,
-    handleNavigateToTokenPicker,
-    handleSelectAuthorizedToken,
-    handleAuthorizeToken
+    handleNewPayment
   ]);
   return /* @__PURE__ */ jsxRuntime.jsx(
     StepRenderer,
@@ -7336,28 +7643,29 @@ function SwypePaymentInner({
       state,
       ready,
       authenticated,
-      activeOtpStatus,
+      activeOtpStatus: auth.activeOtpStatus,
       pollingTransfer: polling.transfer,
       pollingError: polling.error,
       authExecutorError: authExecutor.error,
       transferSigningSigning: transferSigning.signing,
       transferSigningError: transferSigning.error,
-      pendingConnections,
-      depositEligibleAccounts,
-      sourceName,
-      sourceAddress,
-      sourceVerified,
-      maxSourceBalance,
-      tokenCount,
-      selectedAccount,
-      selectedSource,
-      selectSourceChoices,
-      selectSourceRecommended,
-      authInput,
-      otpCode,
-      selectSourceChainName,
-      selectSourceTokenSymbol,
-      savingOneTapLimit,
+      pendingConnections: derived.pendingConnections,
+      depositEligibleAccounts: derived.depositEligibleAccounts,
+      sourceName: derived.sourceName,
+      sourceAddress: derived.sourceAddress,
+      sourceVerified: derived.sourceVerified,
+      maxSourceBalance: derived.maxSourceBalance,
+      tokenCount: derived.tokenCount,
+      selectedAccount: derived.selectedAccount,
+      selectedSource: derived.selectedSource,
+      selectSourceChoices: sourceSelection.selectSourceChoices,
+      selectSourceRecommended: sourceSelection.selectSourceRecommended,
+      selectSourceAvailableBalance: sourceSelection.selectSourceAvailableBalance,
+      authInput: auth.authInput,
+      otpCode: auth.otpCode,
+      selectSourceChainName: sourceSelection.selectSourceChainName,
+      selectSourceTokenSymbol: sourceSelection.selectSourceTokenSymbol,
+      savingOneTapLimit: oneTapSetup.savingOneTapLimit,
       merchantName,
       onBack,
       onDismiss,