@bounded-sh/client 0.0.1

package/dist/phantom-wallet-provider-DMlaSrAl.esm.js

@@ -0,0 +1,1445 @@
+import { W as WebSessionManager, c as convertRemainingAccounts, b as bufferExports, a as buildSetDocumentsTransaction, d as confirmAndCheckTransaction, s as setCurrentUser, S as SOLANA_DEVNET_RPC_URL, e as SOLANA_MAINNET_RPC_URL, f as SURFNET_RPC_URL, g as detectMobile, h as detectAndroid, i as getPlatform, j as setAuthLoading, k as genAuthNonce, l as genSolanaMessage, m as createSessionWithSignature } from './index.native-JPUkdHJj.esm.js';
+import { Connection, PublicKey, VersionedTransaction } from '@solana/web3.js';
+import * as anchor from '@coral-xyz/anchor';
+import 'axios';
+import 'react';
+
+const VALID_PROVIDERS = ['injected', 'google', 'apple', 'deeplink', 'phantom'];
+// When the dApp runs inside an iframe whose parent origin is different from
+// (or can't inject into) the child frame — notably Phantom's Android in-app
+// browser, which injects window.phantom.solana only into the top frame —
+// the Phantom deeplink path tries to navigate phantom.app/ul/browse/... from
+// inside the iframe. Android App Links only hand off on top-level navigations,
+// and phantom.app refuses to be framed (X-Frame-Options: DENY), so the connect
+// fails. To get back to a working context we navigate the top window to the
+// dApp's own URL, dropping the iframe shell. Once top-level, the wallet
+// browser injects its provider and the normal injected flow succeeds.
+function isInIframe() {
+    if (typeof window === 'undefined')
+        return false;
+    try {
+        return window.top !== window.self;
+    }
+    catch (_a) {
+        // Cross-origin access to window.top throws — if we can't read it, we're iframed.
+        return true;
+    }
+}
+function shouldBreakOutOfIframe(provider) {
+    // Only break out when the user chose the deeplink provider. The modal only
+    // offers deeplink on mobile when no injected Phantom is present, so this is
+    // exactly the iframe-without-provider case we need to escape.
+    return provider === 'deeplink' && isInIframe();
+}
+// In a cross-origin iframe (e.g. the poof.new build-page preview) on mobile,
+// Mobile Wallet Adapter can't run: its localhost association handshake needs
+// Chrome's Local Network Access, which is denied to cross-origin sub-frames.
+// So open the app's own URL TOP-LEVEL (a new tab / Custom Tab), where MWA works
+// natively; the connect happens there and the session — written to same-origin
+// storage — reflects back into this iframe (awaitTopLevelConnect picks it up).
+// Must be called synchronously inside a user-gesture handler so window.open
+// isn't popup-blocked. Returns true if the tab was opened.
+function openTopLevelForConnect() {
+    if (typeof window === 'undefined' || !isInIframe())
+        return false;
+    try {
+        const url = new URL(window.location.href);
+        url.searchParams.set('poofConnect', '1');
+        const w = window.open(url.toString(), '_blank');
+        return !!w;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+// Dynamically import React and Phantom SDK - only when needed
+let React;
+let ReactDOM;
+let phantomReactSdk;
+let sdkLoaded = false;
+let loadingPromise = null;
+// Lazy load React and Phantom dependencies only when PhantomWalletProvider is instantiated
+// Uses dynamic import() to ensure code splitting and prevent side effects
+async function loadDependencies() {
+    if (sdkLoaded)
+        return;
+    if (typeof window === 'undefined')
+        return;
+    // Prevent multiple concurrent loads
+    if (loadingPromise)
+        return loadingPromise;
+    loadingPromise = (async () => {
+        const [reactModule, reactDomModule, phantomModule] = await Promise.all([
+            import('react'),
+            import('react-dom/client'),
+            import('./index-CT2j1oic.esm.js')
+        ]);
+        // Extract default export from ESM module namespace
+        // Dynamic import() returns { default: Module, ...exports }, not the module directly
+        React = reactModule.default || reactModule;
+        ReactDOM = reactDomModule.default || reactDomModule;
+        phantomReactSdk = phantomModule;
+        sdkLoaded = true;
+    })();
+    return loadingPromise;
+}
+class PhantomWalletProvider {
+    /** Temporarily override modal appearance for a single login() call. Cleared automatically after login settles. */
+    setLoginOverrides(opts) {
+        this.loginOverrides = opts;
+    }
+    constructor(networkUrl = null, config = {}) {
+        this.containerElement = null;
+        this.root = null;
+        this.phantomMethods = null;
+        this.resolvedProviders = ['injected'];
+        this.pendingLogin = null;
+        this.loginInProgress = false;
+        this.autoLoginInProgress = false;
+        this.initPromise = null;
+        this.loginOverrides = 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') {
+            throw new Error('PhantomWalletProvider can only be instantiated in a browser environment');
+        }
+        // Singleton pattern - reuse existing instance
+        if (PhantomWalletProvider.instance) {
+            return PhantomWalletProvider.instance;
+        }
+        // Resolve providers from config (doesn't need SDK)
+        this.resolveProviders();
+        // Start async initialization (load SDK and initialize React component)
+        this.initPromise = this.initializeAsync();
+        PhantomWalletProvider.instance = this;
+    }
+    async initializeAsync() {
+        // Lazy load dependencies only when actually instantiating
+        await loadDependencies();
+        // Initialize React component
+        this.initialize();
+    }
+    /**
+     * Check if social login providers are configured (non-injected providers).
+     */
+    hasSocialProviders() {
+        return this.resolvedProviders.some(p => p !== 'injected');
+    }
+    static getInstance(networkUrl, config) {
+        if (!PhantomWalletProvider.instance) {
+            new PhantomWalletProvider(networkUrl, config);
+        }
+        return PhantomWalletProvider.instance;
+    }
+    resolveProviders() {
+        if (this.config.providers && this.config.providers.length > 0) {
+            const configProviders = this.config.providers;
+            this.resolvedProviders = configProviders.filter((p) => VALID_PROVIDERS.includes(p));
+            if (this.resolvedProviders.length === 0) {
+                this.resolvedProviders = ['injected'];
+            }
+        }
+        else if (this.config.appId) {
+            this.resolvedProviders = ['injected', 'google', 'apple', 'deeplink'];
+        }
+        else {
+            this.resolvedProviders = ['injected'];
+        }
+    }
+    /**
+     * Patch the Phantom extension's provider to gracefully handle `phantom_getFeatures`
+     * instead of throwing. Some SDKs probe this method to check feature support, but the
+     * extension doesn't implement it, causing noisy console errors.
+     */
+    patchPhantomGetFeatures() {
+        var _a;
+        try {
+            const provider = (_a = window.phantom) === null || _a === void 0 ? void 0 : _a.solana;
+            if (!(provider === null || provider === void 0 ? void 0 : provider.request) || provider.__featuresPatched)
+                return;
+            const originalRequest = provider.request.bind(provider);
+            provider.request = async (args) => {
+                if ((args === null || args === void 0 ? void 0 : args.method) === 'phantom_getFeatures') {
+                    return { features: {} };
+                }
+                return originalRequest(args);
+            };
+            provider.__featuresPatched = true;
+        }
+        catch (_b) {
+            // Phantom extension not present — nothing to patch
+        }
+    }
+    initialize() {
+        if (this.containerElement)
+            return;
+        // Suppress "phantom_getFeatures isn't implemented" errors from SDKs probing
+        // the Phantom extension for features it doesn't support yet.
+        this.patchPhantomGetFeatures();
+        // Remove any existing Phantom providers
+        const existingProviders = document.querySelectorAll('[data-phantom-provider]');
+        existingProviders.forEach(el => el.remove());
+        this.containerElement = document.createElement('div');
+        this.containerElement.setAttribute('data-phantom-provider', 'true');
+        // Keep Phantom UI above host overlays while avoiding global click-capture.
+        this.containerElement.style.position = 'fixed';
+        this.containerElement.style.zIndex = '2147483647';
+        // Full-viewport overlay for custom modal; pointer-events: none lets
+        // clicks pass through to page except where the modal sets 'auto'
+        this.containerElement.style.inset = '0';
+        this.containerElement.style.pointerEvents = 'none';
+        document.body.appendChild(this.containerElement);
+        const that = this;
+        const { PhantomProvider: ReactPhantomProvider, usePhantom, useConnect, useDisconnect, useModal, useSolana, useDiscoveredWallets, AddressType, darkTheme, lightTheme } = phantomReactSdk;
+        // The SDK expects providers as an array of strings: 'injected' | 'google' | 'apple' | 'phantom' | 'deeplink'
+        // Ensure we have a valid non-empty array
+        const sdkProviders = this.resolvedProviders.length > 0 ? [...this.resolvedProviders] : ['injected'];
+        // Inner component that uses hooks
+        const PhantomHooksComponent = () => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            const phantom = usePhantom();
+            const { connect, error: connectError } = useConnect();
+            const { disconnect, isDisconnecting } = useDisconnect();
+            const modal = useModal();
+            const solanaHook = useSolana();
+            const { solana } = solanaHook;
+            const [showWalletModal, setShowWalletModal] = React.useState(false);
+            const [hoveredBtn, setHoveredBtn] = React.useState(null);
+            // Discover all available wallets via Wallet Standard + EIP-6963
+            const { wallets: discoveredWallets } = useDiscoveredWallets();
+            const isMobile = detectMobile();
+            const hasPhantomInjected = discoveredWallets.some((w) => w.id === 'phantom');
+            const showDeeplink = isMobile && sdkProviders.includes('deeplink') && !hasPhantomInjected;
+            // Treat MWA's own wallet-standard registrations as not-injected, so the MWA
+            // button still appears when only MWA is present (e.g. Android Chrome on Seeker).
+            const hasInjectedWallet = discoveredWallets.some((w) => {
+                var _a, _b;
+                const id = String((_a = w.id) !== null && _a !== void 0 ? _a : '').toLowerCase();
+                const name = String((_b = w.name) !== null && _b !== void 0 ? _b : '').toLowerCase();
+                return (id !== 'mobile-wallet-adapter' &&
+                    id !== 'remote-mobile-wallet-adapter' &&
+                    name !== 'mobile wallet adapter' &&
+                    name !== 'remote mobile wallet adapter');
+            });
+            // Track previous modal state to detect closes
+            const prevModalOpen = React.useRef(false);
+            // Track when modal was closed because user selected a wallet (not dismissed)
+            const walletClickedRef = React.useRef(false);
+            // Set up effect to expose methods to the class
+            React.useEffect(() => {
+                if (phantom) {
+                    that.phantomMethods = {
+                        ready: !phantom.isLoading,
+                        isConnected: phantom.isConnected,
+                        addresses: phantom.addresses || [],
+                        user: phantom.user,
+                        connect: async () => {
+                            return await connect();
+                        },
+                        disconnect: async () => {
+                            await disconnect();
+                        },
+                        isDisconnecting,
+                        openModal: () => modal.open(),
+                        closeModal: () => modal.close(),
+                        isModalOpen: modal.isOpened,
+                        connectError,
+                        showCustomModal: () => setShowWalletModal(true),
+                        hideCustomModal: () => setShowWalletModal(false),
+                        solana: solana && solanaHook.isAvailable ? {
+                            // Wrap methods to preserve 'this' context - direct references lose binding
+                            signMessage: (message) => solana.signMessage(message),
+                            signTransaction: (tx) => solana.signTransaction(tx),
+                            signAllTransactions: (txs) => solana.signAllTransactions(txs),
+                            signAndSendTransaction: (tx) => solana.signAndSendTransaction(tx),
+                            getPublicKey: () => solana.getPublicKey(),
+                            isAvailable: solanaHook.isAvailable,
+                            connected: solana.connected,
+                            connect: (options) => solana.connect(options),
+                        } : null,
+                    };
+                }
+            }, [phantom, phantom === null || phantom === void 0 ? void 0 : phantom.isConnected, phantom === null || phantom === void 0 ? void 0 : phantom.addresses, phantom === null || phantom === void 0 ? void 0 : phantom.isLoading, connect, disconnect, isDisconnecting, modal, modal.isOpened, solana, solana === null || solana === void 0 ? void 0 : solana.connected, solanaHook.isAvailable, connectError]);
+            // Auto-login: If connected but no Tarobase session, try to create one.
+            // This handles social login callbacks where user returns from OAuth already connected.
+            React.useEffect(() => {
+                const autoCreateSession = async () => {
+                    var _a;
+                    // Only proceed when SDK is ready, connected, has addresses, and not already in a login flow
+                    if (!(phantom === null || phantom === void 0 ? void 0 : phantom.isConnected) || (phantom === null || phantom === void 0 ? void 0 : phantom.isLoading) || that.loginInProgress || that.autoLoginInProgress || that.pendingLogin) {
+                        return;
+                    }
+                    // Don't clobber a session owned by MWA on Seeker. MWA marks the
+                    // auth method as soon as login starts (see solana-mobile-wallet-provider),
+                    // and clears it on logout, so this guard is correct in both
+                    // steady-state and post-logout cases.
+                    try {
+                        if (getPlatform().storage.getItem('tarobase_last_auth_method') === 'mobile-wallet-adapter') {
+                            return;
+                        }
+                    }
+                    catch (_b) { }
+                    // Need solana to be available AND connected for signing
+                    if (!solana || !solanaHook.isAvailable || !solana.connected) {
+                        return;
+                    }
+                    // Find Solana address
+                    const solAddress = (_a = phantom.addresses) === null || _a === void 0 ? void 0 : _a.find((addr) => addr.addressType === AddressType.solana);
+                    if (!solAddress) {
+                        return;
+                    }
+                    const publicKey = solAddress.address;
+                    // Check if we already have a valid session for this address
+                    const existingSession = await WebSessionManager.getSession();
+                    if (existingSession && existingSession.address === publicKey) {
+                        // Already have a valid session, just set user
+                        setCurrentUser({ provider: that, address: publicKey });
+                        return;
+                    }
+                    // No valid session - try to create one automatically
+                    that.autoLoginInProgress = true;
+                    setAuthLoading(true);
+                    try {
+                        const nonce = await genAuthNonce();
+                        const messageText = await genSolanaMessage(publicKey, nonce);
+                        // signMessage returns { signature: Uint8Array, publicKey: string }
+                        const signResult = await solana.signMessage(messageText);
+                        // Convert Uint8Array signature to base64 string
+                        const signatureBytes = signResult.signature;
+                        const signature = bufferExports.Buffer.from(signatureBytes).toString('base64');
+                        const createSessionResult = await createSessionWithSignature(publicKey, messageText, signature);
+                        // Pre-write guard: MWA may have started a login while we were
+                        // in flight. If MWA owns the auth method now, abort before we
+                        // overwrite its session (or its in-flight session).
+                        try {
+                            if (getPlatform().storage.getItem('tarobase_last_auth_method') === 'mobile-wallet-adapter') {
+                                return;
+                            }
+                        }
+                        catch (_c) { }
+                        await WebSessionManager.storeSession(publicKey, createSessionResult.accessToken, createSessionResult.idToken, createSessionResult.refreshToken);
+                        // Mark auth method so clearIncompatibleSession() doesn't wipe this session
+                        try {
+                            getPlatform().storage.setItem('tarobase_last_auth_method', 'phantom');
+                        }
+                        catch (_d) { }
+                        setCurrentUser({ provider: that, address: publicKey });
+                    }
+                    catch (error) {
+                        // User rejected signing or other error - disconnect fully
+                        try {
+                            await disconnect();
+                        }
+                        catch (e) {
+                            // Ignore disconnect errors
+                        }
+                    }
+                    finally {
+                        that.autoLoginInProgress = false;
+                        setAuthLoading(false);
+                    }
+                };
+                autoCreateSession();
+            }, [phantom === null || phantom === void 0 ? void 0 : phantom.isConnected, phantom === null || phantom === void 0 ? void 0 : phantom.isLoading, phantom === null || phantom === void 0 ? void 0 : phantom.addresses, solana, solana === null || solana === void 0 ? void 0 : solana.connected, solanaHook.isAvailable, disconnect]);
+            // Suppress SDK modal if it opens during custom modal login flow
+            React.useEffect(() => {
+                if (modal.isOpened && that.loginInProgress) {
+                    modal.close();
+                }
+            }, [modal.isOpened]);
+            // Handle modal close without connection
+            React.useEffect(() => {
+                // Detect when modal was open and is now closed
+                if (prevModalOpen.current && !showWalletModal && !modal.isOpened) {
+                    if (walletClickedRef.current) {
+                        // Modal closed because user selected a wallet — don't reject
+                        walletClickedRef.current = false;
+                    }
+                    else if (that.loginInProgress && that.pendingLogin && !(phantom === null || phantom === void 0 ? void 0 : phantom.isConnected)) {
+                        // User dismissed modal without connecting
+                        that.pendingLogin.reject(new Error('User cancelled login'));
+                        that.pendingLogin = null;
+                        that.loginInProgress = false;
+                    }
+                }
+                prevModalOpen.current = showWalletModal || modal.isOpened;
+            }, [showWalletModal, modal.isOpened, phantom === null || phantom === void 0 ? void 0 : phantom.isConnected]);
+            // Handle connection errors
+            React.useEffect(() => {
+                if (connectError && that.pendingLogin) {
+                    that.pendingLogin.reject(connectError);
+                    that.pendingLogin = null;
+                    that.loginInProgress = false;
+                }
+            }, [connectError]);
+            // Handle connection success
+            React.useEffect(() => {
+                const handleConnectionSuccess = async () => {
+                    var _a;
+                    // All conditions must be met for login to proceed
+                    if (!(phantom === null || phantom === void 0 ? void 0 : phantom.isConnected) || !((_a = phantom === null || phantom === void 0 ? void 0 : phantom.addresses) === null || _a === void 0 ? void 0 : _a.length) || !that.pendingLogin || !that.loginInProgress) {
+                        return;
+                    }
+                    // Solana must be available AND connected for signing
+                    // If not ready yet, just return - this effect will re-run when solana.connected changes
+                    if (!solana || !solanaHook.isAvailable || !solana.connected) {
+                        return;
+                    }
+                    try {
+                        // Immediately set loginInProgress to false to prevent double execution
+                        // if the effect runs again before async operations complete
+                        that.loginInProgress = false;
+                        // Find Solana address
+                        const solAddress = phantom.addresses.find((addr) => addr.addressType === AddressType.solana);
+                        if (!solAddress) {
+                            that.pendingLogin.reject(new Error('No Solana address returned'));
+                            that.pendingLogin = null;
+                            return;
+                        }
+                        const publicKey = solAddress.address;
+                        // Check if we already have a valid session
+                        const existingSession = await WebSessionManager.getSession();
+                        if (existingSession && existingSession.address === publicKey) {
+                            const user = { provider: that, address: publicKey };
+                            setCurrentUser(user);
+                            that.pendingLogin.resolve(user);
+                            that.pendingLogin = null;
+                            return;
+                        }
+                        // Create new session with signature
+                        const nonce = await genAuthNonce();
+                        const messageText = await genSolanaMessage(publicKey, nonce);
+                        // signMessage returns { signature: Uint8Array, publicKey: string }
+                        const signResult = await solana.signMessage(messageText);
+                        // Convert Uint8Array signature to base64 string
+                        const signatureBytes = signResult.signature;
+                        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 so clearIncompatibleSession() doesn't wipe this session
+                        try {
+                            getPlatform().storage.setItem('tarobase_last_auth_method', 'phantom');
+                        }
+                        catch (_b) { }
+                        const user = { provider: that, address: publicKey };
+                        setCurrentUser(user);
+                        that.pendingLogin.resolve(user);
+                        that.pendingLogin = null;
+                    }
+                    catch (error) {
+                        // Disconnect Phantom since login failed - don't leave in half-connected state
+                        try {
+                            await disconnect();
+                        }
+                        catch (e) {
+                            // Ignore disconnect errors
+                        }
+                        if (that.pendingLogin) {
+                            that.pendingLogin.reject(error);
+                            that.pendingLogin = null;
+                            that.loginInProgress = false;
+                        }
+                    }
+                };
+                handleConnectionSuccess();
+            }, [phantom === null || phantom === void 0 ? void 0 : phantom.isConnected, phantom === null || phantom === void 0 ? void 0 : phantom.addresses, solana, solana === null || solana === void 0 ? void 0 : solana.connected, solanaHook.isAvailable]);
+            // --- Custom wallet modal handlers ---
+            const handleWalletClick = async (options) => {
+                walletClickedRef.current = true;
+                setShowWalletModal(false);
+                // Cross-origin preview iframe + deeplink: the old approach navigated
+                // the top frame to this URL, but in a TWA that lands out-of-scope and
+                // shows a chrome-error ("bad page"). Instead, open the app TOP-LEVEL
+                // in a new tab where the wallet connect works natively; the session
+                // reflects back into this iframe (see openTopLevelForConnect /
+                // awaitTopLevelConnect).
+                if (shouldBreakOutOfIframe(options === null || options === void 0 ? void 0 : options.provider)) {
+                    if (openTopLevelForConnect()) {
+                        that.awaitTopLevelConnect();
+                        return;
+                    }
+                    // Popup blocked — fall through to the original deeplink path
+                    // (better a broken-ish button than a silently-dead one).
+                }
+                try {
+                    if (options === null || options === void 0 ? void 0 : options.walletId) {
+                        await connect({ provider: 'injected', walletId: options.walletId });
+                    }
+                    else if (options === null || options === void 0 ? void 0 : options.provider) {
+                        await connect({ provider: options.provider });
+                    }
+                    else {
+                        await connect();
+                    }
+                }
+                catch (err) {
+                    // connectError effect handles this
+                }
+            };
+            const handleMobileWalletClick = async () => {
+                that.loginInProgress = false;
+                walletClickedRef.current = true;
+                setShowWalletModal(false);
+                // Cross-origin preview iframe (e.g. poof.new build page) on mobile:
+                // MWA can't run here (Chrome denies Local Network Access to sub-frames,
+                // and its localhost handshake fails). Open the app top-level for the
+                // connect; the session reflects back into this iframe.
+                if (isInIframe() && openTopLevelForConnect()) {
+                    that.awaitTopLevelConnect();
+                    return;
+                }
+                // LNA permission is handled by @solana-mobile/wallet-standard-mobile
+                // >=0.5.0's checkLocalNetworkAccessPermission (three-stage UX, fired
+                // before the localhost reflector opens). No homemade pre-warm needed.
+                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)) {
+                    that.pendingLogin.reject(new Error('User cancelled login'));
+                    that.pendingLogin = null;
+                    that.loginInProgress = false;
+                }
+            };
+            // --- Custom wallet modal ---
+            if (!showWalletModal) {
+                return null;
+            }
+            const effectiveTheme = (_c = (_b = (_a = that.loginOverrides) === null || _a === void 0 ? void 0 : _a.theme) !== null && _b !== void 0 ? _b : that.config.theme) !== null && _c !== void 0 ? _c : 'dark';
+            const isLight = effectiveTheme === 'light';
+            const bgColor = isLight ? '#FFFFFF' : '#111113';
+            const cardBorder = isLight ? '1px solid rgba(0,0,0,0.08)' : '1px solid rgba(255,255,255,0.07)';
+            const textColor = isLight ? '#0f0f0f' : '#f5f5f5';
+            const subTextColor = isLight ? 'rgba(0,0,0,0.45)' : 'rgba(255,255,255,0.4)';
+            const btnBg = isLight ? 'rgba(0,0,0,0.04)' : 'rgba(255,255,255,0.05)';
+            const btnHoverBg = isLight ? 'rgba(0,0,0,0.08)' : 'rgba(255,255,255,0.09)';
+            const btnBorder = isLight ? '1px solid rgba(0,0,0,0.10)' : '1px solid rgba(255,255,255,0.09)';
+            const fontFamily = '"SF Pro Text",-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif';
+            const buttonStyle = (id) => ({
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                gap: '10px',
+                width: '100%',
+                height: '52px',
+                padding: '0 20px',
+                border: btnBorder,
+                borderRadius: '12px',
+                backgroundColor: hoveredBtn === id ? btnHoverBg : btnBg,
+                color: textColor,
+                fontFamily,
+                fontSize: '14px',
+                fontWeight: '500',
+                lineHeight: '1',
+                letterSpacing: '0',
+                cursor: 'pointer',
+                transition: 'background-color 0.15s, border-color 0.15s',
+                boxSizing: 'border-box',
+            });
+            const walletButtons = [];
+            // Google OAuth button — shown when 'google' is in resolved providers
+            if (sdkProviders.includes('google')) {
+                walletButtons.push(React.createElement('button', {
+                    key: 'google-oauth',
+                    style: buttonStyle('google-oauth'),
+                    onClick: () => handleWalletClick({ provider: 'google' }),
+                    onMouseEnter: () => setHoveredBtn('google-oauth'),
+                    onMouseLeave: () => setHoveredBtn(null),
+                }, React.createElement('svg', {
+                    width: '18', height: '18', viewBox: '0 0 24 24',
+                    style: { flexShrink: '0' },
+                }, React.createElement('path', {
+                    d: 'M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92a5.06 5.06 0 0 1-2.2 3.32v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.1z',
+                    fill: '#4285F4',
+                }), React.createElement('path', {
+                    d: 'M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z',
+                    fill: '#34A853',
+                }), React.createElement('path', {
+                    d: 'M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18A11.96 11.96 0 0 0 1 12c0 1.94.46 3.77 1.18 5.41l3.66-2.84z',
+                    fill: '#FBBC05',
+                }), React.createElement('path', {
+                    d: 'M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z',
+                    fill: '#EA4335',
+                })), 'Continue with Google'));
+            }
+            // Apple OAuth button — shown when 'apple' is in resolved providers
+            if (sdkProviders.includes('apple')) {
+                walletButtons.push(React.createElement('button', {
+                    key: 'apple-oauth',
+                    style: buttonStyle('apple-oauth'),
+                    onClick: () => handleWalletClick({ provider: 'apple' }),
+                    onMouseEnter: () => setHoveredBtn('apple-oauth'),
+                    onMouseLeave: () => setHoveredBtn(null),
+                }, React.createElement('svg', {
+                    width: '18', height: '18', viewBox: '0 0 24 24',
+                    fill: textColor,
+                    style: { flexShrink: '0' },
+                }, React.createElement('path', {
+                    d: 'M17.05 20.28c-.98.95-2.05.88-3.08.4-1.09-.5-2.08-.48-3.24 0-1.44.62-2.2.44-3.06-.4C2.79 15.25 3.51 7.59 9.05 7.31c1.35.07 2.29.74 3.08.8 1.18-.24 2.31-.93 3.57-.84 1.51.12 2.65.72 3.4 1.8-3.12 1.87-2.38 5.98.48 7.13-.57 1.5-1.31 2.99-2.54 4.09zM12.03 7.25c-.15-2.23 1.66-4.07 3.74-4.25.29 2.58-2.34 4.5-3.74 4.25z',
+                })), 'Continue with Apple'));
+            }
+            // Fallback icon for Phantom — uses the official SVG path from @phantom/wallet-sdk-ui
+            // (SDK intentionally leaves wallet.icon empty for Phantom, expecting its own UI to render it)
+            const PHANTOM_ICON = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjgiIGhlaWdodD0iMjgiIHZpZXdCb3g9IjAgMCAyOCAyOCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cmVjdCB3aWR0aD0iMjgiIGhlaWdodD0iMjgiIHJ4PSI2IiBmaWxsPSIjQUI5RkYyIi8+PGcgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoNCw0KSI+PHBhdGggZD0iTTIuMzY2NTUgMTguMzI3MUM0LjkxODcxIDE4LjMyNzEgNi44MzY3IDE2LjEwNzYgNy45ODEzMSAxNC4zNTM3QzcuODQyMSAxNC43NDE3IDcuNzY0NzYgMTUuMTI5OCA3Ljc2NDc2IDE1LjUwMjNDNy43NjQ3NiAxNi41MjY3IDguMzUyNTMgMTcuMjU2MiA5LjUxMjYgMTcuMjU2MkMxMS4xMDU4IDE3LjI1NjIgMTIuODA3MiAxNS44NTkzIDEzLjY4ODkgMTQuMzUzN0MxMy42MjcgMTQuNTcxIDEzLjU5NjEgMTQuNzcyOCAxMy41OTYxIDE0Ljk1OUMxMy41OTYxIDE1LjY3MyAxMy45OTgyIDE2LjEyMzEgMTQuODE4IDE2LjEyMzFDMTcuNDAxMSAxNi4xMjMxIDE5Ljk5OTcgMTEuNTQ0NCAxOS45OTk3IDcuNTM5ODdDMTkuOTk5NyA0LjQyMDExIDE4LjQyMiAxLjY3Mjg1IDE0LjQ2MjIgMS42NzI4NUM3LjUwMTgxIDEuNjcyODUgMCAxMC4xNzg1IDAgMTUuNjczQzAgMTcuODMwNSAxLjE2MDA3IDE4LjMyNzEgMi4zNjY1NSAxOC4zMjcxWk0xMi4wNjQ4IDcuMTk4NDFDMTIuMDY0OCA2LjQyMjM1IDEyLjQ5NzkgNS44NzkxIDEzLjEzMiA1Ljg3OTFDMTMuNzUwNyA1Ljg3OTEgMTQuMTgzOCA2LjQyMjM1IDE0LjE4MzggNy4xOTg0MUMxNC4xODM4IDcuOTc0NDcgMTMuNzUwNyA4LjUzMzIzIDEzLjEzMiA4LjUzMzIzQzEyLjQ5NzkgOC41MzMyMyAxMi4wNjQ4IDcuOTc0NDcgMTIuMDY0OCA3LjE5ODQxWk0xNS4zNzQ4IDcuMTk4NDFDMTUuMzc0OCA2LjQyMjM1IDE1LjgwNzkgNS44NzkxIDE2LjQ0MjEgNS44NzkxQzE3LjA2MDggNS44NzkxIDE3LjQ5MzkgNi40MjIzNSAxNy40OTM5IDcuMTk4NDFDMTcuNDkzOSA3Ljk3NDQ3IDE3LjA2MDggOC41MzMyMyAxNi40NDIxIDguNTMzMjNDMTUuODA3OSA4LjUzMzIzIDE1LjM3NDggNy45NzQ0NyAxNS4zNzQ4IDcuMTk4NDFaIiBmaWxsPSJ3aGl0ZSIvPjwvZz48L3N2Zz4=';
+            // Show all discovered injected wallets (Phantom, Solflare, Jupiter, etc.)
+            if (sdkProviders.includes('injected')) {
+                for (const wallet of discoveredWallets) {
+                    const walletKey = `wallet-${wallet.id}`;
+                    const iconSrc = wallet.icon || (wallet.id === 'phantom' ? PHANTOM_ICON : null);
+                    walletButtons.push(React.createElement('button', {
+                        key: walletKey,
+                        style: buttonStyle(walletKey),
+                        onClick: () => handleWalletClick({ walletId: wallet.id }),
+                        onMouseEnter: () => setHoveredBtn(walletKey),
+                        onMouseLeave: () => setHoveredBtn(null),
+                    }, iconSrc
+                        ? React.createElement('img', {
+                            src: iconSrc,
+                            alt: wallet.name,
+                            style: { width: '28px', height: '28px', borderRadius: '6px' },
+                        })
+                        : null, wallet.name));
+                }
+            }
+            if (showDeeplink) {
+                walletButtons.push(React.createElement('button', {
+                    key: 'phantom-deeplink',
+                    style: buttonStyle('phantom-deeplink'),
+                    onClick: () => handleWalletClick({ provider: 'deeplink' }),
+                    onMouseEnter: () => setHoveredBtn('phantom-deeplink'),
+                    onMouseLeave: () => setHoveredBtn(null),
+                }, React.createElement('img', {
+                    src: PHANTOM_ICON,
+                    alt: 'Phantom',
+                    style: { width: '28px', height: '28px', borderRadius: '6px' },
+                }), 'Open Phantom app'));
+            }
+            // Mobile Wallet Adapter button — shown on Android when MWA callback is available
+            // and no injected wallet is present (hides button inside Phantom/Solflare/etc. in-app browsers).
+            const isAndroid = detectAndroid();
+            if (isAndroid && that.onSwitchToMWA && !hasInjectedWallet) {
+                walletButtons.push(React.createElement('button', {
+                    key: 'mobile-wallet',
+                    style: buttonStyle('mobile-wallet'),
+                    onClick: handleMobileWalletClick,
+                    onMouseEnter: () => setHoveredBtn('mobile-wallet'),
+                    onMouseLeave: () => setHoveredBtn(null),
+                }, React.createElement('svg', {
+                    width: '18', height: '18', viewBox: '0 0 24 24', fill: 'none',
+                    style: { flexShrink: '0', opacity: '0.85' },
+                }, 
+                // Phone outline
+                React.createElement('rect', {
+                    x: '5', y: '2', width: '14', height: '20', rx: '2',
+                    stroke: textColor, strokeWidth: '2', fill: 'none',
+                }), 
+                // Screen line
+                React.createElement('line', {
+                    x1: '5', y1: '6', x2: '19', y2: '6',
+                    stroke: textColor, strokeWidth: '1.5',
+                }), 
+                // Wallet/shield checkmark
+                React.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'));
+            }
+            const mainButtons = walletButtons;
+            // Render custom modal
+            return React.createElement('div', {
+                // Overlay
+                style: {
+                    position: 'fixed',
+                    top: '0',
+                    left: '0',
+                    right: '0',
+                    bottom: '0',
+                    backgroundColor: isLight ? 'rgba(0,0,0,0.35)' : 'rgba(0,0,0,0.65)',
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    padding: '16px',
+                    boxSizing: 'border-box',
+                    overflowY: 'auto',
+                    zIndex: 2147483647,
+                    pointerEvents: 'auto',
+                    backdropFilter: 'blur(4px)',
+                    WebkitBackdropFilter: 'blur(4px)',
+                },
+                onClick: (e) => {
+                    if (e.target === e.currentTarget)
+                        handleCloseModal();
+                },
+                onMouseDown: (e) => {
+                    e.stopPropagation();
+                },
+                onPointerDown: (e) => {
+                    e.stopPropagation();
+                },
+            }, 
+            // Card
+            React.createElement('div', {
+                style: {
+                    backgroundColor: bgColor,
+                    border: cardBorder,
+                    borderRadius: '20px',
+                    width: '100%',
+                    maxWidth: '380px',
+                    maxHeight: '100%',
+                    overflowY: 'auto',
+                    padding: '28px 24px 24px',
+                    position: 'relative',
+                    boxShadow: isLight
+                        ? '0 8px 40px rgba(0,0,0,0.12), 0 2px 8px rgba(0,0,0,0.06)'
+                        : '0 8px 40px rgba(0,0,0,0.6), 0 2px 8px rgba(0,0,0,0.3)',
+                    pointerEvents: 'auto',
+                    boxSizing: 'border-box',
+                },
+                onMouseDown: (e) => {
+                    e.stopPropagation();
+                },
+                onPointerDown: (e) => {
+                    e.stopPropagation();
+                },
+            }, 
+            // Close button
+            React.createElement('button', {
+                onClick: handleCloseModal,
+                style: {
+                    position: 'absolute',
+                    top: '14px',
+                    right: '14px',
+                    background: isLight ? 'rgba(0,0,0,0.05)' : 'rgba(255,255,255,0.07)',
+                    border: isLight ? '1px solid rgba(0,0,0,0.08)' : '1px solid rgba(255,255,255,0.08)',
+                    borderRadius: '50%',
+                    width: '28px',
+                    height: '28px',
+                    cursor: 'pointer',
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    padding: '0',
+                    flexShrink: '0',
+                },
+            }, React.createElement('svg', {
+                width: '12', height: '12', viewBox: '0 0 12 12', fill: 'none',
+            }, React.createElement('path', {
+                d: 'M11 1L1 11M1 1l10 10',
+                stroke: subTextColor, strokeWidth: '1.75', strokeLinecap: 'round',
+            }))), 
+            // App icon (if provided)
+            that.config.appIcon ? React.createElement('div', {
+                style: { display: 'flex', justifyContent: 'center', marginBottom: '16px' },
+            }, React.createElement('img', {
+                src: that.config.appIcon,
+                alt: that.config.appName || 'App',
+                style: { width: '44px', height: '44px', borderRadius: '10px' },
+            })) : null, 
+            // Title
+            React.createElement('div', {
+                style: {
+                    color: textColor,
+                    fontFamily,
+                    fontSize: '17px',
+                    fontWeight: '600',
+                    textAlign: 'center',
+                    marginBottom: '6px',
+                    letterSpacing: '-0.2px',
+                },
+            }, (_f = (_e = (_d = that.loginOverrides) === null || _d === void 0 ? void 0 : _d.modalTitle) !== null && _e !== void 0 ? _e : that.config.modalTitle) !== null && _f !== void 0 ? _f : (that.config.appName ? `Log in to ${that.config.appName}` : 'Log in to your account')), 
+            // Subtitle
+            React.createElement('div', {
+                style: {
+                    color: subTextColor,
+                    fontFamily,
+                    fontSize: '13px',
+                    fontWeight: '400',
+                    textAlign: 'center',
+                    marginBottom: '24px',
+                    lineHeight: '1.4',
+                },
+            }, (_j = (_h = (_g = that.loginOverrides) === null || _g === void 0 ? void 0 : _g.modalSubtitle) !== null && _h !== void 0 ? _h : that.config.modalSubtitle) !== null && _j !== void 0 ? _j : 'Choose how you\'d like to continue'), 
+            // Wallet / social login buttons
+            React.createElement('div', {
+                style: {
+                    display: 'flex',
+                    flexDirection: 'column',
+                    gap: '8px',
+                },
+            }, ...mainButtons)));
+        };
+        // Wrapper component with PhantomProvider
+        const PhantomProviderWrapper = () => {
+            // Build SDK config
+            const sdkConfig = React.useMemo(() => {
+                var _a;
+                const config = {
+                    providers: sdkProviders,
+                    addressTypes: [AddressType.solana],
+                    autoConnect: (_a = that.config.autoConnect) !== null && _a !== void 0 ? _a : true,
+                };
+                if (that.config.appId) {
+                    config.appId = that.config.appId;
+                }
+                return config;
+            }, []);
+            const theme = that.config.theme === 'light' ? lightTheme : darkTheme;
+            return React.createElement(ReactPhantomProvider, {
+                config: sdkConfig,
+                theme: theme,
+                appName: that.config.appName || 'App',
+                appIcon: that.config.appIcon,
+            }, React.createElement(PhantomHooksComponent));
+        };
+        this.root = ReactDOM.createRoot(this.containerElement);
+        this.root.render(React.createElement(PhantomProviderWrapper));
+    }
+    async ensureReady() {
+        // Wait for async initialization to complete first
+        if (this.initPromise) {
+            await this.initPromise;
+        }
+        // Wait for SDK to be ready
+        await new Promise((resolve) => {
+            const check = () => {
+                var _a;
+                if ((_a = this.phantomMethods) === null || _a === void 0 ? void 0 : _a.ready) {
+                    resolve();
+                }
+                else {
+                    setTimeout(check, 100);
+                }
+            };
+            check();
+        });
+    }
+    async ensureSolanaReady() {
+        var _a;
+        await this.ensureReady();
+        // If connected at the Phantom level, ensure solana methods are ready
+        if ((_a = this.phantomMethods) === null || _a === void 0 ? void 0 : _a.isConnected) {
+            const timeoutMs = 10000; // 10 second timeout
+            const startTime = Date.now();
+            // First, wait for solana to be available
+            await new Promise((resolve, reject) => {
+                const check = () => {
+                    var _a, _b;
+                    if ((_b = (_a = this.phantomMethods) === null || _a === void 0 ? void 0 : _a.solana) === null || _b === void 0 ? void 0 : _b.isAvailable) {
+                        resolve();
+                    }
+                    else if (Date.now() - startTime > timeoutMs) {
+                        reject(new Error('Timeout waiting for Solana provider to be available'));
+                    }
+                    else {
+                        setTimeout(check, 100);
+                    }
+                };
+                check();
+            });
+            // Now check if the solana provider is connected, if not try to reconnect
+            // Note: We check our wrapper's `connected` which may be stale, but this is just
+            // an optimization to skip reconnect if we know we're already connected.
+            // The actual signing methods use the SDK's bound methods which check live state.
+            if (!this.phantomMethods.solana.connected) {
+                console.log('Solana provider not connected, attempting to reconnect...');
+                try {
+                    // onlyIfTrusted: true means it will reconnect silently if previously approved
+                    // If not trusted, it will throw and we'll catch it below
+                    await this.phantomMethods.solana.connect({ onlyIfTrusted: true });
+                    console.log('Solana provider reconnected successfully');
+                }
+                catch (error) {
+                    // If onlyIfTrusted fails, the user may need to re-approve via modal
+                    console.error('Failed to reconnect solana provider (silent reconnect failed):', error === null || error === void 0 ? void 0 : error.message);
+                    throw new Error('Failed to reconnect Solana provider. Please try logging in again.');
+                }
+            }
+            // Note: We don't do a final connected check here because our wrapper's `connected`
+            // is a snapshot that won't update until React re-renders. If connect() succeeded,
+            // the SDK is connected and signing will work.
+        }
+    }
+    /**
+     * Get the list of available (configured) providers for this wallet.
+     */
+    getAvailableProviders() {
+        return [...this.resolvedProviders];
+    }
+    /**
+     * Login using the Phantom connect modal. A custom modal is rendered with the
+     * discovered wallets and configured social providers instead of the SDK's
+     * built-in modal.
+     */
+    async login() {
+        var _a, _b;
+        await this.ensureReady();
+        // Check if already connected with valid session
+        if (((_a = this.phantomMethods) === null || _a === void 0 ? void 0 : _a.isConnected) && ((_b = this.phantomMethods.addresses) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+            const solAddress = this.phantomMethods.addresses.find((addr) => addr.addressType === phantomReactSdk.AddressType.solana);
+            if (solAddress) {
+                const session = await WebSessionManager.getSession();
+                if (session && session.address === solAddress.address) {
+                    const user = { provider: this, address: solAddress.address };
+                    setCurrentUser(user);
+                    return user;
+                }
+            }
+        }
+        // If already pending, wait for it
+        if (this.pendingLogin) {
+            return new Promise((resolve, reject) => {
+                this.pendingLogin.resolve = resolve;
+                this.pendingLogin.reject = reject;
+            });
+        }
+        const loginPromise = new Promise((resolve, reject) => {
+            this.pendingLogin = { resolve, reject };
+            this.loginInProgress = true;
+            // Always use our custom wallet modal
+            this.phantomMethods.showCustomModal();
+            // Safety timeout
+            setTimeout(() => {
+                if (this.pendingLogin) {
+                    this.pendingLogin.reject(new Error('Login timed out'));
+                    this.pendingLogin = null;
+                    this.loginInProgress = false;
+                }
+            }, 180000);
+        });
+        return loginPromise.finally(() => {
+            this.loginOverrides = null;
+        });
+    }
+    async restoreSession() {
+        await this.ensureReady();
+        const session = await WebSessionManager.getSession();
+        if (session) {
+            return { provider: this, address: session.address };
+        }
+        return null;
+    }
+    // When connect is delegated to a top-level tab (openTopLevelForConnect — used
+    // for the cross-origin preview iframe on mobile, where MWA can't run), the
+    // actual connect happens in that tab and writes the session to same-origin
+    // storage. This watches for that session to appear and resolves the in-flight
+    // login() with it. It listens for `storage` events and visibility regain (the
+    // user returning from the tab), with a polling fallback and a hard timeout.
+    awaitTopLevelConnect() {
+        if (typeof window === 'undefined')
+            return;
+        let done = false;
+        const cleanup = () => {
+            clearInterval(poll);
+            clearTimeout(timeout);
+            window.removeEventListener('storage', onChange);
+            document.removeEventListener('visibilitychange', onVisible);
+        };
+        const tryResolve = async () => {
+            if (done)
+                return;
+            try {
+                const user = await this.restoreSession();
+                if (user && this.pendingLogin) {
+                    done = true;
+                    cleanup();
+                    this.pendingLogin.resolve(user);
+                    this.pendingLogin = null;
+                    this.loginInProgress = false;
+                }
+            }
+            catch (_a) {
+                // not ready yet — keep waiting
+            }
+        };
+        const onChange = () => { void tryResolve(); };
+        const onVisible = () => { if (document.visibilityState === 'visible')
+            void tryResolve(); };
+        const poll = setInterval(() => { void tryResolve(); }, 1500);
+        const timeout = setTimeout(() => {
+            cleanup();
+            if (!done && this.pendingLogin) {
+                this.pendingLogin.reject(new Error('Wallet connection timed out'));
+                this.pendingLogin = null;
+                this.loginInProgress = false;
+            }
+        }, 180000);
+        window.addEventListener('storage', onChange);
+        document.addEventListener('visibilitychange', onVisible);
+    }
+    async address() {
+        var _a, _b, _c, _d;
+        await this.ensureReady();
+        if (!((_a = this.phantomMethods) === null || _a === void 0 ? void 0 : _a.isConnected) || !((_b = this.phantomMethods.addresses) === null || _b === void 0 ? void 0 : _b.length)) {
+            // Try to connect first
+            const user = await this.login();
+            if (!user)
+                return null;
+        }
+        const solAddress = (_d = (_c = this.phantomMethods) === null || _c === void 0 ? void 0 : _c.addresses) === null || _d === void 0 ? void 0 : _d.find((addr) => addr.addressType === phantomReactSdk.AddressType.solana);
+        return (solAddress === null || solAddress === void 0 ? void 0 : solAddress.address) || null;
+    }
+    async runTransaction(_evmTransactionData, solTransactionData, options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        if (!solTransactionData) {
+            throw new Error("Solana transaction data is required for Phantom wallet");
+        }
+        try {
+            await this.ensureSolanaReady();
+        }
+        catch (error) {
+            console.error('Solana provider reconnection failed, logging out:', error.message);
+            await this.logout();
+            throw new Error('Wallet connection lost. Please reconnect.');
+        }
+        if (!((_a = this.phantomMethods) === null || _a === void 0 ? void 0 : _a.isConnected)) {
+            const user = await this.login();
+            if (!user) {
+                throw new Error('Failed to connect wallet');
+            }
+            try {
+                await this.ensureSolanaReady();
+            }
+            catch (error) {
+                console.error('Solana provider reconnection failed after login, logging out:', error.message);
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+        }
+        if (!((_b = this.phantomMethods) === null || _b === void 0 ? void 0 : _b.solana)) {
+            throw new Error('Solana signing not available');
+        }
+        const rpcUrl = this.getRpcUrl(solTransactionData.network);
+        const connection = new Connection(rpcUrl, 'confirmed');
+        const isSurfnet = rpcUrl === SURFNET_RPC_URL;
+        try {
+            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");
+            }
+            // Get address
+            const solAddress = this.phantomMethods.addresses.find((addr) => addr.addressType === phantomReactSdk.AddressType.solana);
+            if (!solAddress) {
+                throw new Error('Failed to get Solana address');
+            }
+            const publicKey = new PublicKey(solAddress.address);
+            // Create wallet adapter using SDK methods
+            const solana = this.phantomMethods.solana;
+            const walletAdapter = {
+                publicKey,
+                signTransaction: async (tx) => {
+                    return await solana.signTransaction(tx);
+                },
+                signAllTransactions: async (txs) => {
+                    return await solana.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);
+                }
+            }
+            // When the server has co-signed a transaction (CPI attestation),
+            // deserialize it and just add the wallet signature instead of
+            // building from components.
+            let tx;
+            if (solTransactionData.signedTransaction) {
+                tx = VersionedTransaction.deserialize(bufferExports.Buffer.from(solTransactionData.signedTransaction, 'base64'));
+            }
+            else {
+                const result = 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, solTransactionData.additionalLutAddresses);
+                tx = result.tx;
+            }
+            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: ""
+                };
+            }
+            // Keep manual submission on surfnet, use Phantom's recommended signAndSend for other networks.
+            if (isSurfnet) {
+                const signedTx = await walletAdapter.signTransaction(tx);
+                const { signature, txInfo } = await this.submitSignedTransaction(signedTx, connection);
+                return {
+                    transactionSignature: signature,
+                    blockNumber: (txInfo === null || txInfo === void 0 ? void 0 : txInfo.slot) || 0,
+                    gasUsed: ((_c = txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta) === null || _c === void 0 ? void 0 : _c.fee.toString()) || '0',
+                    data: txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta,
+                };
+            }
+            const signature = await this.signAndSendViaPhantom(tx);
+            const txInfo = await confirmAndCheckTransaction(connection, signature);
+            return {
+                transactionSignature: signature,
+                blockNumber: (txInfo === null || txInfo === void 0 ? void 0 : txInfo.slot) || 0,
+                gasUsed: ((_d = txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta) === null || _d === void 0 ? void 0 : _d.fee.toString()) || '0',
+                data: txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta,
+            };
+        }
+        catch (error) {
+            // Check if this is a connection error - if so, log out
+            if (((_e = error === null || error === void 0 ? void 0 : error.message) === null || _e === void 0 ? void 0 : _e.includes('not connected')) || ((_f = error === null || error === void 0 ? void 0 : error.message) === null || _f === void 0 ? void 0 : _f.includes('connect first'))) {
+                console.error('Solana provider connection lost during transaction, logging out');
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+            const isUserRejection = (error === null || error === void 0 ? void 0 : error.code) === 4001 ||
+                ((_g = error === null || error === void 0 ? void 0 : error.message) === null || _g === void 0 ? void 0 : _g.toLowerCase().includes('user rejected')) ||
+                ((_h = error === null || error === void 0 ? void 0 : error.message) === null || _h === void 0 ? void 0 : _h.toLowerCase().includes('user denied')) ||
+                ((_j = error === null || error === void 0 ? void 0 : error.message) === null || _j === void 0 ? void 0 : _j.toLowerCase().includes('user cancelled')) ||
+                ((_k = error === null || error === void 0 ? void 0 : error.message) === null || _k === void 0 ? void 0 : _k.toLowerCase().includes('user canceled'));
+            if (!isUserRejection) {
+                console.error('Failed to execute transaction', error);
+            }
+            throw new Error(`Failed to execute transaction: ${error.message}`);
+        }
+    }
+    /**
+     * Signs a Solana transaction without submitting it.
+     *
+     * This method handles blockhash automatically if not set - you do NOT need to
+     * set recentBlockhash on the transaction before calling this method.
+     * The network/RPC URL is derived from the provider's configuration (set during initialization).
+     *
+     * @param transaction - The transaction to sign (Transaction or VersionedTransaction)
+     * @returns The signed transaction
+     */
+    async signTransaction(transaction) {
+        var _a, _b, _c, _d;
+        try {
+            await this.ensureSolanaReady();
+        }
+        catch (error) {
+            // Reconnection failed - log user out and throw
+            console.error('Solana provider reconnection failed, logging out:', error.message);
+            await this.logout();
+            throw new Error('Wallet connection lost. Please reconnect.');
+        }
+        if (!((_a = this.phantomMethods) === null || _a === void 0 ? void 0 : _a.isConnected)) {
+            const user = await this.login();
+            if (!user) {
+                throw new Error('Failed to connect wallet');
+            }
+            try {
+                await this.ensureSolanaReady();
+            }
+            catch (error) {
+                console.error('Solana provider reconnection failed after login, logging out:', error.message);
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+        }
+        if (!((_b = this.phantomMethods) === null || _b === void 0 ? void 0 : _b.solana)) {
+            throw new Error('Solana signing not available');
+        }
+        // Use duck typing instead of instanceof to handle multiple @solana/web3.js versions
+        const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
+        // Ensure blockhash is set before signing
+        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;
+            }
+            // Set feePayer if not already set
+            if (!legacyTx.feePayer) {
+                const solAddress = this.phantomMethods.addresses.find((addr) => addr.addressType === phantomReactSdk.AddressType.solana);
+                if (solAddress) {
+                    legacyTx.feePayer = new PublicKey(solAddress.address);
+                }
+            }
+        }
+        else {
+            // VersionedTransaction
+            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 {
+            return await this.phantomMethods.solana.signTransaction(transaction);
+        }
+        catch (error) {
+            // Check if this is a connection error - if so, log out
+            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('connect first'))) {
+                console.error('Solana provider connection lost during signing, logging out');
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+            throw new Error(`Failed to sign transaction: ${error.message}`);
+        }
+    }
+    /**
+     * Signs and submits a Solana transaction to the network.
+     *
+     * This method handles blockhash and transaction confirmation automatically - you do NOT need to
+     * set recentBlockhash or lastValidBlockHeight on the transaction before calling this method.
+     * The network/RPC URL is derived from the provider's configuration (set during initialization).
+     *
+     * @param transaction - The transaction to sign and submit (Transaction or VersionedTransaction)
+     * @param feePayer - Optional fee payer public key. If not provided and the transaction doesn't
+     *                   already have a feePayer set, the connected wallet address will be used.
+     *                   Useful for co-signing scenarios where a different account pays the fees.
+     * @returns The transaction signature
+     */
+    async signAndSubmitTransaction(transaction, feePayer) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        try {
+            await this.ensureSolanaReady();
+        }
+        catch (error) {
+            console.error('Solana provider reconnection failed, logging out:', error.message);
+            await this.logout();
+            throw new Error('Wallet connection lost. Please reconnect.');
+        }
+        if (!((_a = this.phantomMethods) === null || _a === void 0 ? void 0 : _a.isConnected)) {
+            const user = await this.login();
+            if (!user) {
+                throw new Error('Failed to connect wallet');
+            }
+            try {
+                await this.ensureSolanaReady();
+            }
+            catch (error) {
+                console.error('Solana provider reconnection failed after login, logging out:', error.message);
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+        }
+        if (!((_b = this.phantomMethods) === null || _b === void 0 ? void 0 : _b.solana)) {
+            throw new Error('Solana signing not available');
+        }
+        const rpcUrl = this.getRpcUrl();
+        const connection = new Connection(rpcUrl, 'confirmed');
+        const isSurfnet = rpcUrl === SURFNET_RPC_URL;
+        try {
+            // Get fresh blockhash and set it on the transaction before signing
+            const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+            // Use duck typing instead of instanceof to handle multiple @solana/web3.js versions
+            const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
+            if (isLegacyTransaction) {
+                const legacyTx = transaction;
+                legacyTx.recentBlockhash = blockhash;
+                legacyTx.lastValidBlockHeight = lastValidBlockHeight;
+                // Set feePayer if not already set
+                if (!legacyTx.feePayer) {
+                    if (feePayer) {
+                        legacyTx.feePayer = feePayer;
+                    }
+                    else {
+                        // Use connected wallet address as feePayer
+                        const solAddress = this.phantomMethods.addresses.find((addr) => addr.addressType === phantomReactSdk.AddressType.solana);
+                        if (solAddress) {
+                            legacyTx.feePayer = new PublicKey(solAddress.address);
+                        }
+                    }
+                }
+            }
+            else {
+                // VersionedTransaction
+                const versionedTx = transaction;
+                versionedTx.message.recentBlockhash = blockhash;
+                // Note: VersionedTransaction feePayer is set in the message at creation time
+                // and cannot be modified after creation
+            }
+            // Keep manual submission on surfnet, use Phantom's recommended signAndSend for other networks.
+            if (isSurfnet) {
+                const signedTx = await this.phantomMethods.solana.signTransaction(transaction);
+                const { signature } = await this.submitSignedTransactionWithBlockhash(signedTx, connection, blockhash, lastValidBlockHeight);
+                return signature;
+            }
+            const signature = await this.signAndSendViaPhantom(transaction);
+            await confirmAndCheckTransaction(connection, signature);
+            return signature;
+        }
+        catch (error) {
+            // Check if this is a connection error - if so, log out
+            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('connect first'))) {
+                console.error('Solana provider connection lost during transaction, logging out');
+                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('Failed to execute transaction', error);
+            }
+            throw new Error(`Failed to execute transaction: ${error.message}`);
+        }
+    }
+    async signMessage(message) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        try {
+            await this.ensureSolanaReady();
+        }
+        catch (error) {
+            // Reconnection failed - log user out and throw
+            console.error('Solana provider reconnection failed, logging out:', error.message);
+            await this.logout();
+            throw new Error('Wallet connection lost. Please reconnect.');
+        }
+        if (!((_a = this.phantomMethods) === null || _a === void 0 ? void 0 : _a.isConnected)) {
+            const user = await this.login();
+            if (!user) {
+                throw new Error('Failed to connect wallet');
+            }
+            try {
+                await this.ensureSolanaReady();
+            }
+            catch (error) {
+                console.error('Solana provider reconnection failed after login, logging out:', error.message);
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+        }
+        if (!((_b = this.phantomMethods) === null || _b === void 0 ? void 0 : _b.solana)) {
+            throw new Error('Solana signing not available');
+        }
+        try {
+            // signMessage returns { signature: Uint8Array, publicKey: string }
+            const result = await this.phantomMethods.solana.signMessage(message);
+            return bufferExports.Buffer.from(result.signature).toString('base64');
+        }
+        catch (error) {
+            // Check if this is a connection error - if so, log out
+            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('connect first'))) {
+                console.error('Solana provider connection lost during signing, logging out');
+                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('Failed to sign message', error);
+            }
+            throw new Error('Failed to sign message');
+        }
+    }
+    async logout() {
+        var _a;
+        await this.ensureReady();
+        try {
+            if ((_a = this.phantomMethods) === null || _a === void 0 ? void 0 : _a.isConnected) {
+                await this.phantomMethods.disconnect();
+            }
+        }
+        catch (error) {
+            console.error('Failed to disconnect from Phantom wallet', error);
+        }
+        // Always clear local state
+        WebSessionManager.clearSession();
+        setCurrentUser(null);
+    }
+    async getNativeMethods() {
+        await this.ensureReady();
+        return this.phantomMethods;
+    }
+    /* ----------------------------------------------------------- *
+     * 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; // default to mainnet
+    }
+    async signAndSendViaPhantom(transaction) {
+        var _a, _b, _c;
+        const result = await ((_b = (_a = this.phantomMethods) === null || _a === void 0 ? void 0 : _a.solana) === null || _b === void 0 ? void 0 : _b.signAndSendTransaction(transaction));
+        const signature = (_c = result === null || result === void 0 ? void 0 : result.signature) !== null && _c !== void 0 ? _c : result === null || result === void 0 ? void 0 : result.hash;
+        if (!signature) {
+            throw new Error('Phantom did not return a transaction signature');
+        }
+        return signature;
+    }
+    async submitSignedTransaction(signedTx, connection) {
+        // Get fresh blockhash for confirmation
+        const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+        return this.submitSignedTransactionWithBlockhash(signedTx, connection, blockhash, lastValidBlockHeight);
+    }
+    async submitSignedTransactionWithBlockhash(signedTx, connection, blockhash, lastValidBlockHeight) {
+        // Submit the transaction
+        const signature = await connection.sendRawTransaction(signedTx.serialize(), {
+            preflightCommitment: 'confirmed'
+        });
+        // Confirm using blockhash strategy (same as runTransaction)
+        const confirmation = await connection.confirmTransaction({
+            signature,
+            blockhash,
+            lastValidBlockHeight,
+        }, 'confirmed');
+        if (confirmation.value.err) {
+            throw new Error(`Transaction failed: ${confirmation.value.err.toString()}`);
+        }
+        // Get transaction info
+        const txInfo = await connection.getParsedTransaction(signature, {
+            maxSupportedTransactionVersion: 0,
+            commitment: 'confirmed'
+        });
+        return { signature, txInfo };
+    }
+}
+PhantomWalletProvider.instance = null;
+
+export { PhantomWalletProvider };
+//# sourceMappingURL=phantom-wallet-provider-DMlaSrAl.esm.js.map