feat: prevent commits for confined accounts

Cargo.toml

@@ -153,7 +153,7 @@ serde_json = "1.0"
 serde_with = "3.16"
 serial_test = "3.2"
 sha3 = "0.10.8"
-solana-account = { git = "https://github.com/magicblock-labs/solana-account.git", rev = "5afcedc" }
+solana-account = { git = "https://github.com/magicblock-labs/solana-account.git", rev = "1beed4c" }
 solana-account-decoder = { version = "2.2" }
 solana-accounts-db = { version = "2.2" }
 solana-account-decoder-client-types = { version = "2.2" }
@@ -229,6 +229,6 @@ features = ["dev-context-only-utils"]
 # some solana dependencies have solana-storage-proto as dependency
 # we need to patch them with our version, because they use protobuf-src v1.1.0
 # and we use protobuf-src v2.1.1. Otherwise compilation fails
-solana-account = { git = "https://github.com/magicblock-labs/solana-account.git", rev = "5afcedc" }
+solana-account = { git = "https://github.com/magicblock-labs/solana-account.git", rev = "1beed4c" }
 solana-storage-proto = { path = "./storage-proto" }
 solana-svm = { git = "https://github.com/magicblock-labs/magicblock-svm.git", rev = "86c2cb0f" }

magicblock-account-cloner/src/bpf_loader_v1.rs

@@ -50,6 +50,7 @@ impl BpfUpgradableProgramModifications {
                 executable: Some(false),
                 rent_epoch: Some(u64::MAX),
                 delegated: Some(false),
+                confined: Some(false),
             }
         };
 
@@ -69,6 +70,7 @@ impl BpfUpgradableProgramModifications {
                 executable: Some(true),
                 rent_epoch: Some(u64::MAX),
                 delegated: Some(false),
+                confined: Some(false),
             }
         };
 

magicblock-account-cloner/src/lib.rs

@@ -99,6 +99,7 @@ impl ChainlinkCloner {
             data: Some(request.account.data().to_owned()),
             executable: Some(request.account.executable()),
             delegated: Some(request.account.delegated()),
+            confined: Some(request.account.confined()),
         };
 
         let modify_ix = InstructionUtils::modify_accounts_instruction(vec![
@@ -238,13 +239,15 @@ impl ChainlinkCloner {
                         &validator_kp.pubkey(),
                     );
 
+                // Programs aren't marked as confined since they are also never delegated
                 let pre_deploy_mod_instruction = {
                     let pre_deploy_mods = vec![AccountModification {
                         pubkey: program_id,
                         lamports: Some(lamports),
                         owner: Some(loader_v4::id()),
                         executable: Some(true),
                         data: Some(pre_deploy_loader_state),
+                        confined: Some(false),
                         ..Default::default()
                     }];
                     InstructionUtils::modify_accounts_instruction(
@@ -256,6 +259,7 @@ impl ChainlinkCloner {
                     let post_deploy_mods = vec![AccountModification {
                         pubkey: program_id,
                         data: Some(post_deploy_loader_state),
+                        confined: Some(false),
                         ..Default::default()
                     }];
                     InstructionUtils::modify_accounts_instruction(

magicblock-chainlink/src/chainlink/fetch_cloner.rs

@@ -419,19 +419,14 @@ where
                                         delegation_record.owner
                                     );
                                 }
-                                let is_delegated_to_us = delegation_record
-                                    .authority
-                                    .eq(&self.validator_pubkey) ||
-                                    // TODO(thlorenz): @ once the delegation program supports
-                                    // delegating to specific authority we need to remove the below
-                                    delegation_record.authority.eq(&Pubkey::default());
 
-                                account
-                                    .set_owner(delegation_record.owner)
-                                    .set_delegated(is_delegated_to_us);
+                                self.apply_delegation_record_to_account(
+                                    &mut account,
+                                    &delegation_record,
+                                );
 
                                 // For accounts delegated to us, always unsubscribe from the delegated account
-                                if is_delegated_to_us {
+                                if account.delegated() {
                                     subs_to_remove.insert(pubkey);
                                 }
 
@@ -500,6 +495,31 @@ where
             })
     }
 
+    /// Applies delegation record settings to an account: sets the owner,
+    /// delegation status, and confined status based on the delegation
+    /// record's authority field.
+    /// Returns commit frequency if account is delegated to us
+    fn apply_delegation_record_to_account(
+        &self,
+        account: &mut ResolvedAccountSharedData,
+        delegation_record: &DelegationRecord,
+    ) -> Option<u64> {
+        let is_confined = delegation_record.authority.eq(&Pubkey::default());
+        let is_delegated_to_us =
+            delegation_record.authority.eq(&self.validator_pubkey)
+                || is_confined;
+
+        account
+            .set_owner(delegation_record.owner)
+            .set_confined(is_confined)
+            .set_delegated(is_delegated_to_us);
+        if is_delegated_to_us {
+            Some(delegation_record.commit_frequency_ms)
+        } else {
+            None
+        }
+    }
+
     /// Fetches and parses the delegation record for an account, returning the
     /// parsed DelegationRecord if found and valid, None otherwise.
     async fn fetch_and_parse_delegation_record(
@@ -866,20 +886,11 @@ where
                     };
 
                     trace!("Delegation record found for {pubkey}: {delegation_record:?}");
-                    let is_delegated_to_us = delegation_record
-                        .authority
-                        .eq(&self.validator_pubkey) ||
-                        // TODO(thlorenz): @ once the delegation program supports
-                        // delegating to specific authority we need to remove the below
-                        delegation_record.authority.eq(&Pubkey::default());
-                    account
-                        .set_owner(delegation_record.owner)
-                        .set_delegated(is_delegated_to_us);
-                    if is_delegated_to_us {
-                        Some(delegation_record.commit_frequency_ms)
-                    } else {
-                        None
-                    }
+
+                    self.apply_delegation_record_to_account(
+                        &mut account,
+                        &delegation_record,
+                    )
                 } else {
                     missing_delegation_record
                         .push((pubkey, account.remote_slot()));
@@ -3032,6 +3043,102 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn test_confined_delegation_behavior() {
+        init_logger();
+        let validator_pubkey = random_pubkey();
+        let account_owner = random_pubkey();
+        const CURRENT_SLOT: u64 = 100;
+
+        // Account 1: Delegated to validator authority -> Not confined
+        let account1_pubkey = random_pubkey();
+        let account1 = Account {
+            lamports: 1_000_000,
+            data: vec![1, 2, 3],
+            owner: dlp::id(), // Owned by DLP initially (as it is delegated)
+            executable: false,
+            rent_epoch: 0,
+        };
+
+        // Account 2: Delegated to default pubkey -> Confined
+        let account2_pubkey = random_pubkey();
+        let account2 = Account {
+            lamports: 2_000_000,
+            data: vec![4, 5, 6],
+            owner: dlp::id(),
+            executable: false,
+            rent_epoch: 0,
+        };
+
+        let FetcherTestCtx {
+            accounts_bank,
+            fetch_cloner,
+            rpc_client,
+            ..
+        } = setup(
+            [
+                (account1_pubkey, account1.clone()),
+                (account2_pubkey, account2.clone()),
+            ],
+            CURRENT_SLOT,
+            validator_pubkey,
+        )
+        .await;
+
+        // Add delegation record for Account 1 (Authority = Validator)
+        add_delegation_record_for(
+            &rpc_client,
+            account1_pubkey,
+            validator_pubkey,
+            account_owner,
+        );
+
+        // Add delegation record for Account 2 (Authority = Default/System)
+        add_delegation_record_for(
+            &rpc_client,
+            account2_pubkey,
+            Pubkey::default(),
+            account_owner,
+        );
+
+        // Fetch and clone both accounts
+        fetch_cloner
+            .fetch_and_clone_accounts(
+                &[account1_pubkey, account2_pubkey],
+                None,
+                None,
+                AccountFetchOrigin::GetAccount,
+                None,
+            )
+            .await
+            .expect("Failed to fetch and clone accounts");
+
+        // Verify not confined Account
+        let cloned_account1 = accounts_bank
+            .get_account(&account1_pubkey)
+            .expect("Account 1 not found");
+        assert!(cloned_account1.delegated(), "Account 1 should be delegated");
+        assert!(
+            !cloned_account1.confined(),
+            "Account 1 (delegated to validator) should NOT be confined"
+        );
+        assert_eq!(cloned_account1.owner(), &account_owner);
+
+        // Verify confined Account
+        let cloned_account2 = accounts_bank
+            .get_account(&account2_pubkey)
+            .expect("Account 2 not found");
+        assert!(
+            cloned_account2.delegated(),
+            "Account 2 should be delegated (to us, via confinement)"
+        );
+        assert!(
+            cloned_account2.confined(),
+            "Account 2 (delegated to default) SHOULD be confined"
+        );
+        assert_eq!(cloned_account2.owner(), &account_owner);
+    }
+
     #[tokio::test]
     async fn test_fetch_and_clone_undelegating_account_that_is_closed_on_chain()
     {

magicblock-chainlink/src/remote_account_provider/remote_account.rs

@@ -109,6 +109,23 @@ impl ResolvedAccountSharedData {
         self
     }
 
+    pub fn confined(&self) -> bool {
+        use ResolvedAccountSharedData::*;
+        match self {
+            Fresh(account) => account.confined(),
+            Bank(account) => account.confined(),
+        }
+    }
+
+    pub fn set_confined(&mut self, confined: bool) -> &mut Self {
+        use ResolvedAccountSharedData::*;
+        match self {
+            Fresh(account) => account.set_confined(confined),
+            Bank(account) => account.set_confined(confined),
+        }
+        self
+    }
+
     pub fn set_remote_slot(&mut self, remote_slot: Slot) -> &mut Self {
         use ResolvedAccountSharedData::*;
         match self {

magicblock-magic-program-api/src/instruction.rs

@@ -119,6 +119,7 @@ pub struct AccountModification {
     // https://github.com/magicblock-labs/magicblock-validator/issues/580
     pub rent_epoch: Option<u64>,
     pub delegated: Option<bool>,
+    pub confined: Option<bool>,
 }
 
 #[derive(Default, Clone, Serialize, Deserialize, Debug, PartialEq, Eq)]
@@ -131,4 +132,5 @@ pub struct AccountModificationForInstruction {
     // https://github.com/magicblock-labs/magicblock-validator/issues/580
     pub rent_epoch: Option<u64>,
     pub delegated: Option<bool>,
+    pub confined: Option<bool>,
 }

programs/magicblock/src/mutate_accounts/process_mutate_accounts.rs

@@ -215,6 +215,14 @@ pub(crate) fn process_mutate_accounts(
             );
             account.borrow_mut().set_delegated(delegated);
         }
+        if let Some(confined) = modification.confined {
+            ic_msg!(
+                invoke_context,
+                "MutateAccounts: setting confined to {}",
+                confined
+            );
+            account.borrow_mut().set_confined(confined);
+        }
     }
 
     if lamports_to_debit != 0 {
@@ -320,6 +328,7 @@ mod tests {
             data: Some(vec![1, 2, 3, 4, 5]),
             rent_epoch: None,
             delegated: Some(true),
+            confined: Some(true),
         };
         let ix = InstructionUtils::modify_accounts_instruction(vec![
             modification.clone(),
@@ -346,6 +355,7 @@ mod tests {
         let account_authority: AccountSharedData =
             accounts.drain(0..1).next().unwrap();
         assert!(!account_authority.delegated());
+        assert!(!account_authority.confined());
         assert_matches!(
             account_authority.into(),
             Account {
@@ -363,6 +373,7 @@ mod tests {
         let modified_account: AccountSharedData =
             accounts.drain(0..1).next().unwrap();
         assert!(modified_account.delegated());
+        assert!(modified_account.confined());
         assert_matches!(
             modified_account.into(),
             Account {

programs/magicblock/src/schedule_transactions/process_schedule_commit.rs

@@ -134,6 +134,16 @@ pub(crate) fn process_schedule_commit(
             get_instruction_pubkey_with_idx(transaction_context, idx as u16)?;
         let acc =
             get_instruction_account_with_idx(transaction_context, idx as u16)?;
+
+        if acc.borrow().confined() {
+            ic_msg!(
+                invoke_context,
+                "ScheduleCommit ERR: account {} is confined and cannot be committed",
+                acc_pubkey
+            );
+            return Err(InstructionError::InvalidAccountData);
+        }
+
         {
             if opts.request_undelegation {
                 // Check if account is writable and also undelegated