@bounded-sh/client 0.0.1

package/dist/privy-wallet-provider-nR52lXzI.esm.js

@@ -0,0 +1,933 @@
+import { e as SOLANA_MAINNET_RPC_URL, S as SOLANA_DEVNET_RPC_URL, n as getActiveSessionManager, c as convertRemainingAccounts, b as bufferExports, a as buildSetDocumentsTransaction, o as base58, d as confirmAndCheckTransaction, s as setCurrentUser, i as getPlatform, k as genAuthNonce, l as genSolanaMessage, m as createSessionWithSignature } from './index.native-JPUkdHJj.esm.js';
+import { Connection, VersionedTransaction, PublicKey, Transaction } from '@solana/web3.js';
+import * as anchor from '@coral-xyz/anchor';
+import { createSolanaRpcSubscriptions, createSolanaRpc } from '@solana/kit';
+import * as React from 'react';
+import * as ReactDOM from 'react-dom/client';
+import 'axios';
+
+const SURFNET_RPC_URL = "https://surfpool.fly.dev";
+// @privy-io/react-auth(/solana) are OPTIONAL peer deps. They are loaded lazily
+// via dynamic import() rather than a static top-level import: a static import
+// would (a) in the ESM bundle still be a bare `import` the consumer resolves —
+// fine — but (b) in the CJS bundle become an eager top-level require() that
+// throws for any consumer who hasn't installed Privy (this module is pulled
+// into the entry via a static re-export). The lazy import keeps the browser
+// ESM bundle free of any runtime `require('@privy-io...')` AND lets a consumer
+// who never uses Privy load the package without it installed. Populated once
+// in `initialize()` (browser-only) before the Privy React tree renders.
+let privyImports;
+let privySolana;
+async function loadPrivyModules() {
+    if (privyImports && privySolana)
+        return;
+    [privyImports, privySolana] = await Promise.all([
+        import('@privy-io/react-auth'),
+        import('@privy-io/react-auth/solana'),
+    ]);
+}
+const getDefaultPrivyConfig = () => ({
+    appId: "cm4ve714908o27dk2yurpnfhd",
+    config: {
+        embeddedWallets: {
+            solana: {
+                createOnLogin: "users-without-wallets"
+            }
+        },
+        appearance: {
+            walletChainType: 'solana-only'
+        },
+        externalWallets: { solana: { connectors: privySolana.toSolanaWalletConnectors() } }
+    }
+});
+class PrivyWalletProvider {
+    constructor(appName, appLogoUrl, privyConfig, networkUrl = null) {
+        this.containerElement = null;
+        this.chainId = 'solana:mainnet';
+        this.root = null;
+        this.privyMethods = null;
+        this.pendingLogin = null;
+        // This is used to store the pending transaction until the wallet is connected for workaround for the wallet not being connected after login completion
+        this.pendingTransaction = null;
+        // This is used to store pending signTransaction calls until the wallet is connected
+        this.pendingSignTransaction = null;
+        // This is used to store pending signMessage calls until the wallet is connected
+        this.pendingSignMessage = null;
+        // This is used to store pending signAndSubmitTransaction calls until the wallet is connected
+        this.pendingSignAndSubmitTransaction = null;
+        this.networkUrl = networkUrl;
+        if (typeof window === 'undefined') {
+            throw new Error('PrivyWalletProvider can only be instantiated in a browser environment');
+        }
+        if (PrivyWalletProvider.instance) {
+            return PrivyWalletProvider.instance;
+        }
+        this.containerElement = null;
+        this.root = null;
+        this.privyMethods = null;
+        this.privyConfig = privyConfig !== null && privyConfig !== void 0 ? privyConfig : getDefaultPrivyConfig();
+        // Only use the appName and appLogoUrl if no privyConfig is provided
+        if (privyConfig == null) {
+            if (appName != null && appName != '') {
+                this.privyConfig.config.appearance.landingHeader = appName;
+            }
+            if (appLogoUrl != null && appLogoUrl != '') {
+                this.privyConfig.config.appearance.logo = appLogoUrl;
+            }
+        }
+        // (externalWallets connectors are configured in initialize() once the
+        // Privy SDK is lazily loaded — see loadPrivyModules.)
+        // Add Solana RPC configuration for v3
+        let devnetUrl = SOLANA_DEVNET_RPC_URL;
+        let mainnetUrl = SOLANA_MAINNET_RPC_URL;
+        if (networkUrl != null) {
+            if (networkUrl.includes('mainnet')) {
+                mainnetUrl = networkUrl;
+                this.chainId = 'solana:mainnet';
+            }
+            else if (networkUrl.includes('devnet')) {
+                devnetUrl = networkUrl;
+                this.chainId = 'solana:devnet';
+            }
+        }
+        if (!this.privyConfig.config.solana) {
+            this.privyConfig.config.solana = {};
+        }
+        this.privyConfig.config.solana.rpcs = {
+            'solana:devnet': {
+                rpc: createSolanaRpc(devnetUrl),
+                rpcSubscriptions: createSolanaRpcSubscriptions(devnetUrl.replace('https://', 'wss://'))
+            },
+            'solana:mainnet': {
+                rpc: createSolanaRpc(mainnetUrl),
+                rpcSubscriptions: createSolanaRpcSubscriptions(mainnetUrl.replace('https://', 'wss://'))
+            }
+        };
+        const existingProviders = document.querySelectorAll('[data-privy-provider]');
+        existingProviders.forEach(el => el.remove());
+        // Fire-and-forget: initialize() lazily loads the Privy SDK then renders
+        // the hidden React tree. privyMethods stays null until that render runs,
+        // which the login/connect methods already wait for. Surface a clear error
+        // if the optional @privy-io/react-auth peer dep isn't installed.
+        this.initialize().catch((err) => {
+            console.error('PrivyWalletProvider: failed to load @privy-io/react-auth — ensure it is installed to use Privy login.', err);
+        });
+        // Assign this instance to the static instance property
+        PrivyWalletProvider.instance = this;
+    }
+    // Optional: Provide a static method to get the instance
+    static getInstance(appName, appLogoUrl, privyConfig) {
+        if (!PrivyWalletProvider.instance) {
+            new PrivyWalletProvider(appName, appLogoUrl, privyConfig);
+        }
+        return PrivyWalletProvider.instance;
+    }
+    async initialize() {
+        // Lazily load the Privy SDK (browser-only) before building the React tree.
+        await loadPrivyModules();
+        // Ensure externalWallets connectors are always configured — required for
+        // useWallets().ready to resolve even when no browser extension is present.
+        if (!this.privyConfig.config.externalWallets && privySolana) {
+            this.privyConfig.config.externalWallets = {
+                solana: { connectors: privySolana.toSolanaWalletConnectors() }
+            };
+        }
+        if (!this.containerElement) {
+            this.containerElement = document.createElement('div');
+            this.containerElement.setAttribute('data-privy-provider', 'true');
+            document.body.appendChild(this.containerElement);
+            const that = this;
+            const PrivyComponent = () => {
+                const privy = privyImports.usePrivy();
+                const useOAuthTokens = privyImports.useOAuthTokens();
+                const useFundWalletSolana = privySolana.useFundWallet();
+                const useSendTransactionSolana = privySolana.useSignAndSendTransaction();
+                const { signTransaction } = privySolana.useSignTransaction();
+                const { signMessage: signMessageHook } = privySolana.useSignMessage();
+                const { ready: walletReady, wallets } = privySolana.useWallets();
+                const { createWallet } = privySolana.useCreateWallet();
+                const { exportWallet } = privySolana.useExportWallet();
+                const useSolanaWallets = { createWallet, exportWallet, ready: walletReady, wallets };
+                const useIdentityToken = privyImports.useIdentityToken();
+                const { connectWallet } = privyImports.useConnectWallet({
+                    onSuccess: async ({ wallet }) => {
+                        await that.createSession(wallet.address, await privy.getAccessToken(), useIdentityToken.identityToken);
+                        // If there's a pending transaction, execute it now
+                        if (that.pendingTransaction) {
+                            const { evmTransactionData, solTransactionData, options, resolve, reject } = that.pendingTransaction;
+                            try {
+                                const result = await that.runTransaction(evmTransactionData, solTransactionData, options);
+                                resolve(result);
+                            }
+                            catch (error) {
+                                reject(error);
+                            }
+                            that.pendingTransaction = null;
+                        }
+                        // If there's a pending signTransaction, execute it now
+                        if (that.pendingSignTransaction) {
+                            const { transaction, resolve, reject } = that.pendingSignTransaction;
+                            try {
+                                const result = await that.signTransaction(transaction);
+                                resolve(result);
+                            }
+                            catch (error) {
+                                reject(error);
+                            }
+                            that.pendingSignTransaction = null;
+                        }
+                        // If there's a pending signMessage, execute it now
+                        if (that.pendingSignMessage) {
+                            const { message, resolve, reject } = that.pendingSignMessage;
+                            try {
+                                const result = await that.signMessage(message);
+                                resolve(result);
+                            }
+                            catch (error) {
+                                reject(error);
+                            }
+                            that.pendingSignMessage = null;
+                        }
+                        // If there's a pending signAndSubmitTransaction, execute it now
+                        if (that.pendingSignAndSubmitTransaction) {
+                            const { transaction, feePayer, resolve, reject } = that.pendingSignAndSubmitTransaction;
+                            try {
+                                const result = await that.signAndSubmitTransaction(transaction, feePayer);
+                                resolve(result);
+                            }
+                            catch (error) {
+                                reject(error);
+                            }
+                            that.pendingSignAndSubmitTransaction = null;
+                        }
+                    },
+                    onError: (error) => {
+                        // Only log errors that aren't user-initiated cancellations
+                        if (error !== 'exited_auth_flow' && (error === null || error === void 0 ? void 0 : error.message) !== 'exited_auth_flow') {
+                            console.error('Wallet connection error:', error);
+                        }
+                        if (that.pendingTransaction) {
+                            that.pendingTransaction.reject(error);
+                            that.pendingTransaction = null;
+                        }
+                        if (that.pendingSignTransaction) {
+                            that.pendingSignTransaction.reject(error);
+                            that.pendingSignTransaction = null;
+                        }
+                        if (that.pendingSignMessage) {
+                            that.pendingSignMessage.reject(error);
+                            that.pendingSignMessage = null;
+                        }
+                        if (that.pendingSignAndSubmitTransaction) {
+                            that.pendingSignAndSubmitTransaction.reject(error);
+                            that.pendingSignAndSubmitTransaction = null;
+                        }
+                    }
+                });
+                const { login } = privyImports.useLogin({
+                    onComplete: async ({ user }) => {
+                        var _a;
+                        // This is a hack to indicate to the app that privy login is not complete
+                        // @ts-ignore
+                        window.runningPrivyOnComplete = true;
+                        if (!user) {
+                            getActiveSessionManager().clearSession();
+                            return;
+                        }
+                        const solanaLinkedAccounts = user.linkedAccounts.filter((account) => account.chainType === 'solana');
+                        const sortedLinkedAccounts = solanaLinkedAccounts.sort((a, b) => new Date(b.latestVerifiedAt).getTime() - new Date(a.latestVerifiedAt).getTime());
+                        let finalAddress = (_a = sortedLinkedAccounts[0]) === null || _a === void 0 ? void 0 : _a.address;
+                        if (!finalAddress) {
+                            const solanaWallet = await createWallet();
+                            finalAddress = solanaWallet.address;
+                            getActiveSessionManager().clearSession();
+                            return;
+                        }
+                        const session = await getActiveSessionManager().getSession();
+                        if (!session || finalAddress !== session.address) {
+                            try {
+                                const accessToken = await privy.getAccessToken();
+                                const idToken = useIdentityToken.identityToken;
+                                await that.createSession(finalAddress, accessToken, idToken);
+                            }
+                            catch (error) {
+                                console.error('Error creating session:', error);
+                            }
+                        }
+                        // @ts-ignore
+                        window.runningPrivyOnComplete = false;
+                        setCurrentUser({ address: finalAddress, provider: that });
+                        if (that.pendingLogin) {
+                            that.pendingLogin.resolve({ address: finalAddress, provider: that });
+                            that.pendingLogin = null;
+                        }
+                    },
+                    onError: (error) => {
+                        // Only log errors that aren't user-initiated cancellations
+                        if (error !== 'exited_auth_flow' && (error === null || error === void 0 ? void 0 : error.message) !== 'exited_auth_flow') {
+                            console.error('Login error:', error);
+                        }
+                        if (that.pendingLogin) {
+                            that.pendingLogin.reject(error);
+                            that.pendingLogin = null;
+                        }
+                    }
+                });
+                const { logout } = privyImports.useLogout({
+                    onSuccess: () => {
+                        getActiveSessionManager().clearSession();
+                        setCurrentUser(null);
+                    }
+                });
+                React.useEffect(() => {
+                    if (privy.ready) {
+                        that.privyMethods = {
+                            ready: privy.ready,
+                            walletReady: walletReady,
+                            authenticated: privy.authenticated,
+                            wallets,
+                            login,
+                            logout,
+                            connectWallet,
+                            getAccessToken: privy.getAccessToken,
+                            identityToken: useIdentityToken.identityToken,
+                            usePrivy: privy,
+                            useOAuthTokens: useOAuthTokens,
+                            useFundWalletSolana: useFundWalletSolana,
+                            useSendTransactionSolana: useSendTransactionSolana,
+                            useSolanaWallets: useSolanaWallets,
+                            signTransaction: signTransaction,
+                            signMessage: signMessageHook,
+                        };
+                    }
+                }, [privy.ready, privy.authenticated, wallets, login, logout, walletReady]);
+                return null;
+            };
+            const FinalPrivyComponent = () => {
+                if (typeof window === 'undefined') {
+                    return null;
+                }
+                return React.createElement(privyImports.PrivyProvider, {
+                    appId: this.privyConfig.appId,
+                    config: this.privyConfig.config,
+                    children: React.createElement(PrivyComponent)
+                });
+            };
+            this.root = ReactDOM.createRoot(this.containerElement);
+            this.root.render(React.createElement(FinalPrivyComponent));
+        }
+    }
+    async login() {
+        var _a, _b;
+        await this.ensureReady();
+        // Check if we have a valid session that matches an authenticated wallet
+        const session = await getActiveSessionManager().getSession();
+        if (((_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.authenticated) && ((_b = this.privyMethods.wallets) === null || _b === void 0 ? void 0 : _b.length) > 0 && session) {
+            // Find the wallet matching the session
+            const matchingWallet = this.privyMethods.wallets.find((wallet) => wallet.address === session.address);
+            if (matchingWallet) {
+                // Valid session with matching wallet, return immediately
+                setCurrentUser({ address: matchingWallet.address, provider: this });
+                return {
+                    address: matchingWallet.address,
+                    provider: this
+                };
+            }
+            // Session exists but doesn't match any connected wallet
+            // This can happen after wallet switching - force fresh login
+            console.log('Session wallet mismatch detected, forcing fresh login flow');
+        }
+        // If no valid session or wallet mismatch, force a fresh login flow
+        // This ensures the user can select the correct wallet, especially after logout
+        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 };
+            // open Privy modal to let user select/verify wallet
+            this.privyMethods.login();
+            // safety timeout
+            setTimeout(() => {
+                if (this.pendingLogin) {
+                    this.pendingLogin.reject(new Error("Login timed out"));
+                    this.pendingLogin = null;
+                }
+            }, 180000);
+        });
+    }
+    async getNativeMethods() {
+        var _a;
+        await this.ensureReady();
+        return (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.usePrivy;
+    }
+    async logout() {
+        await this.ensureReady();
+        await this.privyMethods.logout();
+    }
+    async runTransaction(_evmTransactionData, solTransactionData, options) {
+        var _a, _b, _c;
+        await this.ensureReady({ waitForWallets: true });
+        let session = await getActiveSessionManager().getSession();
+        let sessionAddress = session === null || session === void 0 ? void 0 : session.address;
+        let privyWallets = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets;
+        let privyWallet = privyWallets === null || privyWallets === void 0 ? void 0 : privyWallets.find((wallet) => wallet.address === sessionAddress);
+        // If wallet not found yet, it may be an embedded wallet (email login) that hasn't
+        // appeared in the wallets array due to React state timing. Wait for it before
+        // falling back to connectWallet() which shows an unwanted wallet selection modal.
+        if (!privyWallets || privyWallets.length === 0 || !privyWallet) {
+            if (((_b = this.privyMethods) === null || _b === void 0 ? void 0 : _b.authenticated) && sessionAddress) {
+                privyWallet = await this.waitForMatchingWallet(sessionAddress);
+            }
+        }
+        if (!privyWallet) {
+            // If there's already a pending transaction, throw an error to prevent overlapping calls
+            if (this.pendingTransaction) {
+                throw new Error("Oops... something went wrong. Please try again.");
+            }
+            // Create a promise to wait for the transaction result
+            return new Promise((resolve, reject) => {
+                this.pendingTransaction = {
+                    resolve,
+                    reject,
+                    evmTransactionData: _evmTransactionData,
+                    solTransactionData,
+                    options
+                };
+                this.privyMethods.connectWallet();
+                // Set a timeout to reject the promise if connection takes too long
+                setTimeout(() => {
+                    if (this.pendingTransaction) {
+                        this.pendingTransaction.reject(new Error("Wallet connection timed out"));
+                        this.pendingTransaction = null;
+                    }
+                }, 30000); // 30 seconds timeout
+            });
+        }
+        // Proceed with the transaction using privyWallet
+        const wallet = privyWallet;
+        if (solTransactionData == null) {
+            throw new Error("Solana transaction data is required");
+        }
+        const rpcUrl = this.getRpcUrl(solTransactionData.network);
+        const connection = new Connection(rpcUrl, "confirmed");
+        const remainingAccounts = convertRemainingAccounts(solTransactionData.txArgs[0].remainingAccounts);
+        let app_id = solTransactionData.appId;
+        if (typeof window !== 'undefined' && window.CUSTOM_TAROBASE_APP_ID_HEADER) {
+            const customAppId = window.CUSTOM_TAROBASE_APP_ID_HEADER;
+            if (customAppId) {
+                app_id = customAppId;
+            }
+        }
+        if (!app_id) {
+            throw new Error("App ID is required");
+        }
+        const anchorProvider = new anchor.AnchorProvider(connection, wallet.provider, 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);
+            }
+        }
+        let tx;
+        let blockhash;
+        let lastValidBlockHeight;
+        if (solTransactionData.signedTransaction) {
+            // Server already set the blockhash and co-signed — do NOT overwrite
+            // the blockhash or it will invalidate the server's signature.
+            tx = VersionedTransaction.deserialize(bufferExports.Buffer.from(solTransactionData.signedTransaction, 'base64'));
+            // Extract the blockhash that was baked into the signed message
+            blockhash = tx.message.recentBlockhash;
+            const latestBlockhash = await connection.getLatestBlockhash('confirmed');
+            lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;
+        }
+        else {
+            const result = await buildSetDocumentsTransaction(connection, solTransactionData.txArgs[0].idl, anchorProvider, new PublicKey(wallet.address), { 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;
+            blockhash = result.blockhash;
+            lastValidBlockHeight = result.lastValidBlockHeight;
+        }
+        // Use duck typing instead of instanceof to handle multiple @solana/web3.js versions
+        const isLegacyTx = 'recentBlockhash' in tx && !('message' in tx && 'staticAccountKeys' in tx.message);
+        if (isLegacyTx) {
+            tx.recentBlockhash = blockhash;
+            tx.lastValidBlockHeight = lastValidBlockHeight;
+        }
+        else {
+            tx.message.recentBlockhash = blockhash;
+        }
+        try {
+            if ((options === null || options === void 0 ? void 0 : options.shouldSubmitTx) === false) {
+                // Just sign, don't submit - return raw signed bytes (same as original runTransaction)
+                const signedTx = await this.signTransactionRaw(tx, privyWallet);
+                return {
+                    signedTransaction: signedTx, // Raw Uint8Array from Privy
+                    blockNumber: 0,
+                    gasUsed: "0",
+                    data: ""
+                };
+            }
+            // Sign and submit using shared helper
+            const { signature, txInfo } = await this.signAndSubmitInternal(tx, privyWallet, rpcUrl, 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,
+            };
+        }
+        catch (err) {
+            console.error(err);
+            throw err;
+        }
+    }
+    /**
+     * 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;
+        await this.ensureReady({ waitForWallets: true });
+        let privyWallets = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets;
+        let session = await getActiveSessionManager().getSession();
+        let sessionAddress = session === null || session === void 0 ? void 0 : session.address;
+        let privyWallet = privyWallets === null || privyWallets === void 0 ? void 0 : privyWallets.find((wallet) => wallet.address === sessionAddress);
+        // If there's already a pending sign transaction, throw an error to prevent overlapping calls
+        if (this.pendingSignTransaction) {
+            throw new Error("Oops... something went wrong. Please try again.");
+        }
+        // If wallet not found yet, it may be an embedded wallet (email login) that hasn't
+        // appeared in the wallets array due to React state timing. Wait for it before
+        // falling back to connectWallet() which shows an unwanted wallet selection modal.
+        if (!privyWallets || privyWallets.length === 0 || !privyWallet) {
+            if (((_b = this.privyMethods) === null || _b === void 0 ? void 0 : _b.authenticated) && sessionAddress) {
+                privyWallet = await this.waitForMatchingWallet(sessionAddress);
+            }
+        }
+        // If still no wallet after waiting, trigger connection and queue the signing
+        if (!privyWallet) {
+            return new Promise((resolve, reject) => {
+                this.pendingSignTransaction = {
+                    resolve,
+                    reject,
+                    transaction
+                };
+                this.privyMethods.connectWallet();
+                // Set a timeout to reject the promise if connection takes too long
+                setTimeout(() => {
+                    if (this.pendingSignTransaction) {
+                        this.pendingSignTransaction.reject(new Error("Wallet connection timed out"));
+                        this.pendingSignTransaction = null;
+                    }
+                }, 30000); // 30 seconds timeout
+            });
+        }
+        // Privy requires serialized transaction bytes, which requires a blockhash.
+        // If the transaction doesn't have one, get a fresh blockhash and set it.
+        // 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;
+            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) {
+                legacyTx.feePayer = new PublicKey(privyWallet.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;
+            }
+        }
+        // Sign using raw method, then deserialize for the public API
+        const signedTxRaw = await this.signTransactionRaw(transaction, privyWallet);
+        return this.deserializeSignedTransaction(signedTxRaw);
+    }
+    /**
+     * 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;
+        await this.ensureReady({ waitForWallets: true });
+        let privyWallets = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets;
+        let session = await getActiveSessionManager().getSession();
+        let sessionAddress = session === null || session === void 0 ? void 0 : session.address;
+        let privyWallet = privyWallets === null || privyWallets === void 0 ? void 0 : privyWallets.find((wallet) => wallet.address === sessionAddress);
+        // If there's already a pending signAndSubmitTransaction, throw an error to prevent overlapping calls
+        if (this.pendingSignAndSubmitTransaction) {
+            throw new Error("Oops... something went wrong. Please try again.");
+        }
+        // If wallet not found yet, it may be an embedded wallet (email login) that hasn't
+        // appeared in the wallets array due to React state timing. Wait for it before
+        // falling back to connectWallet() which shows an unwanted wallet selection modal.
+        if (!privyWallets || privyWallets.length === 0 || !privyWallet) {
+            if (((_b = this.privyMethods) === null || _b === void 0 ? void 0 : _b.authenticated) && sessionAddress) {
+                privyWallet = await this.waitForMatchingWallet(sessionAddress);
+            }
+        }
+        // If still no wallet after waiting, trigger connection and queue the signing
+        if (!privyWallet) {
+            return new Promise((resolve, reject) => {
+                this.pendingSignAndSubmitTransaction = {
+                    resolve,
+                    reject,
+                    transaction,
+                    feePayer
+                };
+                this.privyMethods.connectWallet();
+                // Set a timeout to reject the promise if connection takes too long
+                setTimeout(() => {
+                    if (this.pendingSignAndSubmitTransaction) {
+                        this.pendingSignAndSubmitTransaction.reject(new Error("Wallet connection timed out"));
+                        this.pendingSignAndSubmitTransaction = null;
+                    }
+                }, 30000); // 30 seconds timeout
+            });
+        }
+        // Get RPC URL and create connection
+        const rpcUrl = this.getRpcUrl();
+        const connection = new Connection(rpcUrl, 'confirmed');
+        // 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) {
+                legacyTx.feePayer = feePayer !== null && feePayer !== void 0 ? feePayer : new PublicKey(privyWallet.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
+        }
+        // Use shared sign and submit logic
+        const { signature } = await this.signAndSubmitInternal(transaction, privyWallet, rpcUrl, connection);
+        return signature;
+    }
+    // ============ 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
+    }
+    /**
+     * Internal sign transaction - serializes and signs via Privy
+     * Returns the raw result from Privy (Uint8Array)
+     * This mirrors exactly what runTransaction was doing
+     */
+    async signTransactionRaw(transaction, privyWallet) {
+        var _a;
+        // Serialize the transaction
+        // 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);
+        let serializedForSign;
+        if (isLegacyTransaction) {
+            serializedForSign = transaction.serialize({ requireAllSignatures: false, verifySignatures: false });
+        }
+        else {
+            serializedForSign = transaction.serialize();
+        }
+        // Sign via Privy - returns { signedTransaction: Uint8Array }
+        const result = await ((_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.signTransaction({
+            transaction: serializedForSign,
+            wallet: privyWallet,
+            chain: this.chainId
+        }));
+        // Privy returns { signedTransaction: Uint8Array }, unwrap it
+        const signedTx = (result === null || result === void 0 ? void 0 : result.signedTransaction) || result;
+        return signedTx;
+    }
+    /**
+     * Deserialize a signed transaction from Uint8Array to Transaction object
+     */
+    deserializeSignedTransaction(signedTxRaw) {
+        // Handle different formats Privy might return
+        let signedTx;
+        if (signedTxRaw instanceof Uint8Array) {
+            signedTx = signedTxRaw;
+        }
+        else if (Array.isArray(signedTxRaw)) {
+            signedTx = new Uint8Array(signedTxRaw);
+        }
+        else if (signedTxRaw && typeof signedTxRaw === 'object' && 'signedTransaction' in signedTxRaw) {
+            // Privy might wrap the result
+            signedTx = signedTxRaw.signedTransaction instanceof Uint8Array
+                ? signedTxRaw.signedTransaction
+                : new Uint8Array(signedTxRaw.signedTransaction);
+        }
+        else if (bufferExports.Buffer.isBuffer(signedTxRaw)) {
+            signedTx = new Uint8Array(signedTxRaw);
+        }
+        else {
+            throw new Error(`Unexpected signed transaction format: ${typeof signedTxRaw}`);
+        }
+        // Try to deserialize as VersionedTransaction first, fall back to legacy Transaction
+        try {
+            return VersionedTransaction.deserialize(signedTx);
+        }
+        catch (_a) {
+            return Transaction.from(signedTx);
+        }
+    }
+    /**
+     * Internal sign and submit - handles Surfnet vs non-Surfnet logic
+     * This is the core submission logic used by both signAndSubmitTransaction and runTransaction
+     *
+     * For Surfnet: sign with signTransactionRaw, then sendRawTransaction
+     * For non-Surfnet: use Privy's signAndSendTransaction (combined operation)
+     */
+    async signAndSubmitInternal(transaction, privyWallet, rpcUrl, connection) {
+        var _a;
+        const isSurfnet = rpcUrl === SURFNET_RPC_URL;
+        let signature;
+        if (isSurfnet) {
+            // For Surfnet: sign with signTransactionRaw, then sendRawTransaction
+            const signedTx = await this.signTransactionRaw(transaction, privyWallet);
+            signature = await connection.sendRawTransaction(signedTx);
+        }
+        else {
+            // For non-Surfnet: use Privy's combined signAndSendTransaction
+            // Serialize the transaction for Privy API
+            // 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);
+            let serializedTx;
+            if (isLegacyTransaction) {
+                serializedTx = transaction.serialize({ requireAllSignatures: false, verifySignatures: false });
+            }
+            else {
+                serializedTx = transaction.serialize();
+            }
+            const result = await ((_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.useSendTransactionSolana.signAndSendTransaction({
+                transaction: serializedTx,
+                wallet: privyWallet,
+                chain: this.chainId
+            }));
+            // Handle case where signature might be bytes instead of string
+            const rawSig = result.signature;
+            if (rawSig instanceof Uint8Array || Array.isArray(rawSig)) {
+                signature = base58.encode(rawSig instanceof Uint8Array ? rawSig : new Uint8Array(rawSig));
+            }
+            else {
+                signature = rawSig;
+            }
+        }
+        const txInfo = await confirmAndCheckTransaction(connection, signature);
+        return { signature, txInfo };
+    }
+    async signMessage(message) {
+        var _a, _b, _c;
+        await this.ensureReady({ waitForWallets: true });
+        const session = await getActiveSessionManager().getSession();
+        let sessionAddress = session === null || session === void 0 ? void 0 : session.address;
+        // If there's already a pending sign message, throw an error to prevent overlapping calls
+        if (this.pendingSignMessage) {
+            throw new Error("Oops... something went wrong. Please try again.");
+        }
+        // If no wallets connected yet, it may be an embedded wallet (email login) that hasn't
+        // appeared in the wallets array due to React state timing. Wait for it before
+        // falling back to connectWallet() which shows an unwanted wallet selection modal.
+        if (!((_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets) || this.privyMethods.wallets.length === 0) {
+            if (((_b = this.privyMethods) === null || _b === void 0 ? void 0 : _b.authenticated) && sessionAddress) {
+                const matchedWallet = await this.waitForMatchingWallet(sessionAddress);
+                if (!matchedWallet) {
+                    return new Promise((resolve, reject) => {
+                        this.pendingSignMessage = {
+                            resolve,
+                            reject,
+                            message
+                        };
+                        this.privyMethods.connectWallet();
+                        // Set a timeout to reject the promise if connection takes too long
+                        setTimeout(() => {
+                            if (this.pendingSignMessage) {
+                                this.pendingSignMessage.reject(new Error("Wallet connection timed out"));
+                                this.pendingSignMessage = null;
+                            }
+                        }, 30000); // 30 seconds timeout
+                    });
+                }
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    this.pendingSignMessage = {
+                        resolve,
+                        reject,
+                        message
+                    };
+                    this.privyMethods.connectWallet();
+                    // Set a timeout to reject the promise if connection takes too long
+                    setTimeout(() => {
+                        if (this.pendingSignMessage) {
+                            this.pendingSignMessage.reject(new Error("Wallet connection timed out"));
+                            this.pendingSignMessage = null;
+                        }
+                    }, 30000); // 30 seconds timeout
+                });
+            }
+        }
+        let privyWallet = this.privyMethods.wallets.find((wallet) => wallet.address === sessionAddress);
+        if (!privyWallet) {
+            // Session address is not a privy wallet, just default to the first wallet
+            const accessToken = await this.privyMethods.getAccessToken();
+            await this.createSession(this.privyMethods.wallets[0].address, accessToken, this.privyMethods.identityToken);
+            setCurrentUser({ address: this.privyMethods.wallets[0].address, provider: this });
+            const session = await getActiveSessionManager().getSession();
+            sessionAddress = session === null || session === void 0 ? void 0 : session.address;
+            if (!sessionAddress) {
+                throw new Error('No wallet connected or logged in to sign message');
+            }
+            privyWallet = this.privyMethods.wallets[0];
+        }
+        // Use the Privy signMessage hook for Solana wallets
+        // The message needs to be passed as a Uint8Array
+        const messageBytes = getPlatform().textEncode(message);
+        const result = await ((_c = this.privyMethods) === null || _c === void 0 ? void 0 : _c.signMessage({
+            message: messageBytes,
+            wallet: privyWallet,
+        }));
+        // The signature is returned as a Uint8Array, encode it as base58 (standard Solana format)
+        const signatureBytes = (result === null || result === void 0 ? void 0 : result.signature) || result;
+        const bs58 = await import('./index.native-JPUkdHJj.esm.js').then(function (n) { return n.aI; });
+        return bs58.default.encode(signatureBytes);
+    }
+    async restoreSession() {
+        const session = await getActiveSessionManager().getSession();
+        if (session) {
+            return { provider: this, address: session.address };
+        }
+        else {
+            return null;
+        }
+    }
+    // NOTE: accessToken/idToken are accepted for backwards-compat with existing
+    // call sites but are no longer used. The session is minted by having the Privy
+    // Solana wallet SIGN the canonical SIWS challenge (the same wallet-signature
+    // path Phantom/MWA/guest use), so the bounded /session issuer needs no
+    // Privy-specific token verification — it arrives as a Solana signature and is
+    // recorded server-side as authMethod 'phantom'.
+    async createSession(address, _accessToken, _idToken) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        // Resolve the Privy wallet for this address (fall back to the first wallet).
+        const privyWallet = (_c = (_b = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets) === null || _b === void 0 ? void 0 : _b.find((w) => w.address === address)) !== null && _c !== void 0 ? _c : (_e = (_d = this.privyMethods) === null || _d === void 0 ? void 0 : _d.wallets) === null || _e === void 0 ? void 0 : _e[0];
+        if (!privyWallet) {
+            throw new Error('No Privy Solana wallet available to mint a session.');
+        }
+        const nonce = await genAuthNonce();
+        const message = await genSolanaMessage(address, nonce);
+        const messageBytes = getPlatform().textEncode(message);
+        // Low-level Privy sign hook — signs WITHOUT touching the session (the public
+        // signMessage() bootstraps sessions, which would recurse here).
+        const signResult = await ((_f = this.privyMethods) === null || _f === void 0 ? void 0 : _f.signMessage({
+            message: messageBytes,
+            wallet: privyWallet,
+        }));
+        const signatureBytes = (_g = signResult === null || signResult === void 0 ? void 0 : signResult.signature) !== null && _g !== void 0 ? _g : signResult;
+        // base64-encoded detached signature (matches Phantom + guest providers).
+        const signature = bufferExports.Buffer.from(signatureBytes).toString('base64');
+        const createSessionResult = await createSessionWithSignature(address, message, signature);
+        if (createSessionResult) {
+            await getActiveSessionManager().storeSession(address, createSessionResult.accessToken, createSessionResult.idToken, createSessionResult.refreshToken);
+        }
+    }
+    /**
+     * Waits for a wallet matching the session address to appear in the wallets array.
+     * This handles the timing gap where Privy's embedded wallet (created for email login users)
+     * may not yet be in the useWallets() array when signTransaction is called immediately after login.
+     */
+    async waitForMatchingWallet(sessionAddress, timeoutMs = 10000) {
+        var _a;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeoutMs) {
+            const wallets = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets;
+            if (wallets && wallets.length > 0) {
+                const wallet = wallets.find((w) => w.address === sessionAddress);
+                if (wallet)
+                    return wallet;
+            }
+            await new Promise(resolve => setTimeout(resolve, 200));
+        }
+        return null;
+    }
+    async ensureReady({ waitForWallets = false, timeoutMs = 15000 } = {}) {
+        const isReady = () => {
+            var _a, _b;
+            if (!((_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.ready))
+                return false;
+            if (waitForWallets && !((_b = this.privyMethods) === null || _b === void 0 ? void 0 : _b.walletReady))
+                return false;
+            return true;
+        };
+        if (isReady())
+            return;
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now();
+            const check = () => {
+                if (isReady()) {
+                    resolve();
+                }
+                else if (Date.now() - startTime > timeoutMs) {
+                    reject(new Error('Login provider failed to initialize. This can happen in incognito mode or when third-party cookies are blocked. Try using a regular browser window.'));
+                }
+                else {
+                    setTimeout(check, 100);
+                }
+            };
+            check();
+        });
+    }
+}
+PrivyWalletProvider.instance = null;
+
+export { PrivyWalletProvider };
+//# sourceMappingURL=privy-wallet-provider-nR52lXzI.esm.js.map