Solana: Rent reduction and reclaiming excess rent

import {
  address,
  appendTransactionMessageInstructions,
  createKeyPairSignerFromBytes,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  createTransactionMessage,
  getSignatureFromTransaction,
  pipe,
  sendAndConfirmTransactionFactory,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  signTransactionMessageWithSigners,
} from "@solana/kit";
import { TOKEN_PROGRAM_ADDRESS, getWithdrawExcessLamportsInstruction } from "@solana-program/token";
import { TOKEN_2022_PROGRAM_ADDRESS } from "@solana-program/token-2022";
import { readFileSync } from "node:fs";

const rpc = createSolanaRpc("YOUR_CHAINSTACK_ENDPOINT");
const rpcSubscriptions = createSolanaRpcSubscriptions("YOUR_CHAINSTACK_WSS_ENDPOINT");

const keypairBytes = new Uint8Array(JSON.parse(readFileSync("YOUR_KEYPAIR_PATH", "utf8")));
const owner = await createKeyPairSignerFromBytes(keypairBytes);

// The current rent-exempt minimum for each account size.
const minimums = new Map();
async function minimumBalance(space) {
  if (!minimums.has(space)) {
    minimums.set(space, await rpc.getMinimumBalanceForRentExemption(space).send());
  }
  return minimums.get(space);
}

// Token accounts that the wallet owns, under both token programs.
const candidates = [];
for (const programId of [TOKEN_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS]) {
  const { value } = await rpc
    .getTokenAccountsByOwner(owner.address, { programId }, { encoding: "jsonParsed" })
    .send();
  for (const { pubkey, account } of value) {
    // Wrapped SOL accounts are not supported. Close them to recover their rent.
    if (account.data.parsed.info.isNative) continue;
    candidates.push({ source: pubkey, account });
  }
}

// Mints that the wallet is the mint authority of, passed as arguments.
for (const mint of process.argv.slice(2)) {
  const { value: account } = await rpc.getAccountInfo(address(mint), { encoding: "base64" }).send();
  candidates.push({ source: address(mint), account });
}

const instructions = [];
let total = 0n;
for (const { source, account } of candidates) {
  const excess = account.lamports - (await minimumBalance(account.space));
  if (excess <= 0n) continue;
  console.log(`${source}: ${excess} lamports`);
  total += excess;
  instructions.push(
    getWithdrawExcessLamportsInstruction(
      { source, destination: owner.address, authority: owner },
      { programAddress: account.owner },
    ),
  );
}
console.log(`Reclaimable: ${total} lamports from ${instructions.length} accounts`);

// Send up to 20 withdrawals per transaction.
const sendAndConfirm = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });
for (let i = 0; i < instructions.length; i += 20) {
  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
  const message = pipe(
    createTransactionMessage({ version: 0 }),
    (m) => setTransactionMessageFeePayerSigner(owner, m),
    (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),
    (m) => appendTransactionMessageInstructions(instructions.slice(i, i + 20), m),
  );
  const transaction = await signTransactionMessageWithSigners(message);
  await sendAndConfirm(transaction, { commitment: "confirmed" });
  console.log("Signature:", getSignatureFromTransaction(transaction));
}

// `vault` is a PDA owned by this program; `authority` receives the excess.
if vault.owner != program_id {
    return Err(ProgramError::IncorrectProgramId);
}
let minimum = Rent::get()?.minimum_balance(vault.data_len());
let excess = vault.lamports().saturating_sub(minimum);
**vault.try_borrow_mut_lamports()? -= excess;
**authority.try_borrow_mut_lamports()? += excess;
Ok(())