Add Quasar port of allow-block-list-token transfer hook example

Port the ABL (Allow/Block List) token transfer hook program from Anchor
to Quasar. This program enforces allow/block lists on Token-2022 transfers.

All 7 instructions ported:
- init_mint: Creates Token-2022 mint with transfer hook, permanent delegate,
  metadata pointer, and embedded metadata (AB mode + threshold)
- init_config: Creates config PDA with authority
- attach_to_mint: Attaches transfer hook to an existing mint
- tx_hook: SPL transfer hook execute handler with allow/block/threshold logic
- init_wallet: Creates per-wallet allow/block entries
- remove_wallet: Removes wallet entries (closes PDA)
- change_mode: Changes mode via Token-2022 metadata update

Key Quasar patterns:
- Raw CPI for Token-2022 extension init (TransferHook, PermanentDelegate,
  MetadataPointer, InitializeMint2, TokenMetadata)
- Manual TLV parsing of Token-2022 metadata in tx_hook for mode detection
- ExtraAccountMetaList with AccountData seed (destination owner lookup)
- Direct lamport manipulation for account closing (remove_wallet)
- 8-byte instruction discriminators (required by SPL transfer hook interface)

Builds with quasar build (54.5 KB). State unit tests pass.

Author: mikemaccana-edwardbot

tokens/token-2022/transfer-hook/allow-block-list-token/quasar/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "quasar-abl-token"
+version = "0.1.0"
+edition = "2021"
+
+[workspace]
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+check-cfg = ['cfg(target_os, values("solana"))']
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[features]
+alloc = ["quasar-lang/alloc"]
+client = []
+debug = []
+
+[dependencies]
+quasar-lang = "0.0"
+quasar-spl = "0.0"
+solana-instruction = { version = "3.2.0" }
+
+[dev-dependencies]
+quasar-svm = { version = "0.1" }

tokens/token-2022/transfer-hook/allow-block-list-token/quasar/Quasar.toml

@@ -0,0 +1,18 @@
+[project]
+name = "quasar_abl_token"
+
+[toolchain]
+type = "solana"
+
+[testing]
+language = "rust"
+
+[testing.rust]
+framework = "quasar-svm"
+
+[testing.rust.test]
+program = "cargo"
+args = ["test", "tests::"]
+
+[clients]
+languages = ["rust"]

tokens/token-2022/transfer-hook/allow-block-list-token/quasar/src/constants.rs

@@ -0,0 +1,14 @@
+pub const META_LIST_ACCOUNT_SEED: &[u8] = b"extra-account-metas";
+pub const CONFIG_SEED: &[u8] = b"config";
+pub const AB_WALLET_SEED: &[u8] = b"ab_wallet";
+
+/// SHA-256("spl-transfer-hook-interface:execute")[:8]
+pub const EXECUTE_DISCRIMINATOR: [u8; 8] = [105, 37, 101, 197, 75, 251, 102, 26];
+
+/// Maximum lengths for metadata fields.
+pub const MAX_NAME: usize = 32;
+pub const MAX_SYMBOL: usize = 10;
+pub const MAX_URI: usize = 128;
+
+/// Maximum buffer size for Token-2022 metadata CPI instructions.
+pub const MAX_META_IX: usize = 512;

tokens/token-2022/transfer-hook/allow-block-list-token/quasar/src/errors.rs

@@ -0,0 +1,30 @@
+use quasar_lang::prelude::ProgramError;
+
+/// Custom error codes for the allow/block list program.
+/// Encoded as ProgramError::Custom(N).
+
+pub const ERROR_INVALID_METADATA: u32 = 6000;
+pub const ERROR_WALLET_NOT_ALLOWED: u32 = 6001;
+pub const ERROR_AMOUNT_NOT_ALLOWED: u32 = 6002;
+pub const ERROR_WALLET_BLOCKED: u32 = 6003;
+pub const ERROR_UNAUTHORIZED: u32 = 6004;
+
+pub fn invalid_metadata() -> ProgramError {
+    ProgramError::Custom(ERROR_INVALID_METADATA)
+}
+
+pub fn wallet_not_allowed() -> ProgramError {
+    ProgramError::Custom(ERROR_WALLET_NOT_ALLOWED)
+}
+
+pub fn amount_not_allowed() -> ProgramError {
+    ProgramError::Custom(ERROR_AMOUNT_NOT_ALLOWED)
+}
+
+pub fn wallet_blocked() -> ProgramError {
+    ProgramError::Custom(ERROR_WALLET_BLOCKED)
+}
+
+pub fn unauthorized() -> ProgramError {
+    ProgramError::Custom(ERROR_UNAUTHORIZED)
+}

tokens/token-2022/transfer-hook/allow-block-list-token/quasar/src/instructions/attach_to_mint.rs

@@ -0,0 +1,120 @@
+use quasar_lang::cpi::{CpiCall, InstructionAccount, Seed};
+use quasar_lang::prelude::*;
+use quasar_lang::sysvars::Sysvar;
+
+use crate::constants::*;
+use crate::instructions::init_mint::Token2022;
+
+#[derive(Accounts)]
+pub struct AttachToMint<'info> {
+    #[account(mut)]
+    pub payer: &'info Signer,
+    #[account(mut)]
+    pub mint: &'info UncheckedAccount,
+    #[account(mut)]
+    pub extra_metas_account: &'info mut UncheckedAccount,
+    pub system_program: &'info Program<System>,
+    pub token_program: &'info Program<Token2022>,
+}
+
+impl AttachToMint<'_> {
+    #[inline(always)]
+    pub fn attach_to_mint(&self) -> Result<(), ProgramError> {
+        let mint_key = self.mint.to_account_view().address();
+        let payer_key = self.payer.to_account_view().address();
+        let token_prog = self.token_program.to_account_view().address();
+
+        // TransferHookUpdate: opcode 36, sub-opcode 1
+        // Sets the transfer hook program_id on the mint.
+        let mut update_data = [0u8; 37];
+        update_data[0] = 36;
+        update_data[1] = 1; // Update sub-instruction
+        // COption<Pubkey>: 4 bytes discriminator (1 = Some) + 32 bytes pubkey
+        update_data[2..6].copy_from_slice(&1u32.to_le_bytes()); // Some
+        update_data[6..38 - 1].copy_from_slice(&crate::ID.as_ref()[..31]);
+        // Actually, COption encoding is: [1u8 if Some, 0 if None] but SPL uses 4 bytes
+        // Let me use the right encoding: just 1 byte bool then 32 byte address? No.
+        // SPL token uses: 1 byte discriminator (1=Some) followed by 32 bytes.
+        // But wait - the TransferHookUpdate instruction encoding for the optional program_id is:
+        //   COption: 4 bytes (0 = None, 1 = Some), then 32 bytes if Some.
+        // Total ix data = 2 (opcode + sub) + 4 + 32 = 38
+        // Let me redo this properly.
+        let mut update_data = [0u8; 38];
+        update_data[0] = 36;  // TransferHookExtension opcode
+        update_data[1] = 1;   // Update sub-instruction
+        update_data[2..6].copy_from_slice(&1u32.to_le_bytes()); // COption::Some
+        update_data[6..38].copy_from_slice(crate::ID.as_ref());
+
+        CpiCall::new(
+            token_prog,
+            [
+                InstructionAccount::writable(mint_key),
+                InstructionAccount::readonly_signer(payer_key),
+            ],
+            [
+                self.mint.to_account_view(),
+                self.payer.to_account_view(),
+            ],
+            update_data,
+        )
+        .invoke()?;
+
+        // Initialize the ExtraAccountMetaList PDA (same as in init_mint).
+        let meta_list_size: u64 = 51;
+        let lamports = Rent::get()?.try_minimum_balance(meta_list_size as usize)?;
+
+        let (expected_pda, bump) = Address::find_program_address(
+            &[META_LIST_ACCOUNT_SEED, mint_key.as_ref()],
+            &crate::ID,
+        );
+        if self.extra_metas_account.to_account_view().address() != &expected_pda {
+            return Err(ProgramError::InvalidSeeds);
+        }
+
+        let bump_bytes = [bump];
+        let seeds = [
+            Seed::from(META_LIST_ACCOUNT_SEED),
+            Seed::from(mint_key.as_ref()),
+            Seed::from(&bump_bytes as &[u8]),
+        ];
+
+        self.system_program
+            .create_account(
+                self.payer,
+                &*self.extra_metas_account,
+                lamports,
+                meta_list_size,
+                &crate::ID,
+            )
+            .invoke_signed(&seeds)?;
+
+        // Write ExtraAccountMeta TLV data
+        let view = unsafe {
+            &mut *(self.extra_metas_account as *const UncheckedAccount as *mut UncheckedAccount
+                as *mut AccountView)
+        };
+        let mut data = view.try_borrow_mut()?;
+
+        data[0..8].copy_from_slice(&EXECUTE_DISCRIMINATOR);
+        data[8..12].copy_from_slice(&39u32.to_le_bytes());
+        data[12..16].copy_from_slice(&1u32.to_le_bytes());
+
+        // ABWallet PDA: seeds = [Literal("ab_wallet"), AccountData(2, 32, 32)]
+        data[16] = 1; // PDA from seeds
+        let mut config = [0u8; 32];
+        config[0] = 2;  // 2 seeds
+        config[1] = 0;  // literal
+        config[2] = 9;  // length
+        config[3..12].copy_from_slice(AB_WALLET_SEED);
+        config[12] = 1; // account data
+        config[13] = 2; // account_index (destination token account)
+        config[14] = 32; // data_index
+        config[15] = 32; // length
+        data[17..49].copy_from_slice(&config);
+        data[49] = 0; // not signer
+        data[50] = 0; // not writable
+
+        log("Transfer hook attached to mint");
+        Ok(())
+    }
+}