refactor: extract instruction handlers for memo-transfer, mint-close-authority, transfer-hook (account-data-as-seed, counter, hello-world)

Move instruction handlers into src/instructions/ directory following
Anchor 1.0 conventions. Shared types and helpers remain in lib.rs.

Author: mikemaccana-edwardbot

tokens/token-2022/memo-transfer/anchor/programs/memo-transfer/src/instructions/disable.rs

@@ -0,0 +1,27 @@
+use anchor_lang::prelude::*;
+use anchor_spl::token_interface::{memo_transfer_disable, MemoTransfer, Token2022, TokenAccount};
+
+#[derive(Accounts)]
+pub struct Disable<'info> {
+    #[account(mut)]
+    pub owner: Signer<'info>,
+
+    #[account(
+        mut,
+        token::authority = owner,
+    )]
+    pub token_account: InterfaceAccount<'info, TokenAccount>,
+    pub token_program: Program<'info, Token2022>,
+}
+
+pub fn handler(context: Context<Disable>) -> Result<()> {
+    memo_transfer_disable(CpiContext::new(
+        context.accounts.token_program.key(),
+        MemoTransfer {
+            token_program_id: context.accounts.token_program.to_account_info(),
+            account: context.accounts.token_account.to_account_info(),
+            owner: context.accounts.owner.to_account_info(),
+        },
+    ))?;
+    Ok(())
+}

tokens/token-2022/memo-transfer/anchor/programs/memo-transfer/src/instructions/initialize.rs

@@ -0,0 +1,67 @@
+use anchor_lang::prelude::*;
+use anchor_lang::system_program::{create_account, CreateAccount};
+use anchor_spl::{
+    token_2022::{
+        initialize_account3,
+        spl_token_2022::{extension::ExtensionType, pod::PodAccount},
+        InitializeAccount3,
+    },
+    token_interface::{memo_transfer_initialize, MemoTransfer, Mint, Token2022},
+};
+
+#[derive(Accounts)]
+pub struct Initialize<'info> {
+    #[account(mut)]
+    pub payer: Signer<'info>,
+
+    #[account(mut)]
+    pub token_account: Signer<'info>,
+    pub mint_account: InterfaceAccount<'info, Mint>,
+    pub token_program: Program<'info, Token2022>,
+    pub system_program: Program<'info, System>,
+}
+
+pub fn handler(context: Context<Initialize>) -> Result<()> {
+    // Calculate space required for token and extension data
+    let token_account_size =
+        ExtensionType::try_calculate_account_len::<PodAccount>(&[ExtensionType::MemoTransfer])?;
+
+    // Calculate minimum lamports required for size of token account with extensions
+    let lamports = (Rent::get()?).minimum_balance(token_account_size);
+
+    // Invoke System Program to create new account with space for token account and extension data
+    create_account(
+        CpiContext::new(
+            context.accounts.system_program.key(),
+            CreateAccount {
+                from: context.accounts.payer.to_account_info(),
+                to: context.accounts.token_account.to_account_info(),
+            },
+        ),
+        lamports,                          // Lamports
+        token_account_size as u64,         // Space
+        &context.accounts.token_program.key(), // Owner Program
+    )?;
+
+    // Initialize the standard token account data
+    initialize_account3(CpiContext::new(
+        context.accounts.token_program.key(),
+        InitializeAccount3 {
+            account: context.accounts.token_account.to_account_info(),
+            mint: context.accounts.mint_account.to_account_info(),
+            authority: context.accounts.payer.to_account_info(),
+        },
+    ))?;
+
+    // Initialize the memo transfer extension
+    // This instruction must come after the token account initialization
+    memo_transfer_initialize(CpiContext::new(
+        context.accounts.token_program.key(),
+        MemoTransfer {
+            token_program_id: context.accounts.token_program.to_account_info(),
+            account: context.accounts.token_account.to_account_info(),
+            owner: context.accounts.payer.to_account_info(),
+        },
+    ))?;
+    Ok(())
+}

tokens/token-2022/memo-transfer/anchor/programs/memo-transfer/src/instructions/mod.rs

@@ -0,0 +1,5 @@
+pub mod disable;
+pub mod initialize;
+
+pub use disable::*;
+pub use initialize::*;

tokens/token-2022/memo-transfer/anchor/programs/memo-transfer/src/lib.rs

@@ -1,16 +1,7 @@
 use anchor_lang::prelude::*;
-use anchor_lang::system_program::{create_account, CreateAccount};
-use anchor_spl::{
-    token_2022::{
-        initialize_account3,
-        spl_token_2022::{extension::ExtensionType, pod::PodAccount},
-        InitializeAccount3,
-    },
-    token_interface::{
-        memo_transfer_disable, memo_transfer_initialize, MemoTransfer, Mint, Token2022,
-        TokenAccount,
-    },
-};
+
+mod instructions;
+use instructions::*;
 
 declare_id!("5BQyC7y2Pc283woThq11uZRqsgcRbBRLKz4yQ8BJadi2");
 
@@ -19,84 +10,10 @@ pub mod memo_transfer {
     use super::*;
 
     pub fn initialize(context: Context<Initialize>) -> Result<()> {
-        // Calculate space required for token and extension data
-        let token_account_size =
-            ExtensionType::try_calculate_account_len::<PodAccount>(&[ExtensionType::MemoTransfer])?;
-
-        // Calculate minimum lamports required for size of token account with extensions
-        let lamports = (Rent::get()?).minimum_balance(token_account_size);
-
-        // Invoke System Program to create new account with space for token account and extension data
-        create_account(
-            CpiContext::new(
-                context.accounts.system_program.key(),
-                CreateAccount {
-                    from: context.accounts.payer.to_account_info(),
-                    to: context.accounts.token_account.to_account_info(),
-                },
-            ),
-            lamports,                          // Lamports
-            token_account_size as u64,         // Space
-            &context.accounts.token_program.key(), // Owner Program
-        )?;
-
-        // Initialize the standard token account data
-        initialize_account3(CpiContext::new(
-            context.accounts.token_program.key(),
-            InitializeAccount3 {
-                account: context.accounts.token_account.to_account_info(),
-                mint: context.accounts.mint_account.to_account_info(),
-                authority: context.accounts.payer.to_account_info(),
-            },
-        ))?;
-
-        // Initialize the memo transfer extension
-        // This instruction must come after the token account initialization
-        memo_transfer_initialize(CpiContext::new(
-            context.accounts.token_program.key(),
-            MemoTransfer {
-                token_program_id: context.accounts.token_program.to_account_info(),
-                account: context.accounts.token_account.to_account_info(),
-                owner: context.accounts.payer.to_account_info(),
-            },
-        ))?;
-        Ok(())
+        instructions::initialize::handler(context)
     }
 
     pub fn disable(context: Context<Disable>) -> Result<()> {
-        memo_transfer_disable(CpiContext::new(
-            context.accounts.token_program.key(),
-            MemoTransfer {
-                token_program_id: context.accounts.token_program.to_account_info(),
-                account: context.accounts.token_account.to_account_info(),
-                owner: context.accounts.owner.to_account_info(),
-            },
-        ))?;
-        Ok(())
+        instructions::disable::handler(context)
     }
 }
-
-#[derive(Accounts)]
-pub struct Initialize<'info> {
-    #[account(mut)]
-    pub payer: Signer<'info>,
-
-    #[account(mut)]
-    pub token_account: Signer<'info>,
-    pub mint_account: InterfaceAccount<'info, Mint>,
-    pub token_program: Program<'info, Token2022>,
-    pub system_program: Program<'info, System>,
-}
-
-#[derive(Accounts)]
-pub struct Disable<'info> {
-    #[account(mut)]
-    pub owner: Signer<'info>,
-
-    #[account(
-        mut,
-        token::authority = owner,
-    )]
-    pub token_account: InterfaceAccount<'info, TokenAccount>,
-    pub token_program: Program<'info, Token2022>,
-}

tokens/token-2022/mint-close-authority/anchor/programs/mint-close-authority/src/instructions/close.rs

@@ -0,0 +1,32 @@
+use anchor_lang::prelude::*;
+use anchor_spl::{
+    token_2022::{close_account, CloseAccount},
+    token_interface::{Mint, Token2022},
+};
+
+#[derive(Accounts)]
+pub struct Close<'info> {
+    #[account(mut)]
+    pub authority: Signer<'info>,
+
+    #[account(
+        mut,
+        extensions::close_authority::authority = authority,
+    )]
+    pub mint_account: InterfaceAccount<'info, Mint>,
+    pub token_program: Program<'info, Token2022>,
+}
+
+pub fn handler(context: Context<Close>) -> Result<()> {
+    // cpi to token extensions programs to close mint account
+    // alternatively, this can also be done in the client
+    close_account(CpiContext::new(
+        context.accounts.token_program.key(),
+        CloseAccount {
+            account: context.accounts.mint_account.to_account_info(),
+            destination: context.accounts.authority.to_account_info(),
+            authority: context.accounts.authority.to_account_info(),
+        },
+    ))?;
+    Ok(())
+}

tokens/token-2022/mint-close-authority/anchor/programs/mint-close-authority/src/instructions/initialize.rs

@@ -0,0 +1,50 @@
+use anchor_lang::prelude::*;
+use anchor_spl::token_interface::{
+    spl_pod::optional_keys::OptionalNonZeroPubkey,
+    spl_token_2022::{
+        extension::{
+            mint_close_authority::MintCloseAuthority, BaseStateWithExtensions,
+            StateWithExtensions,
+        },
+        state::Mint as MintState,
+    },
+    Mint, Token2022,
+};
+
+#[derive(Accounts)]
+pub struct Initialize<'info> {
+    #[account(mut)]
+    pub payer: Signer<'info>,
+
+    #[account(
+        init,
+        payer = payer,
+        mint::decimals = 2,
+        mint::authority = payer,
+        extensions::close_authority::authority = payer,
+    )]
+    pub mint_account: InterfaceAccount<'info, Mint>,
+    pub token_program: Program<'info, Token2022>,
+    pub system_program: Program<'info, System>,
+}
+
+pub fn handler(mut context: Context<Initialize>) -> Result<()> {
+    handle_check_mint_data(&mut context.accounts)?;
+    Ok(())
+}
+
+// helper to check mint data, and demonstrate how to read mint extension data within a program
+fn handle_check_mint_data(accounts: &mut Initialize) -> Result<()> {
+    let mint = &accounts.mint_account.to_account_info();
+    let mint_data = mint.data.borrow();
+    let mint_with_extension = StateWithExtensions::<MintState>::unpack(&mint_data)?;
+    let extension_data = mint_with_extension.get_extension::<MintCloseAuthority>()?;
+
+    assert_eq!(
+        extension_data.close_authority,
+        OptionalNonZeroPubkey::try_from(Some(accounts.payer.key()))?
+    );
+
+    msg!("{:?}", extension_data);
+    Ok(())
+}

tokens/token-2022/mint-close-authority/anchor/programs/mint-close-authority/src/instructions/mod.rs

@@ -0,0 +1,5 @@
+pub mod close;
+pub mod initialize;
+
+pub use close::*;
+pub use initialize::*;

tokens/token-2022/mint-close-authority/anchor/programs/mint-close-authority/src/lib.rs

@@ -1,87 +1,19 @@
 use anchor_lang::prelude::*;
-use anchor_spl::{
-    token_2022::{close_account, CloseAccount},
-    token_interface::{
-        spl_pod::optional_keys::OptionalNonZeroPubkey,
-        spl_token_2022::{
-            extension::{
-                mint_close_authority::MintCloseAuthority, BaseStateWithExtensions,
-                StateWithExtensions,
-            },
-            state::Mint as MintState,
-        },
-        Mint, Token2022,
-    },
-};
+
+mod instructions;
+use instructions::*;
+
 declare_id!("AcfQLsYKuzprcCNH1n96pKKgAbAnZchwpbr3gbVN742n");
 
 #[program]
 pub mod mint_close_authority {
     use super::*;
 
-    pub fn initialize(mut context: Context<Initialize>) -> Result<()> {
-        handle_check_mint_data(&mut context.accounts)?;
-        Ok(())
+    pub fn initialize(context: Context<Initialize>) -> Result<()> {
+        instructions::initialize::handler(context)
     }
 
     pub fn close(context: Context<Close>) -> Result<()> {
-        // cpi to token extensions programs to close mint account
-        // alternatively, this can also be done in the client
-        close_account(CpiContext::new(
-            context.accounts.token_program.key(),
-            CloseAccount {
-                account: context.accounts.mint_account.to_account_info(),
-                destination: context.accounts.authority.to_account_info(),
-                authority: context.accounts.authority.to_account_info(),
-            },
-        ))?;
-        Ok(())
+        instructions::close::handler(context)
     }
 }
-
-#[derive(Accounts)]
-pub struct Initialize<'info> {
-    #[account(mut)]
-    pub payer: Signer<'info>,
-
-    #[account(
-        init,
-        payer = payer,
-        mint::decimals = 2,
-        mint::authority = payer,
-        extensions::close_authority::authority = payer,
-    )]
-    pub mint_account: InterfaceAccount<'info, Mint>,
-    pub token_program: Program<'info, Token2022>,
-    pub system_program: Program<'info, System>,
-}
-
-// helper to check mint data, and demonstrate how to read mint extension data within a program
-pub fn handle_check_mint_data(accounts: &mut Initialize) -> Result<()> {
-        let mint = &accounts.mint_account.to_account_info();
-        let mint_data = mint.data.borrow();
-        let mint_with_extension = StateWithExtensions::<MintState>::unpack(&mint_data)?;
-        let extension_data = mint_with_extension.get_extension::<MintCloseAuthority>()?;
-
-        assert_eq!(
-            extension_data.close_authority,
-            OptionalNonZeroPubkey::try_from(Some(accounts.payer.key()))?
-        );
-
-        msg!("{:?}", extension_data);
-        Ok(())
-    }
-
-
-#[derive(Accounts)]
-pub struct Close<'info> {
-    #[account(mut)]
-    pub authority: Signer<'info>,
-
-    #[account(
-        mut,
-        extensions::close_authority::authority = authority,
-    )]
-    pub mint_account: InterfaceAccount<'info, Mint>,
-    pub token_program: Program<'info, Token2022>,
-}