Replaces KeyedAccount by BorrowedAccount in the config processor. (#23302)

programs/config/src/config_processor.rs

@@ -5,33 +5,29 @@ use {
     bincode::deserialize,
     solana_program_runtime::{ic_msg, invoke_context::InvokeContext},
     solana_sdk::{
-        account::{ReadableAccount, WritableAccount},
+        feature_set, instruction::InstructionError, program_utils::limited_deserialize,
-        feature_set,
-        instruction::InstructionError,
-        keyed_account::keyed_account_at_index,
-        program_utils::limited_deserialize,
         pubkey::Pubkey,
     },
     std::collections::BTreeSet,
 };
 
 pub fn process_instruction(
-    first_instruction_account: usize,
+    _first_instruction_account: usize,
     data: &[u8],
     invoke_context: &mut InvokeContext,
 ) -> Result<(), InstructionError> {
-    let keyed_accounts = invoke_context.get_keyed_accounts()?;
+    let transaction_context = &invoke_context.transaction_context;
+    let instruction_context = transaction_context.get_current_instruction_context()?;
 
     let key_list: ConfigKeys = limited_deserialize(data)?;
-    let config_keyed_account =
-        &mut keyed_account_at_index(keyed_accounts, first_instruction_account)?;
     let current_data: ConfigKeys = {
-        let config_account = config_keyed_account.try_account_ref_mut()?;
+        let config_account =
-        if config_account.owner() != &crate::id() {
+            instruction_context.try_borrow_instruction_account(transaction_context, 0)?;
+        if config_account.get_owner() != &crate::id() {
             return Err(InstructionError::InvalidAccountOwner);
         }
 
-        deserialize(config_account.data()).map_err(|err| {
+        deserialize(config_account.get_data()).map_err(|err| {
             ic_msg!(
                 invoke_context,
                 "Unable to deserialize config account: {}",
@@ -50,7 +46,7 @@ pub fn process_instruction(
     if current_signer_keys.is_empty() {
         // Config account keypair must be a signer on account initialization,
         // or when no signers specified in Config data
-        if config_keyed_account.signer_key().is_none() {
+        if !instruction_context.is_signer(instruction_context.get_number_of_program_accounts())? {
             return Err(InstructionError::MissingRequiredSignature);
         }
     }
@@ -58,9 +54,10 @@ pub fn process_instruction(
     let mut counter = 0;
     for (signer, _) in key_list.keys.iter().filter(|(_, is_signer)| *is_signer) {
         counter += 1;
-        if signer != config_keyed_account.unsigned_key() {
+        if signer != instruction_context.get_instruction_account_key(transaction_context, 0)? {
-            let signer_account =
+            let is_signer = instruction_context
-                keyed_account_at_index(keyed_accounts, counter + 1).map_err(|_| {
+                .is_signer(instruction_context.get_number_of_program_accounts() + counter)
+                .map_err(|_| {
                     ic_msg!(
                         invoke_context,
                         "account {:?} is not in account list",
@@ -68,8 +65,7 @@ pub fn process_instruction(
                     );
                     InstructionError::MissingRequiredSignature
                 })?;
-            let signer_key = signer_account.signer_key();
+            if !is_signer {
-            if signer_key.is_none() {
                 ic_msg!(
                     invoke_context,
                     "account {:?} signer_key().is_none()",
@@ -77,7 +73,9 @@ pub fn process_instruction(
                 );
                 return Err(InstructionError::MissingRequiredSignature);
             }
-            if signer_key.unwrap() != signer {
+            if instruction_context.get_instruction_account_key(transaction_context, counter)?
+                != signer
+            {
                 ic_msg!(
                     invoke_context,
                     "account[{:?}].signer_key() does not match Config data)",
@@ -96,7 +94,9 @@ pub fn process_instruction(
                 );
                 return Err(InstructionError::MissingRequiredSignature);
             }
-        } else if config_keyed_account.signer_key().is_none() {
+        } else if !instruction_context
+            .is_signer(instruction_context.get_number_of_program_accounts())?
+        {
             ic_msg!(invoke_context, "account[0].signer_key().is_none()");
             return Err(InstructionError::MissingRequiredSignature);
         }
@@ -125,15 +125,13 @@ pub fn process_instruction(
         return Err(InstructionError::MissingRequiredSignature);
     }
 
-    if config_keyed_account.data_len()? < data.len() {
+    let mut config_account =
+        instruction_context.try_borrow_instruction_account(transaction_context, 0)?;
+    if config_account.get_data().len() < data.len() {
         ic_msg!(invoke_context, "instruction data too large");
         return Err(InstructionError::InvalidInstructionData);
     }
-
+    config_account.get_data_mut()[..data.len()].copy_from_slice(data);
-    config_keyed_account
-        .try_account_ref_mut()?
-        .data_as_mut_slice()[..data.len()]
-        .copy_from_slice(data);
     Ok(())
 }
 
@@ -146,7 +144,7 @@ mod tests {
         serde_derive::{Deserialize, Serialize},
         solana_program_runtime::invoke_context::mock_process_instruction,
         solana_sdk::{
-            account::AccountSharedData,
+            account::{AccountSharedData, ReadableAccount},
             instruction::AccountMeta,
             pubkey::Pubkey,
             signature::{Keypair, Signer},