@pooflabs/web 0.0.38 → 0.0.39

package/dist/{index-5j5jdNNe.js → index-BaNlnYmn.js}

@@ -12445,6 +12445,13 @@ async function signTransaction(transaction) {
     }
     return config.authProvider.signTransaction(transaction);
 }
+async function signAndSubmitTransaction(transaction, feePayer) {
+    const config = await getConfig();
+    if (!config.authProvider) {
+        throw new Error('Auth provider not initialized. Please call init() first.');
+    }
+    return config.authProvider.signAndSubmitTransaction(transaction, feePayer);
+}
 
 const activeConnections = {};
 const responseCache = {};
@@ -12666,7 +12673,7 @@ async function loadDependencies() {
         const [reactModule, reactDomModule, phantomModule] = await Promise.all([
             import('react'),
             import('react-dom/client'),
-            Promise.resolve().then(function () { return require('./index-C6HaRwOE.js'); })
+            Promise.resolve().then(function () { return require('./index-C-_15_Cq.js'); })
         ]);
         React$1 = reactModule;
         ReactDOM$1 = reactDomModule;
@@ -13112,18 +13119,15 @@ class PhantomWalletProvider {
             await this.ensureSolanaReady();
         }
         catch (error) {
-            // Reconnection failed - log user out and throw
             console.error('Solana provider reconnection failed, logging out:', error.message);
             await this.logout();
             throw new Error('Wallet connection lost. Please reconnect.');
         }
-        // Ensure connected
         if (!((_a = this.phantomMethods) === null || _a === void 0 ? void 0 : _a.isConnected)) {
             const user = await this.login();
             if (!user) {
                 throw new Error('Failed to connect wallet');
             }
-            // Wait for solana to be ready after login
             try {
                 await this.ensureSolanaReady();
             }
@@ -13136,21 +13140,7 @@ class PhantomWalletProvider {
         if (!((_b = this.phantomMethods) === null || _b === void 0 ? void 0 : _b.solana)) {
             throw new Error('Solana signing not available');
         }
-        let rpcUrl = this.networkUrl;
-        if (this.networkUrl == null) {
-            if (solTransactionData.network === 'solana_devnet') {
-                rpcUrl = SOLANA_DEVNET_RPC_URL;
-            }
-            else if (solTransactionData.network === 'solana_mainnet') {
-                rpcUrl = SOLANA_MAINNET_RPC_URL;
-            }
-            else if (solTransactionData.network === 'surfnet') {
-                rpcUrl = SURFNET_RPC_URL;
-            }
-            else {
-                throw new Error('Invalid network for Phantom wallet');
-            }
-        }
+        const rpcUrl = this.getRpcUrl(solTransactionData.network);
         const connection = new web3_js.Connection(rpcUrl, 'confirmed');
         try {
             const remainingAccounts = convertRemainingAccounts(solTransactionData.txArgs[0].remainingAccounts);
@@ -13190,7 +13180,7 @@ class PhantomWalletProvider {
                     finalDeduped.push(acc);
                 }
             }
-            const { tx, blockhash, lastValidBlockHeight } = await buildSetDocumentsTransaction(connection, solTransactionData.txArgs[0].idl, anchorProvider, publicKey, {
+            const { tx } = await buildSetDocumentsTransaction(connection, solTransactionData.txArgs[0].idl, anchorProvider, publicKey, {
                 app_id,
                 documents: solTransactionData.txArgs[0].setDocumentData,
                 delete_paths: solTransactionData.txArgs[0].deletePaths,
@@ -13205,19 +13195,8 @@ class PhantomWalletProvider {
                     data: ""
                 };
             }
-            const signature = await connection.sendRawTransaction(signedTx.serialize());
-            const confirmation = await connection.confirmTransaction({
-                signature,
-                blockhash,
-                lastValidBlockHeight,
-            }, 'confirmed');
-            if (confirmation.value.err) {
-                throw new Error(`Transaction failed: ${confirmation.value.err.toString()}`);
-            }
-            const txInfo = await connection.getParsedTransaction(signature, {
-                maxSupportedTransactionVersion: 0,
-                commitment: 'confirmed'
-            });
+            // Submit using shared helper
+            const { signature, txInfo } = await this.submitSignedTransaction(signedTx, connection);
             return {
                 transactionSignature: signature,
                 blockNumber: (txInfo === null || txInfo === void 0 ? void 0 : txInfo.slot) || 0,
@@ -13243,6 +13222,16 @@ class PhantomWalletProvider {
             throw new Error(`Failed to execute transaction: ${error.message}`);
         }
     }
+    /**
+     * Signs a Solana transaction without submitting it.
+     *
+     * This method handles blockhash automatically if not set - you do NOT need to
+     * set recentBlockhash on the transaction before calling this method.
+     * The network/RPC URL is derived from the provider's configuration (set during initialization).
+     *
+     * @param transaction - The transaction to sign (Transaction or VersionedTransaction)
+     * @returns The signed transaction
+     */
     async signTransaction(transaction) {
         var _a, _b, _c, _d;
         try {
@@ -13271,6 +13260,36 @@ class PhantomWalletProvider {
         if (!((_b = this.phantomMethods) === null || _b === void 0 ? void 0 : _b.solana)) {
             throw new Error('Solana signing not available');
         }
+        // Use duck typing instead of instanceof to handle multiple @solana/web3.js versions
+        const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
+        // Ensure blockhash is set before signing
+        if (isLegacyTransaction) {
+            const legacyTx = transaction;
+            if (!legacyTx.recentBlockhash) {
+                const rpcUrl = this.getRpcUrl();
+                const connection = new web3_js.Connection(rpcUrl, 'confirmed');
+                const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+                legacyTx.recentBlockhash = blockhash;
+                legacyTx.lastValidBlockHeight = lastValidBlockHeight;
+            }
+            // Set feePayer if not already set
+            if (!legacyTx.feePayer) {
+                const solAddress = this.phantomMethods.addresses.find((addr) => addr.addressType === phantomReactSdk.AddressType.solana);
+                if (solAddress) {
+                    legacyTx.feePayer = new web3_js.PublicKey(solAddress.address);
+                }
+            }
+        }
+        else {
+            // VersionedTransaction
+            const versionedTx = transaction;
+            if (!versionedTx.message.recentBlockhash) {
+                const rpcUrl = this.getRpcUrl();
+                const connection = new web3_js.Connection(rpcUrl, 'confirmed');
+                const { blockhash } = await connection.getLatestBlockhash('confirmed');
+                versionedTx.message.recentBlockhash = blockhash;
+            }
+        }
         try {
             return await this.phantomMethods.solana.signTransaction(transaction);
         }
@@ -13284,6 +13303,102 @@ class PhantomWalletProvider {
             throw new Error(`Failed to sign transaction: ${error.message}`);
         }
     }
+    /**
+     * Signs and submits a Solana transaction to the network.
+     *
+     * This method handles blockhash and transaction confirmation automatically - you do NOT need to
+     * set recentBlockhash or lastValidBlockHeight on the transaction before calling this method.
+     * The network/RPC URL is derived from the provider's configuration (set during initialization).
+     *
+     * @param transaction - The transaction to sign and submit (Transaction or VersionedTransaction)
+     * @param feePayer - Optional fee payer public key. If not provided and the transaction doesn't
+     *                   already have a feePayer set, the connected wallet address will be used.
+     *                   Useful for co-signing scenarios where a different account pays the fees.
+     * @returns The transaction signature
+     */
+    async signAndSubmitTransaction(transaction, feePayer) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        try {
+            await this.ensureSolanaReady();
+        }
+        catch (error) {
+            console.error('Solana provider reconnection failed, logging out:', error.message);
+            await this.logout();
+            throw new Error('Wallet connection lost. Please reconnect.');
+        }
+        if (!((_a = this.phantomMethods) === null || _a === void 0 ? void 0 : _a.isConnected)) {
+            const user = await this.login();
+            if (!user) {
+                throw new Error('Failed to connect wallet');
+            }
+            try {
+                await this.ensureSolanaReady();
+            }
+            catch (error) {
+                console.error('Solana provider reconnection failed after login, logging out:', error.message);
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+        }
+        if (!((_b = this.phantomMethods) === null || _b === void 0 ? void 0 : _b.solana)) {
+            throw new Error('Solana signing not available');
+        }
+        const rpcUrl = this.getRpcUrl();
+        const connection = new web3_js.Connection(rpcUrl, 'confirmed');
+        try {
+            // Get fresh blockhash and set it on the transaction before signing
+            const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+            // Use duck typing instead of instanceof to handle multiple @solana/web3.js versions
+            const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
+            if (isLegacyTransaction) {
+                const legacyTx = transaction;
+                legacyTx.recentBlockhash = blockhash;
+                legacyTx.lastValidBlockHeight = lastValidBlockHeight;
+                // Set feePayer if not already set
+                if (!legacyTx.feePayer) {
+                    if (feePayer) {
+                        legacyTx.feePayer = feePayer;
+                    }
+                    else {
+                        // Use connected wallet address as feePayer
+                        const solAddress = this.phantomMethods.addresses.find((addr) => addr.addressType === phantomReactSdk.AddressType.solana);
+                        if (solAddress) {
+                            legacyTx.feePayer = new web3_js.PublicKey(solAddress.address);
+                        }
+                    }
+                }
+            }
+            else {
+                // VersionedTransaction
+                const versionedTx = transaction;
+                versionedTx.message.recentBlockhash = blockhash;
+                // Note: VersionedTransaction feePayer is set in the message at creation time
+                // and cannot be modified after creation
+            }
+            // Sign the transaction
+            const signedTx = await this.phantomMethods.solana.signTransaction(transaction);
+            // Submit using shared helper with the blockhash we set
+            const { signature } = await this.submitSignedTransactionWithBlockhash(signedTx, connection, blockhash, lastValidBlockHeight);
+            return signature;
+        }
+        catch (error) {
+            // Check if this is a connection error - if so, log out
+            if (((_c = error === null || error === void 0 ? void 0 : error.message) === null || _c === void 0 ? void 0 : _c.includes('not connected')) || ((_d = error === null || error === void 0 ? void 0 : error.message) === null || _d === void 0 ? void 0 : _d.includes('connect first'))) {
+                console.error('Solana provider connection lost during transaction, logging out');
+                await this.logout();
+                throw new Error('Wallet connection lost. Please reconnect.');
+            }
+            const isUserRejection = (error === null || error === void 0 ? void 0 : error.code) === 4001 ||
+                ((_e = error === null || error === void 0 ? void 0 : error.message) === null || _e === void 0 ? void 0 : _e.toLowerCase().includes('user rejected')) ||
+                ((_f = error === null || error === void 0 ? void 0 : error.message) === null || _f === void 0 ? void 0 : _f.toLowerCase().includes('user denied')) ||
+                ((_g = error === null || error === void 0 ? void 0 : error.message) === null || _g === void 0 ? void 0 : _g.toLowerCase().includes('user cancelled')) ||
+                ((_h = error === null || error === void 0 ? void 0 : error.message) === null || _h === void 0 ? void 0 : _h.toLowerCase().includes('user canceled'));
+            if (!isUserRejection) {
+                console.error('Failed to execute transaction', error);
+            }
+            throw new Error(`Failed to execute transaction: ${error.message}`);
+        }
+    }
     async signMessage(message) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         try {
@@ -13354,6 +13469,50 @@ class PhantomWalletProvider {
         await this.ensureReady();
         return this.phantomMethods;
     }
+    /* ----------------------------------------------------------- *
+     * Private Helpers
+     * ----------------------------------------------------------- */
+    getRpcUrl(network) {
+        if (this.networkUrl) {
+            return this.networkUrl;
+        }
+        if (network === 'solana_devnet') {
+            return SOLANA_DEVNET_RPC_URL;
+        }
+        else if (network === 'solana_mainnet') {
+            return SOLANA_MAINNET_RPC_URL;
+        }
+        else if (network === 'surfnet') {
+            return SURFNET_RPC_URL;
+        }
+        return SOLANA_MAINNET_RPC_URL; // default to mainnet
+    }
+    async submitSignedTransaction(signedTx, connection) {
+        // Get fresh blockhash for confirmation
+        const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+        return this.submitSignedTransactionWithBlockhash(signedTx, connection, blockhash, lastValidBlockHeight);
+    }
+    async submitSignedTransactionWithBlockhash(signedTx, connection, blockhash, lastValidBlockHeight) {
+        // Submit the transaction
+        const signature = await connection.sendRawTransaction(signedTx.serialize(), {
+            preflightCommitment: 'confirmed'
+        });
+        // Confirm using blockhash strategy (same as runTransaction)
+        const confirmation = await connection.confirmTransaction({
+            signature,
+            blockhash,
+            lastValidBlockHeight,
+        }, 'confirmed');
+        if (confirmation.value.err) {
+            throw new Error(`Transaction failed: ${confirmation.value.err.toString()}`);
+        }
+        // Get transaction info
+        const txInfo = await connection.getParsedTransaction(signature, {
+            maxSupportedTransactionVersion: 0,
+            commitment: 'confirmed'
+        });
+        return { signature, txInfo };
+    }
 }
 PhantomWalletProvider.instance = null;
 
@@ -31865,6 +32024,8 @@ class PrivyWalletProvider {
         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');
@@ -31981,6 +32142,18 @@ class PrivyWalletProvider {
                             }
                             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
@@ -31999,6 +32172,10 @@ class PrivyWalletProvider {
                             that.pendingSignMessage.reject(error);
                             that.pendingSignMessage = null;
                         }
+                        if (that.pendingSignAndSubmitTransaction) {
+                            that.pendingSignAndSubmitTransaction.reject(error);
+                            that.pendingSignAndSubmitTransaction = null;
+                        }
                     }
                 });
                 const { login } = privyImports.useLogin({
@@ -32145,7 +32322,7 @@ class PrivyWalletProvider {
         await this.privyMethods.logout();
     }
     async runTransaction(_evmTransactionData, solTransactionData, options) {
-        var _a, _b, _c, _d;
+        var _a;
         await this.ensureReady();
         let session = await WebSessionManager.getSession();
         let sessionAddress = session === null || session === void 0 ? void 0 : session.address;
@@ -32180,21 +32357,7 @@ class PrivyWalletProvider {
         if (solTransactionData == null) {
             throw new Error("Solana transaction data is required");
         }
-        let rpcUrl = this.networkUrl;
-        if (this.networkUrl == null) {
-            if (solTransactionData.network === 'solana_devnet') {
-                rpcUrl = SOLANA_DEVNET_RPC_URL;
-            }
-            else if (solTransactionData.network === 'solana_mainnet') {
-                rpcUrl = SOLANA_MAINNET_RPC_URL;
-            }
-            else if (solTransactionData.network === 'surfnet') {
-                rpcUrl = SURFNET_RPC_URL$1;
-            }
-            else {
-                throw new Error('Invalid network for Phantom wallet');
-            }
-        }
+        const rpcUrl = this.getRpcUrl(solTransactionData.network);
         const connection = new web3_js.Connection(rpcUrl, "confirmed");
         const remainingAccounts = convertRemainingAccounts(solTransactionData.txArgs[0].remainingAccounts);
         let app_id = solTransactionData.appId;
@@ -32220,71 +32383,28 @@ class PrivyWalletProvider {
             }
         }
         const { tx, blockhash, lastValidBlockHeight } = await buildSetDocumentsTransaction(connection, solTransactionData.txArgs[0].idl, anchorProvider, new web3_js.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);
-        if (tx instanceof web3_js.Transaction) {
+        // 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 if (tx instanceof web3_js.VersionedTransaction) {
+        else {
             tx.message.recentBlockhash = blockhash;
         }
         try {
             if ((options === null || options === void 0 ? void 0 : options.shouldSubmitTx) === false) {
-                // v3 API: serialize transaction and pass wallet/chain
-                let serializedTx;
-                if (tx instanceof web3_js.Transaction) {
-                    serializedTx = tx.serialize({ requireAllSignatures: false, verifySignatures: false });
-                }
-                else {
-                    serializedTx = tx.serialize();
-                }
-                const signedTx = await ((_b = this.privyMethods) === null || _b === void 0 ? void 0 : _b.signTransaction({
-                    transaction: serializedTx,
-                    wallet: privyWallet,
-                    chain: this.chainId
-                }));
+                // Just sign, don't submit - return raw signed bytes (same as original runTransaction)
+                const signedTx = await this.signTransactionRaw(tx, privyWallet);
                 return {
-                    signedTransaction: signedTx,
+                    signedTransaction: signedTx, // Raw Uint8Array from Privy
                     blockNumber: 0,
                     gasUsed: "0",
                     data: ""
                 };
             }
-            const isSurfnet = connection.rpcEndpoint === SURFNET_RPC_URL$1;
-            let txSignature;
-            if (isSurfnet) {
-                // v3 API: serialize transaction and pass wallet/chain
-                let serializedForSign;
-                if (tx instanceof web3_js.Transaction) {
-                    serializedForSign = tx.serialize({ requireAllSignatures: false, verifySignatures: false });
-                }
-                else {
-                    serializedForSign = tx.serialize();
-                }
-                const signedTx = await ((_c = this.privyMethods) === null || _c === void 0 ? void 0 : _c.signTransaction({
-                    transaction: serializedForSign,
-                    wallet: privyWallet,
-                    chain: this.chainId
-                }));
-                txSignature = await connection.sendRawTransaction(signedTx);
-            }
-            else {
-                // v3 API: transaction must be Uint8Array, pass wallet object
-                // Serialize without requiring signatures - Privy will sign it
-                let serializedTx;
-                if (tx instanceof web3_js.Transaction) {
-                    serializedTx = tx.serialize({ requireAllSignatures: false, verifySignatures: false });
-                }
-                else {
-                    // VersionedTransaction
-                    serializedTx = tx.serialize();
-                }
-                const result = await ((_d = this.privyMethods) === null || _d === void 0 ? void 0 : _d.useSendTransactionSolana.signAndSendTransaction({
-                    transaction: serializedTx,
-                    wallet: privyWallet,
-                    chain: this.chainId
-                }));
-                txSignature = result.signature;
-            }
+            // Sign and submit using shared helper
+            const txSignature = await this.signAndSubmitInternal(tx, privyWallet, rpcUrl);
             return {
                 transactionSignature: txSignature,
                 blockNumber: 0,
@@ -32297,58 +32417,262 @@ class PrivyWalletProvider {
             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;
+        var _a;
+        await this.ensureReady();
+        let privyWallets = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets;
+        let session = await WebSessionManager.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 connected, trigger connection and queue the signing
+        if (!privyWallets || privyWallets.length === 0 || !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 web3_js.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 web3_js.PublicKey(privyWallet.address);
+            }
+        }
+        else {
+            // VersionedTransaction
+            const versionedTx = transaction;
+            if (!versionedTx.message.recentBlockhash) {
+                const rpcUrl = this.getRpcUrl();
+                const connection = new web3_js.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;
+        await this.ensureReady();
+        let privyWallets = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets;
+        let session = await WebSessionManager.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 connected, trigger connection and queue the signing
+        if (!privyWallets || privyWallets.length === 0 || !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 web3_js.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 web3_js.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
+        return this.signAndSubmitInternal(transaction, privyWallet, rpcUrl);
+    }
+    // ============ 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$1;
+        }
+        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 (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 {
-            await this.ensureReady();
-            let privyWallets = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets;
-            let session = await WebSessionManager.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.");
+            return web3_js.VersionedTransaction.deserialize(signedTx);
+        }
+        catch (_a) {
+            return web3_js.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) {
+        var _a;
+        const isSurfnet = rpcUrl === SURFNET_RPC_URL$1;
+        if (isSurfnet) {
+            // For Surfnet: sign with signTransactionRaw, then sendRawTransaction
+            const signedTx = await this.signTransactionRaw(transaction, privyWallet);
+            const connection = new web3_js.Connection(rpcUrl, 'confirmed');
+            const signature = await connection.sendRawTransaction(signedTx);
+            return signature;
+        }
+        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 });
             }
-            // If wallet not connected, trigger connection and queue the signing
-            if (!privyWallets || privyWallets.length === 0 || !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
-                });
+            else {
+                serializedTx = transaction.serialize();
             }
-            const serializedForSign = transaction.serialize({ requireAllSignatures: false, verifySignatures: false });
-            const result = await ((_b = this.privyMethods) === null || _b === void 0 ? void 0 : _b.signTransaction({
-                transaction: serializedForSign,
+            const result = await ((_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.useSendTransactionSolana.signAndSendTransaction({
+                transaction: serializedTx,
                 wallet: privyWallet,
                 chain: this.chainId
             }));
-            // Privy returns { signedTransaction: Uint8Array }, unwrap and deserialize to match interface
-            const signedBytes = (result === null || result === void 0 ? void 0 : result.signedTransaction) || result;
-            if (signedBytes instanceof Uint8Array || Buffer.isBuffer(signedBytes)) {
-                // Try to deserialize as VersionedTransaction first, fall back to legacy Transaction
-                try {
-                    return web3_js.VersionedTransaction.deserialize(signedBytes);
-                }
-                catch (_c) {
-                    return web3_js.Transaction.from(signedBytes);
-                }
+            // Handle case where signature might be bytes instead of string
+            let signature = result.signature;
+            if (signature instanceof Uint8Array || Array.isArray(signature)) {
+                // Convert bytes to base58
+                signature = bs58.encode(signature instanceof Uint8Array ? signature : new Uint8Array(signature));
             }
-            // If already a Transaction object, return as-is
-            return signedBytes;
-        }
-        catch (error) {
-            throw new Error(`Failed to sign and send serialized transaction: ${error.message}`);
+            return signature;
         }
     }
     async signMessage(message) {
@@ -32520,6 +32844,14 @@ class MockAuthProvider {
         console.log('[MockAuth] Mock transaction signing (no-op)');
         return transaction;
     }
+    /**
+     * Sign and submit transaction - not supported in mock environment.
+     * See the real providers (PhantomWalletProvider, PrivyWalletProvider, SolanaKeypairProvider)
+     * for the full implementation with blockhash handling and feePayer support.
+     */
+    async signAndSubmitTransaction(_transaction, _feePayer) {
+        throw new Error('signAndSubmitTransaction is not supported in the mock environment');
+    }
     /**
      * Restore session - only restores if user previously called login() explicitly.
      * This prevents auto-login on first page load, but allows session persistence after login.
@@ -32597,6 +32929,16 @@ class OffchainAuthProvider {
     async signTransaction(tx) {
         return this.wrappedProvider.signTransaction(tx);
     }
+    /**
+     * Sign and submit transaction - not supported in poofnet environment.
+     * See the real providers (PhantomWalletProvider, PrivyWalletProvider, SolanaKeypairProvider)
+     * for the full implementation with blockhash handling and feePayer support.
+     */
+    async signAndSubmitTransaction(_transaction, _feePayer) {
+        // Show modal explaining poofnet doesn't support real transactions
+        await this.showUnsupportedTransactionModal();
+        throw new Error('Poofnet does not support real Solana transactions. Deploy your project to mainnet to use this feature.');
+    }
     async getNativeMethods() {
         return this.wrappedProvider.getNativeMethods();
     }
@@ -32629,6 +32971,99 @@ class OffchainAuthProvider {
         }
     }
     // ============ Modal Implementation ============
+    async showUnsupportedTransactionModal() {
+        return new Promise((resolve) => {
+            // Create modal container
+            this.modalContainer = document.createElement("div");
+            this.modalContainer.id = "poofnet-unsupported-modal";
+            this.modalContainer.innerHTML = this.getUnsupportedModalHTML();
+            document.body.appendChild(this.modalContainer);
+            // Add styles
+            const style = document.createElement("style");
+            style.textContent = this.getModalStyles();
+            this.modalContainer.appendChild(style);
+            // Mark all other body children as inert
+            document.body.childNodes.forEach((child) => {
+                if (child !== this.modalContainer &&
+                    child instanceof HTMLElement) {
+                    child.setAttribute("inert", "");
+                }
+            });
+            // Animate in
+            requestAnimationFrame(() => {
+                var _a, _b;
+                const overlay = (_a = this.modalContainer) === null || _a === void 0 ? void 0 : _a.querySelector(".poofnet-modal-overlay");
+                const content = (_b = this.modalContainer) === null || _b === void 0 ? void 0 : _b.querySelector(".poofnet-modal-content");
+                if (overlay)
+                    overlay.style.opacity = "1";
+                if (content) {
+                    content.style.opacity = "1";
+                    content.style.transform = "translateY(0)";
+                }
+            });
+            // Handle close button
+            const closeBtn = this.modalContainer.querySelector("#poofnet-close-btn");
+            closeBtn === null || closeBtn === void 0 ? void 0 : closeBtn.addEventListener("click", () => {
+                this.closeModal();
+                resolve();
+            });
+            // Handle cancel button
+            const cancelBtn = this.modalContainer.querySelector("#poofnet-cancel-btn");
+            cancelBtn === null || cancelBtn === void 0 ? void 0 : cancelBtn.addEventListener("click", () => {
+                this.closeModal();
+                resolve();
+            });
+            // Handle overlay click
+            const overlay = this.modalContainer.querySelector(".poofnet-modal-overlay");
+            overlay === null || overlay === void 0 ? void 0 : overlay.addEventListener("click", (e) => {
+                if (e.target === overlay) {
+                    this.closeModal();
+                    resolve();
+                }
+            });
+            // Handle escape key
+            const escHandler = (e) => {
+                if (e.key === "Escape") {
+                    document.removeEventListener("keydown", escHandler);
+                    this.closeModal();
+                    resolve();
+                }
+            };
+            document.addEventListener("keydown", escHandler);
+        });
+    }
+    getUnsupportedModalHTML() {
+        return `
+      <div class="poofnet-modal-overlay">
+        <div class="poofnet-modal-content">
+          <button id="poofnet-close-btn" class="poofnet-close-btn" aria-label="Close">
+            <svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+              <path d="M1 1L13 13M1 13L13 1" stroke="currentColor" stroke-width="2" stroke-linecap="round"/>
+            </svg>
+          </button>
+          <div class="poofnet-modal-header">
+            <div class="poofnet-modal-icon">⚠️</div>
+            <h2 class="poofnet-modal-title">Transaction Not Supported</h2>
+            <p class="poofnet-modal-subtitle">Poofnet Simulated Blockchain</p>
+          </div>
+
+          <div class="poofnet-modal-body">
+            <div class="poofnet-info-box" style="background: #fef3c7;">
+              <span class="poofnet-info-icon">ℹ️</span>
+              <span class="poofnet-info-text" style="color: #92400e;">
+                Poofnet is a simulated blockchain and does not support real Solana transactions.
+                Deploy your project to mainnet to test real transactions.
+              </span>
+            </div>
+          </div>
+
+          <div class="poofnet-modal-footer">
+            <button id="poofnet-cancel-btn" class="poofnet-btn poofnet-btn-cancel" style="flex: 1;">Close</button>
+          </div>
+        </div>
+      </div>
+    `;
+    }
     async showTransactionModal(message) {
         return new Promise((resolve) => {
             // Parse the transaction message for display
@@ -33398,9 +33833,10 @@ exports.runQueryMany = runQueryMany;
 exports.set = set$1;
 exports.setFile = setFile;
 exports.setMany = setMany;
+exports.signAndSubmitTransaction = signAndSubmitTransaction;
 exports.signMessage = signMessage;
 exports.signSessionCreateMessage = signSessionCreateMessage;
 exports.signTransaction = signTransaction;
 exports.subscribe = subscribe;
 exports.useAuth = useAuth;
-//# sourceMappingURL=index-5j5jdNNe.js.map
+//# sourceMappingURL=index-BaNlnYmn.js.map