đź“– GuidesNEW

Advanced iconAdvanced

Updated: 2025-09-03

Advanced iconAdvanced

Updated: 2025-09-03
Expert Level Guide: This comprehensive guide covers advanced Solana token account recovery using JavaScript/TypeScript. Requires technical knowledge and carries risk of fund loss if executed incorrectly.

Complete Solana Token Account Recovery

Advanced Solana developers can recover SOL from empty Associated Token Accounts (ATA) and close unused SPL token accounts using JavaScript/TypeScript with official Solana libraries. This manual process provides maximum control over token account cleanup, rent recovery, and wallet optimization.

Prerequisites for Advanced Recovery:
  • Node.js 16+ and npm/yarn installed
  • Understanding of Solana account model and rent mechanics
  • Access to wallet private keys or seed phrases
  • Knowledge of SPL Token Program instructions
  • Familiarity with JavaScript/TypeScript and async programming
  • Basic understanding of Solana transaction construction
Why JavaScript/TypeScript?
  • Official Solana documentation and examples primarily in JS/TS
  • Mature ecosystem with @solana/web3.js and @solana/spl-token
  • Active community support and extensive tutorials
  • Web3.js 2.0 (released Nov 2024) offers better performance
  • Easier integration with web applications and wallets
Recovery Potential
Standard ATA:
0.002 SOL per account
Batch limit:
20 accounts per transaction
Transaction fees:
~0.000005 SOL per signature
Net recovery rate:
99%+ of locked rent

Project Setup and Dependencies

Required Dependencies

Installation Commands:
# Web3.js 2.0 (Latest - Recommended)
npm install @solana/web3.js@2

# OR Web3.js 1.x (Stable)
npm install @solana/web3.js@1

# SPL Token Library
npm install @solana/spl-token

# Additional utilities
npm install bs58 bip39 ed25519-hd-key
Official Documentation:

Wallet Connection and Key Management

Method 1: Private Key (Base58)
import { Connection, Keypair } from '@solana/web3.js';
import bs58 from 'bs58';

const connection = new Connection(
  'https://api.mainnet-beta.solana.com'
);

const secretKey = 'YOUR_BASE58_PRIVATE_KEY';
const keypair = Keypair.fromSecretKey(
  bs58.decode(secretKey)
);
Export private keys from Phantom: Settings → Export Private Key
Method 2: Seed Phrase Recovery
import { Keypair } from '@solana/web3.js';
import * as bip39 from 'bip39';
import { derivePath } from 'ed25519-hd-key';

const mnemonic = 'your twelve word seed phrase';
const seed = await bip39.mnemonicToSeed(mnemonic);
const derivedSeed = derivePath(
  "m/44'/501'/0'/0'", seed.toString('hex')
).key;

const keypair = Keypair.fromSeed(derivedSeed);
Standard Solana derivation path: m/44'/501'/0'/0'
Critical Security Measures:
  • Never store private keys in plaintext in production code
  • Use environment variables for sensitive data
  • Test all operations on devnet first
  • Keep backup copies of keypairs in secure locations
  • Consider using hardware wallets for large amounts

Token Account Discovery and Analysis

Find All Token Accounts

import {
  TOKEN_PROGRAM_ID,
  getAccount
} from '@solana/spl-token';

async function findAllTokenAccounts(walletAddress) {
  // Get all token accounts
  const tokenAccounts = await connection.getTokenAccountsByOwner(
    walletAddress,
    { programId: TOKEN_PROGRAM_ID }
  );

  // Categorize accounts
  const emptyAccounts = [];
  const accountsWithTokens = [];

  for (const account of tokenAccounts.value) {
    const accountInfo = await getAccount(connection, account.pubkey);
    if (accountInfo.amount === 0n) {
      emptyAccounts.push(account.pubkey);
    } else {
      accountsWithTokens.push({
        pubkey: account.pubkey,
        mint: accountInfo.mint,
        amount: accountInfo.amount
      });
    }
  }

  return { emptyAccounts, accountsWithTokens };
}
Token-2022 Support:
import { TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';

// For Token Extensions (Token-2022)
{ programId: TOKEN_2022_PROGRAM_ID }
Reference: https://spl.solana.com/token-2022

Token Burning Operations

🚨 CRITICAL WORKFLOW - Follow This Order:
  1. Step 1: Identify - Find all token accounts and categorize them
  2. Step 2: Burn First - If you want to destroy tokens with balance > 0, burn them first
  3. Step 3: Close After - Only close accounts that are 100% empty

⚠️ NEVER close accounts with token balances > 0 - You will lose valuable tokens forever!

Individual Token Burning
import {
  createBurnInstruction,
  Transaction,
  sendAndConfirmTransaction
} from '@solana/spl-token';

async function burnTokens(
  tokenAccount, mint, owner, amount
) {
  const instruction = createBurnInstruction(
    tokenAccount, // Token account
    mint, // Mint account
    owner, // Owner
    amount // Amount to burn
  );

  const transaction = new Transaction().add(instruction);
  return await sendAndConfirmTransaction(
    connection, transaction, [ownerKeypair]
  );
}

Burns tokens permanently, reducing total supply and preparing accounts for closure.

Batch Token Burning
async function burnAllTokensInAccounts(accountsWithTokens) {
  for (const account of accountsWithTokens) {
    console.log(
      `Burning {account.amount} tokens from {account.pubkey}`
    );

    await burnTokens(
      account.pubkey,
      account.mint,
      ownerKeypair.publicKey,
      account.amount
    );

    // Rate limiting
    await new Promise(r => setTimeout(r, 2000));
  }
}
⚠️ WARNING: This permanently destroys tokens! Only burn worthless/unwanted tokens.

Associated Token Account Closure

Individual Account Closure
import {
  createCloseAccountInstruction
} from '@solana/spl-token';

async function closeEmptyTokenAccount(
  tokenAccount, owner, recipient
) {
  // CRITICAL: Verify account is empty first
  const accountInfo = await getAccount(
    connection, tokenAccount
  );
  if (accountInfo.amount !== 0n) {
    throw new Error('Account must be empty!');
  }

  const instruction = createCloseAccountInstruction(
    tokenAccount, // Empty token account
    recipient, // SOL recipient
    owner // Account owner
  );

  const transaction = new Transaction().add(instruction);
  return await sendAndConfirmTransaction(
    connection, transaction, [ownerKeypair]
  );
}

Closes individual EMPTY token accounts and recovers 0.002 SOL rent per account.

Bulk Empty Account Closure
async function closeAllEmptyAccounts(emptyAccounts) {
  const batchSize = 20; // Max per transaction
  const results = [];

  for (let i = 0; i < emptyAccounts.length; i += batchSize) {
    const batch = emptyAccounts.slice(i, i + batchSize);
    const transaction = new Transaction();

    // Double-verify all accounts are empty
    for (const account of batch) {
      const info = await getAccount(connection, account);
      if (info.amount !== 0n) {
        throw new Error(`Account not empty: {account}`);
      }
      transaction.add(
        createCloseAccountInstruction(
          account, recipient, owner
        )
      );
    }

    const signature = await sendAndConfirmTransaction(
      connection, transaction, [ownerKeypair]
    );
    results.push(signature);

    // Rate limiting
    await new Promise(r => setTimeout(r, 1000));
  }

  return results;
}
âś… Safe bulk processing with double-verification that accounts are empty.

Priority Fees for Faster Confirmation

Add Compute Budget Instructions

import { ComputeBudgetProgram } from '@solana/web3.js';

// Add priority fee for faster confirmation
transaction.add(
  ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: 1000 // 0.000001 SOL
  })
);

// Optional: Set compute unit limit
transaction.add(
  ComputeBudgetProgram.setComputeUnitLimit({
    units: 200000
  })
);
Priority fees help ensure faster transaction confirmation during network congestion. Adjust microLamports based on current network conditions.

Troubleshooting and Common Issues

Transaction Failures
  • Account not empty: Verify token balance is exactly 0
  • Authority mismatch: Ensure wallet owns the account
  • Insufficient SOL: Need SOL for transaction fees
  • Network congestion: Add priority fees or retry later
RPC and Network Issues
  • Rate limiting: Add delays between requests (1-2 seconds)
  • Timeout errors: Use reliable RPC provider (Helius, QuickNode)
  • Blockhash expired: Fetch fresh recent blockhash
  • 429 errors: Implement exponential backoff
Optimization Tips
  • Batch operations: Group up to 20 accounts per transaction
  • Error handling: Use try/catch blocks with retry logic
  • Account filters: Pre-filter empty accounts client-side
  • Testing: Always test on devnet first
Security Alert - December 2024:

@solana/web3.js versions 1.95.6 and 1.95.7 were compromised. Always use the latest version:

npm install @solana/web3.js@latest

Security Best Practices and Resources

Critical Security Measures:
  • Test all operations on devnet first
  • Use environment variables for private keys
  • Verify wallet addresses before execution
  • Keep @solana/web3.js updated to latest version
  • Monitor transactions on Solana explorers
  • Use hardware wallets for large amounts
  • Never close accounts with token balances > 0
  • Always double-check account states before operations
Official Resources:

For users uncomfortable with coding, automated tools provide safer alternatives:

  • SweepSOL: Automated GUI-based recovery
  • Professional verification and safety checks
  • Technical support and guidance
Use SweepSOL Tool
UnisolUnibot Recovery
All Guides