@bounded-sh/client 0.0.25 → 0.0.27

package/dist/privy-wallet-provider-YR9Eisgl.mjs

@@ -1,926 +0,0 @@
-import { getActiveSessionManager, convertRemainingAccounts, buildSetDocumentsTransaction, genAuthNonce, genSolanaMessage, createSessionWithSignature } from '@bounded-sh/core';
-import { n as normalizeSolanaRpcUrl, r as resolveSolanaRpcUrl, f as resolveSolanaWalletStandardChain, b as bufferExports, h as bs58, c as confirmAndCheckTransaction, g as getPlatform, s as setCurrentUser, S as SURFNET_RPC_URL } from './index.native-CcpKp_mg.mjs';
-import { Connection, VersionedTransaction, PublicKey, Transaction } from '@solana/web3.js';
-import * as anchor from '@coral-xyz/anchor';
-import * as React from 'react';
-import * as ReactDOM from 'react-dom/client';
-
-// @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'),
-    ]);
-}
-// @solana/kit is an OPTIONAL wallet-only dep, used only to build the Privy
-// Solana RPC transports. Loaded lazily (like the Privy SDKs) via dynamic
-// import() rather than a static top-level import: a static import is hoisted by
-// rollup into the entry chunk, forcing every consumer (including vanilla,
-// non-wallet web apps) to have @solana/kit installed and eagerly require()d.
-// Deferring it here keeps it out of the entry bundle.
-let solanaKit;
-async function loadSolanaKit() {
-    if (!solanaKit) {
-        solanaKit = await import('@solana/kit');
-    }
-    return solanaKit;
-}
-function requirePrivyWalletConfig(privyConfig) {
-    if (!privyConfig || typeof privyConfig.appId !== 'string' || privyConfig.appId.trim() === '') {
-        throw new Error('Privy auth requires config.privyConfig.appId; no default Privy app is used.');
-    }
-    if (!privyConfig.config || typeof privyConfig.config !== 'object') {
-        throw new Error('Privy auth requires config.privyConfig.config for the app-scoped Privy provider.');
-    }
-    return {
-        appId: privyConfig.appId,
-        config: privyConfig.config,
-    };
-}
-class PrivyWalletProvider {
-    constructor(appName, appLogoUrl, privyConfig, networkUrl = null, configuredNetwork = null) {
-        this.containerElement = null;
-        this.chainId = null;
-        this.root = null;
-        this.privyMethods = null;
-        this.pendingLogin = null;
-        // Resolved Solana RPC URLs (computed in the constructor; consumed in
-        // initialize() where @solana/kit is lazily loaded to build the transports).
-        this.configuredRpcUrl = 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 = normalizeSolanaRpcUrl(networkUrl);
-        this.configuredNetwork = configuredNetwork;
-        if (typeof window === 'undefined') {
-            throw new Error('PrivyWalletProvider can only be instantiated in a browser environment');
-        }
-        const requiredPrivyConfig = requirePrivyWalletConfig(privyConfig);
-        if (PrivyWalletProvider.instance) {
-            return PrivyWalletProvider.instance;
-        }
-        this.containerElement = null;
-        this.root = null;
-        this.privyMethods = null;
-        this.privyConfig = requiredPrivyConfig;
-        if (!this.privyConfig.config.appearance) {
-            this.privyConfig.config.appearance = {};
-        }
-        if (appName != null && appName != '' && !this.privyConfig.config.appearance.landingHeader) {
-            this.privyConfig.config.appearance.landingHeader = appName;
-        }
-        if (appLogoUrl != null && appLogoUrl != '' && !this.privyConfig.config.appearance.logo) {
-            this.privyConfig.config.appearance.logo = appLogoUrl;
-        }
-        // (externalWallets connectors are configured in initialize() once the
-        // Privy SDK is lazily loaded — see loadPrivyModules.)
-        // Resolve Solana RPC URLs for v3. The @solana/kit transports are built
-        // lazily in initialize() so a non-Privy consumer never needs @solana/kit.
-        if (this.networkUrl || configuredNetwork) {
-            this.configuredRpcUrl = resolveSolanaRpcUrl(this.networkUrl, configuredNetwork, "Privy Solana RPC");
-        }
-        if (configuredNetwork) {
-            this.chainId = resolveSolanaWalletStandardChain(configuredNetwork, "Privy Solana transaction");
-        }
-        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, networkUrl = null, configuredNetwork = null) {
-        if (!PrivyWalletProvider.instance) {
-            new PrivyWalletProvider(appName, appLogoUrl, privyConfig, networkUrl, configuredNetwork);
-        }
-        return PrivyWalletProvider.instance;
-    }
-    async initialize() {
-        // Lazily load the Privy SDK (browser-only) before building the React tree.
-        await loadPrivyModules();
-        // Build the Solana RPC transports now that we're on the async path, so
-        // @solana/kit can be lazily imported (kept out of the entry bundle).
-        const { createSolanaRpc, createSolanaRpcSubscriptions } = await loadSolanaKit();
-        if (this.configuredRpcUrl && this.chainId && !this.privyConfig.config.solana) {
-            this.privyConfig.config.solana = {};
-        }
-        if (this.configuredRpcUrl && this.chainId) {
-            this.privyConfig.config.solana.rpcs = {
-                [this.chainId]: {
-                    rpc: createSolanaRpc(this.configuredRpcUrl),
-                    rpcSubscriptions: createSolanaRpcSubscriptions(this.configuredRpcUrl.replace('https://', 'wss://'))
-                }
-            };
-        }
-        // 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);
-        const app_id = solTransactionData.appId;
-        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, solTransactionData.network);
-                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, solTransactionData.network);
-            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) {
-        return resolveSolanaRpcUrl(this.networkUrl, network !== null && network !== void 0 ? network : this.configuredNetwork, "Privy Solana transaction");
-    }
-    getChainId(network) {
-        if (network) {
-            return resolveSolanaWalletStandardChain(network, "Privy Solana transaction");
-        }
-        if (this.chainId)
-            return this.chainId;
-        if (this.configuredNetwork) {
-            return resolveSolanaWalletStandardChain(this.configuredNetwork, "Privy Solana transaction");
-        }
-        throw new Error("Privy Solana transaction requires config.chain as solana_devnet, solana_mainnet, or surfnet.");
-    }
-    /**
-     * 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, network) {
-        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.getChainId(network)
-        }));
-        // 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, network) {
-        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, network);
-            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.getChainId(network)
-            }));
-            // Handle case where signature might be bytes instead of string
-            const rawSig = result.signature;
-            if (rawSig instanceof Uint8Array || Array.isArray(rawSig)) {
-                signature = bs58.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) {
-            throw new Error('Active Privy wallets do not include the authenticated session wallet; please log in again.');
-        }
-        // 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-CcpKp_mg.mjs').then(function (n) { return n.J; });
-        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;
-        const privyWallet = (_b = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets) === null || _b === void 0 ? void 0 : _b.find((w) => w.address === address);
-        if (!privyWallet) {
-            throw new Error('No Privy Solana wallet matching the requested session address is available.');
-        }
-        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 ((_c = this.privyMethods) === null || _c === void 0 ? void 0 : _c.signMessage({
-            message: messageBytes,
-            wallet: privyWallet,
-        }));
-        const signatureBytes = (_d = signResult === null || signResult === void 0 ? void 0 : signResult.signature) !== null && _d !== void 0 ? _d : 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-YR9Eisgl.mjs.map