refactor(tokens): convert impl blocks to free handle_* functions

All tokens examples (escrow, create-token, transfer-tokens, nft-minter,
nft-operations, spl-token-minter, token-swap, token-fundraiser,
external-delegate-token-master, pda-mint-authority) refactored.

For escrow: disambiguated handle_withdraw_tokens_and_close using
module-qualified paths (take:: and refund::) since both Take and Refund
had methods with the same name.

Author: mikemaccana-edwardbot

tokens/create-token/quasar/src/lib.rs

@@ -20,13 +20,13 @@ mod quasar_create_token {
     /// Create a new token mint (account init handled by Quasar's `#[account(init)]`).
     #[instruction(discriminator = 0)]
     pub fn create_token(ctx: Ctx<CreateToken>, _decimals: u8) -> Result<(), ProgramError> {
-        ctx.accounts.create_token()
+        handle_create_token(&mut ctx.accounts)
     }
 
     /// Mint tokens to the creator's token account.
     #[instruction(discriminator = 1)]
     pub fn mint_tokens(ctx: Ctx<MintTokens>, amount: u64) -> Result<(), ProgramError> {
-        ctx.accounts.mint_tokens(amount)
+        handle_mint_tokens(&mut ctx.accounts, amount)
     }
 }
 
@@ -43,12 +43,10 @@ pub struct CreateToken<'info> {
     pub system_program: &'info Program<System>,
 }
 
-impl CreateToken<'_> {
-    #[inline(always)]
-    pub fn create_token(&self) -> Result<(), ProgramError> {
-        // Mint account is created and initialised by Quasar's account init.
-        Ok(())
-    }
+#[inline(always)]
+pub fn handle_create_token(accounts: &CreateToken) -> Result<(), ProgramError> {
+    // Mint account is created and initialised by Quasar's account init.
+    Ok(())
 }
 
 /// Accounts for minting tokens to an existing token account.
@@ -63,11 +61,9 @@ pub struct MintTokens<'info> {
     pub token_program: &'info Program<Token>,
 }
 
-impl MintTokens<'_> {
-    #[inline(always)]
-    pub fn mint_tokens(&mut self, amount: u64) -> Result<(), ProgramError> {
-        self.token_program
-            .mint_to(self.mint, self.token_account, self.authority, amount)
-            .invoke()
-    }
+#[inline(always)]
+pub fn handle_mint_tokens(accounts: &mut MintTokens, amount: u64) -> Result<(), ProgramError> {
+    accounts.token_program
+        .mint_to(accounts.mint, accounts.token_account, accounts.authority, amount)
+        .invoke()
 }

tokens/escrow/quasar/src/instructions/make.rs

@@ -23,24 +23,22 @@ pub struct Make<'info> {
     pub system_program: &'info Program<System>,
 }
 
-impl Make<'_> {
-    #[inline(always)]
-    pub fn make_escrow(&mut self, receive: u64, bumps: &MakeBumps) -> Result<(), ProgramError> {
-        self.escrow.set_inner(
-            *self.maker.address(),
-            *self.mint_a.address(),
-            *self.mint_b.address(),
-            *self.maker_ta_b.address(),
-            receive,
-            bumps.escrow,
-        );
-        Ok(())
-    }
+#[inline(always)]
+pub fn handle_make_escrow(accounts: &mut Make, receive: u64, bumps: &MakeBumps) -> Result<(), ProgramError> {
+    accounts.escrow.set_inner(
+        *accounts.maker.address(),
+        *accounts.mint_a.address(),
+        *accounts.mint_b.address(),
+        *accounts.maker_ta_b.address(),
+        receive,
+        bumps.escrow,
+    );
+    Ok(())
+}
 
-    #[inline(always)]
-    pub fn deposit_tokens(&mut self, amount: u64) -> Result<(), ProgramError> {
-        self.token_program
-            .transfer(self.maker_ta_a, self.vault_ta_a, self.maker, amount)
-            .invoke()
-    }
+#[inline(always)]
+pub fn handle_deposit_tokens(accounts: &mut Make, amount: u64) -> Result<(), ProgramError> {
+    accounts.token_program
+        .transfer(accounts.maker_ta_a, accounts.vault_ta_a, accounts.maker, amount)
+        .invoke()
 }

tokens/escrow/quasar/src/instructions/refund.rs

@@ -26,29 +26,27 @@ pub struct Refund<'info> {
     pub system_program: &'info Program<System>,
 }
 
-impl Refund<'_> {
-    #[inline(always)]
-    pub fn withdraw_tokens_and_close(&mut self, bumps: &RefundBumps) -> Result<(), ProgramError> {
-        let maker_key = self.escrow.maker;
-        let bump = [bumps.escrow];
-        let seeds: &[Seed] = &[
-            Seed::from(b"escrow" as &[u8]),
-            Seed::from(maker_key.as_ref()),
-            Seed::from(&bump as &[u8]),
-        ];
+#[inline(always)]
+pub fn handle_withdraw_tokens_and_close(accounts: &mut Refund, bumps: &RefundBumps) -> Result<(), ProgramError> {
+    let maker_key = accounts.escrow.maker;
+    let bump = [bumps.escrow];
+    let seeds: &[Seed] = &[
+        Seed::from(b"escrow" as &[u8]),
+        Seed::from(maker_key.as_ref()),
+        Seed::from(&bump as &[u8]),
+    ];
 
-        self.token_program
-            .transfer(
-                self.vault_ta_a,
-                self.maker_ta_a,
-                self.escrow,
-                self.vault_ta_a.amount(),
-            )
-            .invoke_signed(seeds)?;
+    accounts.token_program
+        .transfer(
+            accounts.vault_ta_a,
+            accounts.maker_ta_a,
+            accounts.escrow,
+            accounts.vault_ta_a.amount(),
+        )
+        .invoke_signed(seeds)?;
 
-        self.token_program
-            .close_account(self.vault_ta_a, self.maker, self.escrow)
-            .invoke_signed(seeds)?;
-        Ok(())
-    }
+    accounts.token_program
+        .close_account(accounts.vault_ta_a, accounts.maker, accounts.escrow)
+        .invoke_signed(seeds)?;
+    Ok(())
 }

tokens/escrow/quasar/src/instructions/take.rs

@@ -35,41 +35,39 @@ pub struct Take<'info> {
     pub system_program: &'info Program<System>,
 }
 
-impl Take<'_> {
-    #[inline(always)]
-    pub fn transfer_tokens(&mut self) -> Result<(), ProgramError> {
-        self.token_program
-            .transfer(
-                self.taker_ta_b,
-                self.maker_ta_b,
-                self.taker,
-                self.escrow.receive,
-            )
-            .invoke()
-    }
+#[inline(always)]
+pub fn handle_transfer_tokens(accounts: &mut Take) -> Result<(), ProgramError> {
+    accounts.token_program
+        .transfer(
+            accounts.taker_ta_b,
+            accounts.maker_ta_b,
+            accounts.taker,
+            accounts.escrow.receive,
+        )
+        .invoke()
+}
 
-    #[inline(always)]
-    pub fn withdraw_tokens_and_close(&mut self, bumps: &TakeBumps) -> Result<(), ProgramError> {
-        let maker_key = self.escrow.maker;
-        let bump = [bumps.escrow];
-        let seeds: &[Seed] = &[
-            Seed::from(b"escrow" as &[u8]),
-            Seed::from(maker_key.as_ref()),
-            Seed::from(&bump as &[u8]),
-        ];
+#[inline(always)]
+pub fn handle_withdraw_tokens_and_close(accounts: &mut Take, bumps: &TakeBumps) -> Result<(), ProgramError> {
+    let maker_key = accounts.escrow.maker;
+    let bump = [bumps.escrow];
+    let seeds: &[Seed] = &[
+        Seed::from(b"escrow" as &[u8]),
+        Seed::from(maker_key.as_ref()),
+        Seed::from(&bump as &[u8]),
+    ];
 
-        self.token_program
-            .transfer(
-                self.vault_ta_a,
-                self.taker_ta_a,
-                self.escrow,
-                self.vault_ta_a.amount(),
-            )
-            .invoke_signed(seeds)?;
+    accounts.token_program
+        .transfer(
+            accounts.vault_ta_a,
+            accounts.taker_ta_a,
+            accounts.escrow,
+            accounts.vault_ta_a.amount(),
+        )
+        .invoke_signed(seeds)?;
 
-        self.token_program
-            .close_account(self.vault_ta_a, self.taker, self.escrow)
-            .invoke_signed(seeds)?;
-        Ok(())
-    }
+    accounts.token_program
+        .close_account(accounts.vault_ta_a, accounts.taker, accounts.escrow)
+        .invoke_signed(seeds)?;
+    Ok(())
 }

tokens/escrow/quasar/src/lib.rs

@@ -19,18 +19,18 @@ mod quasar_escrow {
 
     #[instruction(discriminator = 0)]
     pub fn make(ctx: Ctx<Make>, deposit: u64, receive: u64) -> Result<(), ProgramError> {
-        ctx.accounts.make_escrow(receive, &ctx.bumps)?;
-        ctx.accounts.deposit_tokens(deposit)
+        instructions::handle_make_escrow(&mut ctx.accounts, receive, &ctx.bumps)?;
+        instructions::handle_deposit_tokens(&mut ctx.accounts, deposit)
     }
 
     #[instruction(discriminator = 1)]
     pub fn take(ctx: Ctx<Take>) -> Result<(), ProgramError> {
-        ctx.accounts.transfer_tokens()?;
-        ctx.accounts.withdraw_tokens_and_close(&ctx.bumps)
+        instructions::handle_transfer_tokens(&mut ctx.accounts)?;
+        instructions::take::handle_withdraw_tokens_and_close(&mut ctx.accounts, &ctx.bumps)
     }
 
     #[instruction(discriminator = 2)]
     pub fn refund(ctx: Ctx<Refund>) -> Result<(), ProgramError> {
-        ctx.accounts.withdraw_tokens_and_close(&ctx.bumps)
+        instructions::refund::handle_withdraw_tokens_and_close(&mut ctx.accounts, &ctx.bumps)
     }
 }