fix(allow-block-list-token): address review feedback on kit migration

- remove_wallet.rs: declare ab_wallet's PDA seeds (seeds = [AB_WALLET_SEED,
  wallet.key()]) instead of requiring the caller to pre-derive and pass the
  PDA directly, so getRemoveWalletInstructionAsync({ authority, wallet })
  resolves it the same way getInitWalletInstructionAsync already does.
  Also aligns config's seeds with the CONFIG_SEED constant, matching
  init_wallet.rs. Regenerated the IDL/client and simplified the two
  frontend callers (removeWallet, processBatchWallets) accordingly.
- Bump @solana/kit and @solana/program-client-core to ^7.1.0 (both the
  app's own deps and the generated client's peerDependencies, via a new
  dependencyVersions option on the codama renderVisitor call) and
  @solana-program/token-2022 to ^0.15.0.
- cluster-data-access.tsx: drop useClusterRpc/deriveWebsocketUrl in favor
  of @solana/connector's useSolanaClient across every consumer, and fix
  addCluster's endpoint validation, which silently accepted any string -
  createSolanaRpc doesn't parse its endpoint eagerly despite a comment
  claiming otherwise. new URL(endpoint) is the actual check.
- use-send-instruction.ts: adopt @solana/connector's useTransactionPreparer
  for blockhash + simulation-derived compute unit limit, sourcing
  rpc/rpcSubscriptions for the send-and-confirm step from useSolanaClient
  instead of the removed custom hook. (client.sendAndConfirmTransaction,
  suggested in review, doesn't actually exist in the installed - and
  latest published - @solana/connector@0.2.6, despite one JSDoc example;
  kept sendAndConfirmTransactionFactory from kit for that step.)
- account-data-access.tsx: useSendTokens now resolves the transfer-hook's
  extra accounts via @solana-program/token-2022's
  getTransferCheckedWithTransferHookInstructionAsync (reads the mint's
  on-chain extra-account-metas list) instead of hardcoding this program's
  ab_wallet PDA convention client-side. useRequestAirdrop now uses kit's
  airdropFactory, which confirms the airdrop instead of returning
  immediately after requesting it. useTransferSol now checks
  signer.address against the viewed account instead of silently signing
  with a possibly-different connected wallet than the page's address.
  (useGetBalance/useGetTokenAccounts/useGetSignatures stay on a
  cluster-scoped RPC call, not connector's useBalance/useTokens/
  useTransactions - those hooks are scoped to the connected wallet only
  and don't take an address, so they can't back the generic
  /account/[address] page, which needs to read arbitrary addresses.)
- abl-token-data-access.tsx: fixed transferHookAuthority being set to
  mintAuthority instead of the form's own transferHookAuthority field (a
  legacy bug predating this migration). mintTo now uses
  getMintToATAInstructionPlanAsync + flattenInstructionPlan instead of
  manually assembling the create-ATA and mint-to instructions.
- Added anchor/tests/basic.test.ts: LiteSVM-backed tests exercising the
  generated Kit client directly (init_config, init_wallet, the new
  seeds-based remove_wallet, and an authority-mismatch rejection case).
  This project's `anchor test` has no local-validator step to test
  against - its Anchor.toml [scripts] test command fully replaces
  Anchor's normal build+validator+deploy flow - so a real RPC connection
  isn't available; LiteSVM gives the TS client something real to run
  against without one. The old placeholder test never actually exercised
  anything.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: Harsh-H-Shah

tokens/token-2022/transfer-hook/allow-block-list-token/anchor/programs/abl-token/src/instructions/remove_wallet.rs

@@ -1,22 +1,26 @@
 use anchor_lang::prelude::*;
 
-use crate::{ABWallet, Config};
+use crate::{ABWallet, Config, AB_WALLET_SEED, CONFIG_SEED};
 
 #[derive(Accounts)]
 pub struct RemoveWallet<'info> {
     #[account(mut)]
     pub authority: Signer<'info>,
 
     #[account(
-        seeds = [b"config"],
+        seeds = [CONFIG_SEED],
         bump = config.bump,
         has_one = authority,
     )]
     pub config: Box<Account<'info, Config>>,
 
+    pub wallet: SystemAccount<'info>,
+
     #[account(
         mut,
         close = authority,
+        seeds = [AB_WALLET_SEED, wallet.key().as_ref()],
+        bump,
     )]
     pub ab_wallet: Account<'info, ABWallet>,
 

tokens/token-2022/transfer-hook/allow-block-list-token/anchor/tests/basic.test.ts

@@ -1,14 +1,139 @@
-import type { Program } from '@anchor-lang/core';
-import * as anchor from '@anchor-lang/core';
-import type { AblToken } from '../target/types/abl_token';
+import * as path from 'node:path';
+import {
+    appendTransactionMessageInstructions,
+    createTransactionMessage,
+    generateKeyPairSigner,
+    lamports,
+    pipe,
+    setTransactionMessageFeePayerSigner,
+    signTransactionMessageWithSigners,
+    type Instruction,
+    type KeyPairSigner,
+} from '@solana/kit';
+import { assert } from 'chai';
+import { FailedTransactionMetadata, LiteSVM } from 'litesvm';
+import { decodeABWallet } from '../../src/generated/accounts/aBWallet';
+import { decodeConfig } from '../../src/generated/accounts/config';
+import {
+    getInitConfigInstructionAsync,
+    getInitWalletInstructionAsync,
+    getRemoveWalletInstructionAsync,
+} from '../../src/generated/instructions';
+import { findAbWalletPda, findConfigPda } from '../../src/generated/pdas';
+import { ABL_TOKEN_PROGRAM_ADDRESS } from '../../src/generated/programs';
 
-describe('abl-token', () => {
-    // Configure the client to use the local cluster.
-    anchor.setProvider(anchor.AnchorProvider.env());
+// The Codama-generated Kit client is what the webapp actually talks to, so these tests
+// exercise it directly against a LiteSVM instance loaded with the built program - proving
+// the generated instruction builders, PDA derivation, and account decoders are wired up
+// correctly, which the Rust-side unit/litesvm tests (which never touch the TS client) don't
+// cover. There's no local validator available in this project's `anchor test` flow (the
+// custom [scripts] test command replaces Anchor's normal build+validator+deploy pipeline
+// entirely), so a real RPC connection isn't an option here.
+const PROGRAM_SO = path.join(__dirname, '..', 'target', 'deploy', 'abl_token.so');
 
-    const _program = anchor.workspace.ABLToken as Program<AblToken>;
+describe('abl-token (Kit client, via LiteSVM)', () => {
+    let svm: LiteSVM;
+    let authority: KeyPairSigner;
 
-    it('should run the program', async () => {
-        // Add your test here.
+    before(async () => {
+        svm = new LiteSVM();
+        svm.addProgramFromFile(ABL_TOKEN_PROGRAM_ADDRESS, PROGRAM_SO);
+        authority = await generateKeyPairSigner();
+        svm.airdrop(authority.address, lamports(BigInt(10_000_000_000)));
+    });
+
+    async function send(instructions: Instruction | Instruction[], payer: KeyPairSigner = authority) {
+        const transactionMessage = pipe(
+            createTransactionMessage({ version: 0 }),
+            m => setTransactionMessageFeePayerSigner(payer, m),
+            m => svm.setTransactionMessageLifetimeUsingLatestBlockhash(m),
+            m => appendTransactionMessageInstructions(Array.isArray(instructions) ? instructions : [instructions], m),
+        );
+        const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
+        const result = svm.sendTransaction(signedTransaction);
+        if (result instanceof FailedTransactionMetadata) {
+            throw new Error(`Transaction failed: ${result.toString()}`);
+        }
+        return result;
+    }
+
+    it('initializes the config, owned by the payer', async () => {
+        const ix = await getInitConfigInstructionAsync(
+            { payer: authority },
+            { programAddress: ABL_TOKEN_PROGRAM_ADDRESS },
+        );
+        await send(ix);
+
+        const [configPda] = await findConfigPda({ programAddress: ABL_TOKEN_PROGRAM_ADDRESS });
+        const account = svm.getAccount(configPda);
+        if (!account?.exists) throw new Error('Config account not found');
+
+        const config = decodeConfig({ ...account, address: configPda });
+        assert.equal(config.data.authority, authority.address);
+    });
+
+    it('adds a wallet to the list, then removes it by wallet address alone', async () => {
+        const wallet = await generateKeyPairSigner();
+
+        const initIx = await getInitWalletInstructionAsync(
+            { authority, wallet: wallet.address, allowed: true },
+            { programAddress: ABL_TOKEN_PROGRAM_ADDRESS },
+        );
+        await send(initIx);
+
+        const [abWalletPda] = await findAbWalletPda(
+            { wallet: wallet.address },
+            { programAddress: ABL_TOKEN_PROGRAM_ADDRESS },
+        );
+        const created = svm.getAccount(abWalletPda);
+        if (!created?.exists) throw new Error('ab_wallet account was not created');
+
+        const decoded = decodeABWallet({ ...created, address: abWalletPda });
+        assert.equal(decoded.data.wallet, wallet.address);
+        assert.isTrue(decoded.data.allowed);
+
+        // `getRemoveWalletInstructionAsync` used to require the caller to pre-derive and pass
+        // the `ab_wallet` PDA by hand; now that the Rust account declares its own seeds, it
+        // resolves `ab_wallet` from `wallet` the same way `getInitWalletInstructionAsync` does.
+        const removeIx = await getRemoveWalletInstructionAsync(
+            { authority, wallet: wallet.address },
+            { programAddress: ABL_TOKEN_PROGRAM_ADDRESS },
+        );
+        await send(removeIx);
+
+        const closed = svm.getAccount(abWalletPda);
+        assert.isTrue(!closed?.exists || closed.data.length === 0, 'ab_wallet account should be closed');
+    });
+
+    it('rejects removing a wallet for a caller who is not the config authority', async () => {
+        const wallet = await generateKeyPairSigner();
+        const initIx = await getInitWalletInstructionAsync(
+            { authority, wallet: wallet.address, allowed: false },
+            { programAddress: ABL_TOKEN_PROGRAM_ADDRESS },
+        );
+        await send(initIx);
+
+        const impostor = await generateKeyPairSigner();
+        svm.airdrop(impostor.address, lamports(BigInt(10_000_000_000)));
+
+        const removeIx = await getRemoveWalletInstructionAsync(
+            { authority: impostor, wallet: wallet.address },
+            { programAddress: ABL_TOKEN_PROGRAM_ADDRESS },
+        );
+
+        let threw = false;
+        try {
+            await send(removeIx, impostor);
+        } catch {
+            threw = true;
+        }
+        assert.isTrue(threw, 'expected the has_one authority check to reject a non-authority caller');
+
+        const [abWalletPda] = await findAbWalletPda(
+            { wallet: wallet.address },
+            { programAddress: ABL_TOKEN_PROGRAM_ADDRESS },
+        );
+        const stillThere = svm.getAccount(abWalletPda);
+        if (!stillThere?.exists) throw new Error('ab_wallet account should still exist');
     });
 });

tokens/token-2022/transfer-hook/allow-block-list-token/idl/abl_token.json

@@ -364,9 +364,34 @@
             ]
           }
         },
+        {
+          "name": "wallet"
+        },
         {
           "name": "ab_wallet",
-          "writable": true
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  97,
+                  98,
+                  95,
+                  119,
+                  97,
+                  108,
+                  108,
+                  101,
+                  116
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "wallet"
+              }
+            ]
+          }
         },
         {
           "name": "system_program",

tokens/token-2022/transfer-hook/allow-block-list-token/package.json

@@ -26,10 +26,11 @@
         "@radix-ui/react-label": "^2.1.7",
         "@radix-ui/react-slot": "^1.2.3",
         "@solana-program/system": "^0.13.0",
-        "@solana-program/token-2022": "^0.14.1",
+        "@solana-program/token-2022": "^0.15.0",
         "@solana/connector": "^0.2.6",
-        "@solana/kit": "^7.0.0",
-        "@solana/program-client-core": "^7.0.0",
+        "@solana/instruction-plans": "^7.1.0",
+        "@solana/kit": "^7.1.0",
+        "@solana/program-client-core": "^7.1.0",
         "@solana/web3.js": "^1.98.4",
         "@tanstack/react-query": "^5.82.0",
         "class-variance-authority": "^0.7.1",
@@ -58,6 +59,7 @@
         "codama": "^1.10.0",
         "eslint": "^9.25.1",
         "eslint-config-next": "15.3.1",
+        "litesvm": "^1.3.0",
         "mocha": "^11.7.5",
         "prettier": "^3.5.3",
         "tailwindcss": "^4.1.4",