@pooflabs/web 0.0.73 → 0.0.75

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

@@ -0,0 +1,1307 @@
+import { b as bufferExports } from './index-CrOVJFX9.esm.js';
+import { W as WebSessionManager, c as convertRemainingAccounts, b as buildSetDocumentsTransaction, e as confirmAndCheckTransaction, s as setCurrentUser, a as SOLANA_DEVNET_RPC_URL, S as SOLANA_MAINNET_RPC_URL, h as SURFNET_RPC_URL, i as detectMobile, j as detectAndroid, k as setAuthLoading, l as genAuthNonce, m as genSolanaMessage, n as createSessionWithSignature, g as getPlatform } from './index.native-BB7er4-z.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'];
+// 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-_vhjpl1l.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 {
+    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;
+        /** 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') {
+            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'];
+        }
+        // When Privy handles social logins, strip them from Phantom
+        if (this.config.enablePrivyFallback) {
+            this.resolvedProviders = this.resolvedProviders.filter(p => p !== 'google' && p !== 'apple');
+        }
+    }
+    /**
+     * Patch the Phantom extension's provider to gracefully handle `phantom_getFeatures`
+     * instead of throwing. Privy's SDK probes 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 Privy 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;
+            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;
+            // 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;
+                    }
+                    // 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);
+                        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) { }
+                        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);
+                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 handleEmailClick = async () => {
+                that.loginInProgress = false;
+                walletClickedRef.current = true;
+                setShowWalletModal(false);
+                if (that.onSwitchToPrivy) {
+                    try {
+                        const privyProvider = await that.onSwitchToPrivy();
+                        const user = await privyProvider.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 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)) {
+                    that.pendingLogin.reject(new Error('User cancelled login'));
+                    that.pendingLogin = null;
+                    that.loginInProgress = false;
+                }
+            };
+            // --- Custom wallet modal ---
+            if (!showWalletModal) {
+                return null;
+            }
+            const theme = that.config.theme === 'light' ? lightTheme : darkTheme;
+            const bgColor = ((_a = theme === null || theme === void 0 ? void 0 : theme.background) === null || _a === void 0 ? void 0 : _a.primary) || (that.config.theme === 'light' ? '#FFFFFF' : '#1A1A2E');
+            const textColor = ((_b = theme === null || theme === void 0 ? void 0 : theme.text) === null || _b === void 0 ? void 0 : _b.primary) || (that.config.theme === 'light' ? '#000000' : '#FFFFFF');
+            const btnBg = 'rgba(152,151,156,0.1)';
+            const btnHoverBg = 'rgba(152,151,156,0.15)';
+            const fontFamily = '"SF Pro Text",-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif';
+            const buttonStyle = (id) => ({
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                gap: '12px',
+                width: '100%',
+                height: '56px',
+                padding: '12px 16px',
+                border: 'none',
+                borderRadius: '16px',
+                backgroundColor: hoveredBtn === id ? btnHoverBg : btnBg,
+                color: textColor,
+                fontFamily,
+                fontSize: '14px',
+                fontWeight: '600',
+                lineHeight: '17px',
+                letterSpacing: '-0.14px',
+                cursor: 'pointer',
+                transition: 'background-color 0.2s',
+            });
+            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: '20', height: '20', 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: '20', height: '20', 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
+            const isAndroid = detectAndroid();
+            if (isAndroid && that.onSwitchToMWA) {
+                walletButtons.push(React.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.createElement('svg', {
+                    width: '20', height: '20', viewBox: '0 0 24 24', fill: 'none',
+                    style: { flexShrink: '0' },
+                }, 
+                // 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'));
+            }
+            // Email button — only when Privy fallback is enabled
+            if (that.config.enablePrivyFallback) {
+                walletButtons.push(React.createElement('button', {
+                    key: 'email-login',
+                    style: buttonStyle('email-login'),
+                    onClick: handleEmailClick,
+                    onMouseEnter: () => setHoveredBtn('email-login'),
+                    onMouseLeave: () => setHoveredBtn(null),
+                }, 
+                // Email icon
+                React.createElement('svg', {
+                    width: '20', height: '20', viewBox: '0 0 24 24', fill: 'none',
+                    style: { flexShrink: '0' },
+                }, React.createElement('path', {
+                    d: 'M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z',
+                    stroke: textColor, strokeWidth: '2', strokeLinecap: 'round', strokeLinejoin: 'round', fill: 'none',
+                }), React.createElement('path', {
+                    d: 'M22 6l-10 7L2 6',
+                    stroke: textColor, strokeWidth: '2', strokeLinecap: 'round', strokeLinejoin: 'round', fill: 'none',
+                })), 'Log in with email'));
+            }
+            // Render custom modal
+            return React.createElement('div', {
+                // Overlay
+                style: {
+                    position: 'fixed',
+                    top: '0',
+                    left: '0',
+                    right: '0',
+                    bottom: '0',
+                    backgroundColor: 'rgba(0,0,0,0.5)',
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    zIndex: 2147483647,
+                    pointerEvents: 'auto',
+                },
+                onClick: (e) => {
+                    if (e.target === e.currentTarget)
+                        handleCloseModal();
+                },
+                onMouseDown: (e) => {
+                    e.stopPropagation();
+                },
+                onPointerDown: (e) => {
+                    e.stopPropagation();
+                },
+            }, 
+            // Card
+            React.createElement('div', {
+                style: {
+                    backgroundColor: bgColor,
+                    borderRadius: '24px',
+                    width: '360px',
+                    maxWidth: '90vw',
+                    padding: '24px',
+                    position: 'relative',
+                    boxShadow: '0 20px 60px rgba(0,0,0,0.3)',
+                    pointerEvents: 'auto',
+                },
+                onMouseDown: (e) => {
+                    e.stopPropagation();
+                },
+                onPointerDown: (e) => {
+                    e.stopPropagation();
+                },
+            }, 
+            // Close button (X)
+            React.createElement('button', {
+                onClick: handleCloseModal,
+                style: {
+                    position: 'absolute',
+                    top: '16px',
+                    right: '16px',
+                    background: 'none',
+                    border: 'none',
+                    cursor: 'pointer',
+                    padding: '4px',
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                },
+            }, React.createElement('svg', {
+                width: '14', height: '14', viewBox: '0 0 14 14', fill: 'none',
+            }, React.createElement('path', {
+                d: 'M13 1L1 13M1 1l12 12',
+                stroke: textColor, strokeWidth: '2', 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: '48px', height: '48px', borderRadius: '12px' },
+            })) : null, 
+            // Title
+            React.createElement('div', {
+                style: {
+                    color: textColor,
+                    fontFamily,
+                    fontSize: '18px',
+                    fontWeight: '600',
+                    textAlign: 'center',
+                    marginBottom: '24px',
+                },
+            }, 'Connect Wallet'), 
+            // Wallet buttons
+            React.createElement('div', {
+                style: {
+                    display: 'flex',
+                    flexDirection: 'column',
+                    gap: '8px',
+                },
+            }, ...walletButtons)));
+        };
+        // 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.
+     * When enablePrivyFallback is true, a custom modal is rendered with discovered
+     * wallets and a "Log in with email" button 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;
+            });
+        }
+        return 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);
+        });
+    }
+    async restoreSession() {
+        await this.ensureReady();
+        const session = await WebSessionManager.getSession();
+        if (session) {
+            return { provider: this, address: session.address };
+        }
+        return null;
+    }
+    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-DHok8ui3.esm.js.map