Rename SanitizedMessage::try_from to try_from_legacy_message (#35338

)

* Simplify and refactor tx message creation in tests

* Rename SanitizedMessage::try_from to try_from_legacy_message

banks-server/src/banks_server.rs

@@ -31,7 +31,6 @@ use {
     },
     solana_svm::transaction_results::TransactionExecutionResult,
     std::{
-        convert::TryFrom,
         io,
         net::{Ipv4Addr, SocketAddr},
         sync::{atomic::AtomicBool, Arc, RwLock},
@@ -418,7 +417,7 @@ impl Banks for BanksServer {
         commitment: CommitmentLevel,
     ) -> Option<u64> {
         let bank = self.bank(commitment);
-        let sanitized_message = SanitizedMessage::try_from(message).ok()?;
+        let sanitized_message = SanitizedMessage::try_from_legacy_message(message).ok()?;
         bank.get_fee_for_message(&sanitized_message)
     }
 }

program-runtime/src/message_processor.rs

@@ -180,12 +180,12 @@ mod tests {
         solana_sdk::{
             account::{AccountSharedData, ReadableAccount},
             instruction::{AccountMeta, Instruction, InstructionError},
-            message::{AccountKeys, LegacyMessage, Message},
+            message::{AccountKeys, Message},
             native_loader::{self, create_loadable_account_for_test},
             pubkey::Pubkey,
             rent::Rent,
             secp256k1_instruction::new_secp256k1_instruction,
-            secp256k1_program,
+            secp256k1_program, system_program,
         },
     };
 
@@ -198,6 +198,10 @@ mod tests {
         ModifyReadonly,
     }
 
+    fn new_sanitized_message(message: Message) -> SanitizedMessage {
+        SanitizedMessage::try_from_legacy_message(message).unwrap()
+    }
+
     #[test]
     fn test_process_message_readonly_handling() {
         #[derive(Serialize, Deserialize)]
@@ -272,21 +276,20 @@ mod tests {
             AccountMeta::new_readonly(readonly_pubkey, false),
         ];
 
-        let message =
-            SanitizedMessage::Legacy(LegacyMessage::new(Message::new_with_compiled_instructions(
-                1,
-                0,
-                2,
-                account_keys.clone(),
-                Hash::default(),
-                AccountKeys::new(&account_keys, None).compile_instructions(&[
-                    Instruction::new_with_bincode(
-                        mock_system_program_id,
-                        &MockSystemInstruction::Correct,
-                        account_metas.clone(),
-                    ),
-                ]),
-            )));
+        let message = new_sanitized_message(Message::new_with_compiled_instructions(
+            1,
+            0,
+            2,
+            account_keys.clone(),
+            Hash::default(),
+            AccountKeys::new(&account_keys, None).compile_instructions(&[
+                Instruction::new_with_bincode(
+                    mock_system_program_id,
+                    &MockSystemInstruction::Correct,
+                    account_metas.clone(),
+                ),
+            ]),
+        ));
         let sysvar_cache = SysvarCache::default();
         let mut programs_modified_by_tx = LoadedProgramsForTxBatch::default();
         let result = MessageProcessor::process_message(
@@ -322,21 +325,20 @@ mod tests {
             0
         );
 
-        let message =
-            SanitizedMessage::Legacy(LegacyMessage::new(Message::new_with_compiled_instructions(
-                1,
-                0,
-                2,
-                account_keys.clone(),
-                Hash::default(),
-                AccountKeys::new(&account_keys, None).compile_instructions(&[
-                    Instruction::new_with_bincode(
-                        mock_system_program_id,
-                        &MockSystemInstruction::TransferLamports { lamports: 50 },
-                        account_metas.clone(),
-                    ),
-                ]),
-            )));
+        let message = new_sanitized_message(Message::new_with_compiled_instructions(
+            1,
+            0,
+            2,
+            account_keys.clone(),
+            Hash::default(),
+            AccountKeys::new(&account_keys, None).compile_instructions(&[
+                Instruction::new_with_bincode(
+                    mock_system_program_id,
+                    &MockSystemInstruction::TransferLamports { lamports: 50 },
+                    account_metas.clone(),
+                ),
+            ]),
+        ));
         let mut programs_modified_by_tx = LoadedProgramsForTxBatch::default();
         let result = MessageProcessor::process_message(
             &message,
@@ -361,21 +363,20 @@ mod tests {
             ))
         );
 
-        let message =
-            SanitizedMessage::Legacy(LegacyMessage::new(Message::new_with_compiled_instructions(
-                1,
-                0,
-                2,
-                account_keys.clone(),
-                Hash::default(),
-                AccountKeys::new(&account_keys, None).compile_instructions(&[
-                    Instruction::new_with_bincode(
-                        mock_system_program_id,
-                        &MockSystemInstruction::ChangeData { data: 50 },
-                        account_metas,
-                    ),
-                ]),
-            )));
+        let message = new_sanitized_message(Message::new_with_compiled_instructions(
+            1,
+            0,
+            2,
+            account_keys.clone(),
+            Hash::default(),
+            AccountKeys::new(&account_keys, None).compile_instructions(&[
+                Instruction::new_with_bincode(
+                    mock_system_program_id,
+                    &MockSystemInstruction::ChangeData { data: 50 },
+                    account_metas,
+                ),
+            ]),
+        ));
         let mut programs_modified_by_tx = LoadedProgramsForTxBatch::default();
         let result = MessageProcessor::process_message(
             &message,
@@ -496,14 +497,14 @@ mod tests {
         ];
 
         // Try to borrow mut the same account
-        let message = SanitizedMessage::Legacy(LegacyMessage::new(Message::new(
+        let message = new_sanitized_message(Message::new(
             &[Instruction::new_with_bincode(
                 mock_program_id,
                 &MockSystemInstruction::BorrowFail,
                 account_metas.clone(),
             )],
             Some(transaction_context.get_key_of_account_at_index(0).unwrap()),
-        )));
+        ));
         let sysvar_cache = SysvarCache::default();
         let mut programs_modified_by_tx = LoadedProgramsForTxBatch::default();
         let result = MessageProcessor::process_message(
@@ -530,14 +531,14 @@ mod tests {
         );
 
         // Try to borrow mut the same account in a safe way
-        let message = SanitizedMessage::Legacy(LegacyMessage::new(Message::new(
+        let message = new_sanitized_message(Message::new(
             &[Instruction::new_with_bincode(
                 mock_program_id,
                 &MockSystemInstruction::MultiBorrowMut,
                 account_metas.clone(),
             )],
             Some(transaction_context.get_key_of_account_at_index(0).unwrap()),
-        )));
+        ));
         let mut programs_modified_by_tx = LoadedProgramsForTxBatch::default();
         let result = MessageProcessor::process_message(
             &message,
@@ -557,7 +558,7 @@ mod tests {
         assert!(result.is_ok());
 
         // Do work on the same transaction account but at different instruction accounts
-        let message = SanitizedMessage::Legacy(LegacyMessage::new(Message::new(
+        let message = new_sanitized_message(Message::new(
             &[Instruction::new_with_bincode(
                 mock_program_id,
                 &MockSystemInstruction::DoWork {
@@ -567,7 +568,7 @@ mod tests {
                 account_metas,
             )],
             Some(transaction_context.get_key_of_account_at_index(0).unwrap()),
-        )));
+        ));
         let mut programs_modified_by_tx = LoadedProgramsForTxBatch::default();
         let result = MessageProcessor::process_message(
             &message,
@@ -623,6 +624,10 @@ mod tests {
         let mut mock_program_account = AccountSharedData::new(1, 0, &native_loader::id());
         mock_program_account.set_executable(true);
         let accounts = vec![
+            (
+                Pubkey::new_unique(),
+                AccountSharedData::new(1, 0, &system_program::id()),
+            ),
             (secp256k1_program::id(), secp256k1_account),
             (mock_program_id, mock_program_account),
         ];
@@ -642,13 +647,13 @@ mod tests {
                 }
             }
         };
-        let message = SanitizedMessage::Legacy(LegacyMessage::new(Message::new(
+        let message = new_sanitized_message(Message::new(
             &[
                 new_secp256k1_instruction(&secret_key, b"hello"),
                 Instruction::new_with_bytes(mock_program_id, &[], vec![]),
             ],
-            None,
-        )));
+            Some(transaction_context.get_key_of_account_at_index(0).unwrap()),
+        ));
         let sysvar_cache = SysvarCache::default();
         let mut programs_loaded_for_tx_batch = LoadedProgramsForTxBatch::default();
         programs_loaded_for_tx_batch.replenish(
@@ -658,7 +663,7 @@ mod tests {
         let mut programs_modified_by_tx = LoadedProgramsForTxBatch::default();
         let result = MessageProcessor::process_message(
             &message,
-            &[vec![0], vec![1]],
+            &[vec![1], vec![2]],
             &mut transaction_context,
             None,
             &programs_loaded_for_tx_batch,

programs/sbf/tests/programs.rs

@@ -200,7 +200,7 @@ fn execute_transactions(
                     }
                     .expect("lamports_per_signature must be available");
                     let fee = bank.get_fee_for_message_with_lamports_per_signature(
-                        &SanitizedMessage::try_from(tx.message().clone()).unwrap(),
+                        &SanitizedMessage::try_from_legacy_message(tx.message().clone()).unwrap(),
                         lamports_per_signature,
                     );
 
@@ -3705,7 +3705,7 @@ fn test_program_fees() {
         Some(&mint_keypair.pubkey()),
     );
 
-    let sanitized_message = SanitizedMessage::try_from(message.clone()).unwrap();
+    let sanitized_message = SanitizedMessage::try_from_legacy_message(message.clone()).unwrap();
     let expected_normal_fee = fee_structure.calculate_fee(
         &sanitized_message,
         congestion_multiplier,
@@ -3729,7 +3729,7 @@ fn test_program_fees() {
         ],
         Some(&mint_keypair.pubkey()),
     );
-    let sanitized_message = SanitizedMessage::try_from(message.clone()).unwrap();
+    let sanitized_message = SanitizedMessage::try_from_legacy_message(message.clone()).unwrap();
     let expected_prioritized_fee = fee_structure.calculate_fee(
         &sanitized_message,
         congestion_multiplier,

rpc/src/rpc.rs

@@ -5070,7 +5070,7 @@ pub mod tests {
             let prioritization_fee_cache = &self.meta.prioritization_fee_cache;
             let transactions: Vec<_> = transactions
                 .into_iter()
-                .map(|tx| SanitizedTransaction::try_from_legacy_transaction(tx).unwrap())
+                .map(SanitizedTransaction::from_transaction_for_tests)
                 .collect();
             prioritization_fee_cache.update(&bank, transactions.iter());
         }

runtime/benches/prioritization_fee_cache.rs

@@ -36,7 +36,7 @@ fn build_sanitized_transaction(
         Some(signer_account),
     ));
 
-    SanitizedTransaction::try_from_legacy_transaction(transaction).unwrap()
+    SanitizedTransaction::from_transaction_for_tests(transaction)
 }
 
 #[bench]