Cleanup and add tests

Author: snawaz

test-integration/programs/schedulecommit/src/api.rs

@@ -180,17 +180,16 @@ pub fn schedule_commit_cpi_instruction(
     magic_context_id: Pubkey,
     players: &[Pubkey],
     committees: &[Pubkey],
+    commit_type: ScheduleCommitType,
 ) -> Instruction {
     schedule_commit_cpi_instruction_impl(
         payer,
         magic_program_id,
         magic_context_id,
         players,
         committees,
-        ScheduleCommitCpiInstructionImplArgs {
-            undelegate: false,
-            commit_payer: false,
-        },
+        false,
+        commit_type,
     )
 }
 
@@ -247,10 +246,8 @@ pub fn schedule_commit_with_payer_cpi_instruction(
         magic_context_id,
         players,
         committees,
-        ScheduleCommitCpiInstructionImplArgs {
-            undelegate: false,
-            commit_payer: true,
-        },
+        true,
+        ScheduleCommitType::Commit,
     )
 }
 
@@ -267,25 +264,19 @@ pub fn schedule_commit_and_undelegate_cpi_instruction(
         magic_context_id,
         players,
         committees,
-        ScheduleCommitCpiInstructionImplArgs {
-            undelegate: true,
-            commit_payer: false,
-        },
+        false,
+        ScheduleCommitType::CommitAndUndelegate,
     )
 }
 
-struct ScheduleCommitCpiInstructionImplArgs {
-    undelegate: bool,
-    commit_payer: bool,
-}
-
 fn schedule_commit_cpi_instruction_impl(
     payer: Pubkey,
     magic_program_id: Pubkey,
     magic_context_id: Pubkey,
     players: &[Pubkey],
     committees: &[Pubkey],
-    args: ScheduleCommitCpiInstructionImplArgs,
+    commit_payer: bool,
+    commit_type: ScheduleCommitType,
 ) -> Instruction {
     let program_id = crate::id();
     let mut account_metas = vec![
@@ -300,10 +291,10 @@ fn schedule_commit_cpi_instruction_impl(
     let cpi_args = ScheduleCommitCpiArgs {
         players: players.to_vec(),
         modify_accounts: true,
-        undelegate: args.undelegate,
-        commit_payer: args.commit_payer,
+        commit_payer,
     };
-    let ix = ScheduleCommitInstruction::ScheduleCommitCpi(cpi_args);
+    let ix =
+        ScheduleCommitInstruction::ScheduleCommitCpi(cpi_args, commit_type);
     Instruction::new_with_borsh(program_id, &ix, account_metas)
 }
 

test-integration/programs/schedulecommit/src/lib.rs

@@ -69,8 +69,6 @@ pub struct ScheduleCommitCpiArgs {
     pub players: Vec<Pubkey>,
     /// If true, the accounts will be modified after the commit
     pub modify_accounts: bool,
-    /// If true, the accounts will be undelegated after the commit
-    pub undelegate: bool,
     /// If true, also commit the payer account
     pub commit_payer: bool,
 }
@@ -99,7 +97,7 @@ pub enum ScheduleCommitInstruction {
     /// - **1**    `[]`              MagicContext (used to record scheduled commit)
     /// - **2**    `[]`              MagicBlock Program (used to schedule commit)
     /// - **3..n** `[]`              PDA accounts to be committed
-    ScheduleCommitCpi(ScheduleCommitCpiArgs),
+    ScheduleCommitCpi(ScheduleCommitCpiArgs, ScheduleCommitType),
 
     /// Same instruction input like [ScheduleCommitInstruction::ScheduleCommitCpi].
     /// Behavior differs that it will modify the accounts after it
@@ -165,11 +163,54 @@ pub enum ScheduleCommitInstruction {
 
 #[derive(BorshSerialize, BorshDeserialize, Debug, Clone, Copy)]
 pub enum ScheduleCommitType {
+    Commit,
     CommitAndUndelegate,
     CommitFinalize,
     CommitFinalizeAndUndelegate,
 }
 
+impl ScheduleCommitType {
+    fn invoke_commit<'a, 'info>(
+        self,
+        payer: &'a AccountInfo<'info>,
+        accounts: Vec<&'a AccountInfo<'info>>,
+        magic_context: &'a AccountInfo<'info>,
+        magic_program: &'a AccountInfo<'info>,
+    ) -> ProgramResult {
+        match self {
+            ScheduleCommitType::Commit => {
+                commit_accounts(payer, accounts, magic_context, magic_program)?;
+            }
+            ScheduleCommitType::CommitAndUndelegate => {
+                commit_and_undelegate_accounts(
+                    payer,
+                    accounts,
+                    magic_context,
+                    magic_program,
+                )?;
+            }
+            ScheduleCommitType::CommitFinalize => {
+                commit_finalize_accounts(
+                    payer,
+                    accounts,
+                    magic_context,
+                    magic_program,
+                )?;
+            }
+            ScheduleCommitType::CommitFinalizeAndUndelegate => {
+                commit_finalize_and_undelegate_accounts(
+                    payer,
+                    accounts,
+                    magic_context,
+                    magic_program,
+                )?;
+            }
+        };
+
+        Ok(())
+    }
+}
+
 pub fn process_instruction<'a>(
     program_id: &'a Pubkey,
     accounts: &'a [AccountInfo<'a>],
@@ -197,14 +238,14 @@ pub fn process_instruction<'a>(
     match ix {
         Init => process_init(program_id, accounts),
         DelegateCpi(args) => process_delegate_cpi(accounts, args),
-        ScheduleCommitCpi(args) => process_schedulecommit_cpi(
+        ScheduleCommitCpi(args, commit_type) => process_schedulecommit_cpi(
             accounts,
             &args.players,
             ProcessSchedulecommitCpiArgs {
                 modify_accounts: args.modify_accounts,
-                undelegate: args.undelegate,
                 commit_payer: args.commit_payer,
             },
+            commit_type,
         ),
         ScheduleCommitAndUndelegateCpiModAfter(players) => {
             process_schedulecommit_and_undelegation_cpi_with_mod_after(
@@ -469,32 +510,12 @@ pub fn process_schedulecommit_for_orderbook(
 
     assert_is_signer(payer, "payer")?;
 
-    match commit_type {
-        ScheduleCommitType::CommitAndUndelegate => {
-            commit_and_undelegate_accounts(
-                payer,
-                vec![order_book_account],
-                magic_context,
-                magic_program,
-            )?;
-        }
-        ScheduleCommitType::CommitFinalize => {
-            commit_finalize_accounts(
-                payer,
-                vec![order_book_account],
-                magic_context,
-                magic_program,
-            )?;
-        }
-        ScheduleCommitType::CommitFinalizeAndUndelegate => {
-            commit_finalize_and_undelegate_accounts(
-                payer,
-                vec![order_book_account],
-                magic_context,
-                magic_program,
-            )?;
-        }
-    };
+    commit_type.invoke_commit(
+        payer,
+        vec![order_book_account],
+        magic_context,
+        magic_program,
+    )?;
 
     Ok(())
 }
@@ -541,7 +562,6 @@ pub fn process_delegate_cpi(
 
 pub struct ProcessSchedulecommitCpiArgs {
     pub modify_accounts: bool,
-    pub undelegate: bool,
     pub commit_payer: bool,
 }
 
@@ -552,6 +572,7 @@ pub fn process_schedulecommit_cpi(
     accounts: &[AccountInfo],
     player_pubkeys: &[Pubkey],
     args: ProcessSchedulecommitCpiArgs,
+    commit_type: ScheduleCommitType,
 ) -> Result<(), ProgramError> {
     msg!("Processing schedulecommit_cpi instruction");
 
@@ -604,16 +625,12 @@ pub fn process_schedulecommit_cpi(
         committees.iter().map(|x| x.key).collect::<Vec<_>>()
     );
 
-    if args.undelegate {
-        commit_and_undelegate_accounts(
-            payer,
-            committees,
-            magic_context,
-            magic_program,
-        )?;
-    } else {
-        commit_accounts(payer, committees, magic_context, magic_program)?;
-    }
+    commit_type.invoke_commit(
+        payer,
+        committees,
+        magic_context,
+        magic_program,
+    )?;
 
     Ok(())
 }

test-integration/schedulecommit/test-scenarios/tests/02_commit_and_undelegate.rs

@@ -388,6 +388,9 @@ fn run_test_for_commit_huge_order_book_account(
 
         assert_one_committee_was_committed(&ctx, &res, true);
         match commit_type {
+            ScheduleCommitType::Commit => {
+                assert!(false);
+            }
             ScheduleCommitType::CommitFinalize => {
                 assert_one_committee_account_was_not_undelegated_on_chain(&ctx);
             }