Add MagicBlockInstruction::ScheduleCommitDiffAndUndelegate to efficiently commit changes in delegated accounts

Author: snawaz

Cargo.lock

@@ -124,9 +124,7 @@ magicblock-config = { path = "./magicblock-config" }
 magicblock-config-helpers = { path = "./magicblock-config-helpers" }
 magicblock-config-macro = { path = "./magicblock-config-macro" }
 magicblock-core = { path = "./magicblock-core" }
-magicblock-delegation-program = { git = "https://github.com/magicblock-labs/delegation-program.git", rev = "aa1de56d90c", features = [
-  "no-entrypoint",
-] }
+magicblock-delegation-program = { path="../delegation-program", features = ["no-entrypoint"] }
 magicblock-geyser-plugin = { path = "./magicblock-geyser-plugin" }
 magicblock-ledger = { path = "./magicblock-ledger" }
 magicblock-metrics = { path = "./magicblock-metrics" }

Cargo.toml

@@ -357,6 +357,7 @@ impl<C: BaseIntentCommittor> ScheduledCommitsProcessorImpl<C> {
             excluded_pubkeys: intent_meta.excluded_pubkeys,
             feepayers: intent_meta.feepayers,
             requested_undelegation: intent_meta.requested_undelegation,
+            commit_diff: intent_meta.commit_diff,
         }
     }
 }
@@ -424,6 +425,7 @@ struct ScheduledBaseIntentMeta {
     feepayers: HashSet<FeePayerAccount>,
     intent_sent_transaction: Transaction,
     requested_undelegation: bool,
+    commit_diff: bool,
 }
 
 impl ScheduledBaseIntentMeta {
@@ -443,6 +445,7 @@ impl ScheduledBaseIntentMeta {
             feepayers,
             intent_sent_transaction: intent.action_sent_transaction.clone(),
             requested_undelegation: intent.is_undelegate(),
+            commit_diff: intent.is_commit_diff(),
         }
     }
 }

magicblock-accounts/src/scheduled_commits_processor.rs

@@ -20,6 +20,7 @@ use tokio_util::sync::CancellationToken;
 
 use crate::slot::advance_slot_and_update_ledger;
 
+// ER chain
 pub fn init_slot_ticker<C: ScheduledCommitsProcessor>(
     bank: &Arc<Bank>,
     committor_processor: &Option<Arc<C>>,
@@ -71,6 +72,7 @@ pub fn init_slot_ticker<C: ScheduledCommitsProcessor>(
     })
 }
 
+// ER chain
 async fn handle_scheduled_commits<C: ScheduledCommitsProcessor>(
     bank: &Arc<Bank>,
     committor_processor: &Arc<C>,

magicblock-api/src/tickers.rs

@@ -1,6 +1,8 @@
 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-program/src/instruction.rs

@@ -242,6 +242,7 @@ where
         execution_permit: OwnedSemaphorePermit,
         result_sender: broadcast::Sender<BroadcastedIntentExecutionResult>,
     ) {
+        info!("execute: {:#?}", intent);
         let result = executor
             .execute(intent.inner.clone(), persister)
             .await

magicblock-committor-service/src/intent_execution_manager/intent_execution_engine.rs

@@ -4,11 +4,12 @@ pub mod single_stage_executor;
 pub mod task_info_fetcher;
 pub mod two_stage_executor;
 
+use core::slice;
 use std::{ops::ControlFlow, sync::Arc, time::Duration};
 
 use async_trait::async_trait;
 use futures_util::future::try_join_all;
-use log::{error, trace, warn};
+use log::{error, info, trace, warn};
 use magicblock_program::{
     magic_scheduled_base_intent::ScheduledBaseIntent,
     validator::validator_authority,
@@ -20,6 +21,7 @@ use magicblock_rpc_client::{
 use solana_pubkey::Pubkey;
 use solana_rpc_client_api::client_error::ErrorKind;
 use solana_sdk::{
+    instruction::CompiledInstruction,
     message::VersionedMessage,
     signature::{Keypair, Signature, Signer, SignerError},
     transaction::{TransactionError, VersionedTransaction},
@@ -685,9 +687,26 @@ where
         // This is needed because DEFAULT_MAX_TIME_TO_PROCESSED is 50 sec
         while start.elapsed() < RETRY_FOR || i < MIN_RETRIES {
             i += 1;
+            let message = prepared_message.clone();
+            let changed = {
+                let len = message.instructions().len();
+                let ixs = unsafe {
+                    let ix = message.instructions().as_ptr()
+                        as *mut CompiledInstruction;
+                    slice::from_raw_parts_mut(ix, len)
+                };
+                let mut changed = 0;
+                for ix in ixs.iter_mut() {
+                    if ix.data.len() != 0 && ix.data[0] == 16 {
+                        //ix.data[0] = 1; // CommitState
+                        changed += 1;
+                    }
+                }
+                changed
+            };
+            info!("> changed [{changed}] prepared_message: {:?}", message);
 
-            let result =
-                self.send_prepared_message(prepared_message.clone()).await;
+            let result = self.send_prepared_message(message).await;
             let flow = match result {
                 Ok(result) => {
                     return match result.into_result() {
@@ -708,6 +727,7 @@ where
                     // TransactionError can be mapped to known set of error
                     // We return right away to retry recovery, because this can't be fixed with retries
                     ControlFlow::Break(TransactionStrategyExecutionError::from_transaction_error(err, tasks, |err| {
+                        error!("> ERROR: {:?}", err);
                         MagicBlockRpcClientError::SentTransactionError(err, signature)
                     }))
                 }

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

@@ -62,6 +62,8 @@ where
                 Err(err) => err,
             };
 
+            error!("execution_err: {}", execution_err);
+
             // Attempt patching
             let flow = self
                 .patch_strategy(
@@ -79,6 +81,7 @@ 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/intent_executor/single_stage_executor.rs

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