@swype-org/react-sdk 0.2.173 → 0.2.185

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var buffer = require('buffer');
 var react = require('react');
 var reactAuth = require('@privy-io/react-auth');
 var wagmi = require('wagmi');
@@ -17,6 +18,10 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var g = globalThis;
+if (typeof g.Buffer === "undefined") {
+  g.Buffer = buffer.Buffer;
+}
 
 // src/theme.ts
 var darkTheme = {
@@ -1201,7 +1206,7 @@ async function fetchTransfer(apiBaseUrl, token, transferId, authorizationSession
   if (!res.ok) await throwApiError(res);
   return await res.json();
 }
-async function signTransfer(apiBaseUrl, token, transferId, signedUserOp, authorizationSessionToken) {
+async function signTransfer(apiBaseUrl, token, transferId, signedTransfer, authorizationSessionToken) {
   if (!token && !authorizationSessionToken) {
     throw new Error("Missing auth credentials for transfer signing.");
   }
@@ -1212,7 +1217,9 @@ async function signTransfer(apiBaseUrl, token, transferId, signedUserOp, authori
       ...token ? { Authorization: `Bearer ${token}` } : {},
       ...authorizationSessionToken ? { "x-authorization-session-token": authorizationSessionToken } : {}
     },
-    body: JSON.stringify({ signedUserOp })
+    body: JSON.stringify(
+      signedTransfer.chainFamily === "svm" ? { signedTransfer } : { signedUserOp: signedTransfer }
+    )
   });
   if (!res.ok) await throwApiError(res);
   return await res.json();
@@ -1326,7 +1333,14 @@ async function probeActionCompletion(apiBaseUrl, actionId) {
   if (res.status === 422 && code === "DEPOSIT_TX_NOT_FOUND") {
     return { detected: false, reason: "not-found", status: res.status, code, message };
   }
-  if (res.status === 422 && code === "APPROVE_NOT_DETECTED") {
+  const approvalNotDetectedCodes = /* @__PURE__ */ new Set([
+    "APPROVE_NOT_DETECTED",
+    "APPROVE_SPL_NOT_DETECTED",
+    "SPL_DELEGATE_MISSING",
+    "SPL_DELEGATE_INSUFFICIENT",
+    "SPL_DELEGATE_WRONG_OWNER"
+  ]);
+  if (res.status === 422 && code && approvalNotDetectedCodes.has(code)) {
     return { detected: false, reason: "not-found", status: res.status, code, message };
   }
   if (res.status === 422 && code === "INVALID_TRANSFER_STATE") {
@@ -1354,6 +1368,8 @@ async function pollTransferTick(params) {
 }
 
 // src/hooks/useTransferPolling.ts
+var FAST_POLL_COUNT = 8;
+var FAST_POLL_INTERVAL_MS = 1e3;
 function useTransferPolling(intervalMs = 3e3, overrideGetAccessToken) {
   const { apiBaseUrl } = useBlinkConfig();
   const { getAccessToken: privyGetAccessToken } = reactAuth.usePrivy();
@@ -1361,12 +1377,15 @@ function useTransferPolling(intervalMs = 3e3, overrideGetAccessToken) {
   const [transfer, setTransfer] = react.useState(null);
   const [error, setError] = react.useState(null);
   const [isPolling, setIsPolling] = react.useState(false);
-  const intervalRef = react.useRef(null);
+  const timeoutRef = react.useRef(null);
   const transferIdRef = react.useRef(null);
+  const tickCountRef = react.useRef(0);
+  const runningRef = react.useRef(false);
   const stopPolling = react.useCallback(() => {
-    if (intervalRef.current) {
-      clearInterval(intervalRef.current);
-      intervalRef.current = null;
+    runningRef.current = false;
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
     }
     setIsPolling(false);
   }, []);
@@ -1391,16 +1410,27 @@ function useTransferPolling(intervalMs = 3e3, overrideGetAccessToken) {
       stopPolling();
     }
   }, [apiBaseUrl, getAccessToken, stopPolling]);
+  const scheduleNext = react.useCallback(() => {
+    if (!runningRef.current) return;
+    const next = tickCountRef.current < FAST_POLL_COUNT ? Math.min(FAST_POLL_INTERVAL_MS, intervalMs) : intervalMs;
+    timeoutRef.current = setTimeout(async () => {
+      tickCountRef.current += 1;
+      await poll();
+      scheduleNext();
+    }, next);
+  }, [intervalMs, poll]);
   const startPolling = react.useCallback(
     (transferId) => {
       stopPolling();
       transferIdRef.current = transferId;
+      tickCountRef.current = 0;
+      runningRef.current = true;
       setIsPolling(true);
       setError(null);
       poll();
-      intervalRef.current = setInterval(poll, intervalMs);
+      scheduleNext();
     },
-    [poll, intervalMs, stopPolling]
+    [poll, scheduleNext, stopPolling]
   );
   react.useEffect(() => () => stopPolling(), [stopPolling]);
   return { transfer, error, isPolling, startPolling, stopPolling };
@@ -1653,7 +1683,7 @@ async function resolvePermit2BatchMetadata(options) {
     approveAction = null,
     signAction,
     fetchAuthorizationSession: fetchAuthorizationSession2 = fetchAuthorizationSession,
-    sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    sleep: sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     logPrefix = "[blink-sdk][permit2-batch]",
     waitForAwaitingLimit = false
   } = options;
@@ -1693,7 +1723,7 @@ async function resolvePermit2BatchMetadata(options) {
         `SIGN_PERMIT2 metadata is incomplete for batch execution. Missing: ${missingFields.join(", ")}.`
       );
     }
-    await sleep(BATCH_SIGN_PERMIT2_POLL_MS);
+    await sleep2(BATCH_SIGN_PERMIT2_POLL_MS);
     const refreshedSession = await fetchAuthorizationSession2(apiBaseUrl, sessionId);
     const refreshedSignAction = refreshedSession.actions.find((action) => action.id === signAction.id);
     if (!refreshedSignAction) {
@@ -1747,7 +1777,7 @@ function isTxSettlementTimeoutError(err) {
 async function waitForTransactionReceipt(walletClient, txHash, logContext, options = {}) {
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_TX_RECEIPT_POLL_INTERVAL_MS;
   const maxAttempts = options.maxAttempts ?? DEFAULT_TX_RECEIPT_MAX_ATTEMPTS;
-  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const sleep2 = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   const info = options.logger?.info ?? ((message) => console.info(message));
   const warn = options.logger?.warn ?? ((message) => console.warn(message));
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
@@ -1767,7 +1797,7 @@ async function waitForTransactionReceipt(walletClient, txHash, logContext, optio
         `[blink-sdk][tx-receipt] eth_getTransactionReceipt errored; will retry. context=${logContext}, txHash=${txHash}, error=${err instanceof Error ? err.message : String(err)}`
       );
     }
-    await sleep(pollIntervalMs);
+    await sleep2(pollIntervalMs);
   }
   const waitedMs = pollIntervalMs * maxAttempts;
   if (options.strict) {
@@ -1810,7 +1840,7 @@ function parseNonce(raw) {
 async function waitForNonceAdvance(walletClient, sender, expectedMinNonce, logContext, options = {}) {
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_TX_RECEIPT_POLL_INTERVAL_MS;
   const maxAttempts = options.maxAttempts ?? DEFAULT_TX_RECEIPT_MAX_ATTEMPTS;
-  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const sleep2 = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   const info = options.logger?.info ?? ((message) => console.info(message));
   const warn = options.logger?.warn ?? ((message) => console.warn(message));
   let lastObservedNonce = null;
@@ -1829,7 +1859,7 @@ async function waitForNonceAdvance(walletClient, sender, expectedMinNonce, logCo
         `[blink-sdk][tx-nonce] eth_getTransactionCount errored; will retry. context=${logContext}, sender=${sender}, error=${err instanceof Error ? err.message : String(err)}`
       );
     }
-    await sleep(pollIntervalMs);
+    await sleep2(pollIntervalMs);
   }
   const waitedMs = pollIntervalMs * maxAttempts;
   throw new TxSettlementTimeoutError({
@@ -1852,7 +1882,7 @@ async function waitForTransactionSettled(params) {
     logContext,
     pollIntervalMs,
     maxAttempts,
-    sleep,
+    sleep: sleep2,
     logger
   } = params;
   const expectedMinNonce = preSendNonce + 1;
@@ -1867,7 +1897,7 @@ async function waitForTransactionSettled(params) {
       await waitForTransactionReceipt(walletClient, txHash, logContext, {
         pollIntervalMs: resolvedPollIntervalMs,
         maxAttempts: resolvedMaxAttempts,
-        sleep,
+        sleep: sleep2,
         logger: sharedLogger,
         strict: true
       });
@@ -1889,7 +1919,7 @@ async function waitForTransactionSettled(params) {
         {
           pollIntervalMs: resolvedPollIntervalMs,
           maxAttempts: resolvedMaxAttempts,
-          sleep,
+          sleep: sleep2,
           logger: sharedLogger
         }
       );
@@ -1927,13 +1957,13 @@ async function waitForWalletNonceAgreement(params) {
     pollIntervalMs,
     maxAttempts,
     minWaitMs,
-    sleep,
+    sleep: sleep2,
     logger
   } = params;
   const resolvedPollIntervalMs = pollIntervalMs ?? DEFAULT_WALLET_NONCE_AGREEMENT_POLL_INTERVAL_MS;
   const resolvedMaxAttempts = maxAttempts ?? DEFAULT_WALLET_NONCE_AGREEMENT_MAX_ATTEMPTS;
   const resolvedMinWaitMs = minWaitMs ?? DEFAULT_WALLET_NONCE_AGREEMENT_MIN_WAIT_MS;
-  const resolvedSleep = sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const resolvedSleep = sleep2 ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   const info = logger?.info ?? ((message) => console.info(message));
   const warn = logger?.warn ?? ((message) => console.warn(message));
   const startedAt = Date.now();
@@ -1995,6 +2025,7 @@ var DEFAULT_POLL_INTERVAL_MS = 2e3;
 var DEFAULT_MAX_ATTEMPTS = 60;
 var DEFAULT_REQUEST_TIMEOUT_MS = 8e3;
 var DEFAULT_MAX_CONSECUTIVE_ERRORS = 5;
+var DEFAULT_ERROR_GRACE_PERIOD_MS = 6e4;
 var DEFAULT_LOG_EVERY_N_ATTEMPTS = 5;
 function classifyCallsStatus(status) {
   if (typeof status === "number") {
@@ -2016,15 +2047,18 @@ async function pollWalletCallsStatus(walletClient, callsId, options = {}) {
   const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
   const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
   const maxConsecutiveErrors = options.maxConsecutiveErrors ?? DEFAULT_MAX_CONSECUTIVE_ERRORS;
+  const errorGracePeriodMs = options.errorGracePeriodMs ?? DEFAULT_ERROR_GRACE_PERIOD_MS;
   const logEveryN = Math.max(1, options.logEveryNAttempts ?? DEFAULT_LOG_EVERY_N_ATTEMPTS);
-  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const sleep2 = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const now = options.now ?? (() => Date.now());
   const info = options.logger?.info ?? ((m) => console.info(m));
   const warn = options.logger?.warn ?? ((m) => console.warn(m));
   const error = options.logger?.error ?? ((m) => console.error(m));
+  const pollStartedAt = now();
   let consecutiveErrors = 0;
   let lastStatus;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    await sleep(pollIntervalMs);
+    await sleep2(pollIntervalMs);
     let status;
     try {
       status = await withTimeout(
@@ -2040,9 +2074,15 @@ async function pollWalletCallsStatus(walletClient, callsId, options = {}) {
       consecutiveErrors += 1;
       const message = err instanceof Error ? err.message : String(err);
       const isTimeout = err instanceof PromiseTimeoutError;
+      const elapsedMs = now() - pollStartedAt;
+      const inGracePeriod = elapsedMs < errorGracePeriodMs;
       warn(
-        `[blink-sdk][batch-wallet-calls] wallet_getCallsStatus errored. callsId=${callsId}, attempt=${attempt}, consecutiveErrors=${consecutiveErrors}, isTimeout=${isTimeout}, error=${message}`
+        `[blink-sdk][batch-wallet-calls] wallet_getCallsStatus errored. callsId=${callsId}, attempt=${attempt}, consecutiveErrors=${consecutiveErrors}, isTimeout=${isTimeout}, inGracePeriod=${inGracePeriod}, elapsedMs=${elapsedMs}, error=${message}`
       );
+      if (inGracePeriod) {
+        consecutiveErrors = 0;
+        continue;
+      }
       if (consecutiveErrors >= maxConsecutiveErrors) {
         error(
           `[blink-sdk][batch-wallet-calls] Aborting poll after ${consecutiveErrors} consecutive errors. callsId=${callsId}, attempt=${attempt}, lastError=${message}`
@@ -2200,6 +2240,10 @@ function buildTargetMatchers(target) {
       aliases.add("rabby");
       aliases.add("io.rabby");
     }
+    if (value.includes("phantom")) {
+      aliases.add("phantom");
+      aliases.add("app.phantom");
+    }
     if (value.includes("injected")) {
       aliases.add("injected");
     }
@@ -2237,6 +2281,252 @@ function resolveWalletConnector(connectors, target) {
   return metaMaskConnector ?? connectors[0];
 }
 
+// src/solanaWalletRuntime.ts
+function asSigner(adapter) {
+  return adapter;
+}
+var PHANTOM_SOLANA_CONNECT_TIMEOUT_MESSAGE = "PHANTOM_SOLANA_CONNECT_TIMEOUT";
+var APPROVE_SPL_CONFIRMATION_TIMEOUT_MESSAGE = "APPROVE_SPL_CONFIRMATION_TIMEOUT";
+var APPROVE_SPL_ONCHAIN_FAILURE_PREFIX = "Solana transaction failed:";
+var DEFAULT_CONFIRM_TIMEOUT_MS = 45e3;
+var DEFAULT_POLL_INTERVAL_MS2 = 1e3;
+var DEFAULT_COMMITMENT = "confirmed";
+var cachedAdapter = null;
+var cachedProviderKey = null;
+function providerKey(selection) {
+  const providerName = selection.providerName?.trim();
+  if (!providerName) {
+    throw new Error("Solana wallet metadata is missing providerName.");
+  }
+  return `${selection.providerId ?? ""}:${providerName.toLowerCase()}`;
+}
+function assertSupportedProvider(selection) {
+  const name = selection.providerName?.trim().toLowerCase();
+  if (name !== "phantom") {
+    throw new Error(`Unsupported Solana wallet provider: ${selection.providerName ?? "unknown"}.`);
+  }
+}
+async function createAdapter(selection) {
+  assertSupportedProvider(selection);
+  const { PhantomWalletAdapter } = await import('@solana/wallet-adapter-phantom');
+  return new PhantomWalletAdapter();
+}
+function readPublicKey(adapter) {
+  const publicKey = adapter.publicKey?.toBase58();
+  if (!publicKey) {
+    throw new Error("Solana wallet did not return a public key.");
+  }
+  return publicKey;
+}
+async function connectSolanaWallet(selection, options) {
+  const key = providerKey(selection);
+  if (!cachedAdapter || cachedProviderKey !== key) {
+    cachedAdapter = await createAdapter(selection);
+    cachedProviderKey = key;
+  }
+  if (!cachedAdapter.connected) {
+    const adapter = cachedAdapter;
+    const connectPromise = adapter.connect();
+    const timeoutMs = options?.timeoutMs;
+    if (typeof timeoutMs === "number" && timeoutMs > 0) {
+      let timeoutHandle = null;
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+          reject(new Error(PHANTOM_SOLANA_CONNECT_TIMEOUT_MESSAGE));
+        }, timeoutMs);
+      });
+      try {
+        await Promise.race([connectPromise, timeoutPromise]);
+      } finally {
+        if (timeoutHandle) clearTimeout(timeoutHandle);
+      }
+    } else {
+      await connectPromise;
+    }
+  }
+  return {
+    adapter: cachedAdapter,
+    publicKey: readPublicKey(cachedAdapter)
+  };
+}
+async function signSolanaTransaction(selection, unsignedTxBase64, expectedOwnerPubkey) {
+  const { adapter, publicKey } = await connectSolanaWallet(selection);
+  if (publicKey !== expectedOwnerPubkey) {
+    throw new Error(
+      `Connected Solana wallet ${publicKey} does not match the required source wallet ${expectedOwnerPubkey}. Please switch accounts in Phantom and retry.`
+    );
+  }
+  const signer = asSigner(adapter);
+  if (typeof signer.signTransaction !== "function") {
+    throw new Error("Selected Solana wallet does not support transaction signing.");
+  }
+  const transaction = await deserializeTransaction(unsignedTxBase64);
+  const signedTransaction = await signer.signTransaction(transaction);
+  return {
+    ownerPubkey: publicKey,
+    signedTxBase64: bytesToBase64(serializeTransaction(signedTransaction))
+  };
+}
+async function supportsSignAllSolanaTransactions(selection) {
+  const { adapter } = await connectSolanaWallet(selection);
+  return typeof asSigner(adapter).signAllTransactions === "function";
+}
+async function signAllSolanaTransactions(selection, unsignedTxsBase64, expectedOwnerPubkey) {
+  if (!Array.isArray(unsignedTxsBase64) || unsignedTxsBase64.length === 0) {
+    throw new Error("signAllSolanaTransactions requires at least one unsigned transaction.");
+  }
+  const { adapter, publicKey } = await connectSolanaWallet(selection);
+  if (publicKey !== expectedOwnerPubkey) {
+    throw new Error(
+      `Connected Solana wallet ${publicKey} does not match the required source wallet ${expectedOwnerPubkey}. Please switch accounts in Phantom and retry.`
+    );
+  }
+  const signer = asSigner(adapter);
+  if (typeof signer.signAllTransactions !== "function") {
+    throw new Error("Selected Solana wallet does not support signAllTransactions.");
+  }
+  const transactions = [];
+  for (const txBase64 of unsignedTxsBase64) {
+    transactions.push(await deserializeTransaction(txBase64));
+  }
+  const signed = await signer.signAllTransactions(transactions);
+  if (!Array.isArray(signed) || signed.length !== transactions.length) {
+    throw new Error(
+      `signAllTransactions returned ${Array.isArray(signed) ? signed.length : "non-array"} transactions; expected ${transactions.length}.`
+    );
+  }
+  return {
+    ownerPubkey: publicKey,
+    signedTxsBase64: signed.map((tx) => bytesToBase64(serializeTransaction(tx)))
+  };
+}
+async function deserializeTransaction(unsignedTxBase64) {
+  const { Transaction, VersionedTransaction } = await import('@solana/web3.js');
+  const bytes = base64ToBytes(unsignedTxBase64);
+  try {
+    return Transaction.from(bytes);
+  } catch {
+    return VersionedTransaction.deserialize(bytes);
+  }
+}
+function serializeTransaction(transaction) {
+  if ("version" in transaction) {
+    return transaction.serialize();
+  }
+  return transaction.serialize({
+    requireAllSignatures: false,
+    verifySignatures: false
+  });
+}
+function base64ToBytes(value) {
+  if (typeof globalThis.atob === "function") {
+    const binary = globalThis.atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+  const bufferCtor = globalThis.Buffer;
+  if (bufferCtor) {
+    return bufferCtor.from(value, "base64");
+  }
+  throw new Error("Base64 decoding is not available in this environment.");
+}
+function bytesToBase64(bytes) {
+  if (typeof globalThis.btoa === "function") {
+    let binary = "";
+    for (const byte of bytes) {
+      binary += String.fromCharCode(byte);
+    }
+    return globalThis.btoa(binary);
+  }
+  const bufferCtor = globalThis.Buffer;
+  if (bufferCtor) {
+    return bufferCtor.from(bytes).toString("base64");
+  }
+  throw new Error("Base64 encoding is not available in this environment.");
+}
+async function signAndSendApproveSplViaWallet(params) {
+  const rpcUrl = params.rpcUrl?.trim();
+  if (!rpcUrl) {
+    throw new Error("signAndSendApproveSplViaWallet requires an rpcUrl.");
+  }
+  const unsignedTxBase64 = params.unsignedTxBase64?.trim();
+  if (!unsignedTxBase64) {
+    throw new Error("signAndSendApproveSplViaWallet requires unsignedTxBase64.");
+  }
+  const commitment = params.commitment ?? DEFAULT_COMMITMENT;
+  const { adapter, publicKey } = await connectSolanaWallet(params.selection);
+  if (publicKey !== params.expectedOwnerPubkey) {
+    throw new Error(
+      `Connected Solana wallet ${publicKey} does not match the required source wallet ${params.expectedOwnerPubkey}. Please switch accounts in Phantom and retry.`
+    );
+  }
+  if (!adapter.sendTransaction) {
+    throw new Error("Selected Solana wallet does not support sendTransaction.");
+  }
+  const transaction = await deserializeTransaction(unsignedTxBase64);
+  const connection = await defaultConnectionFactory(rpcUrl, commitment);
+  const signature = await adapter.sendTransaction(
+    transaction,
+    connection,
+    {
+      preflightCommitment: commitment,
+      maxRetries: 3
+    }
+  );
+  return { ownerPubkey: publicKey, signature };
+}
+async function confirmApproveSplViaPolling(params) {
+  const rpcUrl = params.rpcUrl?.trim();
+  if (!rpcUrl) {
+    throw new Error("confirmApproveSplViaPolling requires an rpcUrl.");
+  }
+  const signature = params.signature?.trim();
+  if (!signature) {
+    throw new Error("confirmApproveSplViaPolling requires a signature.");
+  }
+  const confirmTimeoutMs = params.confirmTimeoutMs ?? DEFAULT_CONFIRM_TIMEOUT_MS;
+  const pollIntervalMs = params.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS2;
+  const commitment = params.commitment ?? DEFAULT_COMMITMENT;
+  const connection = await defaultConnectionFactory(rpcUrl, commitment);
+  const slot = await pollForConfirmation({
+    connection,
+    signature,
+    confirmTimeoutMs,
+    pollIntervalMs
+  });
+  return { signature, slot };
+}
+async function defaultConnectionFactory(rpcUrl, commitment) {
+  const { Connection } = await import('@solana/web3.js');
+  return new Connection(rpcUrl, commitment);
+}
+async function pollForConfirmation(args) {
+  const { connection, signature, confirmTimeoutMs, pollIntervalMs } = args;
+  const expiresAt = Date.now() + confirmTimeoutMs;
+  while (Date.now() <= expiresAt) {
+    const result = await connection.getSignatureStatuses(
+      [signature],
+      { searchTransactionHistory: true }
+    );
+    const status = result.value[0];
+    if (status?.err) {
+      throw new Error(`${APPROVE_SPL_ONCHAIN_FAILURE_PREFIX} ${JSON.stringify(status.err)}`);
+    }
+    const confirmationStatus = status?.confirmationStatus;
+    if (confirmationStatus === "confirmed" || confirmationStatus === "finalized") {
+      return status?.slot;
+    }
+    await sleep(pollIntervalMs);
+  }
+  throw new Error(APPROVE_SPL_CONFIRMATION_TIMEOUT_MESSAGE);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 // src/hooks/authorizationExecutor.ts
 var WALLET_CLIENT_MAX_ATTEMPTS = 25;
 var WALLET_CLIENT_POLL_MS = 400;
@@ -2248,6 +2538,7 @@ var EXECUTE_BRIDGE_TX_TIMEOUT_MS = 12e4;
 var EXECUTE_BRIDGE_TX_TIMEOUT_MESSAGE = "EXECUTE_BRIDGE_TX_TIMEOUT";
 var WALLET_PROMPT_TIMEOUT_MS = 9e4;
 var WALLET_PROMPT_TIMEOUT_MESSAGE = "WALLET_PROMPT_TIMEOUT";
+var PHANTOM_SOLANA_CONNECT_TIMEOUT_MS = 8e3;
 var BATCH_RECEIPT_POLL_INTERVAL_MS = 1500;
 var BATCH_RECEIPT_MAX_ATTEMPTS = 20;
 var BATCHABLE_ACTION_TYPES = /* @__PURE__ */ new Set(["APPROVE_PERMIT2", "SIGN_PERMIT2", "EXECUTE_BRIDGE"]);
@@ -2361,13 +2652,110 @@ function parseSignTypedDataPayload(typedData) {
   };
 }
 function isBatchableAction(action) {
+  if (action.type === "EXECUTE_BRIDGE" && action.metadata?.chainFamily === "svm") {
+    return false;
+  }
   return BATCHABLE_ACTION_TYPES.has(action.type);
 }
+function isSvmCombinedFirstTransferPair(pending) {
+  if (pending.length < 2) return false;
+  const [first, second] = pending;
+  if (first.type !== "APPROVE_SPL") return false;
+  if (second.type !== "EXECUTE_BRIDGE") return false;
+  if (second.metadata?.chainFamily !== "svm") return false;
+  if (first.metadata?.awaitingLimit) return false;
+  const approveTx = first.metadata?.unsignedApproveTxBase64;
+  const bridgeTx = second.metadata?.unsignedTxBase64;
+  if (typeof approveTx !== "string" || approveTx.trim() === "") return false;
+  if (typeof bridgeTx !== "string" || bridgeTx.trim() === "") return false;
+  const approveOwner = first.metadata?.ownerPubkey;
+  const bridgeOwner = second.metadata?.ownerPubkey ?? second.metadata?.senderAddress;
+  if (typeof approveOwner !== "string" || approveOwner.trim() === "") return false;
+  if (typeof bridgeOwner !== "string" || bridgeOwner.trim() === "") return false;
+  if (approveOwner !== bridgeOwner) return false;
+  return true;
+}
+function getSolanaWalletSelection(action) {
+  const providerName = action.metadata?.providerName;
+  if (typeof providerName !== "string" || providerName.trim() === "") {
+    throw new Error(`${action.type} metadata is missing providerName.`);
+  }
+  const providerId = action.metadata?.providerId;
+  return {
+    ...typeof providerId === "string" && providerId.trim() !== "" ? { providerId } : {},
+    providerName
+  };
+}
+function isPhantomEvmProviderAvailable() {
+  if (typeof window === "undefined") return false;
+  const phantom = window.phantom;
+  return Boolean(phantom?.ethereum?.isPhantom);
+}
+async function phantomEvmHasAuthorizedAccount() {
+  if (typeof window === "undefined") return false;
+  const provider = window.phantom?.ethereum;
+  if (!provider?.isPhantom) return false;
+  try {
+    const accounts = await provider.request({ method: "eth_accounts" });
+    return Array.isArray(accounts) && accounts.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function attemptPhantomEvmConnect(connectors, connectAsync) {
+  let connector = resolveWalletConnector(connectors, { providerName: "Phantom" });
+  if (!connector) {
+    const ethereum = typeof window !== "undefined" ? window.ethereum : void 0;
+    if (ethereum?.isPhantom) {
+      connector = resolveWalletConnector(connectors, { wagmiConnectorId: "injected" });
+    }
+  }
+  if (!connector) return null;
+  const result = await connectAsync({ connector });
+  const address = result.accounts[0];
+  if (!address) return null;
+  return { address, chainId: result.chainId };
+}
 function getPendingActions(session, completedIds) {
   return session.actions.filter((a) => a.status === "PENDING" && !completedIds.has(a.id)).sort((a, b) => a.orderIndex - b.orderIndex);
 }
 async function executeOpenProvider(action, wagmiConfig2, connectors, connectAsync) {
   try {
+    if (action.metadata?.chainFamily === "svm") {
+      const selection = getSolanaWalletSelection(action);
+      const evmProbed = isPhantomEvmProviderAvailable() && await phantomEvmHasAuthorizedAccount();
+      const svmPromise = connectSolanaWallet(selection, {
+        timeoutMs: evmProbed ? PHANTOM_SOLANA_CONNECT_TIMEOUT_MS : void 0
+      });
+      const evmPromise = evmProbed ? attemptPhantomEvmConnect(connectors, connectAsync) : Promise.resolve(null);
+      const [svmSettled, evmSettled] = await Promise.allSettled([svmPromise, evmPromise]);
+      const svmPublicKey = svmSettled.status === "fulfilled" ? svmSettled.value.publicKey : null;
+      const evmAddress = evmSettled.status === "fulfilled" && evmSettled.value ? evmSettled.value.address : null;
+      if (!svmPublicKey && !evmAddress) {
+        const svmReason = svmSettled.status === "rejected" ? svmSettled.reason instanceof Error ? svmSettled.reason.message : String(svmSettled.reason) : "Failed to connect Phantom.";
+        const friendlyMsg = svmReason === PHANTOM_SOLANA_CONNECT_TIMEOUT_MESSAGE ? "Phantom did not respond. Please try again." : svmReason;
+        return actionError(
+          action,
+          isUserRejection(friendlyMsg) ? "You rejected the Solana wallet connection request. Please connect Phantom to continue." : friendlyMsg
+        );
+      }
+      if (evmAddress) {
+        await refreshWalletCapabilities(wagmiConfig2, "open-provider:phantom-dual");
+      }
+      const messageParts = [];
+      if (svmPublicKey) messageParts.push(`SVM: ${svmPublicKey}`);
+      if (evmAddress) messageParts.push(`EVM: ${evmAddress}`);
+      return actionSuccess(
+        action,
+        `Connected to ${selection.providerName}. ${messageParts.join(", ")}`,
+        {
+          accounts: svmPublicKey ? [svmPublicKey, ...evmAddress ? [evmAddress] : []] : evmAddress ? [evmAddress] : [],
+          chainFamily: "svm",
+          ...svmPublicKey ? { userSolanaWalletPubkey: svmPublicKey } : {},
+          ...evmAddress ? { evmAddress } : {}
+        }
+      );
+    }
     const account = core.getAccount(wagmiConfig2);
     const targetId = action.metadata?.wagmiConnectorId;
     const connector = resolveWalletConnector(connectors, { wagmiConnectorId: targetId });
@@ -2493,9 +2881,16 @@ async function executeOpenProvider(action, wagmiConfig2, connectors, connectAsyn
       { accounts: [...result.accounts], chainId: hexChainId }
     );
   } catch (err) {
+    const msg = err instanceof Error ? err.message : "Failed to connect wallet";
+    if (action.metadata?.chainFamily === "svm") {
+      return actionError(
+        action,
+        isUserRejection(msg) ? "You rejected the Solana wallet connection request. Please connect Phantom to continue." : msg
+      );
+    }
     return actionError(
       action,
-      err instanceof Error ? err.message : "Failed to connect wallet"
+      msg
     );
   }
 }
@@ -2573,6 +2968,334 @@ async function executeSwitchChain(action, wagmiConfig2, switchChainAsync) {
     );
   }
 }
+async function executeApproveSplSolana(action, options) {
+  try {
+    const selection = getSolanaWalletSelection(action);
+    const ownerPubkey = action.metadata?.ownerPubkey;
+    const unsignedApproveTxBase64 = action.metadata?.unsignedApproveTxBase64;
+    const tokenSymbol = action.metadata?.tokenSymbol;
+    const clientRpcUrl = action.metadata?.clientRpcUrl;
+    if (action.metadata?.awaitingLimit) {
+      return actionError(
+        action,
+        "APPROVE_SPL action is still waiting for a One-Tap allowance amount."
+      );
+    }
+    if (typeof ownerPubkey !== "string" || ownerPubkey.trim() === "") {
+      return actionError(action, "APPROVE_SPL metadata is missing ownerPubkey.");
+    }
+    if (typeof unsignedApproveTxBase64 !== "string" || unsignedApproveTxBase64.trim() === "") {
+      return actionError(
+        action,
+        "APPROVE_SPL metadata is missing unsignedApproveTxBase64."
+      );
+    }
+    appendDebug("info", "APPROVE_SPL: entry", {
+      actionId: action.id,
+      ownerPubkey,
+      tokenSymbol: typeof tokenSymbol === "string" ? tokenSymbol : null
+    });
+    if (typeof clientRpcUrl === "string" && clientRpcUrl.trim() !== "") {
+      const sendLabel = "APPROVE_SPL signAndSendApproveSplViaWallet";
+      const sent = await withWatchdog(
+        withTimeout(
+          signAndSendApproveSplViaWallet({
+            selection,
+            unsignedTxBase64: unsignedApproveTxBase64,
+            expectedOwnerPubkey: ownerPubkey,
+            rpcUrl: clientRpcUrl
+          }),
+          WALLET_PROMPT_TIMEOUT_MS,
+          sendLabel
+        ),
+        sendLabel
+      );
+      appendDebug("info", "APPROVE_SPL: tx submitted via wallet", {
+        actionId: action.id,
+        signature: sent.signature
+      });
+      try {
+        options?.onConfirming?.(action);
+      } catch (callbackErr) {
+        appendDebug("warn", "APPROVE_SPL: onConfirming callback threw", {
+          actionId: action.id,
+          error: callbackErr instanceof Error ? callbackErr.message : String(callbackErr)
+        });
+      }
+      const confirmLabel = "APPROVE_SPL confirmApproveSplViaPolling";
+      let slot;
+      try {
+        const confirmation = await withWatchdog(
+          confirmApproveSplViaPolling({
+            rpcUrl: clientRpcUrl,
+            signature: sent.signature
+          }),
+          confirmLabel
+        );
+        slot = confirmation.slot;
+        appendDebug("info", "APPROVE_SPL: settled", {
+          actionId: action.id,
+          signature: sent.signature,
+          slot
+        });
+      } catch (pollErr) {
+        const pollMsg = pollErr instanceof Error ? pollErr.message : String(pollErr);
+        if (pollMsg === APPROVE_SPL_CONFIRMATION_TIMEOUT_MESSAGE) {
+          throw pollErr;
+        }
+        if (pollMsg.startsWith(APPROVE_SPL_ONCHAIN_FAILURE_PREFIX)) {
+          throw pollErr;
+        }
+        appendDebug("warn", "APPROVE_SPL: confirmation poll failed; relying on server verification", {
+          actionId: action.id,
+          signature: sent.signature,
+          error: pollMsg
+        });
+      }
+      return actionSuccess(
+        action,
+        `Confirmed SPL approval for ${typeof tokenSymbol === "string" ? tokenSymbol : "tokens"}.`,
+        {
+          approveSignature: sent.signature
+        }
+      );
+    }
+    const signLabel = "APPROVE_SPL signSolanaTransaction";
+    const signed = await withWatchdog(
+      withTimeout(
+        signSolanaTransaction(
+          selection,
+          unsignedApproveTxBase64,
+          ownerPubkey
+        ),
+        WALLET_PROMPT_TIMEOUT_MS,
+        signLabel
+      ),
+      signLabel
+    );
+    appendDebug("info", "APPROVE_SPL: signed (legacy path)", {
+      actionId: action.id
+    });
+    return actionSuccess(
+      action,
+      `Signed SPL approval for ${typeof tokenSymbol === "string" ? tokenSymbol : "tokens"}.`,
+      { signedTxBase64: signed.signedTxBase64 }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Failed to sign SPL approval";
+    const timedOut = err instanceof PromiseTimeoutError;
+    const confirmTimedOut = msg === APPROVE_SPL_CONFIRMATION_TIMEOUT_MESSAGE;
+    appendDebug(timedOut || confirmTimedOut ? "warn" : "error", "APPROVE_SPL: threw", {
+      actionId: action.id,
+      error: msg,
+      userRejected: isUserRejection(msg),
+      timedOut,
+      confirmTimedOut
+    });
+    if (timedOut) {
+      return actionError(action, WALLET_PROMPT_TIMEOUT_MESSAGE);
+    }
+    if (confirmTimedOut) {
+      return actionError(
+        action,
+        "Your SPL approval was submitted but did not confirm in time. Please wait a moment and retry \u2014 do not re-approve in Phantom yet, as that would create a duplicate transaction."
+      );
+    }
+    return actionError(
+      action,
+      isUserRejection(msg) ? "You rejected the SPL approval transaction. Please approve the transaction in Phantom to continue." : msg
+    );
+  }
+}
+async function executeExecuteBridgeSolana(action) {
+  try {
+    const selection = getSolanaWalletSelection(action);
+    const ownerPubkey = action.metadata?.ownerPubkey ?? action.metadata?.senderAddress;
+    const unsignedTxBase64 = action.metadata?.unsignedTxBase64;
+    if (typeof ownerPubkey !== "string" || ownerPubkey.trim() === "") {
+      return actionError(action, "SVM EXECUTE_BRIDGE metadata is missing ownerPubkey.");
+    }
+    if (typeof unsignedTxBase64 !== "string" || unsignedTxBase64.trim() === "") {
+      return actionError(action, "SVM EXECUTE_BRIDGE metadata is missing unsignedTxBase64.");
+    }
+    appendDebug("info", "EXECUTE_BRIDGE: svm entry", {
+      actionId: action.id,
+      ownerPubkey
+    });
+    const label = "EXECUTE_BRIDGE signSolanaTransaction";
+    const signed = await withWatchdog(
+      withTimeout(
+        signSolanaTransaction(
+          selection,
+          unsignedTxBase64,
+          ownerPubkey
+        ),
+        WALLET_PROMPT_TIMEOUT_MS,
+        label
+      ),
+      label
+    );
+    appendDebug("info", "EXECUTE_BRIDGE: svm signed", {
+      actionId: action.id
+    });
+    return actionSuccess(
+      action,
+      "Signed Solana bridge transfer in Phantom.",
+      { signedTxBase64: signed.signedTxBase64, ownerPubkey: signed.ownerPubkey }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Failed to sign Solana bridge transfer";
+    const timedOut = err instanceof PromiseTimeoutError;
+    appendDebug(timedOut ? "warn" : "error", "EXECUTE_BRIDGE: svm threw", {
+      actionId: action.id,
+      error: msg,
+      userRejected: isUserRejection(msg),
+      timedOut
+    });
+    if (timedOut) {
+      return actionError(action, WALLET_PROMPT_TIMEOUT_MESSAGE);
+    }
+    return actionError(
+      action,
+      isUserRejection(msg) ? "You rejected the Solana transfer transaction. Please approve the transaction in Phantom to continue." : msg
+    );
+  }
+}
+async function executeSvmCombinedFirstTransfer(actions, options) {
+  if (actions.length !== 2) {
+    throw new Error(
+      `executeSvmCombinedFirstTransfer requires exactly 2 actions, received ${actions.length}.`
+    );
+  }
+  const approveAction = actions[0].action;
+  const bridgeAction = actions[1].action;
+  if (approveAction.type !== "APPROVE_SPL") {
+    throw new Error(
+      `executeSvmCombinedFirstTransfer expects APPROVE_SPL first, got ${approveAction.type}.`
+    );
+  }
+  if (bridgeAction.type !== "EXECUTE_BRIDGE" || bridgeAction.metadata?.chainFamily !== "svm") {
+    throw new Error(
+      `executeSvmCombinedFirstTransfer expects SVM EXECUTE_BRIDGE second, got ${bridgeAction.type}/${bridgeAction.metadata?.chainFamily ?? "unknown"}.`
+    );
+  }
+  const ownerPubkey = approveAction.metadata?.ownerPubkey;
+  const unsignedApproveTxBase64 = approveAction.metadata?.unsignedApproveTxBase64;
+  const tokenSymbol = approveAction.metadata?.tokenSymbol;
+  const unsignedBridgeTxBase64 = bridgeAction.metadata?.unsignedTxBase64;
+  if (typeof ownerPubkey !== "string" || ownerPubkey.trim() === "") {
+    return failBothActions(
+      approveAction,
+      bridgeAction,
+      "APPROVE_SPL metadata is missing ownerPubkey."
+    );
+  }
+  if (typeof unsignedApproveTxBase64 !== "string" || unsignedApproveTxBase64.trim() === "") {
+    return failBothActions(
+      approveAction,
+      bridgeAction,
+      "APPROVE_SPL metadata is missing unsignedApproveTxBase64."
+    );
+  }
+  if (typeof unsignedBridgeTxBase64 !== "string" || unsignedBridgeTxBase64.trim() === "") {
+    return failBothActions(
+      approveAction,
+      bridgeAction,
+      "SVM EXECUTE_BRIDGE metadata is missing unsignedTxBase64."
+    );
+  }
+  const selection = getSolanaWalletSelection(approveAction);
+  appendDebug("info", "SVM_COMBINED: entry", {
+    approveActionId: approveAction.id,
+    bridgeActionId: bridgeAction.id,
+    ownerPubkey,
+    tokenSymbol: typeof tokenSymbol === "string" ? tokenSymbol : null
+  });
+  const signLabel = "SVM_COMBINED signAllSolanaTransactions";
+  let signed;
+  try {
+    signed = await withWatchdog(
+      withTimeout(
+        signAllSolanaTransactions(
+          selection,
+          [unsignedApproveTxBase64, unsignedBridgeTxBase64],
+          ownerPubkey
+        ),
+        WALLET_PROMPT_TIMEOUT_MS,
+        signLabel
+      ),
+      signLabel
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Failed to sign Solana transactions";
+    const timedOut = err instanceof PromiseTimeoutError;
+    appendDebug(timedOut ? "warn" : "error", "SVM_COMBINED: signAllTransactions threw", {
+      approveActionId: approveAction.id,
+      bridgeActionId: bridgeAction.id,
+      error: msg,
+      userRejected: isUserRejection(msg),
+      timedOut
+    });
+    if (timedOut) {
+      return failBothActions(
+        approveAction,
+        bridgeAction,
+        WALLET_PROMPT_TIMEOUT_MESSAGE
+      );
+    }
+    if (isUserRejection(msg)) {
+      return failBothActions(
+        approveAction,
+        bridgeAction,
+        "You rejected the Solana transactions. Please approve the prompt in Phantom to continue."
+      );
+    }
+    return failBothActions(approveAction, bridgeAction, msg);
+  }
+  const [approveSignedB64, bridgeSignedB64] = signed.signedTxsBase64;
+  appendDebug("info", "SVM_COMBINED: signAllTransactions returned", {
+    approveActionId: approveAction.id,
+    bridgeActionId: bridgeAction.id
+  });
+  try {
+    options?.onApproveSplConfirming?.(approveAction);
+  } catch (callbackErr) {
+    appendDebug("warn", "SVM_COMBINED: onApproveSplConfirming callback threw", {
+      approveActionId: approveAction.id,
+      error: callbackErr instanceof Error ? callbackErr.message : String(callbackErr)
+    });
+  }
+  return {
+    txHash: void 0,
+    actionResults: [
+      {
+        action: approveAction,
+        result: actionSuccess(
+          approveAction,
+          `Signed SPL approval for ${typeof tokenSymbol === "string" ? tokenSymbol : "tokens"}.`,
+          { signedTxBase64: approveSignedB64, ownerPubkey: signed.ownerPubkey }
+        )
+      },
+      {
+        action: bridgeAction,
+        result: actionSuccess(
+          bridgeAction,
+          "Signed Solana bridge transfer in Phantom.",
+          { signedTxBase64: bridgeSignedB64, ownerPubkey: signed.ownerPubkey }
+        )
+      }
+    ]
+  };
+}
+function failBothActions(approveAction, bridgeAction, message) {
+  return {
+    txHash: void 0,
+    actionResults: [
+      { action: approveAction, result: actionError(approveAction, message) },
+      { action: bridgeAction, result: actionError(bridgeAction, message) }
+    ]
+  };
+}
 async function executeApprovePermit2(action, wagmiConfig2) {
   let walletClient = null;
   let sender = null;
@@ -3218,6 +3941,7 @@ function useAuthorizationExecutor(options) {
   const [results, setResults] = react.useState([]);
   const [error, setError] = react.useState(null);
   const [currentAction, setCurrentAction] = react.useState(null);
+  const [approveSplConfirming, setApproveSplConfirming] = react.useState(null);
   const executingRef = react.useRef(false);
   const walletCapabilitiesRef = react.useRef({});
   const walletCapabilitiesRefreshedRef = react.useRef(false);
@@ -3256,16 +3980,17 @@ function useAuthorizationExecutor(options) {
     }
     setError(null);
     setCurrentAction(null);
+    setApproveSplConfirming(null);
     setExecuting(false);
     executingRef.current = false;
   }, []);
   const dispatchAction = react.useCallback(
-    async (action) => {
+    async (action, dispatchOptions) => {
       setCurrentAction(action);
       switch (action.type) {
         case "OPEN_PROVIDER": {
           const result = await executeOpenProvider(action, wagmiConfig2, connectors, connectAsync);
-          if (result.status === "success") {
+          if (result.status === "success" && action.metadata?.chainFamily !== "svm") {
             walletCapabilitiesRef.current = await refreshWalletCapabilities(
               wagmiConfig2,
               "open-provider"
@@ -3277,7 +4002,7 @@ function useAuthorizationExecutor(options) {
           return executeSelectSource(action, waitForSelection);
         case "SWITCH_CHAIN": {
           const result = await executeSwitchChain(action, wagmiConfig2, switchChainAsync);
-          if (result.status === "success") {
+          if (result.status === "success" && action.metadata?.chainFamily !== "svm") {
             walletCapabilitiesRef.current = await refreshWalletCapabilities(
               wagmiConfig2,
               "switch-chain"
@@ -3297,7 +4022,33 @@ function useAuthorizationExecutor(options) {
           }
           return executeSignPermit2(action, wagmiConfig2, apiBaseUrl ?? "", sessionIdRef.current);
         }
+        case "APPROVE_SPL": {
+          if (action.metadata?.awaitingLimit) {
+            throw new Error(
+              "APPROVE_SPL action has awaitingLimit. The orchestrator must handle one-tap setup before executing this action."
+            );
+          }
+          const externalConfirmingCallback = dispatchOptions?.onApproveSplConfirming;
+          return executeApproveSplSolana(action, {
+            onConfirming: (a) => {
+              setApproveSplConfirming(a);
+              if (externalConfirmingCallback) {
+                try {
+                  externalConfirmingCallback(a);
+                } catch (callbackErr) {
+                  appendDebug("warn", "APPROVE_SPL: orchestrator onApproveSplConfirming threw", {
+                    actionId: a.id,
+                    error: callbackErr instanceof Error ? callbackErr.message : String(callbackErr)
+                  });
+                }
+              }
+            }
+          });
+        }
         case "EXECUTE_BRIDGE":
+          if (action.metadata?.chainFamily === "svm") {
+            return executeExecuteBridgeSolana(action);
+          }
           return executeExecuteBridge(action, wagmiConfig2);
         default:
           return actionError(action, `Unsupported action type: ${action.type}`);
@@ -3310,7 +4061,11 @@ function useAuthorizationExecutor(options) {
       if (options2?.sessionId) {
         sessionIdRef.current = options2.sessionId;
       }
-      return dispatchAction(action);
+      try {
+        return await dispatchAction(action, options2);
+      } finally {
+        setApproveSplConfirming(null);
+      }
     },
     [dispatchAction]
   );
@@ -3331,6 +4086,43 @@ function useAuthorizationExecutor(options) {
     },
     [apiBaseUrl, wagmiConfig2]
   );
+  const executeSvmCombinedFirstTransferImpl = react.useCallback(
+    async (actions, options2) => {
+      setCurrentAction(actions[0]?.action ?? null);
+      const externalConfirmingCallback = options2?.onApproveSplConfirming;
+      return executeSvmCombinedFirstTransfer(actions, {
+        onApproveSplConfirming: (a) => {
+          setApproveSplConfirming(a);
+          if (externalConfirmingCallback) {
+            try {
+              externalConfirmingCallback(a);
+            } catch (callbackErr) {
+              appendDebug("warn", "SVM_COMBINED: orchestrator onApproveSplConfirming threw", {
+                actionId: a.id,
+                error: callbackErr instanceof Error ? callbackErr.message : String(callbackErr)
+              });
+            }
+          }
+        }
+      });
+    },
+    []
+  );
+  const canSignAllSolanaTransactions = react.useCallback(
+    async (action) => {
+      try {
+        const selection = getSolanaWalletSelection(action);
+        return await supportsSignAllSolanaTransactions(selection);
+      } catch (err) {
+        appendDebug("warn", "SVM_COMBINED: signAllTransactions feature-detect failed", {
+          actionId: action.id,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return false;
+      }
+    },
+    []
+  );
   const canBatch = react.useCallback(async () => {
     const cacheKey = getBatchCapabilityCacheKey(wagmiConfig2);
     const cachedDecision = batchCapabilityDecisionRef.current;
@@ -3374,11 +4166,13 @@ function useAuthorizationExecutor(options) {
     setResults([]);
     setError(null);
     setBatchTxHash(null);
+    setApproveSplConfirming(null);
     return true;
   }, []);
   const endExecution = react.useCallback(() => {
     sessionIdRef.current = null;
     setCurrentAction(null);
+    setApproveSplConfirming(null);
     setExecuting(false);
     executingRef.current = false;
   }, []);
@@ -3471,12 +4265,15 @@ function useAuthorizationExecutor(options) {
     results,
     error,
     currentAction,
+    approveSplConfirming,
     pendingSelectSource,
     resolveSelectSource,
     cancelPendingExecution,
     batchTxHash,
     executeAction,
     executeBatch,
+    executeSvmCombinedFirstTransfer: executeSvmCombinedFirstTransferImpl,
+    canSignAllSolanaTransactions,
     canBatch,
     checkPaymasterSupport,
     getCapabilitySnapshot,
@@ -3505,6 +4302,8 @@ function isWebAuthnPasskeyDismissalError(err) {
 
 // src/hooks/useTransferSigning.ts
 var TRANSFER_SIGN_MAX_POLLS = 60;
+var FAST_POLL_COUNT2 = 6;
+var FAST_POLL_INTERVAL_MS2 = 500;
 function waitForDocumentFocus2(timeoutMs = 5e3, intervalMs = 100) {
   return new Promise((resolve, reject) => {
     if (typeof document === "undefined") {
@@ -3532,9 +4331,23 @@ function hexToBytes(hex) {
   const bytes = clean.match(/.{1,2}/g).map((b) => parseInt(b, 16));
   return new Uint8Array(bytes);
 }
+function base64ToBytes2(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
 function toBase642(buffer) {
   return btoa(String.fromCharCode(...new Uint8Array(buffer)));
 }
+function getSigningChallenge(payload) {
+  if (payload.chainFamily === "svm") {
+    return base64ToBytes2(payload.message);
+  }
+  return hexToBytes(payload.userOpHash);
+}
 function useTransferSigning(pollIntervalMs = 2e3, options) {
   const blinkConfig = useOptionalBlinkConfig();
   const apiBaseUrl = options?.apiBaseUrl ?? blinkConfig?.apiBaseUrl;
@@ -3551,7 +4364,7 @@ function useTransferSigning(pollIntervalMs = 2e3, options) {
   const [error, setError] = react.useState(null);
   const [passkeyDismissed, setPasskeyDismissed] = react.useState(false);
   const signTransfer2 = react.useCallback(
-    async (transferId) => {
+    async (transferId, opts) => {
       setSigning(true);
       setError(null);
       setPasskeyDismissed(false);
@@ -3568,22 +4381,28 @@ function useTransferSigning(pollIntervalMs = 2e3, options) {
           throw new Error("Could not get access token");
         }
         let payload = null;
-        for (let i = 0; i < TRANSFER_SIGN_MAX_POLLS; i++) {
-          const transfer = await fetchTransfer(
-            apiBaseUrl,
-            token ?? "",
-            transferId,
-            authorizationSessionToken
-          );
-          if (transfer.signPayload) {
-            payload = transfer.signPayload;
-            setSignPayload(payload);
-            break;
-          }
-          if (transfer.status !== "AUTHORIZED" && transfer.status !== "CREATED") {
-            throw new Error(`Unexpected transfer status: ${transfer.status}`);
+        if (opts?.knownSignPayload) {
+          payload = opts.knownSignPayload;
+          setSignPayload(payload);
+        } else {
+          for (let i = 0; i < TRANSFER_SIGN_MAX_POLLS; i++) {
+            const transfer = await fetchTransfer(
+              apiBaseUrl,
+              token ?? "",
+              transferId,
+              authorizationSessionToken
+            );
+            if (transfer.signPayload) {
+              payload = transfer.signPayload;
+              setSignPayload(payload);
+              break;
+            }
+            if (transfer.status !== "AUTHORIZED" && transfer.status !== "CREATED") {
+              throw new Error(`Unexpected transfer status: ${transfer.status}`);
+            }
+            const intervalMs = i < FAST_POLL_COUNT2 ? Math.min(FAST_POLL_INTERVAL_MS2, pollIntervalMs) : pollIntervalMs;
+            await new Promise((r) => setTimeout(r, intervalMs));
           }
-          await new Promise((r) => setTimeout(r, pollIntervalMs));
         }
         if (!payload) {
           throw new Error("Timed out waiting for sign payload. Please try again.");
@@ -3594,8 +4413,7 @@ function useTransferSigning(pollIntervalMs = 2e3, options) {
             "Sign payload is missing passkeyCredentialId. Cannot request passkey signing without it."
           );
         }
-        const hashBytes = hexToBytes(payload.userOpHash);
-        let signedUserOp;
+        const challengeBytes = getSigningChallenge(payload);
         const allowCredentials = [{
           type: "public-key",
           id: credentialIdBase64ToBytes(passkeyCredentialId)
@@ -3614,7 +4432,7 @@ function useTransferSigning(pollIntervalMs = 2e3, options) {
         try {
           assertion = await navigator.credentials.get({
             publicKey: {
-              challenge: hashBytes,
+              challenge: challengeBytes,
               rpId: signingRpId,
               allowCredentials,
               userVerification: "required",
@@ -3631,18 +4449,24 @@ function useTransferSigning(pollIntervalMs = 2e3, options) {
           throw new TransferSigningPasskeyDismissedError();
         }
         const response = assertion.response;
-        signedUserOp = {
-          ...payload.userOp,
+        const webauthnAssertion = {
           credentialId: toBase642(assertion.rawId),
           signature: toBase642(response.signature),
           authenticatorData: toBase642(response.authenticatorData),
           clientDataJSON: toBase642(response.clientDataJSON)
         };
+        const signedTransfer = payload.chainFamily === "svm" ? {
+          chainFamily: "svm",
+          webauthnAssertion
+        } : {
+          ...payload.userOp,
+          ...webauthnAssertion
+        };
         return await signTransfer(
           apiBaseUrl,
           token ?? "",
           transferId,
-          signedUserOp,
+          signedTransfer,
           authorizationSessionToken
         );
       } catch (err) {
@@ -3757,6 +4581,8 @@ function assertLinkedTransferBridgeExecuted(params) {
 // src/hooks/useAuthorizationOrchestrator.ts
 var ACTION_POLL_INTERVAL_MS2 = 500;
 var ACTION_POLL_MAX_RETRIES2 = 20;
+var REPORT_COMPLETION_TIMEOUT_MS = 9e4;
+var REPORT_COMPLETION_TIMEOUT_MESSAGE = "REPORT_COMPLETION_TIMEOUT";
 function useAuthorizationOrchestrator(deps) {
   const blinkConfig = useOptionalBlinkConfig();
   const resolvedApiBaseUrl = deps.apiBaseUrl ?? blinkConfig?.apiBaseUrl;
@@ -3884,6 +4710,7 @@ function useAuthorizationOrchestrator(deps) {
           waitForLinkedTransferSession: options?.waitForLinkedTransferSession ?? false
         });
         let cachedBatchSupport = null;
+        let cachedSvmSignAllSupport = null;
         while (mergedPending.length > 0) {
           await ingestPendingSessions(apiBaseUrl, sessions, actionSessionMap, pendingSessionIdsRef);
           mergedPending = getMergedPending(sessions, completedIds);
@@ -3971,6 +4798,112 @@ function useAuthorizationOrchestrator(deps) {
             });
             continue;
           }
+          if (action.type === "APPROVE_SPL" && (action.metadata?.awaitingLimit || options?.alwaysPauseForOneTap) && !oneTapCompletedActionIds.has(action.id)) {
+            if (options?.onAwaitingOneTap) {
+              console.info("[blink-sdk][orchestrator] Awaiting Solana one-tap setup via callback.", {
+                actionId: action.id,
+                ownerSessionId
+              });
+              await options.onAwaitingOneTap(action);
+              console.info("[blink-sdk][orchestrator] Solana one-tap setup resumed via callback.", {
+                actionId: action.id,
+                ownerSessionId
+              });
+            } else {
+              console.info("[blink-sdk][orchestrator] Awaiting Solana one-tap setup.", {
+                actionId: action.id,
+                ownerSessionId
+              });
+              await waitForOneTapPause(action);
+              console.info("[blink-sdk][orchestrator] Solana one-tap setup resumed.", {
+                actionId: action.id,
+                ownerSessionId
+              });
+            }
+            oneTapCompletedActionIds.add(action.id);
+            await ingestPendingSessions(apiBaseUrl, sessions, actionSessionMap, pendingSessionIdsRef);
+            await refreshAllSessions(apiBaseUrl, sessions, actionSessionMap);
+            queueLinkedTransferSessions({
+              sessions,
+              linkedTransferSessionIds,
+              pendingSessionIdsRef
+            });
+            await ingestPendingSessions(apiBaseUrl, sessions, actionSessionMap, pendingSessionIdsRef);
+            markPendingOneTapActionsCompleted(sessions, oneTapCompletedActionIds);
+            mergedPending = await waitForPendingActions({
+              apiBaseUrl,
+              sessions,
+              completedIds,
+              actionSessionMap,
+              pendingSessionIdsRef,
+              linkedTransferSessionIds,
+              waitForLinkedTransferSession: options?.waitForLinkedTransferSession ?? false
+            });
+            continue;
+          }
+          if (isSvmCombinedFirstTransferPair(mergedPending)) {
+            const pair = mergedPending.slice(0, 2);
+            const [svmApproveAction, svmBridgeAction] = pair;
+            if (cachedSvmSignAllSupport == null) {
+              cachedSvmSignAllSupport = await authExecutor.canSignAllSolanaTransactions(
+                svmApproveAction
+              );
+            }
+            appendDebug("info", "orchestrator:svm-combined evaluation", {
+              approveActionId: svmApproveAction.id,
+              bridgeActionId: svmBridgeAction.id,
+              ownerSessionId,
+              signAllSupported: cachedSvmSignAllSupport
+            });
+            if (cachedSvmSignAllSupport) {
+              const svmInputs = pair.map((candidate) => ({
+                action: candidate,
+                sessionId: actionSessionMap.get(candidate.id) ?? sessionId
+              }));
+              const svmBatchResult = await authExecutor.executeSvmCombinedFirstTransfer(
+                svmInputs,
+                {
+                  onApproveSplConfirming: options?.onApproveSplConfirming
+                }
+              );
+              const errorResult = svmBatchResult.actionResults.find(
+                ({ result: result2 }) => result2.status === "error"
+              );
+              if (errorResult) {
+                authExecutor.addResult(errorResult.result);
+                throw new Error(errorResult.result.message);
+              }
+              for (const { action: svmAction, result: result2 } of svmBatchResult.actionResults) {
+                completedIds.add(svmAction.id);
+                oneTapCompletedActionIds.delete(svmAction.id);
+                authExecutor.addResult(result2);
+                const svmOwnerSessionId = actionSessionMap.get(svmAction.id) ?? ownerSessionId;
+                const reportedSession2 = await reportActionCompletionWithLogging(
+                  apiBaseUrl,
+                  svmAction,
+                  svmOwnerSessionId,
+                  result2
+                );
+                updateTrackedSession(sessions, svmOwnerSessionId, reportedSession2, actionSessionMap);
+              }
+              queueLinkedTransferSessions({
+                sessions,
+                linkedTransferSessionIds,
+                pendingSessionIdsRef
+              });
+              await ingestPendingSessions(apiBaseUrl, sessions, actionSessionMap, pendingSessionIdsRef);
+              mergedPending = await waitForPendingActions({
+                apiBaseUrl,
+                sessions,
+                completedIds,
+                actionSessionMap,
+                pendingSessionIdsRef,
+                linkedTransferSessionIds,
+                waitForLinkedTransferSession: options?.waitForLinkedTransferSession ?? false
+              });
+              continue;
+            }
+          }
           if (isBatchableAction(action)) {
             const batchable = getLeadingBatchableActions(
               mergedPending
@@ -3997,7 +4930,7 @@ function useAuthorizationOrchestrator(deps) {
                 pendingSessionIdsRef
               });
               await ingestPendingSessions(apiBaseUrl, sessions, actionSessionMap, pendingSessionIdsRef);
-              markPendingPermit2AsOneTapCompleted(sessions, oneTapCompletedActionIds);
+              markPendingOneTapActionsCompleted(sessions, oneTapCompletedActionIds);
               mergedPending = await waitForPendingActions({
                 apiBaseUrl,
                 sessions,
@@ -4028,7 +4961,7 @@ function useAuthorizationOrchestrator(deps) {
                 pendingSessionIdsRef
               });
               await ingestPendingSessions(apiBaseUrl, sessions, actionSessionMap, pendingSessionIdsRef);
-              markPendingPermit2AsOneTapCompleted(sessions, oneTapCompletedActionIds);
+              markPendingOneTapActionsCompleted(sessions, oneTapCompletedActionIds);
               mergedPending = await waitForPendingActions({
                 apiBaseUrl,
                 sessions,
@@ -4100,7 +5033,7 @@ function useAuthorizationOrchestrator(deps) {
               continue;
             }
           }
-          const isPrePromptProbableActionType = action.type === "SIGN_PERMIT2" || action.type === "APPROVE_PERMIT2";
+          const isPrePromptProbableActionType = action.type === "SIGN_PERMIT2" || action.type === "APPROVE_PERMIT2" || action.type === "APPROVE_SPL";
           if (isPrePromptProbableActionType && probeBeforePrompt && !preProbedIds.has(action.id)) {
             preProbedIds.add(action.id);
             appendDebug("info", `${action.type}: pre-prompt probe start`, {
@@ -4145,7 +5078,10 @@ function useAuthorizationOrchestrator(deps) {
             actionId: action.id,
             ownerSessionId
           });
-          const result = await authExecutor.executeAction(action, { sessionId: ownerSessionId });
+          const result = await authExecutor.executeAction(action, {
+            sessionId: ownerSessionId,
+            onApproveSplConfirming: options?.onApproveSplConfirming
+          });
           if (result.status === "success" && (action.type === "OPEN_PROVIDER" || action.type === "SWITCH_CHAIN")) {
             cachedBatchSupport = null;
           }
@@ -4385,7 +5321,24 @@ function getMergedPending(sessions, completedIds) {
   for (const { session } of sessions) {
     allActions.push(...getPendingActions(session, completedIds));
   }
-  return allActions.sort((a, b) => a.orderIndex - b.orderIndex);
+  const hasPendingSvmSetupAction = allActions.some((action) => isSvmSetupAction(action));
+  return allActions.sort((a, b) => {
+    const leftIsDeferredSvmBridge = hasPendingSvmSetupAction && isSvmTransferBridgeAction(a);
+    const rightIsDeferredSvmBridge = hasPendingSvmSetupAction && isSvmTransferBridgeAction(b);
+    if (leftIsDeferredSvmBridge !== rightIsDeferredSvmBridge) {
+      return leftIsDeferredSvmBridge ? 1 : -1;
+    }
+    return a.orderIndex - b.orderIndex;
+  });
+}
+function isSvmSetupAction(action) {
+  if (action.type === "APPROVE_SPL") {
+    return true;
+  }
+  return action.type === "OPEN_PROVIDER" && action.metadata?.chainFamily === "svm";
+}
+function isSvmTransferBridgeAction(action) {
+  return action.type === "EXECUTE_BRIDGE" && action.metadata?.chainFamily === "svm";
 }
 async function waitForPendingActions(params) {
   const {
@@ -4459,14 +5412,19 @@ async function reportActionCompletionWithLogging(apiBaseUrl, action, ownerSessio
     actionId: action.id,
     ownerSessionId
   });
+  const label = `reportActionCompletion ${action.type}`;
   try {
     const reportedSession = await withWatchdog(
-      reportActionCompletion(
-        apiBaseUrl,
-        action.id,
-        result.data ?? {}
+      withTimeout(
+        reportActionCompletion(
+          apiBaseUrl,
+          action.id,
+          result.data ?? {}
+        ),
+        REPORT_COMPLETION_TIMEOUT_MS,
+        label
       ),
-      `reportActionCompletion ${action.type}`
+      label
     );
     console.info("[blink-sdk][orchestrator] Action completion reported.", {
       actionId: action.id,
@@ -4482,16 +5440,22 @@ async function reportActionCompletionWithLogging(apiBaseUrl, action, ownerSessio
     });
     return reportedSession;
   } catch (err) {
+    const timedOut = err instanceof PromiseTimeoutError;
     console.warn("[blink-sdk][orchestrator] Failed to report action completion.", {
       actionId: action.id,
       actionType: action.type,
       ownerSessionId,
+      timedOut,
       error: err instanceof Error ? err.message : String(err)
     });
-    appendDebug("error", `orchestrator:reportActionCompletion failed ${action.type}`, {
+    appendDebug(timedOut ? "warn" : "error", `orchestrator:reportActionCompletion ${timedOut ? "timed out" : "failed"} ${action.type}`, {
       actionId: action.id,
+      timedOut,
       error: err instanceof Error ? err.message : String(err)
     });
+    if (timedOut) {
+      throw new Error(REPORT_COMPLETION_TIMEOUT_MESSAGE);
+    }
     throw err;
   }
 }
@@ -4524,10 +5488,10 @@ function updateTrackedSession(sessions, ownerSessionId, reportedSession, actionS
     }
   }
 }
-function markPendingPermit2AsOneTapCompleted(sessions, oneTapCompletedActionIds) {
+function markPendingOneTapActionsCompleted(sessions, oneTapCompletedActionIds) {
   for (const { session } of sessions) {
     for (const action of session.actions) {
-      if (action.type === "SIGN_PERMIT2" && action.status === "PENDING") {
+      if ((action.type === "SIGN_PERMIT2" || action.type === "APPROVE_SPL") && action.status === "PENDING") {
         oneTapCompletedActionIds.add(action.id);
       }
     }
@@ -4580,6 +5544,8 @@ function screenForPhase(phase) {
     case "completed":
     case "failed":
       return "success";
+    case "amount-too-low":
+      return "amount-too-low";
   }
 }
 
@@ -4629,6 +5595,12 @@ function hasActiveWallet(accounts) {
   return accounts.some((a) => a.wallets.some((w) => w.status === "ACTIVE"));
 }
 function resolveTerminalPhase(state) {
+  if (state.amountTooLow != null) {
+    return {
+      step: "amount-too-low",
+      minAmountUsd: state.amountTooLow.minAmountUsd
+    };
+  }
   const transferCompleted = state.transfer?.status === "COMPLETED";
   const needsPasskeyBootstrap = state.privyAuthenticated && !state.activeCredentialId;
   if (transferCompleted && !needsPasskeyBootstrap && !state.loginRequested) {
@@ -4782,7 +5754,8 @@ function createInitialState(config) {
     setupDepositToken: null,
     setupDepositConfirmed: false,
     guestWalletPrepared: null,
-    guestWalletDeeplinksPreparing: false
+    guestWalletDeeplinksPreparing: false,
+    amountTooLow: null
   };
 }
 function clearAuthenticatedSessionState(state) {
@@ -4819,7 +5792,8 @@ function clearAuthenticatedSessionState(state) {
     setupDepositToken: null,
     setupDepositConfirmed: false,
     guestWalletPrepared: null,
-    guestWalletDeeplinksPreparing: false
+    guestWalletDeeplinksPreparing: false,
+    amountTooLow: null
   };
 }
 function paymentReducer(state, action) {
@@ -5158,6 +6132,13 @@ function applyAction(state, action) {
       };
     case "SET_ERROR":
       return { ...state, error: action.error };
+    case "AMOUNT_TOO_LOW":
+      return {
+        ...state,
+        amountTooLow: { minAmountUsd: action.minAmountUsd },
+        creatingTransfer: false,
+        error: null
+      };
     case "SET_ONE_TAP_LIMIT_SAVED_DURING_SETUP":
       return { ...state, oneTapLimitSavedDuringSetup: action.saved };
     case "SET_STANDARD_DESKTOP_INLINE_OPEN_WALLET":
@@ -5191,7 +6172,8 @@ function applyAction(state, action) {
         setupDepositConfirmed: false,
         setupFlowScreen: null,
         guestWalletPrepared: null,
-        guestWalletDeeplinksPreparing: false
+        guestWalletDeeplinksPreparing: false,
+        amountTooLow: null
       };
     case "LOGOUT":
       return {
@@ -5538,6 +6520,17 @@ var RABBY_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="70 88 386 334"
 </linearGradient>
 </defs>
 </svg>`;
+var PHANTOM_SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="1200" viewBox="0 0 1200 1200" fill="none">
+<g clip-path="url(#clip0_2596_138580)">
+<rect y="-0.000976562" width="1200" height="1200" fill="#AB9FF2"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M522.218 764.813C475.101 837.011 396.147 928.377 291.089 928.377C241.425 928.377 193.671 907.932 193.671 819.121C193.671 592.942 502.479 242.812 789.003 242.812C952.003 242.812 1016.95 355.901 1016.95 484.325C1016.95 649.167 909.979 837.65 803.647 837.65C769.901 837.65 753.346 819.121 753.346 789.731C753.346 782.064 754.62 773.758 757.167 764.813C720.874 826.788 650.835 884.292 585.253 884.292C537.499 884.292 513.304 854.262 513.304 812.093C513.304 796.759 516.487 780.786 522.218 764.813ZM769.035 479.871C769.035 517.293 746.956 536.003 722.258 536.003C697.185 536.003 675.481 517.293 675.481 479.871C675.481 442.449 697.185 423.738 722.258 423.738C746.956 423.738 769.035 442.449 769.035 479.871ZM909.367 479.872C909.367 517.294 887.288 536.005 862.59 536.005C837.517 536.005 815.813 517.294 815.813 479.872C815.813 442.45 837.517 423.74 862.59 423.74C887.288 423.74 909.367 442.45 909.367 479.872Z" fill="#FFFDF8"/>
+</g>
+<defs>
+<clipPath id="clip0_2596_138580">
+<rect y="-0.000976562" width="1200" height="1200" rx="600" fill="white"/>
+</clipPath>
+</defs>
+</svg>`;
 var BLINK_SVG = `<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
 <g clip-path="url(#clip0_125_480)">
 <rect width="100" height="100" rx="18.5874" fill="black"/>
@@ -5580,11 +6573,13 @@ var POLYGON_CHAIN_LOGO = svgToDataUri(POLYGON_CHAIN_SVG);
 var ETHEREUM_CHAIN_LOGO = "https://assets.relay.link/icons/1/light.png";
 var MEGAETH_CHAIN_LOGO = svgToDataUri(MEGAETH_CHAIN_SVG);
 var MONAD_CHAIN_LOGO = svgToDataUri(MONAD_CHAIN_SVG);
+var SOLANA_CHAIN_LOGO = "https://assets.relay.link/icons/792703809/light.png";
 var USDM_LOGO = svgToDataUri(USDM_TOKEN_SVG);
 var METAMASK_LOGO = svgToDataUri(METAMASK_SVG);
 var TRUST_WALLET_LOGO = svgToDataUri(TRUST_WALLET_SVG);
 var OKX_WALLET_LOGO = svgToDataUri(OKX_WALLET_SVG);
 var RABBY_LOGO = svgToDataUri(RABBY_SVG);
+var PHANTOM_LOGO = svgToDataUri(PHANTOM_SVG);
 var USDC_LOGO = svgToDataUri(USDC_SVG);
 var TETHER_LOGO = svgToDataUri(TETHER_SVG);
 var KNOWN_LOGOS = {
@@ -5593,6 +6588,7 @@ var KNOWN_LOGOS = {
   "base account": BASE_LOGO,
   "base app": BASE_LOGO,
   "okx wallet": OKX_WALLET_LOGO,
+  phantom: PHANTOM_LOGO,
   rabby: RABBY_LOGO,
   "trust wallet": TRUST_WALLET_LOGO
 };
@@ -5605,15 +6601,20 @@ var TOKEN_LOGOS = {
 var CHAIN_LOGOS = {
   base: BASE_CHAIN_LOGO,
   ethereum: ETHEREUM_CHAIN_LOGO,
+  "ethereum mainnet": ETHEREUM_CHAIN_LOGO,
   polygon: POLYGON_CHAIN_LOGO,
+  "polygon mainnet": POLYGON_CHAIN_LOGO,
   arbitrum: ARBITRUM_CHAIN_LOGO,
   "arbitrum one": ARBITRUM_CHAIN_LOGO,
+  "arbitrum mainnet": ARBITRUM_CHAIN_LOGO,
   bnb: BNB_CHAIN_LOGO,
   "bnb chain": BNB_CHAIN_LOGO,
   "bnb smart chain": BNB_CHAIN_LOGO,
   bsc: BNB_CHAIN_LOGO,
   megaeth: MEGAETH_CHAIN_LOGO,
-  monad: MONAD_CHAIN_LOGO
+  monad: MONAD_CHAIN_LOGO,
+  solana: SOLANA_CHAIN_LOGO,
+  "solana mainnet": SOLANA_CHAIN_LOGO
 };
 function ScreenLayout({ children, footer }) {
   const { tokens, theme } = useBlinkConfig();
@@ -5861,6 +6862,8 @@ function PrimaryButton({
   children,
   onClick,
   href,
+  target,
+  rel,
   disabled,
   loading,
   loadingText = "Please wait...",
@@ -5913,6 +6916,8 @@ function PrimaryButton({
       "a",
       {
         href,
+        target,
+        rel,
         onClick,
         style: {
           ...buttonStyle2(tokens, { disabled: false, loading: false }),
@@ -6669,6 +7674,8 @@ function SourceRow(props) {
       "a",
       {
         href: props.href,
+        target: props.target,
+        rel: props.rel,
         onClick: props.onClick,
         onMouseEnter: () => setHovered(true),
         onMouseLeave: () => setHovered(false),
@@ -7192,6 +8199,22 @@ var closeButtonStyle2 = (tokens) => ({
   cursor: "pointer",
   padding: 0
 });
+function AmountTooLowScreen({
+  minAmountUsd,
+  onRetry,
+  onClose
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    BlinkErrorScreen,
+    {
+      title: "Amount too low",
+      message: `The minimum payment amount is $${minAmountUsd.toFixed(2)}.`,
+      retryLabel: onRetry ? "Try Again" : void 0,
+      onRetry,
+      onClose
+    }
+  );
+}
 var RESEND_COOLDOWN_SECONDS = 30;
 function OtpVerifyScreen({
   maskedIdentifier,
@@ -7467,19 +8490,15 @@ var contentStyle5 = {
   gap: 16
 };
 var illustrationFrameStyle = {
-  flex: 1,
-  minHeight: 0,
+  flex: "0 0 auto",
   width: "100%",
-  maxWidth: 329,
   display: "flex",
   alignItems: "center",
   justifyContent: "center"
 };
 var illustrationImgStyle = {
-  maxWidth: "100%",
-  maxHeight: "100%",
-  width: "auto",
-  height: "auto",
+  width: 200,
+  height: 200,
   objectFit: "contain",
   display: "block",
   pointerEvents: "none",
@@ -7487,7 +8506,7 @@ var illustrationImgStyle = {
 };
 var footerButtonStyle = {
   width: "100%",
-  paddingTop: 20,
+  paddingTop: 48,
   paddingBottom: 36
 };
 var errorBannerStyle3 = (tokens) => ({
@@ -7561,19 +8580,17 @@ var contentStyle6 = {
   gap: 16
 };
 var illustrationFrameStyle2 = {
-  flex: 1,
-  minHeight: 0,
+  flex: "0 1 auto",
   width: "100%",
-  maxWidth: 329,
+  maxWidth: 280,
+  height: "clamp(140px, 34vh, 248px)",
   display: "flex",
   alignItems: "center",
   justifyContent: "center"
 };
 var illustrationImgStyle2 = {
-  maxWidth: "100%",
-  maxHeight: "100%",
-  width: "auto",
-  height: "auto",
+  width: "100%",
+  height: "100%",
   objectFit: "contain",
   display: "block",
   pointerEvents: "none",
@@ -7717,6 +8734,36 @@ function triggerDeeplink(uri) {
   }
 }
 
+// src/walletDeeplinks.ts
+function resolveWalletDeeplink(providerId, walletDeeplinks, fallbackUri) {
+  const matchedUri = walletDeeplinks?.find((item) => item.providerId === providerId)?.uri;
+  return matchedUri ?? fallbackUri;
+}
+function classifyWalletDeeplinkNavigation(uri) {
+  if (isCustomSchemeUri(uri)) {
+    return { navigationClass: "javascript" };
+  }
+  try {
+    const parsed = new URL(uri);
+    if (isBrowseUniversalLink(parsed)) {
+      return {
+        navigationClass: "iframe-escaping-native-anchor",
+        anchorTarget: "_blank",
+        anchorRel: "noopener noreferrer"
+      };
+    }
+  } catch {
+    return { navigationClass: "javascript" };
+  }
+  return { navigationClass: "javascript" };
+}
+function shouldOpenWithJavaScript(navigation) {
+  return navigation.navigationClass === "javascript";
+}
+function isBrowseUniversalLink(parsed) {
+  return parsed.protocol === "https:" && parsed.pathname.startsWith("/ul/browse/") && parsed.searchParams.has("ref");
+}
+
 // src/sentry.ts
 var _mod;
 function captureException(error) {
@@ -7791,14 +8838,20 @@ function WalletPickerScreen({
         const rowLoader = isRowPreparing ? /* @__PURE__ */ jsxRuntime.jsx(Spinner, { size: 20 }) : void 0;
         if (usesDirectLinkCards) {
           if (directPreparedSession?.uri) {
+            const navigation = classifyWalletDeeplinkNavigation(directPreparedSession.uri);
+            const openWithJavaScript = shouldOpenWithJavaScript(navigation);
             return /* @__PURE__ */ jsxRuntime.jsx(
               SourceRow,
               {
                 logo: logoSrc,
                 name: provider.name,
                 href: directPreparedSession.uri,
+                target: navigation.anchorTarget,
+                rel: navigation.anchorRel,
                 onClick: (e) => {
-                  e.preventDefault();
+                  if (openWithJavaScript) {
+                    e.preventDefault();
+                  }
                   setSelectedProviderId(provider.id);
                   if (directPreparedSession.sessionId) {
                     void setAuthorizationSessionProvider(
@@ -7809,7 +8862,9 @@ function WalletPickerScreen({
                       captureException(err);
                     });
                   }
-                  openDeeplink(directPreparedSession.uri);
+                  if (openWithJavaScript) {
+                    openDeeplink(directPreparedSession.uri);
+                  }
                   void onSelectProvider(provider.id, directPreparedSession);
                 }
               },
@@ -8667,6 +9722,7 @@ function SelectDepositSourceScreen({
   const rowAccountId = (opt) => opt.accountId ?? fallbackAccountId;
   const isSelected = (opt) => !!selectedTokenSymbol && !!selectedChainName && !!selectedWalletId && opt.symbol === selectedTokenSymbol && opt.chainName === selectedChainName && opt.walletId === selectedWalletId;
   const tokenOptionKey = (opt) => `${opt.accountId ?? ""}-${opt.chainName}-${opt.symbol}-${opt.walletId ?? ""}`;
+  const hasPendingMobileSelection = pendingMobileSelection != null;
   const handleAuthorizedPick = (opt) => {
     onPickToken(opt.symbol, opt.chainName, opt.walletId);
     onDone();
@@ -8696,14 +9752,20 @@ function SelectDepositSourceScreen({
     handleAuthorizedPick(opt);
   };
   const footerProviderName = preparedAuthorization?.providerName ?? pendingMobileSelection?.providerName ?? "your wallet";
+  const preparedAuthorizationNavigation = preparedAuthorization ? classifyWalletDeeplinkNavigation(preparedAuthorization.deeplinkUri) : null;
+  const preparedAuthorizationOpensWithJavaScript = preparedAuthorizationNavigation ? shouldOpenWithJavaScript(preparedAuthorizationNavigation) : false;
   const footer = pendingMobileSelection ? preparedAuthorization ? /* @__PURE__ */ jsxRuntime.jsx(
     PrimaryButton,
     {
       href: preparedAuthorization.deeplinkUri,
+      target: preparedAuthorizationNavigation?.anchorTarget,
+      rel: preparedAuthorizationNavigation?.anchorRel,
       onClick: (event) => {
-        event.preventDefault();
         onCommitTokenAuthorization?.(preparedAuthorization);
-        openDeeplink(preparedAuthorization.deeplinkUri);
+        if (preparedAuthorizationOpensWithJavaScript) {
+          event.preventDefault();
+          openDeeplink(preparedAuthorization.deeplinkUri);
+        }
       },
       children: `Continue in ${footerProviderName}`
     }
@@ -8753,7 +9815,7 @@ function SelectDepositSourceScreen({
                   symbol: opt.symbol,
                   chainName: opt.chainName,
                   balance: opt.balance,
-                  selected: isSelected(opt),
+                  selected: !hasPendingMobileSelection && isSelected(opt),
                   onClick: () => handleAuthorizedPick(opt)
                 },
                 `auth-${opt.accountId ?? ""}-${opt.chainName}-${opt.symbol}-${opt.walletId ?? ""}`
@@ -8767,7 +9829,7 @@ function SelectDepositSourceScreen({
                     chainName: opt.chainName,
                     balance: opt.balance,
                     requiresAuth: true,
-                    selected: isSelected(opt) || pendingMobileSelection?.key === tokenOptionKey(opt),
+                    selected: hasPendingMobileSelection ? pendingMobileSelection?.key === tokenOptionKey(opt) : isSelected(opt),
                     onClick: () => handleRequiresAuthPick(account, opt)
                   },
                   `req-${opt.accountId ?? ""}-${opt.chainName}-${opt.symbol}-${opt.walletId ?? ""}`
@@ -9952,11 +11014,13 @@ function OpenWalletScreen({
     !loading && onRetryStatus != null && error == null,
     deeplinkUri
   );
+  const deeplinkNavigation = classifyWalletDeeplinkNavigation(deeplinkUri);
+  const openWithJavaScript = shouldOpenWithJavaScript(deeplinkNavigation);
   react.useEffect(() => {
-    if (!useDeeplink || loading || !deeplinkUri || autoOpenedRef.current === deeplinkUri) return;
+    if (!useDeeplink || loading || !deeplinkUri || !openWithJavaScript || autoOpenedRef.current === deeplinkUri) return;
     autoOpenedRef.current = deeplinkUri;
     triggerDeeplink(deeplinkUri);
-  }, [useDeeplink, loading, deeplinkUri]);
+  }, [useDeeplink, loading, deeplinkUri, openWithJavaScript]);
   const handleOpen = react.useCallback(() => {
     openDeeplink(deeplinkUri);
   }, [deeplinkUri]);
@@ -9996,7 +11060,10 @@ function OpenWalletScreen({
         /* @__PURE__ */ jsxRuntime.jsxs(
           PrimaryButton,
           {
-            onClick: handleOpen,
+            href: !openWithJavaScript ? deeplinkUri : void 0,
+            target: deeplinkNavigation.anchorTarget,
+            rel: deeplinkNavigation.anchorRel,
+            onClick: openWithJavaScript ? handleOpen : void 0,
             loading,
             loadingText: "Preparing authorization\u2026",
             children: [
@@ -10088,6 +11155,7 @@ var inlineWaitStyle = (color) => ({
 });
 function ConfirmSignScreen({
   walletName,
+  chainFamily,
   signing,
   error,
   onSign,
@@ -10096,26 +11164,28 @@ function ConfirmSignScreen({
   const { tokens } = useBlinkConfig();
   const displayName = walletName ?? "your wallet";
   const logoSrc = walletName ? KNOWN_LOGOS[walletName.toLowerCase()] : void 0;
+  const isSvmTransfer = chainFamily === "svm";
+  const heading = isSvmTransfer ? "Ready for passkey approval" : "Wallet authorized";
+  const subtitle = isSvmTransfer ? `${displayName} setup is complete. Your Solana payment signs with your passkey only.` : `${displayName} approved the connection. Tap below to confirm your payment.`;
+  const badge = isSvmTransfer ? "Wallet setup complete" : "Authorization complete";
+  const hint = isSvmTransfer ? "No wallet pop-up is needed for this transfer" : "You may be prompted for biometric verification";
   return /* @__PURE__ */ jsxRuntime.jsxs(
     ScreenLayout,
     {
       footer: /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
         /* @__PURE__ */ jsxRuntime.jsx(PrimaryButton, { onClick: onSign, disabled: signing, children: "Confirm payment" }),
         error && /* @__PURE__ */ jsxRuntime.jsx("p", { style: errorStyle2(tokens.textMuted), children: error }),
-        !error && /* @__PURE__ */ jsxRuntime.jsx("p", { style: hintStyle(tokens.textMuted), children: "You may be prompted for biometric verification" })
+        !error && /* @__PURE__ */ jsxRuntime.jsx("p", { style: hintStyle(tokens.textMuted), children: hint })
       ] }),
       children: [
         /* @__PURE__ */ jsxRuntime.jsx(ScreenHeader, { onLogout }),
         /* @__PURE__ */ jsxRuntime.jsxs("div", { style: contentStyle15, children: [
           logoSrc ? /* @__PURE__ */ jsxRuntime.jsx("img", { src: logoSrc, alt: displayName, style: logoStyle3 }) : /* @__PURE__ */ jsxRuntime.jsx(Spinner, { size: 48 }),
-          /* @__PURE__ */ jsxRuntime.jsx("h2", { style: headingStyle14(tokens.text), children: "Wallet authorized" }),
-          /* @__PURE__ */ jsxRuntime.jsxs("p", { style: subtitleStyle11(tokens.textSecondary), children: [
-            displayName,
-            " approved the connection. Tap below to confirm your payment."
-          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("h2", { style: headingStyle14(tokens.text), children: heading }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { style: subtitleStyle11(tokens.textSecondary), children: subtitle }),
           /* @__PURE__ */ jsxRuntime.jsxs("div", { style: successBadgeStyle(tokens), children: [
             /* @__PURE__ */ jsxRuntime.jsx("span", { style: checkmarkStyle, children: "\u2713" }),
-            /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Authorization complete" })
+            /* @__PURE__ */ jsxRuntime.jsx("span", { children: badge })
           ] })
         ] })
       ]
@@ -10858,6 +11928,7 @@ function buildConfirmSignScreenProps({
 }) {
   return {
     walletName: flow.state.providers.find((p) => p.id === flow.state.selectedProviderId)?.name ?? null,
+    chainFamily: remote.pollingTransfer?.signPayload?.chainFamily ?? null,
     signing: remote.transferSigningSigning,
     error: flow.state.error || remote.transferSigningError,
     onSign: handlers.onConfirmSign,
@@ -11078,6 +12149,19 @@ function buildSuccessScreenProps({
     onLogout: authenticated ? handlers.onLogout : void 0
   };
 }
+function buildAmountTooLowScreenProps({
+  flow,
+  handlers
+}) {
+  const { state, onDismiss } = flow;
+  const minAmountUsd = state.phase.step === "amount-too-low" ? state.phase.minAmountUsd : state.amountTooLow?.minAmountUsd ?? flow.minTransferAmountUsd;
+  const canRetry = flow.depositAmount == null;
+  return {
+    minAmountUsd,
+    onRetry: canRetry ? handlers.onNewPayment : void 0,
+    onClose: onDismiss
+  };
+}
 function StepRenderer(props) {
   const screen = screenForPhase(props.flow.state.phase);
   return /* @__PURE__ */ jsxRuntime.jsx(StepRendererContent, { ...props, screen });
@@ -11145,6 +12229,8 @@ function StepRendererContent({
       return /* @__PURE__ */ jsxRuntime.jsx(SelectSourceScreen, { ...buildSelectSourceScreenProps(input) });
     case "success":
       return /* @__PURE__ */ jsxRuntime.jsx(SuccessScreen, { ...buildSuccessScreenProps(input) });
+    case "amount-too-low":
+      return /* @__PURE__ */ jsxRuntime.jsx(AmountTooLowScreen, { ...buildAmountTooLowScreenProps(input) });
     default: {
       const _exhaustive = screen;
       throw new Error(`Unhandled screen: ${_exhaustive}`);
@@ -11574,9 +12660,8 @@ function useTransferHandlers(deps) {
     destination
   ]);
   const handlePay = react.useCallback(async (payAmount, sourceOverrides) => {
-    const minUsd = effectiveMinTransferAmountUsd(depositAmount, minTransferAmountUsd);
-    if (isNaN(payAmount) || payAmount < minUsd) {
-      dispatch({ type: "SET_ERROR", error: `Minimum amount is $${minUsd.toFixed(2)}.` });
+    if (isNaN(payAmount) || payAmount < minTransferAmountUsd) {
+      dispatch({ type: "AMOUNT_TOO_LOW", minAmountUsd: minTransferAmountUsd });
       return;
     }
     if (!sourceOverrides?.sourceId && !sourceId) {
@@ -11627,7 +12712,10 @@ function useTransferHandlers(deps) {
         );
         clearPendingTransferState();
         dispatch({ type: "TRANSFER_CREATED", transfer: stagedTransfer });
-        const signedTransfer2 = await transferSigning.signTransfer(stagedTransfer.id);
+        const signedTransfer2 = await transferSigning.signTransfer(
+          stagedTransfer.id,
+          { knownSignPayload: stagedTransfer.signPayload }
+        );
         dispatch({ type: "TRANSFER_SIGNED", transfer: signedTransfer2 });
         polling.startPolling(stagedTransfer.id);
         return;
@@ -11658,7 +12746,10 @@ function useTransferHandlers(deps) {
         polling.startPolling(t.id);
         return;
       }
-      const signedTransfer = await transferSigning.signTransfer(t.id);
+      const signedTransfer = await transferSigning.signTransfer(
+        t.id,
+        { knownSignPayload: t.signPayload }
+      );
       dispatch({ type: "TRANSFER_SIGNED", transfer: signedTransfer });
       polling.startPolling(t.id);
     } catch (err) {
@@ -11865,12 +12956,6 @@ function useMobileFlowHandlers(dispatch, polling, reloadAccounts, pollingTransfe
   };
 }
 
-// src/walletDeeplinks.ts
-function resolveWalletDeeplink(providerId, walletDeeplinks, fallbackUri) {
-  const matchedUri = walletDeeplinks?.find((item) => item.providerId === providerId)?.uri;
-  return matchedUri ?? fallbackUri;
-}
-
 // src/hooks/providerSelectionGuards.ts
 function resolveSetupFlowDepositAmount({
   hasActiveWallet: hasActiveWallet2,
@@ -11937,9 +13022,10 @@ function buildDesktopDirectDuringSetupRunOptions() {
     alwaysPauseForOneTap: true
   };
 }
-function buildDesktopTokenAuthorizationRunOptions(chainName, tokenSymbol) {
+function buildDesktopTokenAuthorizationRunOptions(chainName, tokenSymbol, _chainFamily = "evm") {
+  const options = buildDesktopDirectDuringSetupRunOptions();
   return {
-    ...buildDesktopDirectDuringSetupRunOptions(),
+    ...options,
     // Token authorization should batch like the first-time desktop setup flow:
     // auto-resolve SELECT_SOURCE now, then inject the transfer session during one-tap setup.
     autoResolveSource: { chainName, tokenSymbol }
@@ -12608,10 +13694,10 @@ function useProviderHandlers(deps) {
     dispatch({ type: "SET_ERROR", error: null });
     dispatch({ type: "SET_INCREASING_LIMIT", value: true });
     dispatch({ type: "SET_SETUP_DEPOSIT_AMOUNT", amount: depositAmount ?? 5 });
-    let desktopChainName = null;
+    let desktopChain = null;
     if (!isMobile) {
-      desktopChainName = chains.find((chain) => chain.commonId === chainId)?.name ?? null;
-      if (!desktopChainName) {
+      desktopChain = chains.find((chain) => chain.commonId === chainId) ?? null;
+      if (!desktopChain) {
         dispatch({ type: "SET_INCREASING_LIMIT", value: false });
         dispatch({ type: "SET_SETUP_DEPOSIT_AMOUNT", amount: null });
         dispatch({ type: "SET_ERROR", error: `No chain found for chainId ${chainId}` });
@@ -12620,7 +13706,7 @@ function useProviderHandlers(deps) {
       dispatch({
         type: "SET_SETUP_DEPOSIT_TOKEN",
         symbol: tokenSymbol,
-        chainName: desktopChainName,
+        chainName: desktopChain.name,
         walletId: _walletId,
         tokenAddress,
         chainId
@@ -12654,7 +13740,11 @@ function useProviderHandlers(deps) {
         dispatch({ type: "SET_SETUP_FLOW_SCREEN", screen: "one-tap-setup" });
         const result = await orchestrator.run(
           session.id,
-          buildDesktopTokenAuthorizationRunOptions(desktopChainName, tokenSymbol)
+          buildDesktopTokenAuthorizationRunOptions(
+            desktopChain.name,
+            tokenSymbol,
+            desktopChain.chainFamily
+          )
         );
         if (result.status === "cancelled") {
           dispatch({ type: "SET_SETUP_DEPOSIT_AMOUNT", amount: null });
@@ -14060,6 +15150,11 @@ function BlinkPaymentInner({
       dispatch({ type: "SYNC_AMOUNT", amount: depositAmount.toString() });
     }
   }, [depositAmount, dispatch]);
+  react.useEffect(() => {
+    if (depositAmount != null && depositAmount < minTransferAmountUsd) {
+      dispatch({ type: "AMOUNT_TOO_LOW", minAmountUsd: minTransferAmountUsd });
+    }
+  }, [depositAmount, minTransferAmountUsd, dispatch]);
   react.useEffect(() => {
     if (!ready || effectiveAuthenticated) return;
     clearLocalSessionArtifacts();