@abstraxn/signer-react 3.3.8 → 3.3.10

package/CHANGELOG.md

@@ -5,6 +5,30 @@ 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.10] - 2026-09-18
+
+### Fixed
+- **Mobile WalletConnect reject / confirm / on-chain failure** (aligned with WC + EIP-1193):
+  - **Reject:** On return from MetaMask, force-resume the relay (time-bounded). Map EIP-1193 `4001` / WC `5000` to `User rejected the request`. If WC stays silent and pending nonce never moved, surface the same reject error so loaders clear.
+  - **Confirm:** WC success is a **tx hash** only. Gated chain poll recovers the hash when the relay drops after approve (success-only; does not invent rejects).
+  - **On-chain failure:** `useWaitForTxnReceipt` defaults to `throwOnRevert: true` so a mined `status: reverted` throws `Transaction reverted` (receipt check is dapp/RPC, not WalletConnect).
+
+### Added
+- `isUserRejectionError`, `toUserRejectionError`, `forceResumeWalletConnectOnReturn`.
+
+## [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;
@@ -8165,11 +8165,12 @@ export declare function useWalletClient(chain: any, rpcUrl?: string): {
             [x: `bytes3[${string}]`]: undefined;
             [x: `bytes1[${string}]`]: undefined;
             [x: `bytes2[${string}]`]: undefined;
+            [x: `bytes16[${string}]`]: undefined;
+            [x: `bytes8[${string}]`]: undefined;
             [x: `bytes4[${string}]`]: undefined;
             [x: `bytes5[${string}]`]: undefined;
             [x: `bytes6[${string}]`]: undefined;
             [x: `bytes7[${string}]`]: undefined;
-            [x: `bytes8[${string}]`]: undefined;
             [x: `bytes9[${string}]`]: undefined;
             [x: `bytes10[${string}]`]: undefined;
             [x: `bytes11[${string}]`]: undefined;
@@ -8177,7 +8178,6 @@ export declare function useWalletClient(chain: any, rpcUrl?: string): {
             [x: `bytes13[${string}]`]: undefined;
             [x: `bytes14[${string}]`]: undefined;
             [x: `bytes15[${string}]`]: undefined;
-            [x: `bytes16[${string}]`]: undefined;
             [x: `bytes17[${string}]`]: undefined;
             [x: `bytes18[${string}]`]: undefined;
             [x: `bytes19[${string}]`]: undefined;
@@ -8195,8 +8195,8 @@ export declare function useWalletClient(chain: any, rpcUrl?: string): {
             [x: `bytes31[${string}]`]: undefined;
             [x: `bytes32[${string}]`]: undefined;
             [x: `int[${string}]`]: undefined;
-            [x: `int8[${string}]`]: undefined;
             [x: `int16[${string}]`]: undefined;
+            [x: `int8[${string}]`]: undefined;
             [x: `int24[${string}]`]: undefined;
             [x: `int32[${string}]`]: undefined;
             [x: `int40[${string}]`]: undefined;
@@ -8228,8 +8228,8 @@ export declare function useWalletClient(chain: any, rpcUrl?: string): {
             [x: `int248[${string}]`]: undefined;
             [x: `int256[${string}]`]: undefined;
             [x: `uint[${string}]`]: undefined;
-            [x: `uint8[${string}]`]: undefined;
             [x: `uint16[${string}]`]: undefined;
+            [x: `uint8[${string}]`]: undefined;
             [x: `uint24[${string}]`]: undefined;
             [x: `uint32[${string}]`]: undefined;
             [x: `uint40[${string}]`]: undefined;
@@ -8267,11 +8267,12 @@ export declare function useWalletClient(chain: any, rpcUrl?: string): {
             bytes3?: undefined;
             bytes1?: undefined;
             bytes2?: undefined;
+            bytes16?: undefined;
+            bytes8?: undefined;
             bytes4?: undefined;
             bytes5?: undefined;
             bytes6?: undefined;
             bytes7?: undefined;
-            bytes8?: undefined;
             bytes9?: undefined;
             bytes10?: undefined;
             bytes11?: undefined;
@@ -8279,7 +8280,6 @@ export declare function useWalletClient(chain: any, rpcUrl?: string): {
             bytes13?: undefined;
             bytes14?: undefined;
             bytes15?: undefined;
-            bytes16?: undefined;
             bytes17?: undefined;
             bytes18?: undefined;
             bytes19?: undefined;
@@ -8296,8 +8296,8 @@ export declare function useWalletClient(chain: any, rpcUrl?: string): {
             bytes30?: undefined;
             bytes31?: undefined;
             bytes32?: undefined;
-            int8?: undefined;
             int16?: undefined;
+            int8?: undefined;
             int24?: undefined;
             int32?: undefined;
             int40?: undefined;
@@ -8328,8 +8328,8 @@ export declare function useWalletClient(chain: any, rpcUrl?: string): {
             int240?: undefined;
             int248?: undefined;
             int256?: undefined;
-            uint8?: undefined;
             uint16?: undefined;
+            uint8?: undefined;
             uint24?: undefined;
             uint32?: undefined;
             uint40?: undefined;
@@ -8811,10 +8811,16 @@ export declare function useSignAndSendTxn(provider: PublicClient): {
  * ```
  */
 export declare function useWaitForTxnReceipt(provider: PublicClient): {
-    waitForTxnReceipt: ({ hash, confirmations, timeout, }: {
+    waitForTxnReceipt: ({ hash, confirmations, timeout, throwOnRevert, }: {
         hash: `0x${string}`;
         confirmations?: number;
         timeout?: number;
+        /**
+         * When true (default), a mined receipt with status reverted throws
+         * `Transaction reverted` — on-chain failure is not a WalletConnect concern;
+         * the dapp must check the receipt after receiving the hash.
+         */
+        throwOnRevert?: boolean;
     }) => Promise<TransactionReceipt>;
 };
 /**
@@ -13140,11 +13146,12 @@ export declare function useExternalWalletClient(): {
             [x: `bytes3[${string}]`]: undefined;
             [x: `bytes1[${string}]`]: undefined;
             [x: `bytes2[${string}]`]: undefined;
+            [x: `bytes16[${string}]`]: undefined;
+            [x: `bytes8[${string}]`]: undefined;
             [x: `bytes4[${string}]`]: undefined;
             [x: `bytes5[${string}]`]: undefined;
             [x: `bytes6[${string}]`]: undefined;
             [x: `bytes7[${string}]`]: undefined;
-            [x: `bytes8[${string}]`]: undefined;
             [x: `bytes9[${string}]`]: undefined;
             [x: `bytes10[${string}]`]: undefined;
             [x: `bytes11[${string}]`]: undefined;
@@ -13152,7 +13159,6 @@ export declare function useExternalWalletClient(): {
             [x: `bytes13[${string}]`]: undefined;
             [x: `bytes14[${string}]`]: undefined;
             [x: `bytes15[${string}]`]: undefined;
-            [x: `bytes16[${string}]`]: undefined;
             [x: `bytes17[${string}]`]: undefined;
             [x: `bytes18[${string}]`]: undefined;
             [x: `bytes19[${string}]`]: undefined;
@@ -13170,8 +13176,8 @@ export declare function useExternalWalletClient(): {
             [x: `bytes31[${string}]`]: undefined;
             [x: `bytes32[${string}]`]: undefined;
             [x: `int[${string}]`]: undefined;
-            [x: `int8[${string}]`]: undefined;
             [x: `int16[${string}]`]: undefined;
+            [x: `int8[${string}]`]: undefined;
             [x: `int24[${string}]`]: undefined;
             [x: `int32[${string}]`]: undefined;
             [x: `int40[${string}]`]: undefined;
@@ -13203,8 +13209,8 @@ export declare function useExternalWalletClient(): {
             [x: `int248[${string}]`]: undefined;
             [x: `int256[${string}]`]: undefined;
             [x: `uint[${string}]`]: undefined;
-            [x: `uint8[${string}]`]: undefined;
             [x: `uint16[${string}]`]: undefined;
+            [x: `uint8[${string}]`]: undefined;
             [x: `uint24[${string}]`]: undefined;
             [x: `uint32[${string}]`]: undefined;
             [x: `uint40[${string}]`]: undefined;
@@ -13242,11 +13248,12 @@ export declare function useExternalWalletClient(): {
             bytes3?: undefined;
             bytes1?: undefined;
             bytes2?: undefined;
+            bytes16?: undefined;
+            bytes8?: undefined;
             bytes4?: undefined;
             bytes5?: undefined;
             bytes6?: undefined;
             bytes7?: undefined;
-            bytes8?: undefined;
             bytes9?: undefined;
             bytes10?: undefined;
             bytes11?: undefined;
@@ -13254,7 +13261,6 @@ export declare function useExternalWalletClient(): {
             bytes13?: undefined;
             bytes14?: undefined;
             bytes15?: undefined;
-            bytes16?: undefined;
             bytes17?: undefined;
             bytes18?: undefined;
             bytes19?: undefined;
@@ -13271,8 +13277,8 @@ export declare function useExternalWalletClient(): {
             bytes30?: undefined;
             bytes31?: undefined;
             bytes32?: undefined;
-            int8?: undefined;
             int16?: undefined;
+            int8?: undefined;
             int24?: undefined;
             int32?: undefined;
             int40?: undefined;
@@ -13303,8 +13309,8 @@ export declare function useExternalWalletClient(): {
             int240?: undefined;
             int248?: undefined;
             int256?: undefined;
-            uint8?: undefined;
             uint16?: undefined;
+            uint8?: undefined;
             uint24?: undefined;
             uint32?: undefined;
             uint40?: undefined;

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, isUserRejectionError, toUserRejectionError, } from './walletConnectMobile';
 /**
  * Hook to check if wallet is connected
  */
@@ -2057,7 +2057,7 @@ export function useSignAndSendTxn(provider) {
  * ```
  */
 export function useWaitForTxnReceipt(provider) {
-    const waitForTxnReceipt = useCallback(async ({ hash, confirmations, timeout, }) => {
+    const waitForTxnReceipt = useCallback(async ({ hash, confirmations, timeout, throwOnRevert = true, }) => {
         if (!provider) {
             throw new Error('Provider (publicClient) is required');
         }
@@ -2080,9 +2080,18 @@ export function useWaitForTxnReceipt(provider) {
                         timeout: Math.min(20_000, remaining),
                         pollingInterval: 1_500,
                     });
+                    if (throwOnRevert &&
+                        (receipt.status === 'reverted' ||
+                            receipt.status === 0 ||
+                            receipt.status === '0x0')) {
+                        throw new Error('Transaction reverted');
+                    }
                     return receipt;
                 }
                 catch (error) {
+                    if (error instanceof Error && error.message === 'Transaction reverted') {
+                        throw error;
+                    }
                     lastError = error;
                     await waitUntilDocumentVisible();
                     await new Promise((resolve) => setTimeout(resolve, 1_000));
@@ -2096,6 +2105,9 @@ export function useWaitForTxnReceipt(provider) {
                 : new Error('Failed to wait for transaction receipt');
         }
         catch (error) {
+            if (error instanceof Error && error.message === 'Transaction reverted') {
+                throw error;
+            }
             if (error instanceof Error && error.message.startsWith('Failed to wait for transaction receipt')) {
                 throw error;
             }
@@ -2430,69 +2442,133 @@ 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().then((hash) => hash, (err) => {
+                if (isUserRejectionError(err))
+                    throw toUserRejectionError(err);
+                throw err;
+            });
+            // Success-only chain recovery when WC hash never arrives.
+            const pollPromise = pollForOutgoingTx({
+                publicClient,
+                from: fromAddress,
+                to: address,
+                dataPrefix,
+                value,
+                startBlock,
+                signal: cancelPoll,
+                initialDelayMs: 1_000,
+                timeoutMs: 60_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]);
+                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, forceResumeWalletConnectOnReturn, isUserRejectionError, toUserRejectionError, } 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, forceResumeWalletConnectOnReturn, isUserRejectionError, toUserRejectionError, } 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,17 +103,47 @@ 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;
+/** EIP-1193 4001 / WC 5000 (and common message shapes). */
+export declare function isUserRejectionError(error: unknown): boolean;
+export declare function toUserRejectionError(error?: unknown): Error;
+/**
+ * Success-only recovery: find an on-chain hash when WC never returns one.
+ * Does not infer reject (that is handled by relay resume + reject fallback).
+ */
+export declare function pollForOutgoingTx(params: {
+    publicClient: {
+        getBlockNumber: () => Promise<bigint>;
+        getBlock: (args: {
+            blockNumber: bigint;
+            includeTransactions: boolean;
+        }) => Promise<{
+            transactions?: unknown[];
+        } | null>;
+    };
+    from: string;
+    to: string;
+    dataPrefix?: string;
+    value?: bigint;
+    startBlock: bigint;
+    signal: {
+        cancelled: boolean;
+    };
+    timeoutMs?: number;
+    initialDelayMs?: number;
+}): Promise<`0x${string}`>;
+/** Time-bounded force-resume (must not hang on transportOpen). */
+export declare function forceResumeWalletConnectOnReturn(provider: any, timeoutMs?: number): Promise<void>;
 /**
  * Patch the EIP-1193 provider so signing/tx requests resume the relay first.
  * Covers wagmi hooks, viem walletClient, and direct provider.request calls.
  */
 export declare function patchWalletConnectProviderForMobile(provider: any): void;
 /**
- * When the dapp tab is shown again (user left MetaMask), restart the relay so
- * the pending WalletConnect response can be received.
+ * When the dapp tab is shown again, restart the relay so pending
+ * approve/reject responses can be delivered (WalletConnect mobile linking).
  */
 export declare function subscribeWalletConnectForegroundResume(provider: any): () => void;

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,190 @@ 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
+    }
+}
+/** EIP-1193 4001 / WC 5000 (and common message shapes). */
+export function isUserRejectionError(error) {
+    const walk = (err, depth = 0) => {
+        if (err == null || depth > 8)
+            return false;
+        if (typeof err === "string") {
+            return /user rejected|rejected by user|user denied|denied transaction|request rejected|cancelled by user/i.test(err);
+        }
+        if (typeof err !== "object")
+            return false;
+        const e = err;
+        if (e.code === 4001 || e.code === 5000 || e.code === "4001" || e.code === "ACTION_REJECTED") {
+            return true;
+        }
+        if (typeof e.name === "string" && /UserRejected/i.test(e.name))
+            return true;
+        const msg = `${e.message ?? ""} ${e.shortMessage ?? ""}`;
+        if (/user rejected|rejected by user|user denied|denied transaction|request rejected|user cancelled|user canceled/i.test(msg)) {
+            return true;
+        }
+        return walk(e.cause, depth + 1);
+    };
+    return walk(error);
+}
+export function toUserRejectionError(error) {
+    if (error instanceof Error && isUserRejectionError(error)) {
+        const err = new Error("User rejected the request");
+        err.code = 4001;
+        err.cause = error;
+        return err;
+    }
+    const err = new Error("User rejected the request");
+    err.code = 4001;
+    if (error !== undefined)
+        err.cause = error;
+    return err;
+}
+/**
+ * Success-only recovery: find an on-chain hash when WC never returns one.
+ * Does not infer reject (that is handled by relay resume + reject fallback).
+ */
+export async function pollForOutgoingTx(params) {
+    const { publicClient, from, to, dataPrefix, value, startBlock, signal, timeoutMs = 60_000, initialDelayMs = 1_000, } = params;
+    await waitUntilDocumentVisible();
+    if (signal.cancelled)
+        throw new Error("cancelled");
+    if (initialDelayMs > 0) {
+        await new Promise((r) => setTimeout(r, initialDelayMs));
+    }
+    if (signal.cancelled)
+        throw new Error("cancelled");
+    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
         }
+        await new Promise((r) => setTimeout(r, 2_000));
+    }
+    // Stay pending until cancelled — reject UX is owned by the approval race.
+    if (signal.cancelled)
+        throw new Error("cancelled");
+    await new Promise(() => { });
+    throw new Error("cancelled");
+}
+/** Time-bounded force-resume (must not hang on transportOpen). */
+export async function forceResumeWalletConnectOnReturn(provider, timeoutMs = 1_500) {
+    if (!provider)
+        return;
+    try {
+        provider[NEEDS_RESUME_FLAG] = true;
+        await Promise.race([
+            resumeWalletConnectRelayer(provider, { force: true }),
+            new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+        ]);
+    }
+    catch {
+        // best-effort
+    }
+}
+async function readPendingNonce(provider) {
+    try {
+        const accounts = provider?.accounts ||
+            provider?.session?.namespaces?.eip155?.accounts?.map((a) => a.includes(":") ? a.split(":").pop() : a) ||
+            [];
+        const address = accounts[0];
+        if (!address || typeof provider.request !== "function")
+            return null;
+        // Use unbound original if patched — readPendingNonce is called from
+        // inside the patch with the live provider; eth_getTransactionCount is
+        // not an approval method so the patch forwards it.
+        const hex = await provider.request({
+            method: "eth_getTransactionCount",
+            params: [address, "pending"],
+        });
+        return typeof hex === "string" ? parseInt(hex, 16) : Number(hex);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Prefer WC delivering real approve/reject after return (docs: respondSessionRequest).
+ * If still pending with no nonce bump → EIP-1193-style user rejection.
+ * If nonce moved → do not fake reject (let success hash arrive via WC or poll).
+ */
+async function raceApprovalWithResumeAndRejectFallback(resultPromise, provider, startNonce) {
+    const normalizedResult = resultPromise.then((v) => v, (err) => {
+        if (isUserRejectionError(err))
+            throw toUserRejectionError(err);
+        throw err;
     });
+    const rejectFallback = (async () => {
+        await waitUntilDocumentVisible();
+        await forceResumeWalletConnectOnReturn(provider, 1_500);
+        await new Promise((r) => setTimeout(r, 400));
+        await forceResumeWalletConnectOnReturn(provider, 1_500);
+        // Window for MetaMask's real JSON-RPC reject/hash after resume.
+        await new Promise((r) => setTimeout(r, 5_000));
+        if (!hasPendingWalletConnectApproval(provider)) {
+            return await new Promise(() => { });
+        }
+        const currentNonce = await readPendingNonce(provider);
+        if (startNonce != null &&
+            currentNonce != null &&
+            currentNonce > startNonce) {
+            // Tx submitted — confirmation path owns this.
+            return await new Promise(() => { });
+        }
+        throw toUserRejectionError();
+    })();
+    return await Promise.race([normalizedResult, rejectFallback]);
 }
 function getRequestMethod(args) {
     const payload = args[0];
@@ -468,62 +768,101 @@ export function patchWalletConnectProviderForMobile(provider) {
         }
         if (!isApproval && wasBackgrounded) {
             try {
-                await resumeWalletConnectRelayer(provider, { force: true });
+                await Promise.race([
+                    resumeWalletConnectRelayer(provider, { force: true }),
+                    new Promise((resolve) => setTimeout(resolve, 1_500)),
+                ]);
             }
             finally {
                 provider[NEEDS_RESUME_FLAG] = false;
             }
             return originalRequest(...args);
         }
+        let cancelDeeplinks;
+        let startNonce = null;
         if (isApproval) {
             provider[PENDING_FLAG] = (provider[PENDING_FLAG] || 0) + 1;
-            restoreWalletConnectModal();
+            startNonce = await readPendingNonce(provider);
+            if (hasActiveWalletConnectSession(provider)) {
+                hideWalletConnectModal(provider);
+            }
+            else {
+                restoreWalletConnectModal();
+            }
             syncWalletConnectDappRedirect(provider);
+            provider[NEEDS_RESUME_FLAG] = true;
         }
         try {
-            // Never force-restart right before sending a new tx — that is what
-            // blocked the MetaMask popup on Create Proposal after 3.3.7.
             await Promise.race([
                 resumeWalletConnectRelayer(provider, { force: false }),
                 new Promise((resolve) => setTimeout(resolve, 1000)),
             ]);
             const resultPromise = originalRequest(...args);
-            if (typeof window !== "undefined") {
-                window.setTimeout(() => openConnectedWalletApp(provider), 400);
+            if (isApproval) {
+                if (!hasActiveWalletConnectSession(provider)) {
+                    cancelDeeplinks = scheduleOpenConnectedWalletApp(provider);
+                }
+                else {
+                    hideWalletConnectModal(provider);
+                }
+                if (isMobileDevice()) {
+                    return await raceApprovalWithResumeAndRejectFallback(resultPromise, provider, startNonce);
+                }
             }
             return await resultPromise;
         }
         finally {
+            cancelDeeplinks?.();
             if (isApproval) {
                 provider[PENDING_FLAG] = Math.max(0, (provider[PENDING_FLAG] || 1) - 1);
+                provider.__abstraxnWcDeeplinkOpened = false;
+                hideWalletConnectModal(provider);
+                if (!hasPendingWalletConnectApproval(provider)) {
+                    provider[NEEDS_RESUME_FLAG] = false;
+                }
             }
         }
     };
 }
 /**
- * When the dapp tab is shown again (user left MetaMask), restart the relay so
- * the pending WalletConnect response can be received.
+ * When the dapp tab is shown again, restart the relay so pending
+ * approve/reject responses can be delivered (WalletConnect mobile linking).
  */
 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
-        // session_request so MetaMask never opened for Create Proposal.
         if (!needsResume) {
             clearWalletReturnIfSameDocument();
             return;
         }
-        timer = setTimeout(() => {
+        const run = () => {
+            if (!hasPendingWalletConnectApproval(provider) &&
+                !provider[NEEDS_RESUME_FLAG]) {
+                return;
+            }
             clearWalletReturnIfSameDocument();
-            void resumeWalletConnectRelayer(provider, { force: true });
-            restoreWalletConnectModal();
-        }, 50);
+            void forceResumeWalletConnectOnReturn(provider, 1_500).then(() => {
+                if (!hasPendingWalletConnectApproval(provider)) {
+                    provider[NEEDS_RESUME_FLAG] = false;
+                    hideWalletConnectModal(provider);
+                }
+            });
+            if (!hasActiveWalletConnectSession(provider)) {
+                restoreWalletConnectModal();
+            }
+            else {
+                hideWalletConnectModal(provider);
+            }
+        };
+        run();
+        [800, 2_000].forEach((ms) => {
+            timers.push(setTimeout(run, ms));
+        });
     };
     const onVisibility = () => {
         if (document.visibilityState === "hidden") {
@@ -539,8 +878,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.10",
   "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",