Needs work but getting there

Author: jongan69

src/components/home/item-list.tsx

@@ -17,7 +17,7 @@ type Props = {
 export const ItemList = ({ initialItems, totalValue }: Props) => {
   const { publicKey, sendTransaction, signAllTransactions } = useWallet(); // Get wallet details from useWallet hook
   const { connection } = useConnection(); // Get connection from useConnection hook
-  const { closeTokenAccount } = useCloseTokenAccount(); // Get closeTokenAccount function from useCloseTokenAccount hook
+  const { closeTokenAccount, closeTokenAccountsAndSendTransaction } = useCloseTokenAccount(); // Get closeTokenAccount function from useCloseTokenAccount hook
 
   const [items] = useState<TokenData[]>(initialItems); // Initialize items state
   const [sortedItems, setSortedItems] = useState<TokenData[]>(initialItems); // Initialize sorted items state
@@ -100,17 +100,21 @@ export const ItemList = ({ initialItems, totalValue }: Props) => {
 
   const handleCloseTokenAccounts = async () => {
     if (closableTokenAccounts.length > 0 && publicKey && signAllTransactions) {
-      let closeAccountInstructions: TransactionInstruction[] = [];
-      for (const closable of closableTokenAccounts) {
-        const closeAccountInstr = await closeTokenAccount(new PublicKey(closable.tokenAddress)); // Get close account instruction
-        closeAccountInstructions.push(closeAccountInstr); // Add instruction to list
+      try {
+        setMessage("Preparing to close accounts...");
+        const tokenAccountPubkeys = closableTokenAccounts.map(
+          account => new PublicKey(account.tokenAddress)
+        );
+        const success = await closeTokenAccountsAndSendTransaction(tokenAccountPubkeys, setMessage);
+        if (success) {
+          setClosableTokenAccounts([]);
+          setMessage("");
+        }
+      } catch (error) {
+        console.error("Error closing accounts:", error);
+        toast.error("Error Closing Token Accounts, Please Reload Page.");
+        setMessage("");
       }
-      // Send transaction batch to close token accounts
-      await sendTransactionBatch(closeAccountInstructions, publicKey, signAllTransactions, connection, setMessage, sendTransaction, 'Closing token accounts');
-      setClosableTokenAccounts([]); // Reset closable token accounts
-    } else {
-      toast.error("Error Closing Token Accounts, Please Reload Page."); // Show error toast
-      setClosableTokenAccounts([]); // Reset closable token accounts
     }
   };
 

src/pages/api/sign/create.ts

@@ -2,8 +2,6 @@ import {
   Connection,
   Keypair,
   PublicKey,
-  Transaction,
-  TransactionInstruction,
   VersionedTransaction
 } from "@solana/web3.js";
 import { NextApiRequest, NextApiResponse } from "next";
@@ -38,9 +36,6 @@ export default async function handler(
       return;
     }
 
-    const connection = new Connection(NETWORK);
-    const publicKey = new PublicKey(publicKeyStr);
-    const wallet = new Wallet(Keypair.fromSecretKey(bs58.decode(privateKey)));
 
     // Get the quote for the swap
     const quoteResponse = await (
@@ -67,7 +62,6 @@ export default async function handler(
     const transaction = VersionedTransaction.deserialize(swapTransactionBuf);
     // transaction.feePayer = publicKey;
 
-    const blockHash = (await connection.getLatestBlockhash("finalized")).blockhash;
     // transaction.recentBlockhash = blockHash;
 
     // Serialize the transaction

src/utils/hooks/useCloseTokenAccount.ts

@@ -1,15 +1,25 @@
 import { useWallet, useConnection } from "@solana/wallet-adapter-react";
-import { PublicKey, Transaction, TransactionInstruction } from "@solana/web3.js";
+import { 
+  PublicKey, 
+  TransactionInstruction,
+  VersionedTransaction,
+  TransactionMessage 
+} from "@solana/web3.js";
 import { createCloseAccountInstruction } from "@solana/spl-token";
 import { toast } from "react-hot-toast";
-import { useState } from "react";
+import { getTipAccounts, sendTxUsingJito, waitForBundleConfirmation } from "@utils/hooks/useCreateSwapInstructions";
+import { SystemProgram } from "@solana/web3.js";
+
+const MAX_ACCOUNTS_PER_TX = 12; // Conservative limit for accounts per transaction
+const BUNDLE_TIP = 1000; // Tip amount for Jito bundles
+const USER_REJECTION_ERROR = 'User rejected the request';
 
 export const useCloseTokenAccount = () => {
-  const { publicKey, signTransaction, sendTransaction } = useWallet();
+  const { publicKey, signAllTransactions } = useWallet();
   const { connection } = useConnection();
 
   const closeTokenAccount = async (tokenAccountPubkey: PublicKey): Promise<TransactionInstruction> => {
-    if (!publicKey || !signTransaction || !tokenAccountPubkey) {
+    if (!publicKey || !tokenAccountPubkey) {
       throw new Error("Wallet not connected or not able to sign transactions or Error with token account address");
     }
 
@@ -37,34 +47,82 @@ export const useCloseTokenAccount = () => {
     return closeInstruction;
   };
 
-  const closeTokenAccountsAndSendTransaction = async (instructions: TransactionInstruction[]) => {
-    if (!publicKey || !signTransaction) {
-      throw new Error("Wallet not connected or not able to sign transactions");
+  const closeTokenAccountsAndSendTransaction = async (
+    tokenAccounts: PublicKey[],
+    setMessage?: (msg: string) => void
+  ) => {
+    if (!publicKey || !signAllTransactions) {
+      throw new Error("Wallet not connected");
     }
 
-    const transaction = new Transaction().add(...instructions);
-
     try {
+      setMessage?.("Preparing to close token accounts...");
+      const tipAccount = await getTipAccounts();
+
+      // Split token accounts into chunks
+      const chunks: PublicKey[][] = [];
+      for (let i = 0; i < tokenAccounts.length; i += MAX_ACCOUNTS_PER_TX) {
+        chunks.push(tokenAccounts.slice(i, i + MAX_ACCOUNTS_PER_TX));
+      }
+
+      console.log(`Split ${tokenAccounts.length} accounts into ${chunks.length} chunks`);
+      
+      // Create all transactions
+      const transactions: VersionedTransaction[] = [];
       const { blockhash } = await connection.getLatestBlockhash();
-      const latestBlockHash = await connection.getLatestBlockhash();
-      transaction.recentBlockhash = blockhash;
-      transaction.feePayer = publicKey;
-
-      const signedTransaction = await signTransaction(transaction);
-      const signature = await sendTransaction(signedTransaction, connection);
-
-      await connection.confirmTransaction({
-        blockhash,
-        lastValidBlockHeight: latestBlockHash.lastValidBlockHeight,
-        signature
-      });
-
-      console.log("Transaction confirmed with signature:", signature);
-      toast.success("Transaction confirmed successfully!");
-      return signature;
-    } catch (error) {
-      console.error("Failed to send transaction:", error);
-      toast.error("Failed to send transaction. Please try again.");
+
+      for (const chunk of chunks) {
+        const instructions = await Promise.all(
+          chunk.map(account => closeTokenAccount(account))
+        );
+
+        const tipInstruction = SystemProgram.transfer({
+          fromPubkey: publicKey,
+          toPubkey: new PublicKey(tipAccount),
+          lamports: BUNDLE_TIP,
+        });
+
+        const messageV0 = new TransactionMessage({
+          payerKey: publicKey,
+          recentBlockhash: blockhash,
+          instructions: [...instructions, tipInstruction],
+        }).compileToV0Message();
+
+        transactions.push(new VersionedTransaction(messageV0));
+      }
+
+      setMessage?.("Please approve the transaction in your wallet...");
+      
+      try {
+        // Sign all transactions at once
+        const signedTransactions = await signAllTransactions(transactions);
+
+        // Send transactions as Jito bundles
+        for (let i = 0; i < signedTransactions.length; i++) {
+          setMessage?.(`Processing chunk ${i + 1}/${signedTransactions.length}...`);
+          const signedTx = signedTransactions[i];
+          const serializedTx = signedTx.serialize();
+          const bundleId = await sendTxUsingJito([serializedTx]);
+          
+          setMessage?.(`Confirming chunk ${i + 1}...`);
+          const confirmed = await waitForBundleConfirmation(bundleId);
+          if (!confirmed) {
+            throw new Error(`Bundle ${bundleId} failed to confirm`);
+          }
+        }
+
+        toast.success("Successfully closed all token accounts!");
+        return true;
+      } catch (error: any) {
+        if (error?.message?.includes(USER_REJECTION_ERROR)) {
+          toast.error("Transaction rejected by user");
+          return false;
+        }
+        throw error;
+      }
+    } catch (error: any) {
+      console.error("Failed to close token accounts:", error);
+      toast.error(error?.message || "Failed to close token accounts. Please try again.");
       throw error;
     }
   };