fix

Author: snawaz

magicblock-api/src/tickers.rs

@@ -22,7 +22,6 @@ use tokio_util::sync::CancellationToken;
 
 use crate::slot::advance_slot_and_update_ledger;
 
-// ER chain
 pub fn init_slot_ticker<C: ScheduledCommitsProcessor>(
     accountsdb: Arc<AccountsDb>,
     committor_processor: &Option<Arc<C>>,
@@ -80,7 +79,6 @@ pub fn init_slot_ticker<C: ScheduledCommitsProcessor>(
     })
 }
 
-// ER chain
 async fn handle_scheduled_commits<C: ScheduledCommitsProcessor>(
     committor_processor: &Arc<C>,
     transaction_scheduler: &TransactionSchedulerHandle,

magicblock-committor-program/src/instruction.rs

@@ -1,8 +1,6 @@
 use borsh::{BorshDeserialize, BorshSerialize};
 use solana_pubkey::Pubkey;
 
-// this is deployed on Base chain as user-program
-
 #[derive(BorshSerialize, BorshDeserialize, Debug, Clone)]
 pub enum CommittorInstruction {
     /// Initializes the buffer and [Chunks] accounts which will be used to

magicblock-committor-service/src/intent_executor/single_stage_executor.rs

@@ -62,8 +62,6 @@ where
                 Err(err) => err,
             };
 
-            error!("execution_err: {}", execution_err);
-
             // Attempt patching
             let flow = self
                 .patch_strategy(
@@ -81,7 +79,6 @@ where
                     cleanup
                 }
                 ControlFlow::Break(()) => {
-                    info!("base_intent: {:?}", base_intent);
                     error!("Could not patch failed intent: {}", base_intent.id);
                     break (execution_err, transaction_strategy);
                 }

magicblock-committor-service/src/service.rs

@@ -30,8 +30,6 @@ pub struct LookupTables {
     pub released: Vec<Pubkey>,
 }
 
-// this is a part of ER.. and communicates with Base chain
-
 #[derive(Debug)]
 pub enum CommittorMessage {
     ReservePubkeysForCommittee {

run-schedulecommit-ephm.sh

@@ -9,7 +9,7 @@ use solana_program::{
 };
 
 use crate::{
-    BookUpdate, DelegateCpiArgs, ScheduleCommitCpiArgs,
+    BookUpdate, DelegateCpiArgs, DelegateOrderBookArgs, ScheduleCommitCpiArgs,
     ScheduleCommitInstruction,
 };
 
@@ -35,13 +35,14 @@ pub fn init_account_instruction(
 
 pub fn init_order_book_instruction(
     payer: Pubkey,
+    book_manager: Pubkey,
     order_book: Pubkey,
 ) -> Instruction {
     let program_id = crate::id();
     let account_metas = vec![
         AccountMeta::new(payer, true),
+        AccountMeta::new_readonly(book_manager, true),
         AccountMeta::new(order_book, false),
-        //AccountMeta::new_readonly(system_program::id(), false),
         AccountMeta::new_readonly(system_program::id(), false),
     ];
 
@@ -54,14 +55,15 @@ pub fn init_order_book_instruction(
 
 pub fn grow_order_book_instruction(
     payer: Pubkey,
+    book_manager: Pubkey,
     order_book: Pubkey,
     additional_space: u64,
 ) -> Instruction {
     let program_id = crate::id();
     let account_metas = vec![
         AccountMeta::new(payer, true),
+        AccountMeta::new_readonly(book_manager, false),
         AccountMeta::new(order_book, false),
-        //AccountMeta::new_readonly(system_program::id(), false),
         AccountMeta::new_readonly(system_program::id(), false),
     ];
 
@@ -97,18 +99,14 @@ pub fn init_payer_escrow(payer: Pubkey) -> [Instruction; 2] {
 
 pub fn delegate_account_cpi_instruction(
     payer: Pubkey,
-    player: Pubkey,
+    player_or_book_manager: Pubkey,
     user_seed: &[u8],
 ) -> Instruction {
     let program_id = crate::id();
-    let (pda, _) =
-        Pubkey::find_program_address(&[user_seed, player.as_ref()], &crate::ID);
-
-    let args = DelegateCpiArgs {
-        valid_until: i64::MAX,
-        commit_frequency_ms: 1_000_000_000,
-        player,
-    };
+    let (pda, _) = Pubkey::find_program_address(
+        &[user_seed, player_or_book_manager.as_ref()],
+        &crate::ID,
+    );
 
     let delegate_accounts = DelegateAccounts::new(pda, program_id);
     let delegate_metas = DelegateAccountMetas::from(delegate_accounts);
@@ -126,9 +124,18 @@ pub fn delegate_account_cpi_instruction(
     Instruction::new_with_borsh(
         program_id,
         &if user_seed == b"magic_schedule_commit" {
-            ScheduleCommitInstruction::DelegateCpi(args)
+            ScheduleCommitInstruction::DelegateCpi(DelegateCpiArgs {
+                valid_until: i64::MAX,
+                commit_frequency_ms: 1_000_000_000,
+                player: player_or_book_manager,
+            })
         } else {
-            ScheduleCommitInstruction::DelegateOrderBook(args)
+            ScheduleCommitInstruction::DelegateOrderBook(
+                DelegateOrderBookArgs {
+                    commit_frequency_ms: 1_000_000_000,
+                    book_manager: player_or_book_manager,
+                },
+            )
         },
         account_metas,
     )

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

@@ -50,6 +50,12 @@ pub struct DelegateCpiArgs {
     player: Pubkey,
 }
 
+#[derive(BorshSerialize, BorshDeserialize, Debug, Clone)]
+pub struct DelegateOrderBookArgs {
+    commit_frequency_ms: u32,
+    book_manager: Pubkey,
+}
+
 #[derive(BorshSerialize, BorshDeserialize, Debug, Clone)]
 pub struct ScheduleCommitCpiArgs {
     /// Pubkeys of players from which PDAs were derived
@@ -122,7 +128,7 @@ pub enum ScheduleCommitInstruction {
     GrowOrderBook(u64), // additional_space
 
     /// Delegate order book to ER nodes
-    DelegateOrderBook(DelegateCpiArgs),
+    DelegateOrderBook(DelegateOrderBookArgs),
 
     /// Update order book
     UpdateOrderBook(BookUpdate),
@@ -275,32 +281,29 @@ fn process_init_order_book<'a>(
     accounts: &'a [AccountInfo<'a>],
 ) -> entrypoint::ProgramResult {
     msg!("Init OrderBook account");
-    let [payer, order_book, _system_program] = accounts else {
-        return Err(ProgramError::Immutable);
+    let [payer, book_manager, order_book, _system_program] = accounts else {
+        return Err(ProgramError::NotEnoughAccountKeys);
     };
 
     assert_is_signer(payer, "payer")?;
 
     let (pda, bump) = Pubkey::find_program_address(
-        &[b"order_book", payer.key.as_ref()],
+        &[b"order_book", book_manager.key.as_ref()],
         &crate::ID,
     );
-    let seeds = &[b"order_book", payer.key.as_ref(), &[bump]];
-    msg!("payer:    {}", payer.key);
-    msg!("pda:      {}", pda);
-    msg!("seeds:    {:?}", seeds);
-    msg!("seedsnb:  {:?}", &[b"order_book", payer.key.as_ref()]);
+
     assert_keys_equal(order_book.key, &pda, || {
         format!(
-            "PDA for the account ('{}') and for payer ('{}') is incorrect",
-            order_book.key, payer.key
+            "PDA for the account ('{}') and for book_manager ('{}') is incorrect",
+            order_book.key, book_manager.key
         )
     })?;
+
     allocate_account_and_assign_owner(AllocateAndAssignAccountArgs {
         payer_info: payer,
         account_info: order_book,
         owner: &crate::ID,
-        signer_seeds: seeds,
+        signer_seeds: &[b"order_book", book_manager.key.as_ref(), &[bump]],
         size: 10 * 1024,
     })?;
 
@@ -312,20 +315,20 @@ fn process_grow_order_book<'a>(
     additional_space: u64,
 ) -> entrypoint::ProgramResult {
     msg!("Grow OrderBook account");
-    let [payer, order_book, system_program] = accounts else {
-        return Err(ProgramError::Immutable);
+    let [payer, book_manager, order_book, system_program] = accounts else {
+        return Err(ProgramError::NotEnoughAccountKeys);
     };
 
     assert_is_signer(payer, "payer")?;
 
     let (pda, _bump) = Pubkey::find_program_address(
-        &[b"order_book", payer.key.as_ref()],
+        &[b"order_book", book_manager.key.as_ref()],
         &crate::ID,
     );
 
     assert_keys_equal(order_book.key, &pda, || {
         format!(
-            "PDA for the account ('{}') and for payer ('{}') is incorrect",
+            "PDA for the account ('{}') and for book_manager ('{}') is incorrect",
             order_book.key, payer.key
         )
     })?;
@@ -356,19 +359,17 @@ fn process_grow_order_book<'a>(
 // -----------------
 pub fn process_delegate_order_book(
     accounts: &[AccountInfo],
-    args: DelegateCpiArgs,
+    args: DelegateOrderBookArgs,
 ) -> Result<(), ProgramError> {
     msg!("Processing delegate_order_book instruction");
 
     let [payer, order_book, owner_program, buffer, delegation_record, delegation_metadata, delegation_program, system_program] =
         accounts
     else {
-        return Err(ProgramError::Custom(959));
+        return Err(ProgramError::NotEnoughAccountKeys);
     };
 
-    let seeds_no_bump = [b"order_book", args.player.as_ref()];
-
-    msg!("seeds:  {:?}", seeds_no_bump);
+    let seeds_no_bump = [b"order_book", args.book_manager.as_ref()];
 
     delegate_account(
         DelegateAccounts {

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

@@ -170,15 +170,21 @@ impl ScheduleCommitTestContext {
         if self.user_seed == b"magic_schedule_commit" {
             ixs.extend(self.committees.iter().map(|(player, committee)| {
                 init_account_instruction(
-                    self.payer_ephem.pubkey(),
+                    self.payer_chain.pubkey(),
                     player.pubkey(),
                     *committee,
                 )
             }));
         } else {
-            ixs.extend(self.committees.iter().map(|(payer, committee)| {
-                init_order_book_instruction(payer.pubkey(), *committee)
-            }));
+            ixs.extend(self.committees.iter().map(
+                |(book_manager, committee)| {
+                    init_order_book_instruction(
+                        self.payer_chain.pubkey(),
+                        book_manager.pubkey(),
+                        *committee,
+                    )
+                },
+            ));
 
             //// TODO (snawaz): currently the size of delegatable-account cannot be
             //// more than 10K, else delegation will fail. So Let's revisit this when