Adds more assertions of invoke_context.get_keyed_accounts() being equ…

…al to the keyed_accounts parameter.
solana-labs · Mar 2, 2021 · 0f9652c · 0f9652c
1 parent a08095d
commit 0f9652c
Show file tree

Hide file tree

Showing 12 changed files with 65 additions and 18 deletions.
diff --git a/program-test/src/lib.rs b/program-test/src/lib.rs
@@ -110,6 +110,9 @@ pub fn builtin_process_instruction(
 ) -> Result<(), InstructionError> {
     set_invoke_context(invoke_context);
 
+    // TODO [KeyedAccounts to InvokeContext refactoring]
+    assert_eq!(invoke_context.get_keyed_accounts(), keyed_accounts);
+
     // Copy all the accounts into a HashMap to ensure there are no duplicates
     let mut accounts: HashMap<Pubkey, Account> = keyed_accounts
         .iter()

diff --git a/programs/budget/src/budget_processor.rs b/programs/budget/src/budget_processor.rs
@@ -117,8 +117,11 @@ pub fn process_instruction(
     _program_id: &Pubkey,
     keyed_accounts: &[KeyedAccount],
     data: &[u8],
-    _invoke_context: &mut dyn InvokeContext,
+    invoke_context: &mut dyn InvokeContext,
 ) -> Result<(), InstructionError> {
+    // TODO [KeyedAccounts to InvokeContext refactoring]
+    assert_eq!(keyed_accounts, invoke_context.get_keyed_accounts());
+
     let instruction = limited_deserialize(data)?;
 
     trace!("process_instruction: {:?}", instruction);

diff --git a/programs/config/src/config_processor.rs b/programs/config/src/config_processor.rs
@@ -17,6 +17,9 @@ pub fn process_instruction(
     data: &[u8],
     invoke_context: &mut dyn InvokeContext,
 ) -> Result<(), InstructionError> {
+    // TODO [KeyedAccounts to InvokeContext refactoring]
+    assert_eq!(keyed_accounts, invoke_context.get_keyed_accounts());
+
     let key_list: ConfigKeys = limited_deserialize(data)?;
     let config_keyed_account = &mut keyed_account_at_index(keyed_accounts, 0)?;
     let current_data: ConfigKeys = {

diff --git a/programs/exchange/src/exchange_processor.rs b/programs/exchange/src/exchange_processor.rs
@@ -464,10 +464,13 @@ pub fn process_instruction(
     _program_id: &Pubkey,
     keyed_accounts: &[KeyedAccount],
     data: &[u8],
-    _invoke_context: &mut dyn InvokeContext,
+    invoke_context: &mut dyn InvokeContext,
 ) -> Result<(), InstructionError> {
     solana_logger::setup();
 
+    // TODO [KeyedAccounts to InvokeContext refactoring]
+    assert_eq!(keyed_accounts, invoke_context.get_keyed_accounts());
+
     match limited_deserialize::<ExchangeInstruction>(data)? {
         ExchangeInstruction::AccountRequest => {
             ExchangeProcessor::do_account_request(keyed_accounts)

diff --git a/programs/ownable/src/ownable_processor.rs b/programs/ownable/src/ownable_processor.rs
@@ -31,8 +31,10 @@ pub fn process_instruction(
     _program_id: &Pubkey,
     keyed_accounts: &[KeyedAccount],
     data: &[u8],
-    _invoke_context: &mut dyn InvokeContext,
+    invoke_context: &mut dyn InvokeContext,
 ) -> Result<(), InstructionError> {
+    // TODO [KeyedAccounts to InvokeContext refactoring]
+    assert_eq!(keyed_accounts, invoke_context.get_keyed_accounts());
     let new_owner_pubkey: Pubkey = limited_deserialize(data)?;
     let account_keyed_account = &mut keyed_account_at_index(keyed_accounts, 0)?;
     let mut account_owner_pubkey: Pubkey =

diff --git a/programs/stake/src/stake_instruction.rs b/programs/stake/src/stake_instruction.rs
@@ -487,6 +487,8 @@ pub fn process_instruction(
     data: &[u8],
     invoke_context: &mut dyn InvokeContext,
 ) -> Result<(), InstructionError> {
+    // TODO [KeyedAccounts to InvokeContext refactoring]
+    assert_eq!(keyed_accounts, invoke_context.get_keyed_accounts());
     trace!("process_instruction: {:?}", data);
     trace!("keyed_accounts: {:?}", keyed_accounts);
 

diff --git a/programs/vest/src/vest_processor.rs b/programs/vest/src/vest_processor.rs
@@ -63,6 +63,9 @@ pub fn process_instruction(
     data: &[u8],
     invoke_context: &mut dyn InvokeContext,
 ) -> Result<(), InstructionError> {
+    // TODO [KeyedAccounts to InvokeContext refactoring]
+    assert_eq!(keyed_accounts, invoke_context.get_keyed_accounts());
+
     let contract_account = &mut keyed_account_at_index(keyed_accounts, 0)?.try_account_ref_mut()?;
     if invoke_context.is_feature_active(&feature_set::check_program_owner::id())
         && contract_account.owner != crate::id()

diff --git a/programs/vote/src/vote_instruction.rs b/programs/vote/src/vote_instruction.rs
@@ -281,6 +281,9 @@ pub fn process_instruction(
     data: &[u8],
     invoke_context: &mut dyn InvokeContext,
 ) -> Result<(), InstructionError> {
+    // TODO [KeyedAccounts to InvokeContext refactoring]
+    assert_eq!(keyed_accounts, invoke_context.get_keyed_accounts());
+
     trace!("process_instruction: {:?}", data);
     trace!("keyed_accounts: {:?}", keyed_accounts);
 

diff --git a/runtime/src/bank.rs b/runtime/src/bank.rs
@@ -5350,8 +5350,10 @@ pub(crate) mod tests {
         _program_id: &Pubkey,
         keyed_accounts: &[KeyedAccount],
         data: &[u8],
-        _invoke_context: &mut dyn InvokeContext,
+        invoke_context: &mut dyn InvokeContext,
     ) -> result::Result<(), InstructionError> {
+        // TODO [KeyedAccounts to InvokeContext refactoring]
+        assert_eq!(invoke_context.get_keyed_accounts(), keyed_accounts);
         if let Ok(instruction) = bincode::deserialize(data) {
             match instruction {
                 MockInstruction::Deduction => {
@@ -8905,10 +8907,12 @@ pub(crate) mod tests {
         }
         fn mock_vote_processor(
             program_id: &Pubkey,
-            _keyed_accounts: &[KeyedAccount],
+            keyed_accounts: &[KeyedAccount],
             _instruction_data: &[u8],
-            _invoke_context: &mut dyn InvokeContext,
+            invoke_context: &mut dyn InvokeContext,
         ) -> std::result::Result<(), InstructionError> {
+            // TODO [KeyedAccounts to InvokeContext refactoring]
+            assert_eq!(invoke_context.get_keyed_accounts(), keyed_accounts);
             if mock_vote_program_id() != *program_id {
                 return Err(InstructionError::IncorrectProgramId);
             }
@@ -9751,8 +9755,10 @@ pub(crate) mod tests {
             _program_id: &Pubkey,
             keyed_accounts: &[KeyedAccount],
             data: &[u8],
-            _invoke_context: &mut dyn InvokeContext,
+            invoke_context: &mut dyn InvokeContext,
         ) -> result::Result<(), InstructionError> {
+            // TODO [KeyedAccounts to InvokeContext refactoring]
+            assert_eq!(invoke_context.get_keyed_accounts(), keyed_accounts);
             let lamports = data[0] as u64;
             {
                 let mut to_account = keyed_accounts[1].try_account_ref_mut()?;
@@ -9803,10 +9809,12 @@ pub(crate) mod tests {
         #[allow(clippy::unnecessary_wraps)]
         fn mock_process_instruction(
             _program_id: &Pubkey,
-            _keyed_accounts: &[KeyedAccount],
+            keyed_accounts: &[KeyedAccount],
             _data: &[u8],
-            _invoke_context: &mut dyn InvokeContext,
+            invoke_context: &mut dyn InvokeContext,
         ) -> result::Result<(), InstructionError> {
+            // TODO [KeyedAccounts to InvokeContext refactoring]
+            assert_eq!(invoke_context.get_keyed_accounts(), keyed_accounts);
             Ok(())
         }
 
@@ -10239,8 +10247,10 @@ pub(crate) mod tests {
             _program_id: &Pubkey,
             keyed_accounts: &[KeyedAccount],
             _data: &[u8],
-            _invoke_context: &mut dyn InvokeContext,
+            invoke_context: &mut dyn InvokeContext,
         ) -> result::Result<(), InstructionError> {
+            // TODO [KeyedAccounts to InvokeContext refactoring]
+            assert_eq!(invoke_context.get_keyed_accounts(), keyed_accounts);
             assert_eq!(42, keyed_accounts[0].lamports().unwrap());
             let mut account = keyed_accounts[0].try_account_ref_mut()?;
             account.lamports += 1;
@@ -11216,10 +11226,12 @@ pub(crate) mod tests {
         #[allow(clippy::unnecessary_wraps)]
         fn mock_process_instruction(
             _program_id: &Pubkey,
-            _keyed_accounts: &[KeyedAccount],
+            keyed_accounts: &[KeyedAccount],
             _data: &[u8],
-            _invoke_context: &mut dyn InvokeContext,
+            invoke_context: &mut dyn InvokeContext,
         ) -> std::result::Result<(), solana_sdk::instruction::InstructionError> {
+            // TODO [KeyedAccounts to InvokeContext refactoring]
+            assert_eq!(invoke_context.get_keyed_accounts(), keyed_accounts);
             Ok(())
         }
         let builtins = Builtins {

diff --git a/runtime/src/builtins.rs b/runtime/src/builtins.rs
@@ -18,6 +18,9 @@ fn process_instruction_with_program_logging(
     instruction_data: &[u8],
     invoke_context: &mut dyn InvokeContext,
 ) -> Result<(), InstructionError> {
+    // TODO [KeyedAccounts to InvokeContext refactoring]
+    assert_eq!(keyed_accounts, invoke_context.get_keyed_accounts());
+
     let logger = invoke_context.get_logger();
     stable_log::program_invoke(&logger, program_id, invoke_context.invoke_depth());
 

diff --git a/runtime/src/message_processor.rs b/runtime/src/message_processor.rs
@@ -1625,8 +1625,10 @@ mod tests {
             _program_id: &Pubkey,
             keyed_accounts: &[KeyedAccount],
             data: &[u8],
-            _invoke_context: &mut dyn InvokeContext,
+            invoke_context: &mut dyn InvokeContext,
         ) -> Result<(), InstructionError> {
+            // TODO [KeyedAccounts to InvokeContext refactoring]
+            assert_eq!(keyed_accounts, invoke_context.get_keyed_accounts());
             if let Ok(instruction) = bincode::deserialize(data) {
                 match instruction {
                     MockSystemInstruction::Correct => Ok(()),
@@ -1766,8 +1768,10 @@ mod tests {
             _program_id: &Pubkey,
             keyed_accounts: &[KeyedAccount],
             data: &[u8],
-            _invoke_context: &mut dyn InvokeContext,
+            invoke_context: &mut dyn InvokeContext,
         ) -> Result<(), InstructionError> {
+            // TODO [KeyedAccounts to InvokeContext refactoring]
+            assert_eq!(keyed_accounts, invoke_context.get_keyed_accounts());
             if let Ok(instruction) = bincode::deserialize(data) {
                 match instruction {
                     MockSystemInstruction::BorrowFail => {
@@ -1932,8 +1936,10 @@ mod tests {
             program_id: &Pubkey,
             keyed_accounts: &[KeyedAccount],
             data: &[u8],
-            _invoke_context: &mut dyn InvokeContext,
+            invoke_context: &mut dyn InvokeContext,
         ) -> Result<(), InstructionError> {
+            // TODO [KeyedAccounts to InvokeContext refactoring]
+            assert_eq!(keyed_accounts, invoke_context.get_keyed_accounts());
             assert_eq!(*program_id, keyed_accounts[0].owner()?);
             assert_ne!(
                 keyed_accounts[1].owner()?,
@@ -2070,10 +2076,12 @@ mod tests {
         #[allow(clippy::unnecessary_wraps)]
         fn mock_process_instruction(
             _program_id: &Pubkey,
-            _keyed_accounts: &[KeyedAccount],
+            keyed_accounts: &[KeyedAccount],
             _data: &[u8],
-            _invoke_context: &mut dyn InvokeContext,
+            invoke_context: &mut dyn InvokeContext,
         ) -> Result<(), InstructionError> {
+            // TODO [KeyedAccounts to InvokeContext refactoring]
+            assert_eq!(keyed_accounts, invoke_context.get_keyed_accounts());
             Ok(())
         }
         #[allow(clippy::unnecessary_wraps)]

diff --git a/runtime/src/system_instruction_processor.rs b/runtime/src/system_instruction_processor.rs
@@ -214,8 +214,10 @@ pub fn process_instruction(
     _owner: &Pubkey,
     keyed_accounts: &[KeyedAccount],
     instruction_data: &[u8],
-    _invoke_context: &mut dyn InvokeContext,
+    invoke_context: &mut dyn InvokeContext,
 ) -> Result<(), InstructionError> {
+    // TODO [KeyedAccounts to InvokeContext refactoring]
+    assert_eq!(keyed_accounts, invoke_context.get_keyed_accounts());
     let instruction = limited_deserialize(instruction_data)?;
 
     trace!("process_instruction: {:?}", instruction);