@abstraxn/signer-react 3.3.8 → 3.3.9

package/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.3.9] - 2026-09-17
+
+### Fixed
+- **Mobile WalletConnect `writeContract` loader stuck after MetaMask confirm** – On iOS/Android the browser often drops the WalletConnect relay while MetaMask is open, so `eth_sendTransaction` never returns even though the tx is on-chain. `useWriteContract` now races the wallet call against an RPC scan for the matching outgoing contract tx (`from` / `to` / function selector) and clears pending WC mobile flags when the hash is recovered that way.
+- **Stacked “Open in MetaMask?” / “All Wallets” after an already-connected session** – Auto-deeplink and WalletConnect modal restore are skipped when a WC session already exists; only the connect flow may schedule a single wallet open. Connected sessions hide the picker instead of reopening it.
+
+### Changed
+- **Chain-poll recovery is gated** – The on-chain hash poll runs only for WalletConnect when the device is mobile or the document is `hidden`. Desktop injected wallets and idle desktop WC keep the plain `writeContract` path (no always-on poll).
+- **`gasLimit` on `useWriteContract`** – Mapped to viem’s `gas` option on the direct `walletClient.writeContract` path so callers that pass `gasLimit` are honored.
+
+### Added
+- Public helpers: `pollForOutgoingTx`, `clearWalletConnectPendingState`, `waitUntilDocumentVisible`, `isWalletConnectConnector`, `isMobileDevice`.
+
 ## [3.3.8] - 2026-09-16
 
 ### Fixed

package/dist/src/hooks.d.ts

@@ -360,15 +360,15 @@ export declare function usePublicClient(chain: Chain, rpcUrl: string): {
             transactions: includeTransactions extends true ? ({
                 input: import("viem").Hex;
                 s: import("viem").Hex;
-                type: "legacy";
+                from: Address;
+                to: Address | null;
                 value: bigint;
+                hash: import("viem").Hash;
+                type: "legacy";
                 yParity?: undefined | undefined;
-                from: Address;
                 gas: bigint;
-                hash: import("viem").Hash;
                 nonce: number;
                 r: import("viem").Hex;
-                to: Address | null;
                 typeHex: import("viem").Hex | null;
                 v: bigint;
                 accessList?: undefined | undefined;
@@ -385,15 +385,15 @@ export declare function usePublicClient(chain: Chain, rpcUrl: string): {
             } | {
                 input: import("viem").Hex;
                 s: import("viem").Hex;
-                type: "eip2930";
+                from: Address;
+                to: Address | null;
                 value: bigint;
+                hash: import("viem").Hash;
+                type: "eip2930";
                 yParity: number;
-                from: Address;
                 gas: bigint;
-                hash: import("viem").Hash;
                 nonce: number;
                 r: import("viem").Hex;
-                to: Address | null;
                 typeHex: import("viem").Hex | null;
                 v: bigint;
                 accessList: import("viem").AccessList;
@@ -410,15 +410,15 @@ export declare function usePublicClient(chain: Chain, rpcUrl: string): {
             } | {
                 input: import("viem").Hex;
                 s: import("viem").Hex;
-                type: "eip1559";
+                from: Address;
+                to: Address | null;
                 value: bigint;
+                hash: import("viem").Hash;
+                type: "eip1559";
                 yParity: number;
-                from: Address;
                 gas: bigint;
-                hash: import("viem").Hash;
                 nonce: number;
                 r: import("viem").Hex;
-                to: Address | null;
                 typeHex: import("viem").Hex | null;
                 v: bigint;
                 accessList: import("viem").AccessList;
@@ -435,15 +435,15 @@ export declare function usePublicClient(chain: Chain, rpcUrl: string): {
             } | {
                 input: import("viem").Hex;
                 s: import("viem").Hex;
-                type: "eip4844";
+                from: Address;
+                to: Address | null;
                 value: bigint;
+                hash: import("viem").Hash;
+                type: "eip4844";
                 yParity: number;
-                from: Address;
                 gas: bigint;
-                hash: import("viem").Hash;
                 nonce: number;
                 r: import("viem").Hex;
-                to: Address | null;
                 typeHex: import("viem").Hex | null;
                 v: bigint;
                 accessList: import("viem").AccessList;
@@ -460,15 +460,15 @@ export declare function usePublicClient(chain: Chain, rpcUrl: string): {
             } | {
                 input: import("viem").Hex;
                 s: import("viem").Hex;
-                type: "eip7702";
+                from: Address;
+                to: Address | null;
                 value: bigint;
+                hash: import("viem").Hash;
+                type: "eip7702";
                 yParity: number;
-                from: Address;
                 gas: bigint;
-                hash: import("viem").Hash;
                 nonce: number;
                 r: import("viem").Hex;
-                to: Address | null;
                 typeHex: import("viem").Hex | null;
                 v: bigint;
                 accessList: import("viem").AccessList;
@@ -510,15 +510,15 @@ export declare function usePublicClient(chain: Chain, rpcUrl: string): {
         getTransaction: <blockTag extends import("viem").BlockTag = "latest">(args: import("viem").GetTransactionParameters<blockTag>) => Promise<{
             input: import("viem").Hex;
             s: import("viem").Hex;
-            type: "legacy";
+            from: Address;
+            to: Address | null;
             value: bigint;
+            hash: import("viem").Hash;
+            type: "legacy";
             yParity?: undefined | undefined;
-            from: Address;
             gas: bigint;
-            hash: import("viem").Hash;
             nonce: number;
             r: import("viem").Hex;
-            to: Address | null;
             typeHex: import("viem").Hex | null;
             v: bigint;
             accessList?: undefined | undefined;
@@ -535,15 +535,15 @@ export declare function usePublicClient(chain: Chain, rpcUrl: string): {
         } | {
             input: import("viem").Hex;
             s: import("viem").Hex;
-            type: "eip2930";
+            from: Address;
+            to: Address | null;
             value: bigint;
+            hash: import("viem").Hash;
+            type: "eip2930";
             yParity: number;
-            from: Address;
             gas: bigint;
-            hash: import("viem").Hash;
             nonce: number;
             r: import("viem").Hex;
-            to: Address | null;
             typeHex: import("viem").Hex | null;
             v: bigint;
             accessList: import("viem").AccessList;
@@ -560,15 +560,15 @@ export declare function usePublicClient(chain: Chain, rpcUrl: string): {
         } | {
             input: import("viem").Hex;
             s: import("viem").Hex;
-            type: "eip1559";
+            from: Address;
+            to: Address | null;
             value: bigint;
+            hash: import("viem").Hash;
+            type: "eip1559";
             yParity: number;
-            from: Address;
             gas: bigint;
-            hash: import("viem").Hash;
             nonce: number;
             r: import("viem").Hex;
-            to: Address | null;
             typeHex: import("viem").Hex | null;
             v: bigint;
             accessList: import("viem").AccessList;
@@ -585,15 +585,15 @@ export declare function usePublicClient(chain: Chain, rpcUrl: string): {
         } | {
             input: import("viem").Hex;
             s: import("viem").Hex;
-            type: "eip4844";
+            from: Address;
+            to: Address | null;
             value: bigint;
+            hash: import("viem").Hash;
+            type: "eip4844";
             yParity: number;
-            from: Address;
             gas: bigint;
-            hash: import("viem").Hash;
             nonce: number;
             r: import("viem").Hex;
-            to: Address | null;
             typeHex: import("viem").Hex | null;
             v: bigint;
             accessList: import("viem").AccessList;
@@ -610,15 +610,15 @@ export declare function usePublicClient(chain: Chain, rpcUrl: string): {
         } | {
             input: import("viem").Hex;
             s: import("viem").Hex;
-            type: "eip7702";
+            from: Address;
+            to: Address | null;
             value: bigint;
+            hash: import("viem").Hash;
+            type: "eip7702";
             yParity: number;
-            from: Address;
             gas: bigint;
-            hash: import("viem").Hash;
             nonce: number;
             r: import("viem").Hex;
-            to: Address | null;
             typeHex: import("viem").Hex | null;
             v: bigint;
             accessList: import("viem").AccessList;

package/dist/src/hooks.js

@@ -9,10 +9,10 @@ import { toAccount } from 'viem/accounts';
 import { Connection as SolanaConnection, Transaction as SolanaTransaction, SystemProgram, PublicKey, LAMPORTS_PER_SOL, TransactionInstruction, } from '@solana/web3.js';
 import { SolanaRelayer } from '@abstraxn/solana-relayer';
 import { useWalletClient as useWagmiWalletClient, useAccount, useConfig, useChainId as useWagmiChainId, useSwitchChain as useWagmiSwitchChain, useSignMessage as useWagmiSignMessage, useReconnect as useWagmiReconnect } from 'wagmi';
-import { getWalletClient, switchChain } from '@wagmi/core';
+import { getWalletClient, switchChain, getPublicClient } from '@wagmi/core';
 import { getConnectorMeta } from './connectors';
 import { getChainById } from './chains';
-import { waitUntilDocumentVisible } from './walletConnectMobile';
+import { waitUntilDocumentVisible, pollForOutgoingTx, clearWalletConnectPendingState, isWalletConnectConnector, isMobileDevice, } from './walletConnectMobile';
 /**
  * Hook to check if wallet is connected
  */
@@ -2430,69 +2430,129 @@ export function useWriteContract() {
             }
             // Cast to any to avoid type issues with different viem versions
             const walletClientAny = activeClient;
-            // Try using writeContract method directly if available
-            if (walletClientAny && typeof walletClientAny.writeContract === 'function') {
-                return walletClientAny.writeContract({
+            const fromAddress = account ||
+                walletClientAny?.account?.address;
+            const resolvedGas = gas !== undefined ? gas : gasLimit !== undefined ? gasLimit : undefined;
+            const sendWrite = async () => {
+                // Try using writeContract method directly if available
+                if (walletClientAny && typeof walletClientAny.writeContract === 'function') {
+                    return walletClientAny.writeContract({
+                        address,
+                        abi: abi,
+                        functionName: functionName,
+                        args: args,
+                        value,
+                        account,
+                        gas: resolvedGas,
+                        gasPrice,
+                        maxFeePerGas,
+                        maxPriorityFeePerGas,
+                        nonce,
+                        chain: null, // Let the client determine the chain (or use current)
+                    });
+                }
+                // If writeContract is not available, use getContract to create a contract instance
+                // This works with wagmi's connectorClient
+                const contract = getContract({
                     address,
+                    abi: abi,
+                    client: walletClientAny,
+                });
+                // Get the write function from the contract
+                const writeFunction = contract.write?.[functionName];
+                if (!writeFunction || typeof writeFunction !== 'function') {
+                    throw new Error(`Function "${functionName}" not found in contract ABI or is not a write function. ` +
+                        'Make sure the function exists in the ABI and is a state-changing function.');
+                }
+                // Prepare the call options (viem contract write methods accept options as the last parameter)
+                const hasOptions = value !== undefined || account !== undefined || resolvedGas !== undefined ||
+                    gasPrice !== undefined || maxFeePerGas !== undefined ||
+                    maxPriorityFeePerGas !== undefined || nonce !== undefined;
+                // Viem contract write methods expect args as an array, not spread
+                const functionArgs = args || [];
+                if (hasOptions) {
+                    const callOptions = {};
+                    if (value !== undefined)
+                        callOptions.value = value;
+                    if (account !== undefined)
+                        callOptions.account = account;
+                    if (resolvedGas !== undefined)
+                        callOptions.gas = resolvedGas;
+                    if (gasPrice !== undefined)
+                        callOptions.gasPrice = gasPrice;
+                    if (maxFeePerGas !== undefined)
+                        callOptions.maxFeePerGas = maxFeePerGas;
+                    if (maxPriorityFeePerGas !== undefined)
+                        callOptions.maxPriorityFeePerGas = maxPriorityFeePerGas;
+                    if (nonce !== undefined)
+                        callOptions.nonce = nonce;
+                    return writeFunction(functionArgs, callOptions);
+                }
+                return writeFunction(functionArgs);
+            };
+            // Mobile WalletConnect: MetaMask confirms on-chain but eth_sendTransaction
+            // never resolves if the relay WS died while the browser was backgrounded.
+            // Only race an RPC scan in that scenario — not for desktop / injected wallets.
+            const publicClient = getPublicClient(config, {
+                chainId: currentChainId,
+            });
+            const documentHidden = typeof document !== "undefined" &&
+                document.visibilityState === "hidden";
+            const shouldPollForWcHang = isWalletConnectConnector(connector) &&
+                (isMobileDevice() || documentHidden);
+            if (!shouldPollForWcHang || !publicClient || !fromAddress) {
+                return sendWrite();
+            }
+            let startBlock = 0n;
+            try {
+                startBlock = await publicClient.getBlockNumber();
+            }
+            catch {
+                // ignore — poll will use a recent window
+            }
+            let dataPrefix;
+            try {
+                const data = encodeFunctionData({
                     abi: abi,
                     functionName: functionName,
                     args: args,
-                    value,
-                    account,
-                    gas,
-                    gasPrice,
-                    maxFeePerGas,
-                    maxPriorityFeePerGas,
-                    nonce,
-                    chain: null, // Let the client determine the chain (or use current)
                 });
+                dataPrefix = data.slice(0, 10);
             }
-            // If writeContract is not available, use getContract to create a contract instance
-            // This works with wagmi's connectorClient
-            const contract = getContract({
-                address,
-                abi: abi,
-                client: walletClientAny,
+            catch {
+                // Matching without selector is still useful (from + to).
+            }
+            const cancelPoll = { cancelled: false };
+            const sendPromise = sendWrite();
+            const pollPromise = pollForOutgoingTx({
+                publicClient,
+                from: fromAddress,
+                to: address,
+                dataPrefix,
+                value,
+                startBlock,
+                signal: cancelPoll,
+                initialDelayMs: 10_000,
+                timeoutMs: 90_000,
             });
-            // Get the write function from the contract
-            const writeFunction = contract.write?.[functionName];
-            if (!writeFunction || typeof writeFunction !== 'function') {
-                throw new Error(`Function "${functionName}" not found in contract ABI or is not a write function. ` +
-                    'Make sure the function exists in the ABI and is a state-changing function.');
+            try {
+                const hash = await Promise.race([sendPromise, pollPromise]);
+                // Poll may win while WC is still hanging — ignore a late reject.
+                void sendPromise.then(() => undefined, () => undefined);
+                return hash;
             }
-            // Prepare the call options (viem contract write methods accept options as the last parameter)
-            const hasOptions = value !== undefined || account !== undefined || gas !== undefined || gasLimit !== undefined ||
-                gasPrice !== undefined || maxFeePerGas !== undefined ||
-                maxPriorityFeePerGas !== undefined || nonce !== undefined;
-            // Viem contract write methods expect args as an array, not spread
-            const functionArgs = args || [];
-            if (hasOptions) {
-                const callOptions = {};
-                if (value !== undefined)
-                    callOptions.value = value;
-                if (account !== undefined)
-                    callOptions.account = account;
-                // `gas` in viem is the gas *limit*. Allow either `gas` or `gasLimit` from the hook caller.
-                if (gas !== undefined) {
-                    callOptions.gas = gas;
+            finally {
+                cancelPoll.cancelled = true;
+                try {
+                    const getProvider = connector?.getProvider;
+                    if (typeof getProvider === 'function') {
+                        const provider = await getProvider();
+                        clearWalletConnectPendingState(provider);
+                    }
                 }
-                else if (gasLimit !== undefined) {
-                    callOptions.gas = gasLimit;
+                catch {
+                    // ignore
                 }
-                if (gasPrice !== undefined)
-                    callOptions.gasPrice = gasPrice;
-                if (maxFeePerGas !== undefined)
-                    callOptions.maxFeePerGas = maxFeePerGas;
-                if (maxPriorityFeePerGas !== undefined)
-                    callOptions.maxPriorityFeePerGas = maxPriorityFeePerGas;
-                if (nonce !== undefined)
-                    callOptions.nonce = nonce;
-                // Call the write function with args array and options object
-                return writeFunction(functionArgs, callOptions);
-            }
-            else {
-                // Call the write function with args array only
-                return writeFunction(functionArgs);
             }
         })();
     }, [hookClient, isPending, isError, error, isConnected, config, currentChainId, reconnect, connector]);

package/dist/src/index.d.ts

@@ -16,3 +16,4 @@ export type { OnboardingUIComponentProps, OnboardingUIComponentRef } from './Onb
 export { ALL_CHAINS, EVM_CHAINS, SOLANA_CHAINS, getChainById, getChainsByType, getDefaultChains, toCoreChain, type ChainData, } from './chains';
 export { CONNECTORS, getConnectorMeta, isOAuthConnector, isWalletConnector, isAuthConnector, type ConnectorType, type ConnectorMeta, } from './connectors';
 export { createWagmiConfig } from './wagmiConfig';
+export { pollForOutgoingTx, clearWalletConnectPendingState, waitUntilDocumentVisible, isWalletConnectConnector, isMobileDevice, } from './walletConnectMobile';

package/dist/src/index.js

@@ -11,4 +11,5 @@ export { OnboardingUIComponent as OnboardingUI } from './OnboardingUI';
 export { ALL_CHAINS, EVM_CHAINS, SOLANA_CHAINS, getChainById, getChainsByType, getDefaultChains, toCoreChain, } from './chains';
 export { CONNECTORS, getConnectorMeta, isOAuthConnector, isWalletConnector, isAuthConnector, } from './connectors';
 export { createWagmiConfig } from './wagmiConfig';
+export { pollForOutgoingTx, clearWalletConnectPendingState, waitUntilDocumentVisible, isWalletConnectConnector, isMobileDevice, } from './walletConnectMobile';
 //# sourceMappingURL=index.js.map

package/dist/src/walletConnectMobile.d.ts

@@ -34,12 +34,34 @@ export declare function getDappReturnUrl(): string;
  * navigating Safari to a new URL (which reloads and drops in-memory state).
  */
 export declare function getSourceBrowserNativeRedirect(): string | undefined;
+export declare function isMobileDevice(): boolean;
+/**
+ * Undo the inline `display: none !important` we apply after connect so the
+ * WalletConnect modal can show "Continue in wallet" and process the response.
+ * Prefer hideWalletConnectModal() once a session already exists — restoring
+ * during a later tx reopens the "All Wallets" picker on top of MetaMask.
+ */
+export declare function restoreWalletConnectModal(): void;
+/** Force-close / hide Reown AppKit + WalletConnect modal DOM after connect or tx. */
+export declare function hideWalletConnectModal(provider?: any): void;
 /**
  * Open the already-connected wallet app so the user sees the confirmation UI.
  * WalletConnect often sends the session_request but does not deeplink on a
  * later tx if the QR modal is hidden — Create Proposal then sits on a loader.
+ *
+ * When a session already exists, do NOT reopen the WC "All Wallets" modal —
+ * that stacks under the iOS "Open in MetaMask?" prompt and stays after confirm.
+ *
+ * Returns false if skipped (already backgrounded / already opened once).
+ */
+export declare function openConnectedWalletApp(provider: any): boolean;
+/**
+ * At most one MetaMask deeplink per approval request.
+ * Extra retries queue iOS "Open in MetaMask?" prompts that stay on screen
+ * after the tx is already confirmed (JS cannot dismiss that system dialog).
+ * Cancel remaining work as soon as the tab is backgrounded (user opened MM).
  */
-export declare function openConnectedWalletApp(provider: any): void;
+export declare function scheduleOpenConnectedWalletApp(provider: any, delaysMs?: number[]): () => void;
 /**
  * Lazy metadata so url/redirect are read at connect/request time, not at
  * provider mount (which is often the homepage in Next.js layouts).
@@ -81,10 +103,36 @@ export declare function resumeWalletConnectRelayer(provider: any, options?: {
 /** Resolves when the dapp tab is in the foreground again (mobile wallet return). */
 export declare function waitUntilDocumentVisible(): Promise<void>;
 /**
- * Undo the inline `display: none !important` we apply after connect so the
- * WalletConnect modal can show "Continue in wallet" and process the response.
+ * Clear mobile WC pending flags after we recover the tx hash from chain
+ * (poll won while eth_sendTransaction is still hanging).
  */
-export declare function restoreWalletConnectModal(): void;
+export declare function clearWalletConnectPendingState(provider: any): void;
+/**
+ * When WalletConnect never returns eth_sendTransaction after MetaMask approve,
+ * scan recent blocks for a matching outgoing tx (from/to + optional calldata prefix).
+ */
+export declare function pollForOutgoingTx(params: {
+    publicClient: {
+        getBlockNumber: () => Promise<bigint>;
+        getBlock: (args: {
+            blockNumber: bigint;
+            includeTransactions: boolean;
+        }) => Promise<{
+            transactions?: unknown[];
+        } | null>;
+    };
+    from: string;
+    to: string;
+    /** Match tx.input prefix (e.g. 0x + 4-byte selector). */
+    dataPrefix?: string;
+    value?: bigint;
+    startBlock: bigint;
+    signal: {
+        cancelled: boolean;
+    };
+    timeoutMs?: number;
+    initialDelayMs?: number;
+}): Promise<`0x${string}`>;
 /**
  * Patch the EIP-1193 provider so signing/tx requests resume the relay first.
  * Covers wagmi hooks, viem walletClient, and direct provider.request calls.

package/dist/src/walletConnectMobile.js

@@ -128,7 +128,7 @@ function isAndroid() {
         return false;
     return /Android/i.test(navigator.userAgent || "");
 }
-function isMobileDevice() {
+export function isMobileDevice() {
     return isIOS() || isAndroid();
 }
 function isWalletHttpDeepLink(url) {
@@ -151,50 +151,185 @@ function canOpenAsWalletApp(url) {
         return isWalletHttpDeepLink(url);
     return true;
 }
+function navigateToWalletDeepLink(target) {
+    if (!target || typeof window === "undefined")
+        return;
+    try {
+        // Prefer an invisible <a> click — more reliable than location.href behind
+        // iOS "open another application?" prompts and after a prior soft navigation.
+        const a = document.createElement("a");
+        a.href = target;
+        a.rel = "noreferrer";
+        a.style.display = "none";
+        document.body.appendChild(a);
+        a.click();
+        a.remove();
+    }
+    catch {
+        try {
+            window.location.href = target;
+        }
+        catch {
+            // Ignore
+        }
+    }
+}
+/**
+ * Undo the inline `display: none !important` we apply after connect so the
+ * WalletConnect modal can show "Continue in wallet" and process the response.
+ * Prefer hideWalletConnectModal() once a session already exists — restoring
+ * during a later tx reopens the "All Wallets" picker on top of MetaMask.
+ */
+export function restoreWalletConnectModal() {
+    if (typeof document === "undefined")
+        return;
+    WALLETCONNECT_MODAL_SELECTORS.forEach((sel) => {
+        try {
+            document.querySelectorAll(sel).forEach((el) => {
+                const htmlEl = el;
+                if (htmlEl?.style) {
+                    htmlEl.style.removeProperty("display");
+                }
+            });
+        }
+        catch {
+            // Ignore invalid selectors in older browsers.
+        }
+    });
+}
+/** Force-close / hide Reown AppKit + WalletConnect modal DOM after connect or tx. */
+export function hideWalletConnectModal(provider) {
+    try {
+        if (typeof provider?.modal?.close === "function") {
+            provider.modal.close();
+        }
+    }
+    catch {
+        // Ignore
+    }
+    if (typeof document === "undefined")
+        return;
+    WALLETCONNECT_MODAL_SELECTORS.forEach((sel) => {
+        try {
+            document.querySelectorAll(sel).forEach((el) => {
+                try {
+                    if (typeof el.close === "function") {
+                        el.close();
+                    }
+                }
+                catch {
+                    // Ignore
+                }
+                const htmlEl = el;
+                if (htmlEl?.style) {
+                    htmlEl.style.setProperty("display", "none", "important");
+                }
+            });
+        }
+        catch {
+            // Ignore invalid selectors
+        }
+    });
+}
 /**
  * Open the already-connected wallet app so the user sees the confirmation UI.
  * WalletConnect often sends the session_request but does not deeplink on a
  * later tx if the QR modal is hidden — Create Proposal then sits on a loader.
+ *
+ * When a session already exists, do NOT reopen the WC "All Wallets" modal —
+ * that stacks under the iOS "Open in MetaMask?" prompt and stays after confirm.
+ *
+ * Returns false if skipped (already backgrounded / already opened once).
  */
 export function openConnectedWalletApp(provider) {
     if (typeof window === "undefined" || !isMobileDevice())
-        return;
-    restoreWalletConnectModal();
-    try {
-        if (typeof provider?.modal?.open === "function") {
-            void provider.modal.open();
+        return false;
+    // Never queue another metamask:// while the tab is already leaving / hidden —
+    // those become stuck "Open in MetaMask?" dialogs after the user returns.
+    if (typeof document !== "undefined" && document.visibilityState === "hidden") {
+        return false;
+    }
+    if (provider?.__abstraxnWcDeeplinkOpened) {
+        return false;
+    }
+    const hasSession = hasActiveWalletConnectSession(provider);
+    // Only touch the WC modal when there is no session yet (connect flow).
+    // For later txs, deeplink straight into the peer wallet app.
+    if (!hasSession) {
+        restoreWalletConnectModal();
+        try {
+            if (typeof provider?.modal?.open === "function") {
+                void provider.modal.open();
+            }
+        }
+        catch {
+            // Modal may not exist after we force-hid it post-connect.
         }
     }
-    catch {
-        // Modal may not exist after we force-hid it post-connect.
+    else {
+        // Keep the picker closed while MetaMask opens.
+        hideWalletConnectModal(provider);
     }
     const peer = provider?.session?.peer?.metadata ??
         provider?.signer?.session?.peer?.metadata;
     const native = String(peer?.redirect?.native || "");
     const universal = String(peer?.redirect?.universal || "");
     const name = String(peer?.name || "").toLowerCase();
-    let target = "";
+    const candidates = [];
     if (canOpenAsWalletApp(native))
-        target = native;
-    else if (canOpenAsWalletApp(universal))
-        target = universal;
-    else if (name.includes("metamask") || !name) {
-        target = isIOS() ? "metamask://" : "https://metamask.app.link/wc";
+        candidates.push(native);
+    if (canOpenAsWalletApp(universal))
+        candidates.push(universal);
+    if (name.includes("metamask") || !name) {
+        candidates.push(isIOS() ? "metamask://" : "https://metamask.app.link/wc", "https://metamask.app.link/wc");
     }
     else if (name.includes("rainbow")) {
-        target = "rainbow://";
+        candidates.push("rainbow://");
     }
     else if (name.includes("trust")) {
-        target = "trust://";
-    }
-    if (!target)
-        return;
-    try {
-        window.location.href = target;
-    }
-    catch {
-        // Ignore
+        candidates.push("trust://");
     }
+    const unique = [...new Set(candidates.filter(Boolean))];
+    if (!unique.length)
+        return false;
+    provider.__abstraxnWcDeeplinkOpened = true;
+    navigateToWalletDeepLink(unique[0]);
+    return true;
+}
+/**
+ * At most one MetaMask deeplink per approval request.
+ * Extra retries queue iOS "Open in MetaMask?" prompts that stay on screen
+ * after the tx is already confirmed (JS cannot dismiss that system dialog).
+ * Cancel remaining work as soon as the tab is backgrounded (user opened MM).
+ */
+export function scheduleOpenConnectedWalletApp(provider, delaysMs = [150]) {
+    if (typeof window === "undefined" || !isMobileDevice())
+        return () => { };
+    provider.__abstraxnWcDeeplinkOpened = false;
+    const timers = [];
+    let cancelled = false;
+    const cancel = () => {
+        cancelled = true;
+        timers.splice(0).forEach((id) => window.clearTimeout(id));
+        if (typeof document !== "undefined") {
+            document.removeEventListener("visibilitychange", onHidden);
+        }
+    };
+    const onHidden = () => {
+        if (document.visibilityState === "hidden") {
+            // User is in (or opening) MetaMask — stop any further deeplinks.
+            cancel();
+        }
+    };
+    document.addEventListener("visibilitychange", onHidden);
+    delaysMs.forEach((ms) => {
+        timers.push(window.setTimeout(() => {
+            if (cancelled)
+                return;
+            openConnectedWalletApp(provider);
+        }, ms));
+    });
+    return cancel;
 }
 function getWalletConnectRedirect() {
     const native = getSourceBrowserNativeRedirect();
@@ -418,25 +553,83 @@ export function waitUntilDocumentVisible() {
     });
 }
 /**
- * Undo the inline `display: none !important` we apply after connect so the
- * WalletConnect modal can show "Continue in wallet" and process the response.
+ * Clear mobile WC pending flags after we recover the tx hash from chain
+ * (poll won while eth_sendTransaction is still hanging).
  */
-export function restoreWalletConnectModal() {
-    if (typeof document === "undefined")
+export function clearWalletConnectPendingState(provider) {
+    if (!provider)
         return;
-    WALLETCONNECT_MODAL_SELECTORS.forEach((sel) => {
+    try {
+        provider[PENDING_FLAG] = 0;
+        provider[NEEDS_RESUME_FLAG] = false;
+        provider.__abstraxnWcDeeplinkOpened = true;
+        hideWalletConnectModal(provider);
+    }
+    catch {
+        // ignore
+    }
+}
+/**
+ * When WalletConnect never returns eth_sendTransaction after MetaMask approve,
+ * scan recent blocks for a matching outgoing tx (from/to + optional calldata prefix).
+ */
+export async function pollForOutgoingTx(params) {
+    const { publicClient, from, to, dataPrefix, value, startBlock, signal, timeoutMs = 90_000, initialDelayMs = 10_000, } = params;
+    if (initialDelayMs > 0) {
+        await new Promise((r) => setTimeout(r, initialDelayMs));
+    }
+    if (signal.cancelled) {
+        throw new Error("cancelled");
+    }
+    await waitUntilDocumentVisible();
+    const fromLc = from.toLowerCase();
+    const toLc = to.toLowerCase();
+    const prefixLc = dataPrefix ? dataPrefix.toLowerCase() : undefined;
+    const started = Date.now();
+    while (!signal.cancelled && Date.now() - started < timeoutMs) {
         try {
-            document.querySelectorAll(sel).forEach((el) => {
-                const htmlEl = el;
-                if (htmlEl?.style) {
-                    htmlEl.style.removeProperty("display");
+            const latest = await publicClient.getBlockNumber();
+            const fromBlock = startBlock > 0n
+                ? startBlock
+                : latest > 12n
+                    ? latest - 12n
+                    : 0n;
+            for (let b = fromBlock; b <= latest; b++) {
+                if (signal.cancelled)
+                    break;
+                const block = await publicClient.getBlock({
+                    blockNumber: b,
+                    includeTransactions: true,
+                });
+                const txs = (block?.transactions || []);
+                for (const tx of txs) {
+                    if (!tx || typeof tx === "string")
+                        continue;
+                    if (String(tx.from || "").toLowerCase() !== fromLc)
+                        continue;
+                    if (String(tx.to || "").toLowerCase() !== toLc)
+                        continue;
+                    if (value !== undefined && BigInt(tx.value ?? 0) !== value) {
+                        continue;
+                    }
+                    if (prefixLc) {
+                        const input = String(tx.input || tx.data || "").toLowerCase();
+                        if (!input.startsWith(prefixLc))
+                            continue;
+                    }
+                    const hash = tx.hash;
+                    if (typeof hash === "string" && hash.startsWith("0x")) {
+                        return hash;
+                    }
                 }
-            });
+            }
         }
         catch {
-            // Ignore invalid selectors in older browsers.
+            // RPC blip — keep polling
         }
-    });
+        await new Promise((r) => setTimeout(r, 2_000));
+    }
+    throw new Error("No WalletConnect response and no matching on-chain transaction found. If MetaMask showed confirmed, refresh and check the explorer.");
 }
 function getRequestMethod(args) {
     const payload = args[0];
@@ -475,10 +668,20 @@ export function patchWalletConnectProviderForMobile(provider) {
             }
             return originalRequest(...args);
         }
+        let cancelDeeplinks;
         if (isApproval) {
             provider[PENDING_FLAG] = (provider[PENDING_FLAG] || 0) + 1;
-            restoreWalletConnectModal();
+            // Already connected: never re-open "All Wallets". Only restore modal
+            // during connect (no session yet).
+            if (hasActiveWalletConnectSession(provider)) {
+                hideWalletConnectModal(provider);
+            }
+            else {
+                restoreWalletConnectModal();
+            }
             syncWalletConnectDappRedirect(provider);
+            // Mark before deeplink so a fast backgrounding still triggers force-resume.
+            provider[NEEDS_RESUME_FLAG] = true;
         }
         try {
             // Never force-restart right before sending a new tx — that is what
@@ -488,14 +691,31 @@ export function patchWalletConnectProviderForMobile(provider) {
                 new Promise((resolve) => setTimeout(resolve, 1000)),
             ]);
             const resultPromise = originalRequest(...args);
-            if (typeof window !== "undefined") {
-                window.setTimeout(() => openConnectedWalletApp(provider), 400);
+            if (isApproval) {
+                // Do NOT auto-deeplink when a session already exists.
+                // WC ethereum-provider already opens the peer wallet; our extra
+                // metamask:// calls queue iOS "Open in MetaMask?" dialogs that stay
+                // on screen after the tx is confirmed (JS cannot dismiss them).
+                // Connect flow (no session) may still use a single scheduled open.
+                if (!hasActiveWalletConnectSession(provider)) {
+                    cancelDeeplinks = scheduleOpenConnectedWalletApp(provider);
+                }
+                else {
+                    hideWalletConnectModal(provider);
+                }
             }
             return await resultPromise;
         }
         finally {
+            cancelDeeplinks?.();
             if (isApproval) {
                 provider[PENDING_FLAG] = Math.max(0, (provider[PENDING_FLAG] || 1) - 1);
+                provider.__abstraxnWcDeeplinkOpened = false;
+                // Close picker that may have been left open after approve/reject.
+                hideWalletConnectModal(provider);
+                if (!hasPendingWalletConnectApproval(provider)) {
+                    provider[NEEDS_RESUME_FLAG] = false;
+                }
             }
         }
     };
@@ -507,10 +727,9 @@ export function patchWalletConnectProviderForMobile(provider) {
 export function subscribeWalletConnectForegroundResume(provider) {
     if (typeof window === "undefined" || !provider)
         return () => { };
-    let timer = null;
+    const timers = [];
     const resume = () => {
-        if (timer)
-            clearTimeout(timer);
+        timers.splice(0).forEach((t) => clearTimeout(t));
         const pending = hasPendingWalletConnectApproval(provider);
         const needsResume = pending || !!provider[NEEDS_RESUME_FLAG];
         // Do not restart after connect-only backgrounding — that broke the next
@@ -519,11 +738,30 @@ export function subscribeWalletConnectForegroundResume(provider) {
             clearWalletReturnIfSameDocument();
             return;
         }
-        timer = setTimeout(() => {
-            clearWalletReturnIfSameDocument();
-            void resumeWalletConnectRelayer(provider, { force: true });
-            restoreWalletConnectModal();
-        }, 50);
+        // iOS often reports "visible" before networking is ready; retry force-resume.
+        const delays = [50, 300, 1000, 2000, 4000];
+        delays.forEach((ms) => {
+            timers.push(setTimeout(() => {
+                if (!hasPendingWalletConnectApproval(provider) &&
+                    !provider[NEEDS_RESUME_FLAG]) {
+                    return;
+                }
+                clearWalletReturnIfSameDocument();
+                void resumeWalletConnectRelayer(provider, { force: true }).then(() => {
+                    if (!hasPendingWalletConnectApproval(provider)) {
+                        provider[NEEDS_RESUME_FLAG] = false;
+                        hideWalletConnectModal(provider);
+                    }
+                });
+                // Do not restoreWalletConnectModal here — that reopens "All Wallets".
+                if (!hasActiveWalletConnectSession(provider)) {
+                    restoreWalletConnectModal();
+                }
+                else {
+                    hideWalletConnectModal(provider);
+                }
+            }, ms));
+        });
     };
     const onVisibility = () => {
         if (document.visibilityState === "hidden") {
@@ -539,8 +777,7 @@ export function subscribeWalletConnectForegroundResume(provider) {
     window.addEventListener("pageshow", resume);
     window.addEventListener("focus", resume);
     return () => {
-        if (timer)
-            clearTimeout(timer);
+        timers.splice(0).forEach((t) => clearTimeout(t));
         document.removeEventListener("visibilitychange", onVisibility);
         window.removeEventListener("pageshow", resume);
         window.removeEventListener("focus", resume);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abstraxn/signer-react",
-  "version": "3.3.8",
+  "version": "3.3.9",
   "description": "React SDK for Abstraxn Wallet - React components, hooks, and providers for seamless Web3 wallet integration",
   "main": "./dist/src/index.js",
   "module": "./dist/src/index.js",