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

All 15 basics examples refactored to use free functions instead of
impl methods on Accounts structs. Pattern: handle_{method_name}(accounts, ...)
replaces self.method_name(...) on impl blocks.

Author: mikemaccana-edwardbot

basics/account-data/quasar/src/instructions/create.rs

@@ -15,22 +15,19 @@ pub struct CreateAddressInfo<'info> {
     pub system_program: &'info Program<System>,
 }
 
-impl<'info> CreateAddressInfo<'info> {
-    #[inline(always)]
-    pub fn create_address_info(
-        &mut self,
-        name: &str,
-        house_number: u8,
-        street: &str,
-        city: &str,
-    ) -> Result<(), ProgramError> {
-        self.address_info.set_inner(
-            house_number,
-            name,
-            street,
-            city,
-            self.payer.to_account_view(),
-            None,
-        )
-    }
+#[inline(always)]
+pub fn handle_create_address_info(
+    accounts: &mut CreateAddressInfo, name: &str,
+    house_number: u8,
+    street: &str,
+    city: &str,
+) -> Result<(), ProgramError> {
+    accounts.address_info.set_inner(
+        house_number,
+        name,
+        street,
+        city,
+        accounts.payer.to_account_view(),
+        None,
+    )
 }

basics/account-data/quasar/src/lib.rs

@@ -30,6 +30,6 @@ mod quasar_account_data {
         street: String,
         city: String,
     ) -> Result<(), ProgramError> {
-        ctx.accounts.create_address_info(name, house_number, street, city)
+        instructions::handle_create_address_info(&mut ctx.accounts, name, house_number, street, city)
     }
 }

basics/checking-accounts/quasar/src/instructions/check_accounts.rs

@@ -21,11 +21,9 @@ pub struct CheckAccounts<'info> {
     pub system_program: &'info Program<System>,
 }
 
-impl<'info> CheckAccounts<'info> {
-    #[inline(always)]
-    pub fn check_accounts(&self) -> Result<(), ProgramError> {
-        // All validation happens declaratively via the account types above.
-        // If any check fails, the runtime rejects the transaction before this runs.
-        Ok(())
-    }
+#[inline(always)]
+pub fn handle_check_accounts(accounts: &CheckAccounts) -> Result<(), ProgramError> {
+    // All validation happens declaratively via the account types above.
+    // If any check fails, the runtime rejects the transaction before this runs.
+    Ok(())
 }

basics/checking-accounts/quasar/src/lib.rs

@@ -19,6 +19,6 @@ mod quasar_checking_accounts {
     /// - Program<System>: checks account is executable and is the system program
     #[instruction(discriminator = 0)]
     pub fn check_accounts(ctx: Ctx<CheckAccounts>) -> Result<(), ProgramError> {
-        ctx.accounts.check_accounts()
+        instructions::handle_check_accounts(&mut ctx.accounts)
     }
 }

basics/close-account/quasar/src/instructions/close_user.rs

@@ -15,9 +15,7 @@ pub struct CloseUser<'info> {
     pub user_account: Account<UserState<'info>>,
 }
 
-impl<'info> CloseUser<'info> {
-    #[inline(always)]
-    pub fn close_user(&mut self) -> Result<(), ProgramError> {
-        self.user_account.close(self.user.to_account_view())
-    }
+#[inline(always)]
+pub fn handle_close_user(accounts: &mut CloseUser) -> Result<(), ProgramError> {
+    accounts.user_account.close(accounts.user.to_account_view())
 }

basics/close-account/quasar/src/instructions/create_user.rs

@@ -13,16 +13,14 @@ pub struct CreateUser<'info> {
     pub system_program: &'info Program<System>,
 }
 
-impl<'info> CreateUser<'info> {
-    #[inline(always)]
-    pub fn create_user(&mut self, name: &str, bump: u8) -> Result<(), ProgramError> {
-        let user_address = *self.user.to_account_view().address();
-        self.user_account.set_inner(
-            bump,
-            user_address,
-            name,
-            self.user.to_account_view(),
-            None,
-        )
-    }
+#[inline(always)]
+pub fn handle_create_user(accounts: &mut CreateUser, name: &str, bump: u8) -> Result<(), ProgramError> {
+    let user_address = *accounts.user.to_account_view().address();
+    accounts.user_account.set_inner(
+        bump,
+        user_address,
+        name,
+        accounts.user.to_account_view(),
+        None,
+    )
 }

basics/close-account/quasar/src/lib.rs

@@ -18,12 +18,12 @@ mod quasar_close_account {
     #[instruction(discriminator = 0)]
     pub fn create_user(ctx: Ctx<CreateUser>, name: String) -> Result<(), ProgramError> {
         let bump = ctx.bumps.user_account;
-        ctx.accounts.create_user(name, bump)
+        instructions::handle_create_user(&mut ctx.accounts, name, bump)
     }
 
     /// Close a user account and return lamports to the user.
     #[instruction(discriminator = 1)]
     pub fn close_user(ctx: Ctx<CloseUser>) -> Result<(), ProgramError> {
-        ctx.accounts.close_user()
+        instructions::handle_close_user(&mut ctx.accounts)
     }
 }

basics/counter/quasar/src/instructions/increment.rs

@@ -10,11 +10,9 @@ pub struct Increment<'info> {
     pub counter: &'info mut Account<Counter>,
 }
 
-impl<'info> Increment<'info> {
-    #[inline(always)]
-    pub fn increment(&mut self) -> Result<(), ProgramError> {
-        let current: u64 = self.counter.count.into();
-        self.counter.count = PodU64::from(current.checked_add(1).unwrap());
-        Ok(())
-    }
+#[inline(always)]
+pub fn handle_increment(accounts: &mut Increment) -> Result<(), ProgramError> {
+    let current: u64 = accounts.counter.count.into();
+    accounts.counter.count = PodU64::from(current.checked_add(1).unwrap());
+    Ok(())
 }

basics/counter/quasar/src/instructions/initialize_counter.rs

@@ -14,10 +14,8 @@ pub struct InitializeCounter<'info> {
     pub system_program: &'info Program<System>,
 }
 
-impl<'info> InitializeCounter<'info> {
-    #[inline(always)]
-    pub fn initialize_counter(&mut self) -> Result<(), ProgramError> {
-        self.counter.set_inner(0u64);
-        Ok(())
-    }
+#[inline(always)]
+pub fn handle_initialize_counter(accounts: &mut InitializeCounter) -> Result<(), ProgramError> {
+    accounts.counter.set_inner(0u64);
+    Ok(())
 }

basics/counter/quasar/src/lib.rs

@@ -16,11 +16,11 @@ mod quasar_counter {
 
     #[instruction(discriminator = 0)]
     pub fn initialize_counter(ctx: Ctx<InitializeCounter>) -> Result<(), ProgramError> {
-        ctx.accounts.initialize_counter()
+        instructions::handle_initialize_counter(&mut ctx.accounts)
     }
 
     #[instruction(discriminator = 1)]
     pub fn increment(ctx: Ctx<Increment>) -> Result<(), ProgramError> {
-        ctx.accounts.increment()
+        instructions::handle_increment(&mut ctx.accounts)
     }
 }