@pooflabs/web 0.0.38 → 0.0.39

package/dist/{index-CSe3WqP-.esm.js → index-CK_KC-Oy.esm.js}

@@ -12425,6 +12425,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 = {};
@@ -12646,7 +12653,7 @@ async function loadDependencies() {
         const [reactModule, reactDomModule, phantomModule] = await Promise.all([
             import('react'),
             import('react-dom/client'),
-            import('./index-DIB1IdkM.esm.js')
+            import('./index-CfbGteXj.esm.js')
         ]);
         React$1 = reactModule;
         ReactDOM$1 = reactDomModule;
@@ -13092,18 +13099,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();
             }
@@ -13116,21 +13120,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 Connection(rpcUrl, 'confirmed');
         try {
             const remainingAccounts = convertRemainingAccounts(solTransactionData.txArgs[0].remainingAccounts);
@@ -13170,7 +13160,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,
@@ -13185,19 +13175,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,
@@ -13223,6 +13202,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 {
@@ -13251,6 +13240,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 Connection(rpcUrl, 'confirmed');
+                const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+                legacyTx.recentBlockhash = blockhash;
+                legacyTx.lastValidBlockHeight = lastValidBlockHeight;
+            }
+            // Set feePayer if not already set
+            if (!legacyTx.feePayer) {
+                const solAddress = this.phantomMethods.addresses.find((addr) => addr.addressType === phantomReactSdk.AddressType.solana);
+                if (solAddress) {
+                    legacyTx.feePayer = new PublicKey(solAddress.address);
+                }
+            }
+        }
+        else {
+            // VersionedTransaction
+            const versionedTx = transaction;
+            if (!versionedTx.message.recentBlockhash) {
+                const rpcUrl = this.getRpcUrl();
+                const connection = new Connection(rpcUrl, 'confirmed');
+                const { blockhash } = await connection.getLatestBlockhash('confirmed');
+                versionedTx.message.recentBlockhash = blockhash;
+            }
+        }
         try {
             return await this.phantomMethods.solana.signTransaction(transaction);
         }
@@ -13264,6 +13283,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 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 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 {
@@ -13334,6 +13449,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;
 
@@ -31845,6 +32004,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');
@@ -31961,6 +32122,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
@@ -31979,6 +32152,10 @@ class PrivyWalletProvider {
                             that.pendingSignMessage.reject(error);
                             that.pendingSignMessage = null;
                         }
+                        if (that.pendingSignAndSubmitTransaction) {
+                            that.pendingSignAndSubmitTransaction.reject(error);
+                            that.pendingSignAndSubmitTransaction = null;
+                        }
                     }
                 });
                 const { login } = privyImports.useLogin({
@@ -32125,7 +32302,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;
@@ -32160,21 +32337,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 Connection(rpcUrl, "confirmed");
         const remainingAccounts = convertRemainingAccounts(solTransactionData.txArgs[0].remainingAccounts);
         let app_id = solTransactionData.appId;
@@ -32200,71 +32363,28 @@ class PrivyWalletProvider {
             }
         }
         const { tx, blockhash, lastValidBlockHeight } = 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);
-        if (tx instanceof 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 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 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 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 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,
@@ -32277,58 +32397,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 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;
+        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 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
+        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 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) {
+        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 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 VersionedTransaction.deserialize(signedBytes);
-                }
-                catch (_c) {
-                    return 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) {
@@ -32500,6 +32824,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.
@@ -32577,6 +32909,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();
     }
@@ -32609,6 +32951,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
@@ -33340,5 +33775,5 @@ async function getIdToken() {
     return getIdToken$1(false);
 }
 
-export { getIdToken as A, PrivyWalletProvider as B, buildSetDocumentsTransaction as C, DEFAULT_TEST_ADDRESS as D, EventEmitter4 as E, convertRemainingAccounts as F, createSessionWithPrivy as G, createSessionWithSignature as H, genAuthNonce as I, genSolanaMessage as J, refreshSession as K, signSessionCreateMessage as L, MockAuthProvider as M, OffchainAuthProvider as O, PhantomWalletProvider as P, ServerSessionManager as S, WebSessionManager as W, bs58 as a, bufferExports$1 as b, commonjsRequire as c, onAuthLoadingChanged as d, getAuthLoading as e, logout as f, getCurrentUser as g, getConfig as h, init as i, getAuthProvider as j, get$2 as k, login as l, setMany as m, setFile as n, onAuthStateChanged as o, getFiles as p, runQuery as q, require$$0$1 as r, set$1 as s, runQueryMany as t, runExpression as u, runExpressionMany as v, signMessage as w, signTransaction as x, subscribe as y, useAuth as z };
-//# sourceMappingURL=index-CSe3WqP-.esm.js.map
+export { useAuth as A, getIdToken as B, PrivyWalletProvider as C, DEFAULT_TEST_ADDRESS as D, EventEmitter4 as E, buildSetDocumentsTransaction as F, convertRemainingAccounts as G, createSessionWithPrivy as H, createSessionWithSignature as I, genAuthNonce as J, genSolanaMessage as K, refreshSession as L, MockAuthProvider as M, signSessionCreateMessage as N, OffchainAuthProvider as O, PhantomWalletProvider as P, ServerSessionManager as S, WebSessionManager as W, bs58 as a, bufferExports$1 as b, commonjsRequire as c, onAuthLoadingChanged as d, getAuthLoading as e, logout as f, getCurrentUser as g, getConfig as h, init as i, getAuthProvider as j, get$2 as k, login as l, setMany as m, setFile as n, onAuthStateChanged as o, getFiles as p, runQuery as q, require$$0$1 as r, set$1 as s, runQueryMany as t, runExpression as u, runExpressionMany as v, signMessage as w, signTransaction as x, signAndSubmitTransaction as y, subscribe as z };
+//# sourceMappingURL=index-CK_KC-Oy.esm.js.map