@pooflabs/web 0.0.69 → 0.0.70-rc.1

package/dist/{index-BMWeM64T.esm.js → index-DEHeP5Qr.esm.js}

@@ -10757,7 +10757,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);
         }
@@ -13543,7 +13546,7 @@ async function loadDependencies() {
         const [reactModule, reactDomModule, phantomModule] = await Promise.all([
             import('react'),
             import('react-dom/client'),
-            import('./index-CitlpjWv.esm.js')
+            import('./index-B3B6I7hT.esm.js')
         ]);
         // Extract default export from ESM module namespace
         // Dynamic import() returns { default: Module, ...exports }, not the module directly
@@ -13566,6 +13569,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') {
@@ -13933,6 +13938,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)) {
@@ -14008,6 +14038,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',
@@ -34883,6 +34944,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 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 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 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 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.AnchorProvider(connection, walletAdapter, anchor.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;
@@ -34952,6 +35527,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";
@@ -34971,7 +35570,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
@@ -34997,8 +35596,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;
@@ -35214,5 +35818,5 @@ async function getIdToken() {
     return getIdToken$1(false);
 }
 
-export { useAuth as A, getIdToken as B, PrivyWalletProvider as C, DEFAULT_TEST_ADDRESS as D, EventEmitter3 as E, buildSetDocumentsTransaction as F, clearCache as G, closeAllSubscriptions as H, convertRemainingAccounts as I, createSessionWithPrivy as J, createSessionWithSignature as K, genAuthNonce as L, MockAuthProvider as M, genSolanaMessage as N, OffchainAuthProvider as O, PhantomWalletProvider as P, getCachedData as Q, reconnectWithNewAuth as R, ServerSessionManager as S, refreshSession as T, signSessionCreateMessage as U, WebSessionManager as W, bs58 as a, bufferExports as b, onAuthLoadingChanged as c, getAuthLoading as d, logout as e, getConfig as f, getCurrentUser as g, getAuthProvider as h, init as i, get$2 as j, setMany as k, login as l, setFile as m, getFiles as n, onAuthStateChanged as o, runQueryMany as p, runExpression as q, runQuery as r, set$1 as s, runExpressionMany as t, signMessage as u, signTransaction as v, signAndSubmitTransaction as w, count as x, aggregate as y, subscribe as z };
-//# sourceMappingURL=index-BMWeM64T.esm.js.map
+export { useAuth as A, getIdToken as B, PrivyWalletProvider as C, DEFAULT_TEST_ADDRESS as D, EventEmitter3 as E, isMobileWalletAvailable as F, registerMobileWalletAdapter as G, ServerSessionManager as H, buildSetDocumentsTransaction as I, clearCache as J, closeAllSubscriptions as K, convertRemainingAccounts as L, MockAuthProvider as M, createSessionWithPrivy as N, OffchainAuthProvider as O, PhantomWalletProvider as P, createSessionWithSignature as Q, genAuthNonce as R, SolanaMobileWalletProvider as S, genSolanaMessage as T, getCachedData as U, reconnectWithNewAuth as V, WebSessionManager as W, refreshSession as X, signSessionCreateMessage as Y, bs58 as a, bufferExports as b, onAuthLoadingChanged as c, getAuthLoading as d, logout as e, getConfig as f, getCurrentUser as g, getAuthProvider as h, init as i, get$2 as j, setMany as k, login as l, setFile as m, getFiles as n, onAuthStateChanged as o, runQueryMany as p, runExpression as q, runQuery as r, set$1 as s, runExpressionMany as t, signMessage as u, signTransaction as v, signAndSubmitTransaction as w, count as x, aggregate as y, subscribe as z };
+//# sourceMappingURL=index-DEHeP5Qr.esm.js.map