@b3dotfun/sdk 0.0.62-alpha.2 → 0.0.62-alpha.4

package/dist/cjs/anyspend/react/hooks/usePhantomTransfer.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePhantomTransfer = usePhantomTransfer;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const react_1 = require("react");
+const sonner_1 = require("sonner");
+/**
+ * Custom hook for handling Phantom wallet transfers on Solana.
+ * Supports both native SOL and SPL token transfers with automatic priority fee calculation.
+ *
+ * @example
+ * ```tsx
+ * const { initiateTransfer, isPhantomAvailable } = usePhantomTransfer();
+ *
+ * await initiateTransfer({
+ *   amountLamports: "1000000000", // 1 SOL
+ *   tokenAddress: "11111111111111111111111111111111",
+ *   recipientAddress: "..."
+ * });
+ * ```
+ */
+function usePhantomTransfer({ rpcEndpoint } = {}) {
+    // Default RPC endpoint
+    const defaultRpcEndpoint = "https://mainnet.helius-rpc.com/?api-key=efafd9b3-1807-4cf8-8aa4-3d984f56d8fb";
+    const effectiveRpcEndpoint = rpcEndpoint || defaultRpcEndpoint;
+    // Check for Phantom wallet availability
+    const isPhantomMobile = (0, react_1.useMemo)(() => navigator.userAgent.includes("Phantom"), []);
+    const isPhantomBrowser = (0, react_1.useMemo)(() => window.phantom?.solana?.isPhantom, []);
+    const isPhantomAvailable = isPhantomMobile || isPhantomBrowser;
+    /**
+     * Get the connected Phantom wallet address if available
+     */
+    const getConnectedAddress = (0, react_1.useCallback)(() => {
+        const phantom = window.phantom?.solana;
+        if (phantom?.isConnected && phantom?.publicKey) {
+            return phantom.publicKey.toString();
+        }
+        return null;
+    }, []);
+    /**
+     * Calculate optimal priority fee based on recent network activity
+     */
+    const calculatePriorityFee = (0, react_1.useCallback)(async (connection, fromPubkey) => {
+        let priorityFee = 10000; // Default fallback (10,000 micro-lamports)
+        try {
+            const recentFees = await connection.getRecentPrioritizationFees({
+                lockedWritableAccounts: [fromPubkey],
+            });
+            if (recentFees && recentFees.length > 0) {
+                // Use 75th percentile of recent fees for good priority
+                const sortedFees = recentFees.map(fee => fee.prioritizationFee).sort((a, b) => a - b);
+                const percentile75Index = Math.floor(sortedFees.length * 0.75);
+                priorityFee = Math.max(sortedFees[percentile75Index] || 10000, 10000);
+            }
+        }
+        catch (feeError) {
+            console.warn("Failed to fetch recent priority fees, using default:", feeError);
+        }
+        return priorityFee;
+    }, []);
+    /**
+     * Create a native SOL transfer transaction with priority fees
+     */
+    const createNativeTransferTransaction = (0, react_1.useCallback)(async (_connection, fromPubkey, toPubkey, amount, priorityFee) => {
+        const computeUnitLimit = 1000; // SOL transfer + compute budget instructions need ~600-800 CU
+        const computeUnitPrice = Math.min(priorityFee, 100000); // Cap at 100k micro-lamports for safety
+        const transaction = new web3_js_1.Transaction()
+            .add(
+        // Set compute unit limit first (must come before other instructions)
+        web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+            units: computeUnitLimit,
+        }))
+            .add(
+        // Set priority fee
+        web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: computeUnitPrice,
+        }))
+            .add(
+        // Actual transfer instruction
+        web3_js_1.SystemProgram.transfer({
+            fromPubkey,
+            toPubkey,
+            lamports: Number(amount),
+        }));
+        console.log(`Using priority fee: ${computeUnitPrice} micro-lamports per CU, limit: ${computeUnitLimit} CU`);
+        return transaction;
+    }, []);
+    /**
+     * Create an SPL token transfer transaction with priority fees
+     */
+    const createSPLTransferTransaction = (0, react_1.useCallback)(async (connection, fromPubkey, toPubkey, mintPubkey, amount, priorityFee) => {
+        // Get associated token accounts
+        const fromTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(mintPubkey, fromPubkey);
+        const toTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(mintPubkey, toPubkey);
+        // Check if destination token account exists
+        const toTokenAccountInfo = await connection.getAccountInfo(toTokenAccount);
+        const needsDestinationAccount = !toTokenAccountInfo;
+        // Get mint info to determine decimals
+        const mintInfo = await connection.getParsedAccountInfo(mintPubkey);
+        const decimals = mintInfo.value?.data?.parsed?.info?.decimals || 9;
+        // SPL transfers need more compute units than SOL transfers
+        // Add extra CU if we need to create destination account
+        const computeUnitLimit = needsDestinationAccount ? 40000 : 20000;
+        const computeUnitPrice = Math.min(priorityFee, 100000);
+        // Create transfer instruction
+        const transferInstruction = (0, spl_token_1.createTransferCheckedInstruction)(fromTokenAccount, mintPubkey, toTokenAccount, fromPubkey, Number(amount), decimals);
+        const transaction = new web3_js_1.Transaction()
+            .add(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+            units: computeUnitLimit,
+        }))
+            .add(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: computeUnitPrice,
+        }));
+        // Add create destination account instruction if needed
+        if (needsDestinationAccount) {
+            transaction.add((0, spl_token_1.createAssociatedTokenAccountInstruction)(fromPubkey, // payer
+            toTokenAccount, // ata
+            toPubkey, // owner
+            mintPubkey));
+        }
+        // Add the transfer instruction
+        transaction.add(transferInstruction);
+        console.log(`SPL Token transfer: ${computeUnitPrice} micro-lamports per CU, limit: ${computeUnitLimit} CU, creating destination: ${needsDestinationAccount}`);
+        return transaction;
+    }, []);
+    /**
+     * Initiate a Phantom wallet transfer for SOL or SPL tokens
+     */
+    const initiateTransfer = (0, react_1.useCallback)(async ({ amountLamports, tokenAddress, recipientAddress }) => {
+        try {
+            // Step 1: Check if Phantom is installed
+            if (!isPhantomAvailable) {
+                sonner_1.toast.error("Phantom wallet not installed. Please install Phantom wallet to continue.");
+                return;
+            }
+            // Step 2: Ensure Phantom is connected/unlocked
+            const phantom = window.phantom?.solana;
+            if (!phantom) {
+                sonner_1.toast.error("Phantom wallet not accessible");
+                return;
+            }
+            // Connect and unlock wallet if needed
+            let publicKey;
+            try {
+                const connection = await phantom.connect();
+                publicKey = connection.publicKey;
+            }
+            catch (connectError) {
+                sonner_1.toast.error("Failed to connect to Phantom wallet");
+                return;
+            }
+            // Step 3: Setup connection and public keys
+            const connection = new web3_js_1.Connection(effectiveRpcEndpoint);
+            const fromPubkey = new web3_js_1.PublicKey(publicKey.toString());
+            const toPubkey = new web3_js_1.PublicKey(recipientAddress);
+            const amount = BigInt(amountLamports);
+            // Step 4: Calculate optimal priority fee
+            const priorityFee = await calculatePriorityFee(connection, fromPubkey);
+            // Step 5: Create transaction based on token type
+            let transaction;
+            if (tokenAddress === "11111111111111111111111111111111") {
+                // Native SOL transfer
+                transaction = await createNativeTransferTransaction(connection, fromPubkey, toPubkey, amount, priorityFee);
+            }
+            else {
+                // SPL Token transfer
+                const mintPubkey = new web3_js_1.PublicKey(tokenAddress);
+                transaction = await createSPLTransferTransaction(connection, fromPubkey, toPubkey, mintPubkey, amount, priorityFee);
+            }
+            // Step 6: Get latest blockhash and set fee payer
+            const { blockhash } = await connection.getLatestBlockhash("confirmed");
+            transaction.recentBlockhash = blockhash;
+            transaction.feePayer = fromPubkey;
+            // Step 7: Sign and send transaction
+            const signedTransaction = await phantom.signAndSendTransaction(transaction);
+            sonner_1.toast.success(`Transaction successful! Signature: ${signedTransaction.signature}`);
+            console.log("Transaction sent with priority fees. Signature:", signedTransaction.signature);
+        }
+        catch (error) {
+            console.error("Transfer error:", error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes("User rejected")) {
+                sonner_1.toast.error("Transaction was cancelled by user");
+            }
+            else if (errorMessage.includes("insufficient")) {
+                sonner_1.toast.error("Insufficient balance for this transaction");
+            }
+            else if (errorMessage.includes("blockhash not found")) {
+                sonner_1.toast.error("Network congestion detected. Please try again in a moment.");
+            }
+            else {
+                sonner_1.toast.error(`Transfer failed: ${errorMessage}`);
+            }
+        }
+    }, [
+        isPhantomAvailable,
+        effectiveRpcEndpoint,
+        calculatePriorityFee,
+        createNativeTransferTransaction,
+        createSPLTransferTransaction,
+    ]);
+    return {
+        /** Function to initiate a transfer */
+        initiateTransfer,
+        /** Whether Phantom wallet is available (installed) */
+        isPhantomAvailable,
+        /** Get the currently connected Phantom wallet address */
+        getConnectedAddress,
+    };
+}