Manage SPL Token Accounts

import { useParaSolanaV2 } from './hooks/useParaSolanaV2';
import { 
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayer,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  address
} from '@solana/web3.js';
import { 
  getCreateAssociatedTokenAccountInstruction,
  findAssociatedTokenPda,
  getCloseAccountInstruction
} from '@solana-program/token';

function ManageTokenAccounts() {
  const { rpc, signer } = useParaSolanaV2();
  
  const createTokenAccount = async (mint: string, owner?: string) => {
    const mintAddress = address(mint);
    const ownerAddress = owner ? address(owner) : signer.address;
    
    const [ata] = await findAssociatedTokenPda({
      mint: mintAddress,
      owner: ownerAddress,
    });
    
    const accountInfo = await rpc.getAccountInfo(ata).send();
    if (accountInfo.value) {
      console.log("Token account already exists:", ata);
      return ata;
    }
    
    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
    
    const transaction = pipe(
      createTransactionMessage({ version: 0 }),
      tx => setTransactionMessageFeePayer(signer.address, tx),
      tx => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
      tx => appendTransactionMessageInstruction(
        getCreateAssociatedTokenAccountInstruction({
          ata,
          mint: mintAddress,
          owner: ownerAddress,
          payer: signer,
        }),
        tx
      )
    );
    
    try {
      const [signature] = await signer.signAndSendTransactions([transaction]);
      console.log("Created token account:", ata);
      console.log("Transaction signature:", signature);
      return ata;
    } catch (error) {
      console.error("Failed to create token account:", error);
      throw error;
    }
  };
  
  const closeTokenAccount = async (tokenAccount: string) => {
    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
    
    const transaction = pipe(
      createTransactionMessage({ version: 0 }),
      tx => setTransactionMessageFeePayer(signer.address, tx),
      tx => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
      tx => appendTransactionMessageInstruction(
        getCloseAccountInstruction({
          account: address(tokenAccount),
          destination: signer.address,
          authority: signer,
        }),
        tx
      )
    );
    
    try {
      const [signature] = await signer.signAndSendTransactions([transaction]);
      console.log("Closed token account:", tokenAccount);
      console.log("Transaction signature:", signature);
      return signature;
    } catch (error) {
      console.error("Failed to close token account:", error);
      throw error;
    }
  };
  
  return (
    <div>
      <button onClick={() => createTokenAccount("USDC_MINT_ADDRESS")}>
        Create USDC Account
      </button>
      <button onClick={() => closeTokenAccount("TOKEN_ACCOUNT_ADDRESS")}>
        Close Token Account
      </button>
    </div>
  );
}

import { useParaAnchor } from './hooks/useParaAnchor';
import { Transaction, PublicKey } from '@solana/web3.js';
import { 
  createAssociatedTokenAccountInstruction,
  getAssociatedTokenAddress,
  createCloseAccountInstruction,
  TOKEN_PROGRAM_ID,
  ASSOCIATED_TOKEN_PROGRAM_ID
} from '@solana/spl-token';

function ManageTokenAccounts() {
  const provider = useParaAnchor();
  
  const createTokenAccount = async (mint: string, owner?: string) => {
    const mintPubkey = new PublicKey(mint);
    const ownerPubkey = owner ? new PublicKey(owner) : provider.publicKey;
    
    const ata = await getAssociatedTokenAddress(mintPubkey, ownerPubkey);
    
    const accountInfo = await provider.connection.getAccountInfo(ata);
    if (accountInfo) {
      console.log("Token account already exists:", ata.toString());
      return ata;
    }
    
    const transaction = new Transaction().add(
      createAssociatedTokenAccountInstruction(
        provider.publicKey,
        ata,
        ownerPubkey,
        mintPubkey,
        TOKEN_PROGRAM_ID,
        ASSOCIATED_TOKEN_PROGRAM_ID
      )
    );
    
    try {
      const signature = await provider.sendAndConfirm(transaction);
      console.log("Created token account:", ata.toString());
      console.log("Transaction signature:", signature);
      return ata;
    } catch (error) {
      console.error("Failed to create token account:", error);
      throw error;
    }
  };
  
  const closeTokenAccount = async (tokenAccount: string) => {
    const tokenAccountPubkey = new PublicKey(tokenAccount);
    
    const transaction = new Transaction().add(
      createCloseAccountInstruction(
        tokenAccountPubkey,
        provider.publicKey,
        provider.publicKey,
        [],
        TOKEN_PROGRAM_ID
      )
    );
    
    try {
      const signature = await provider.sendAndConfirm(transaction);
      console.log("Closed token account:", tokenAccount);
      console.log("Transaction signature:", signature);
      return signature;
    } catch (error) {
      console.error("Failed to close token account:", error);
      throw error;
    }
  };
  
  return (
    <div>
      <button onClick={() => createTokenAccount("USDC_MINT_ADDRESS")}>
        Create USDC Account
      </button>
      <button onClick={() => closeTokenAccount("TOKEN_ACCOUNT_ADDRESS")}>
        Close Token Account
      </button>
    </div>
  );
}