📖 GuidesNEW

Avancé iconAvancé

Mis à jour: 2025-09-03

Avancé iconAvancé

Mis à jour: 2025-09-03
Guide de niveau expert : Ce guide complet couvre la récupération avancée des comptes de tokens Solana en utilisant JavaScript/TypeScript. Nécessite des connaissances techniques et comporte un risque de perte de fonds en cas d'exécution incorrecte.

Récupération complète des comptes de tokens Solana

Les développeurs Solana avancés peuvent récupérer du SOL à partir de comptes de tokens associés (ATA) vides et fermer les comptes de tokens SPL non utilisés en utilisant JavaScript/TypeScript avec les bibliothèques officielles de Solana. Ce processus manuel offre un contrôle maximal sur le nettoyage des comptes de tokens, la récupération de loyers et l'optimisation du portefeuille.

Prérequis pour la récupération avancée :
  • Node.js 16+ et npm/yarn installés
  • Compréhension du modèle de compte Solana et des mécanismes de loyer
  • Accès aux clés privées du portefeuille ou aux phrases de récupération
  • Connaissance des instructions du programme de tokens SPL
  • Familiarité avec JavaScript/TypeScript et la programmation asynchrone
  • Compréhension de base de la construction de transactions Solana
Pourquoi JavaScript/TypeScript ?
  • La documentation officielle de Solana et les exemples sont principalement en JS/TS
  • Écosystème mature avec @solana/web3.js et @solana/spl-token
  • Soutien actif de la communauté et tutoriels détaillés
  • Web3.js 2.0 (sorti en novembre 2024) offre de meilleures performances
  • Intégration plus facile avec les applications web et les portefeuilles
Potentiel de récupération
ATA standard :
0.002 SOL par compte
Limite de lot :
20 comptes par transaction
Frais de transaction :
~0.000005 SOL par signature
Taux de récupération net :
99%+ du loyer bloqué

Configuration du projet et dépendances

Dépendances requises

Commandes d'installation :
# 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
Documentation officielle :

Connexion au portefeuille et gestion des clés

Méthode 1 : Clé privée (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)
);
Exporter les clés privées depuis Phantom : Paramètres → Exporter la clé privée
Méthode 2 : Récupération par phrase de récupération
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);
Chemin de dérivation standard de Solana : m/44'/501'/0'/0'
Mesures de sécurité critiques :
  • Ne jamais stocker les clés privées en texte brut dans le code de production
  • Utiliser des variables d'environnement pour les données sensibles
  • Tester toutes les opérations sur devnet d'abord
  • Conserver des copies de sauvegarde des paires de clés dans des endroits sécurisés
  • Envisager d'utiliser des portefeuilles matériels pour de grandes quantités

Découverte et analyse des comptes de tokens

Trouver tous les comptes de tokens

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 };
}
Support pour Token-2022 :
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

Opérations de combustion de tokens

🚨 FLUX DE TRAVAIL CRITIQUE - Suivez cet ordre :
  1. Étape 1 : Identifier - Trouver tous les comptes de tokens et les catégoriser
  2. Étape 2 : Brûler d'abord - Si vous voulez détruire des tokens avec un solde > 0, brûlez-les d'abord
  3. Étape 3 : Fermer ensuite - Ne fermer que les comptes 100% vides

⚠️ NE JAMAIS fermer les comptes avec des soldes de tokens > 0 - Vous perdrez des tokens précieux pour toujours !

Combustion de tokens individuelle
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]
  );
}

Brûle les tokens de manière permanente, réduisant l'offre totale et préparant les comptes à la fermeture.

Combustion de tokens par lots
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));
  }
}
⚠️ AVERTISSEMENT : Cela détruit les tokens de manière permanente ! Ne brûlez que des tokens sans valeur ou non désirés.

Fermeture des comptes de tokens associés

Fermeture de compte individuelle
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]
  );
}

Ferme les comptes de tokens VIDES individuels et récupère 0.002 SOL de loyer par compte.

Fermeture massive de comptes vides
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;
}
✅ Traitement par lots sécurisé avec double vérification que les comptes sont vides.

Frais prioritaires pour une confirmation plus rapide

Ajouter des instructions de budget de calcul

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
  })
);
Les frais prioritaires aident à garantir une confirmation de transaction plus rapide pendant la congestion du réseau. Ajustez les microLamports en fonction des conditions actuelles du réseau.

Dépannage et problèmes courants

Échecs de transaction
  • Compte non vide : Vérifiez que le solde des tokens est exactement 0
  • Incohérence d'autorité : Assurez-vous que le portefeuille possède le compte
  • SOL insuffisant : Besoin de SOL pour les frais de transaction
  • Congestion du réseau : Ajoutez des frais prioritaires ou réessayez plus tard
Problèmes de RPC et de réseau
  • Limitation de débit : Ajoutez des délais entre les requêtes (1-2 secondes)
  • Erreurs de délai d'attente : Utilisez un fournisseur RPC fiable (Helius, QuickNode)
  • Blockhash expiré : Récupérez un blockhash récent
  • Erreurs 429 : Implémentez un backoff exponentiel
Conseils d'optimisation
  • Opérations par lots : Regroupez jusqu'à 20 comptes par transaction
  • Gestion des erreurs : Utilisez des blocs try/catch avec une logique de réessai
  • Filtres de compte : Pré-filtrez les comptes vides côté client
  • Tests : Testez toujours sur devnet d'abord
Alerte de sécurité - Décembre 2024 :

Les versions 1.95.6 et 1.95.7 de @solana/web3.js ont été compromises. Utilisez toujours la dernière version :

npm install @solana/web3.js@latest

Meilleures pratiques de sécurité et ressources

Mesures de sécurité critiques :
  • Tester toutes les opérations sur devnet d'abord
  • Utilisez des variables d'environnement pour les clés privées
  • Vérifiez les adresses de portefeuille avant exécution
  • Maintenez @solana/web3.js à jour avec la dernière version
  • Surveillez les transactions sur les explorateurs Solana
  • Utilisez des portefeuilles matériels pour de grandes quantités
  • Ne fermez jamais les comptes avec des soldes de tokens > 0
  • Vérifiez toujours deux fois l'état des comptes avant les opérations
Ressources officielles :

Pour les utilisateurs qui ne sont pas à l'aise avec le codage, des outils automatisés offrent des alternatives plus sûres :

  • SweepSOL : Récupération automatisée basée sur une interface graphique
  • Vérification professionnelle et contrôles de sécurité
  • Support technique et orientation
Utiliser l'outil SweepSOL
UnisolUnibot Recovery
Tous les Guides