@pooflabs/web 0.0.69 → 0.0.70-rc.1

package/dist/{index-C-ADfv7y.js → index-CMKICH1P.js}

@@ -10777,7 +10777,10 @@ function handleServerMessage(connection, message) {
 }
 function notifyCallbacks(subscription, data) {
     var _a;
-    for (const callback of subscription.callbacks) {
+    // Snapshot the callbacks array so that unsubscriptions during
+    // notification don't cause callbacks to be skipped.
+    const callbacks = subscription.callbacks.slice();
+    for (const callback of callbacks) {
         try {
             (_a = callback.onData) === null || _a === void 0 ? void 0 : _a.call(callback, data);
         }
@@ -13563,7 +13566,7 @@ async function loadDependencies() {
         const [reactModule, reactDomModule, phantomModule] = await Promise.all([
             import('react'),
             import('react-dom/client'),
-            Promise.resolve().then(function () { return require('./index-DG-p1jRT.js'); })
+            Promise.resolve().then(function () { return require('./index-BO2G95MR.js'); })
         ]);
         // Extract default export from ESM module namespace
         // Dynamic import() returns { default: Module, ...exports }, not the module directly
@@ -13586,6 +13589,8 @@ class PhantomWalletProvider {
         this.initPromise = null;
         /** Callback to swap to a Privy provider when the user clicks "Log in with email" */
         this.onSwitchToPrivy = null;
+        /** Callback to swap to a Mobile Wallet Adapter provider when the user clicks "Connect Mobile Wallet" */
+        this.onSwitchToMWA = null;
         this.networkUrl = networkUrl;
         this.config = config;
         if (typeof window === 'undefined') {
@@ -13953,6 +13958,31 @@ class PhantomWalletProvider {
                     }
                 }
             };
+            const handleMobileWalletClick = async () => {
+                that.loginInProgress = false;
+                walletClickedRef.current = true;
+                setShowWalletModal(false);
+                if (that.onSwitchToMWA) {
+                    try {
+                        const mwaProvider = await that.onSwitchToMWA();
+                        const user = await mwaProvider.login();
+                        if (that.pendingLogin && user) {
+                            that.pendingLogin.resolve(user);
+                            that.pendingLogin = null;
+                        }
+                        else if (that.pendingLogin) {
+                            that.pendingLogin.reject(new Error('User cancelled login'));
+                            that.pendingLogin = null;
+                        }
+                    }
+                    catch (error) {
+                        if (that.pendingLogin) {
+                            that.pendingLogin.reject(error);
+                            that.pendingLogin = null;
+                        }
+                    }
+                }
+            };
             const handleCloseModal = () => {
                 setShowWalletModal(false);
                 if (that.loginInProgress && that.pendingLogin && !(phantom === null || phantom === void 0 ? void 0 : phantom.isConnected)) {
@@ -14028,6 +14058,37 @@ class PhantomWalletProvider {
                     style: { width: '28px', height: '28px', borderRadius: '6px' },
                 }), 'Open Phantom app'));
             }
+            // Mobile Wallet Adapter button — shown on Android when MWA callback is available
+            const isAndroid = /Android/i.test(navigator.userAgent);
+            if (isAndroid && that.onSwitchToMWA) {
+                walletButtons.push(React$1.createElement('button', {
+                    key: 'mobile-wallet',
+                    style: buttonStyle('mobile-wallet'),
+                    onClick: handleMobileWalletClick,
+                    onMouseEnter: () => setHoveredBtn('mobile-wallet'),
+                    onMouseLeave: () => setHoveredBtn(null),
+                }, 
+                // Mobile wallet icon (phone with wallet)
+                React$1.createElement('svg', {
+                    width: '20', height: '20', viewBox: '0 0 24 24', fill: 'none',
+                    style: { flexShrink: '0' },
+                }, 
+                // Phone outline
+                React$1.createElement('rect', {
+                    x: '5', y: '2', width: '14', height: '20', rx: '2',
+                    stroke: textColor, strokeWidth: '2', fill: 'none',
+                }), 
+                // Screen line
+                React$1.createElement('line', {
+                    x1: '5', y1: '6', x2: '19', y2: '6',
+                    stroke: textColor, strokeWidth: '1.5',
+                }), 
+                // Wallet/shield checkmark
+                React$1.createElement('path', {
+                    d: 'M9.5 12.5l2 2 3.5-3.5',
+                    stroke: textColor, strokeWidth: '2', strokeLinecap: 'round', strokeLinejoin: 'round', fill: 'none',
+                })), 'Connect Mobile Wallet'));
+            }
             // Email button (always shown in custom modal since enablePrivyFallback is true)
             walletButtons.push(React$1.createElement('button', {
                 key: 'email-login',
@@ -34903,6 +34964,520 @@ class OffchainAuthProvider {
     }
 }
 
+/**
+ * Detects whether the current environment is a mobile browser capable of
+ * Mobile Wallet Adapter (MWA) communication.
+ *
+ * Returns true on Android browsers (Chrome, etc.) where MWA intents work,
+ * or inside a Seeker/Saga in-app browser context.
+ */
+function isMobileWalletAvailable() {
+    if (typeof window === 'undefined' || typeof navigator === 'undefined')
+        return false;
+    const ua = navigator.userAgent || '';
+    // Android browser — MWA uses Android intents
+    const isAndroid = /Android/i.test(ua);
+    // In-app browser inside a wallet app on Seeker/Saga
+    const isWalletInAppBrowser = /SolanaWallet/i.test(ua) || /SeedVault/i.test(ua);
+    return isAndroid || isWalletInAppBrowser;
+}
+// Dynamically imported MWA module
+let mwaModule = null;
+let mwaLoadPromise = null;
+async function loadMwaModule() {
+    if (mwaModule)
+        return;
+    if (typeof window === 'undefined')
+        return;
+    if (mwaLoadPromise)
+        return mwaLoadPromise;
+    mwaLoadPromise = (async () => {
+        try {
+            mwaModule = await import('@solana-mobile/wallet-adapter-mobile');
+        }
+        catch (e) {
+            console.warn('[SolanaMobileWallet] @solana-mobile/wallet-adapter-mobile not installed. Install it to enable Seeker wallet support.');
+            throw new Error('Missing @solana-mobile/wallet-adapter-mobile dependency');
+        }
+    })();
+    return mwaLoadPromise;
+}
+/**
+ * Registers Mobile Wallet Adapter as a wallet-standard wallet so it appears
+ * in wallet selection UIs and can be discovered by other wallet-standard consumers.
+ *
+ * Call this once at app startup (in a browser-only / non-SSR context).
+ *
+ * @param config - App identity and optional remote host authority for desktop QR code support
+ */
+async function registerMobileWalletAdapter(config) {
+    var _a;
+    if (typeof window === 'undefined')
+        return;
+    try {
+        const walletStandardMobile = await import('@solana-mobile/wallet-standard-mobile');
+        const registerMwa = walletStandardMobile.registerMwa || ((_a = walletStandardMobile.default) === null || _a === void 0 ? void 0 : _a.registerMwa);
+        if (!registerMwa) {
+            console.warn('[SolanaMobileWallet] registerMwa not found in @solana-mobile/wallet-standard-mobile');
+            return;
+        }
+        const options = {};
+        if (config === null || config === void 0 ? void 0 : config.appIdentity) {
+            options.appIdentity = config.appIdentity;
+        }
+        if (config === null || config === void 0 ? void 0 : config.chains) {
+            options.chains = config.chains;
+        }
+        if (config === null || config === void 0 ? void 0 : config.remoteHostAuthority) {
+            options.remoteHostAuthority = config.remoteHostAuthority;
+        }
+        // Use the library's default helpers if available
+        if (walletStandardMobile.createDefaultAuthorizationCache) {
+            options.authorizationCache = walletStandardMobile.createDefaultAuthorizationCache();
+        }
+        if (walletStandardMobile.createDefaultChainSelector) {
+            options.chainSelector = walletStandardMobile.createDefaultChainSelector();
+        }
+        if (walletStandardMobile.createDefaultWalletNotFoundHandler) {
+            options.onWalletNotFound = walletStandardMobile.createDefaultWalletNotFoundHandler();
+        }
+        registerMwa(options);
+    }
+    catch (e) {
+        // @solana-mobile/wallet-standard-mobile is an optional dependency
+        // Silently skip if not installed — the provider still works via
+        // @solana-mobile/wallet-adapter-mobile directly
+        console.debug('[SolanaMobileWallet] @solana-mobile/wallet-standard-mobile not available, skipping wallet-standard registration');
+    }
+}
+/**
+ * SolanaMobileWalletProvider implements the AuthProvider interface using the
+ * Solana Mobile Wallet Adapter (MWA) protocol.
+ *
+ * This enables TaroBase dApps to work with any MWA-compliant wallet on Solana
+ * mobile devices (Seeker, Saga) — including the native Seed Vault Wallet,
+ * Phantom, Solflare, and any other wallet that implements the MWA protocol.
+ *
+ * The MWA protocol communicates with wallet apps via Android intents (on mobile)
+ * or WebSocket relay (on desktop via QR code), eliminating the need to integrate
+ * with each wallet individually.
+ */
+class SolanaMobileWalletProvider {
+    constructor(networkUrl = null, config = {}) {
+        this.mwaAdapter = null;
+        this.authorizedPublicKey = null;
+        this.networkUrl = networkUrl;
+        this.config = config;
+        if (typeof window === 'undefined') {
+            throw new Error('SolanaMobileWalletProvider can only be instantiated in a browser environment');
+        }
+        if (SolanaMobileWalletProvider.instance) {
+            return SolanaMobileWalletProvider.instance;
+        }
+        SolanaMobileWalletProvider.instance = this;
+    }
+    static getInstance(networkUrl, config) {
+        if (!SolanaMobileWalletProvider.instance) {
+            new SolanaMobileWalletProvider(networkUrl, config);
+        }
+        return SolanaMobileWalletProvider.instance;
+    }
+    async ensureAdapter() {
+        var _a;
+        if ((_a = this.mwaAdapter) === null || _a === void 0 ? void 0 : _a.connected)
+            return this.mwaAdapter;
+        await loadMwaModule();
+        const { SolanaMobileWalletAdapter, createDefaultAddressSelector, createDefaultAuthorizationResultCache } = mwaModule;
+        if (!this.mwaAdapter) {
+            const cluster = this.config.cluster || 'mainnet-beta';
+            this.mwaAdapter = new SolanaMobileWalletAdapter({
+                addressSelector: createDefaultAddressSelector(),
+                appIdentity: this.config.appIdentity || {
+                    name: 'TaroBase App',
+                    uri: typeof window !== 'undefined' ? window.location.origin : undefined,
+                },
+                authorizationResultCache: createDefaultAuthorizationResultCache(),
+                cluster,
+            });
+        }
+        return this.mwaAdapter;
+    }
+    async login() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        setAuthLoading(true);
+        try {
+            const adapter = await this.ensureAdapter();
+            // Connect triggers the MWA authorization flow — this opens the wallet app
+            // via Android intent and asks the user to authorize this dApp
+            await adapter.connect();
+            // The MWA adapter populates `publicKey` asynchronously via an internal
+            // change-event handler that fires after connect() resolves. Poll for it
+            // with a short timeout to handle this race condition.
+            let publicKey;
+            const maxWaitMs = 3000;
+            const pollIntervalMs = 50;
+            const start = Date.now();
+            while (Date.now() - start < maxWaitMs) {
+                publicKey = ((_b = (_a = adapter.publicKey) === null || _a === void 0 ? void 0 : _a.toBase58) === null || _b === void 0 ? void 0 : _b.call(_a)) || ((_d = (_c = adapter.publicKey) === null || _c === void 0 ? void 0 : _c.toString) === null || _d === void 0 ? void 0 : _d.call(_c));
+                if (publicKey)
+                    break;
+                await new Promise(r => setTimeout(r, pollIntervalMs));
+            }
+            if (!publicKey) {
+                throw new Error('No public key returned from wallet');
+            }
+            this.authorizedPublicKey = publicKey;
+            // Check if we already have a valid session
+            const existingSession = await WebSessionManager.getSession();
+            if (existingSession && existingSession.address === publicKey) {
+                const user = { provider: this, address: publicKey };
+                setCurrentUser(user);
+                return user;
+            }
+            // Create new session with signature
+            const nonce = await genAuthNonce();
+            const messageText = await genSolanaMessage(publicKey, nonce);
+            // MWA signMessage expects Uint8Array
+            const messageBytes = new TextEncoder().encode(messageText);
+            const signatureBytes = await adapter.signMessage(messageBytes);
+            const signature = bufferExports.Buffer.from(signatureBytes).toString('base64');
+            const createSessionResult = await createSessionWithSignature(publicKey, messageText, signature);
+            await WebSessionManager.storeSession(publicKey, createSessionResult.accessToken, createSessionResult.idToken, createSessionResult.refreshToken);
+            // Mark auth method
+            try {
+                localStorage.setItem('tarobase_last_auth_method', 'mobile-wallet-adapter');
+            }
+            catch (_k) { }
+            const user = { provider: this, address: publicKey };
+            setCurrentUser(user);
+            return user;
+        }
+        catch (error) {
+            const isUserRejection = (error === null || error === void 0 ? void 0 : error.code) === 4001 ||
+                ((_e = error === null || error === void 0 ? void 0 : error.message) === null || _e === void 0 ? void 0 : _e.toLowerCase().includes('user rejected')) ||
+                ((_f = error === null || error === void 0 ? void 0 : error.message) === null || _f === void 0 ? void 0 : _f.toLowerCase().includes('user denied')) ||
+                ((_g = error === null || error === void 0 ? void 0 : error.message) === null || _g === void 0 ? void 0 : _g.toLowerCase().includes('user cancelled')) ||
+                ((_h = error === null || error === void 0 ? void 0 : error.message) === null || _h === void 0 ? void 0 : _h.toLowerCase().includes('user canceled')) ||
+                ((_j = error === null || error === void 0 ? void 0 : error.message) === null || _j === void 0 ? void 0 : _j.toLowerCase().includes('user declined'));
+            if (!isUserRejection) {
+                console.error('[SolanaMobileWallet] Login failed:', error);
+            }
+            throw error;
+        }
+        finally {
+            setAuthLoading(false);
+        }
+    }
+    async restoreSession() {
+        const session = await WebSessionManager.getSession();
+        if (session) {
+            this.authorizedPublicKey = session.address;
+            return { provider: this, address: session.address };
+        }
+        return null;
+    }
+    async logout() {
+        var _a;
+        try {
+            if ((_a = this.mwaAdapter) === null || _a === void 0 ? void 0 : _a.connected) {
+                await this.mwaAdapter.disconnect();
+            }
+        }
+        catch (error) {
+            console.error('[SolanaMobileWallet] Disconnect error:', error);
+        }
+        this.authorizedPublicKey = null;
+        WebSessionManager.clearSession();
+        setCurrentUser(null);
+    }
+    async signMessage(message) {
+        var _a, _b;
+        const adapter = await this.ensureAdapter();
+        if (!adapter.connected) {
+            await adapter.connect();
+        }
+        try {
+            const messageBytes = new TextEncoder().encode(message);
+            const signatureBytes = await adapter.signMessage(messageBytes);
+            return bufferExports.Buffer.from(signatureBytes).toString('base64');
+        }
+        catch (error) {
+            if (((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('not connected')) || ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.includes('not authorized'))) {
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+            throw new Error(`Failed to sign message: ${error.message}`);
+        }
+    }
+    async signTransaction(transaction) {
+        var _a, _b;
+        const adapter = await this.ensureAdapter();
+        if (!adapter.connected) {
+            await adapter.connect();
+        }
+        // Ensure blockhash is set
+        const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
+        if (isLegacyTransaction) {
+            const legacyTx = transaction;
+            if (!legacyTx.recentBlockhash) {
+                const rpcUrl = this.getRpcUrl();
+                const connection = new web3_js.Connection(rpcUrl, 'confirmed');
+                const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+                legacyTx.recentBlockhash = blockhash;
+                legacyTx.lastValidBlockHeight = lastValidBlockHeight;
+            }
+            if (!legacyTx.feePayer && adapter.publicKey) {
+                legacyTx.feePayer = adapter.publicKey;
+            }
+        }
+        else {
+            const versionedTx = transaction;
+            if (!versionedTx.message.recentBlockhash) {
+                const rpcUrl = this.getRpcUrl();
+                const connection = new web3_js.Connection(rpcUrl, 'confirmed');
+                const { blockhash } = await connection.getLatestBlockhash('confirmed');
+                versionedTx.message.recentBlockhash = blockhash;
+            }
+        }
+        try {
+            const signed = await adapter.signTransaction(transaction);
+            return signed;
+        }
+        catch (error) {
+            if (((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('not connected')) || ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.includes('not authorized'))) {
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+            throw new Error(`Failed to sign transaction: ${error.message}`);
+        }
+    }
+    async signAndSubmitTransaction(transaction, feePayer) {
+        var _a, _b, _c, _d, _e, _f;
+        const adapter = await this.ensureAdapter();
+        if (!adapter.connected) {
+            await adapter.connect();
+        }
+        const rpcUrl = this.getRpcUrl();
+        const connection = new web3_js.Connection(rpcUrl, 'confirmed');
+        const isSurfnet = rpcUrl === SURFNET_RPC_URL;
+        try {
+            const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+            const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
+            if (isLegacyTransaction) {
+                const legacyTx = transaction;
+                legacyTx.recentBlockhash = blockhash;
+                legacyTx.lastValidBlockHeight = lastValidBlockHeight;
+                if (!legacyTx.feePayer) {
+                    if (feePayer) {
+                        legacyTx.feePayer = feePayer;
+                    }
+                    else if (adapter.publicKey) {
+                        legacyTx.feePayer = adapter.publicKey;
+                    }
+                }
+            }
+            else {
+                const versionedTx = transaction;
+                versionedTx.message.recentBlockhash = blockhash;
+            }
+            // On surfnet, sign then submit manually
+            if (isSurfnet) {
+                const signedTx = await adapter.signTransaction(transaction);
+                const signature = await connection.sendRawTransaction(signedTx.serialize(), {
+                    preflightCommitment: 'confirmed'
+                });
+                const confirmation = await connection.confirmTransaction({
+                    signature,
+                    blockhash,
+                    lastValidBlockHeight,
+                }, 'confirmed');
+                if (confirmation.value.err) {
+                    throw new Error(`Transaction failed: ${confirmation.value.err.toString()}`);
+                }
+                return signature;
+            }
+            // MWA supports signAndSendTransaction natively — this lets the wallet
+            // app submit the transaction directly, which is more reliable on mobile
+            if (adapter.sendTransaction) {
+                const signature = await adapter.sendTransaction(transaction, connection, {
+                    preflightCommitment: 'confirmed',
+                });
+                await confirmAndCheckTransaction(connection, signature);
+                return signature;
+            }
+            // Fallback: sign then submit
+            const signedTx = await adapter.signTransaction(transaction);
+            const signature = await connection.sendRawTransaction(signedTx.serialize(), {
+                preflightCommitment: 'confirmed'
+            });
+            await confirmAndCheckTransaction(connection, signature);
+            return signature;
+        }
+        catch (error) {
+            if (((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('not connected')) || ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.includes('not authorized'))) {
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+            const isUserRejection = (error === null || error === void 0 ? void 0 : error.code) === 4001 ||
+                ((_c = error === null || error === void 0 ? void 0 : error.message) === null || _c === void 0 ? void 0 : _c.toLowerCase().includes('user rejected')) ||
+                ((_d = error === null || error === void 0 ? void 0 : error.message) === null || _d === void 0 ? void 0 : _d.toLowerCase().includes('user denied')) ||
+                ((_e = error === null || error === void 0 ? void 0 : error.message) === null || _e === void 0 ? void 0 : _e.toLowerCase().includes('user cancelled')) ||
+                ((_f = error === null || error === void 0 ? void 0 : error.message) === null || _f === void 0 ? void 0 : _f.toLowerCase().includes('user canceled'));
+            if (!isUserRejection) {
+                console.error('[SolanaMobileWallet] Transaction failed:', error);
+            }
+            throw new Error(`Failed to execute transaction: ${error.message}`);
+        }
+    }
+    async runTransaction(_evmTransactionData, solTransactionData, options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (!solTransactionData) {
+            throw new Error('Solana transaction data is required for mobile wallet');
+        }
+        const adapter = await this.ensureAdapter();
+        if (!adapter.connected) {
+            await this.login();
+        }
+        const rpcUrl = this.getRpcUrl(solTransactionData.network);
+        const connection = new web3_js.Connection(rpcUrl, 'confirmed');
+        const isSurfnet = rpcUrl === SURFNET_RPC_URL;
+        try {
+            const publicKey = adapter.publicKey;
+            if (!publicKey) {
+                throw new Error('No wallet connected');
+            }
+            const remainingAccounts = convertRemainingAccounts(solTransactionData.txArgs[0].remainingAccounts);
+            let app_id = solTransactionData.appId;
+            if (typeof window !== 'undefined' && window.CUSTOM_TAROBASE_APP_ID_HEADER) {
+                app_id = window.CUSTOM_TAROBASE_APP_ID_HEADER;
+            }
+            if (!app_id) {
+                throw new Error('App ID is required');
+            }
+            // Create wallet adapter interface for Anchor
+            const walletAdapter = {
+                publicKey,
+                signTransaction: async (tx) => {
+                    return await adapter.signTransaction(tx);
+                },
+                signAllTransactions: async (txs) => {
+                    return await adapter.signAllTransactions(txs);
+                }
+            };
+            const anchorProvider = new anchor__namespace.AnchorProvider(connection, walletAdapter, anchor__namespace.AnchorProvider.defaultOptions());
+            const finalDeduped = [];
+            for (const acc of remainingAccounts) {
+                const existing = finalDeduped.find((d) => d.pubkey.equals(acc.pubkey));
+                if (existing) {
+                    existing.isSigner = existing.isSigner || acc.isSigner;
+                    existing.isWritable = existing.isWritable || acc.isWritable;
+                }
+                else {
+                    finalDeduped.push(acc);
+                }
+            }
+            const { tx } = await buildSetDocumentsTransaction(connection, solTransactionData.txArgs[0].idl, anchorProvider, publicKey, {
+                app_id,
+                documents: solTransactionData.txArgs[0].setDocumentData,
+                delete_paths: solTransactionData.txArgs[0].deletePaths,
+                txData: solTransactionData.txArgs[0].txData
+            }, finalDeduped, solTransactionData.lutKey, solTransactionData.preInstructions, false);
+            if ((options === null || options === void 0 ? void 0 : options.shouldSubmitTx) === false) {
+                const signedTx = await walletAdapter.signTransaction(tx);
+                return {
+                    signedTransaction: signedTx,
+                    blockNumber: 0,
+                    gasUsed: '0',
+                    data: ''
+                };
+            }
+            // On surfnet, sign + submit manually
+            if (isSurfnet) {
+                const signedTx = await walletAdapter.signTransaction(tx);
+                const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+                const signature = await connection.sendRawTransaction(signedTx.serialize(), {
+                    preflightCommitment: 'confirmed'
+                });
+                const confirmation = await connection.confirmTransaction({
+                    signature,
+                    blockhash,
+                    lastValidBlockHeight,
+                }, 'confirmed');
+                if (confirmation.value.err) {
+                    throw new Error(`Transaction failed: ${confirmation.value.err.toString()}`);
+                }
+                const txInfo = await connection.getParsedTransaction(signature, {
+                    maxSupportedTransactionVersion: 0,
+                    commitment: 'confirmed'
+                });
+                return {
+                    transactionSignature: signature,
+                    blockNumber: (txInfo === null || txInfo === void 0 ? void 0 : txInfo.slot) || 0,
+                    gasUsed: ((_a = txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta) === null || _a === void 0 ? void 0 : _a.fee.toString()) || '0',
+                    data: txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta,
+                };
+            }
+            // Use MWA's sendTransaction for mobile-optimized submission
+            let signature;
+            if (adapter.sendTransaction) {
+                signature = await adapter.sendTransaction(tx, connection, {
+                    preflightCommitment: 'confirmed',
+                });
+            }
+            else {
+                const signedTx = await walletAdapter.signTransaction(tx);
+                signature = await connection.sendRawTransaction(signedTx.serialize(), {
+                    preflightCommitment: 'confirmed'
+                });
+            }
+            const txInfo = await confirmAndCheckTransaction(connection, signature);
+            return {
+                transactionSignature: signature,
+                blockNumber: (txInfo === null || txInfo === void 0 ? void 0 : txInfo.slot) || 0,
+                gasUsed: ((_b = txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta) === null || _b === void 0 ? void 0 : _b.fee.toString()) || '0',
+                data: txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta,
+            };
+        }
+        catch (error) {
+            if (((_c = error === null || error === void 0 ? void 0 : error.message) === null || _c === void 0 ? void 0 : _c.includes('not connected')) || ((_d = error === null || error === void 0 ? void 0 : error.message) === null || _d === void 0 ? void 0 : _d.includes('not authorized'))) {
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+            const isUserRejection = (error === null || error === void 0 ? void 0 : error.code) === 4001 ||
+                ((_e = error === null || error === void 0 ? void 0 : error.message) === null || _e === void 0 ? void 0 : _e.toLowerCase().includes('user rejected')) ||
+                ((_f = error === null || error === void 0 ? void 0 : error.message) === null || _f === void 0 ? void 0 : _f.toLowerCase().includes('user denied')) ||
+                ((_g = error === null || error === void 0 ? void 0 : error.message) === null || _g === void 0 ? void 0 : _g.toLowerCase().includes('user cancelled')) ||
+                ((_h = error === null || error === void 0 ? void 0 : error.message) === null || _h === void 0 ? void 0 : _h.toLowerCase().includes('user canceled'));
+            if (!isUserRejection) {
+                console.error('[SolanaMobileWallet] Transaction failed:', error);
+            }
+            throw new Error(`Failed to execute transaction: ${error.message}`);
+        }
+    }
+    async getNativeMethods() {
+        return this.mwaAdapter;
+    }
+    /* ----------------------------------------------------------- *
+     * Private Helpers
+     * ----------------------------------------------------------- */
+    getRpcUrl(network) {
+        if (this.networkUrl) {
+            return this.networkUrl;
+        }
+        if (network === 'solana_devnet') {
+            return SOLANA_DEVNET_RPC_URL;
+        }
+        else if (network === 'solana_mainnet') {
+            return SOLANA_MAINNET_RPC_URL;
+        }
+        else if (network === 'surfnet') {
+            return SURFNET_RPC_URL;
+        }
+        return SOLANA_MAINNET_RPC_URL;
+    }
+}
+SolanaMobileWalletProvider.instance = null;
+
 let currentAuthProvider = null;
 let currentAuthMethod = null;
 let initConfig = null;
@@ -34972,6 +35547,30 @@ async function hotSwapToPrivyProvider(config) {
     setAuthProviderInstance(provider);
     return privyProvider;
 }
+async function hotSwapToMWAProvider(config) {
+    var _a, _b;
+    const rpcUrl = (_a = config.rpcUrl) !== null && _a !== void 0 ? _a : null;
+    const mwaConfig = (_b = config.mobileWalletConfig) !== null && _b !== void 0 ? _b : {
+        appIdentity: {
+            name: config.name || undefined,
+            uri: typeof window !== 'undefined' ? window.location.origin : undefined,
+        },
+    };
+    const mwaProvider = new SolanaMobileWalletProvider(rpcUrl, mwaConfig);
+    let provider = mwaProvider;
+    if (config.chain === "offchain") {
+        provider = new OffchainAuthProvider(mwaProvider);
+    }
+    currentAuthProvider = provider;
+    currentAuthMethod = 'mobile-wallet-adapter';
+    const coreConfig = await getConfig();
+    coreConfig.authProvider = provider;
+    // Send 'phantom' as authMethod so the server routes to Solana verification.
+    // TODO: change back to 'mobile-wallet-adapter' once the backend is deployed.
+    coreConfig.authMethod = 'phantom';
+    setAuthProviderInstance(provider);
+    return provider;
+}
 const SOLANA_DEVNET_RPC_URL = "https://idelle-8nxsep-fast-devnet.helius-rpc.com";
 const SOLANA_MAINNET_RPC_URL = "https://celestia-cegncv-fast-mainnet.helius-rpc.com";
 const SURFNET_RPC_URL = "https://surfpool.fly.dev";
@@ -34991,7 +35590,7 @@ async function getAuthProvider(config) {
         return currentAuthProvider;
     }
     // If the user previously logged in with a specific method, use that instead
-    const validAuthMethods = ['privy', 'phantom', 'wallet', 'rainbowkit', 'coinbase-smart-wallet', 'onboard', 'none'];
+    const validAuthMethods = ['privy', 'phantom', 'wallet', 'rainbowkit', 'coinbase-smart-wallet', 'onboard', 'mobile-wallet-adapter', 'none'];
     const storedMethod = getStoredAuthMethod();
     const authMethod = (storedMethod && validAuthMethods.includes(storedMethod))
         ? storedMethod
@@ -35017,8 +35616,13 @@ async function getAuthProvider(config) {
             if ((_d = config.phantomConfig) === null || _d === void 0 ? void 0 : _d.enablePrivyFallback) {
                 currentAuthProvider.onSwitchToPrivy =
                     () => hotSwapToPrivyProvider(config);
+                currentAuthProvider.onSwitchToMWA =
+                    () => hotSwapToMWAProvider(config);
             }
             break;
+        case "mobile-wallet-adapter":
+            currentAuthProvider = new SolanaMobileWalletProvider(rpcUrl, config.mobileWalletConfig);
+            break;
         case "onboard":
             console.warn("Onboard auth is not yet supported.");
             break;
@@ -35241,6 +35845,7 @@ exports.OffchainAuthProvider = OffchainAuthProvider;
 exports.PhantomWalletProvider = PhantomWalletProvider;
 exports.PrivyWalletProvider = PrivyWalletProvider;
 exports.ServerSessionManager = ServerSessionManager;
+exports.SolanaMobileWalletProvider = SolanaMobileWalletProvider;
 exports.WebSessionManager = WebSessionManager;
 exports.aggregate = aggregate;
 exports.bs58 = bs58;
@@ -35263,12 +35868,14 @@ exports.getCurrentUser = getCurrentUser;
 exports.getFiles = getFiles;
 exports.getIdToken = getIdToken;
 exports.init = init;
+exports.isMobileWalletAvailable = isMobileWalletAvailable;
 exports.login = login;
 exports.logout = logout;
 exports.onAuthLoadingChanged = onAuthLoadingChanged;
 exports.onAuthStateChanged = onAuthStateChanged;
 exports.reconnectWithNewAuth = reconnectWithNewAuth;
 exports.refreshSession = refreshSession;
+exports.registerMobileWalletAdapter = registerMobileWalletAdapter;
 exports.runExpression = runExpression;
 exports.runExpressionMany = runExpressionMany;
 exports.runQuery = runQuery;
@@ -35282,4 +35889,4 @@ exports.signSessionCreateMessage = signSessionCreateMessage;
 exports.signTransaction = signTransaction;
 exports.subscribe = subscribe;
 exports.useAuth = useAuth;
-//# sourceMappingURL=index-C-ADfv7y.js.map
+//# sourceMappingURL=index-CMKICH1P.js.map