blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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
This commit is contained in:
Justin Starry 2024-02-29 08:25:22 +08:00 committed by GitHub
parent 9146236f02
commit 312f786abf
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 173 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
banks-server/src/banks_server.rs
View File

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

119
program-runtime/src/message_processor.rs
View File

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

6
programs/sbf/tests/programs.rs
View File

@ -200,7 +200,7 @@ fn execute_transactions(
} }
.expect("lamports_per_signature must be available"); .expect("lamports_per_signature must be available");
let fee = bank.get_fee_for_message_with_lamports_per_signature( 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, lamports_per_signature,
); );
@ -3705,7 +3705,7 @@ fn test_program_fees() {
Some(&mint_keypair.pubkey()), 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( let expected_normal_fee = fee_structure.calculate_fee(
&sanitized_message, &sanitized_message,
congestion_multiplier, congestion_multiplier,
@ -3729,7 +3729,7 @@ fn test_program_fees() {
], ],
Some(&mint_keypair.pubkey()), 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( let expected_prioritized_fee = fee_structure.calculate_fee(
&sanitized_message, &sanitized_message,
congestion_multiplier, congestion_multiplier,

2
rpc/src/rpc.rs
View File

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

2
runtime/benches/prioritization_fee_cache.rs
View File

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

74
runtime/src/bank/tests.rs
View File

@ -117,7 +117,7 @@ use {
}, },
std::{ std::{
collections::{HashMap, HashSet}, collections::{HashMap, HashSet},
convert::{TryFrom, TryInto}, convert::TryInto,
fs::File, fs::File,
io::Read, io::Read,
str::FromStr, str::FromStr,
@ -195,6 +195,10 @@ fn create_genesis_config(lamports: u64) -> (GenesisConfig, Keypair) {
solana_sdk::genesis_config::create_genesis_config(lamports) solana_sdk::genesis_config::create_genesis_config(lamports)
} }
fn new_sanitized_message(message: Message) -> SanitizedMessage {
SanitizedMessage::try_from_legacy_message(message).unwrap()
}
#[test] #[test]
fn test_race_register_tick_freeze() { fn test_race_register_tick_freeze() {
solana_logger::setup(); solana_logger::setup();
@ -2666,7 +2670,7 @@ fn test_bank_tx_compute_unit_fee() {
let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config); let (bank, bank_forks) = Bank::new_with_bank_forks_for_tests(&genesis_config);
let expected_fee_paid = calculate_test_fee( let expected_fee_paid = calculate_test_fee(
&SanitizedMessage::try_from(Message::new(&[], Some(&Pubkey::new_unique()))).unwrap(), &new_sanitized_message(Message::new(&[], Some(&Pubkey::new_unique()))),
genesis_config genesis_config
.fee_rate_governor .fee_rate_governor
.create_fee_calculator() .create_fee_calculator()
@ -2794,7 +2798,7 @@ fn test_bank_blockhash_fee_structure() {
assert_eq!(bank.process_transaction(&tx), Ok(())); assert_eq!(bank.process_transaction(&tx), Ok(()));
assert_eq!(bank.get_balance(&key), 1); assert_eq!(bank.get_balance(&key), 1);
let cheap_fee = calculate_test_fee( let cheap_fee = calculate_test_fee(
&SanitizedMessage::try_from(Message::new(&[], Some(&Pubkey::new_unique()))).unwrap(), &new_sanitized_message(Message::new(&[], Some(&Pubkey::new_unique()))),
cheap_lamports_per_signature, cheap_lamports_per_signature,
&bank.fee_structure, &bank.fee_structure,
); );
@ -2810,7 +2814,7 @@ fn test_bank_blockhash_fee_structure() {
assert_eq!(bank.process_transaction(&tx), Ok(())); assert_eq!(bank.process_transaction(&tx), Ok(()));
assert_eq!(bank.get_balance(&key), 1); assert_eq!(bank.get_balance(&key), 1);
let expensive_fee = calculate_test_fee( let expensive_fee = calculate_test_fee(
&SanitizedMessage::try_from(Message::new(&[], Some(&Pubkey::new_unique()))).unwrap(), &new_sanitized_message(Message::new(&[], Some(&Pubkey::new_unique()))),
expensive_lamports_per_signature, expensive_lamports_per_signature,
&bank.fee_structure, &bank.fee_structure,
); );
@ -2856,7 +2860,7 @@ fn test_bank_blockhash_compute_unit_fee_structure() {
assert_eq!(bank.process_transaction(&tx), Ok(())); assert_eq!(bank.process_transaction(&tx), Ok(()));
assert_eq!(bank.get_balance(&key), 1); assert_eq!(bank.get_balance(&key), 1);
let cheap_fee = calculate_test_fee( let cheap_fee = calculate_test_fee(
&SanitizedMessage::try_from(Message::new(&[], Some(&Pubkey::new_unique()))).unwrap(), &new_sanitized_message(Message::new(&[], Some(&Pubkey::new_unique()))),
cheap_lamports_per_signature, cheap_lamports_per_signature,
&bank.fee_structure, &bank.fee_structure,
); );
@ -2872,7 +2876,7 @@ fn test_bank_blockhash_compute_unit_fee_structure() {
assert_eq!(bank.process_transaction(&tx), Ok(())); assert_eq!(bank.process_transaction(&tx), Ok(()));
assert_eq!(bank.get_balance(&key), 1); assert_eq!(bank.get_balance(&key), 1);
let expensive_fee = calculate_test_fee( let expensive_fee = calculate_test_fee(
&SanitizedMessage::try_from(Message::new(&[], Some(&Pubkey::new_unique()))).unwrap(), &new_sanitized_message(Message::new(&[], Some(&Pubkey::new_unique()))),
expensive_lamports_per_signature, expensive_lamports_per_signature,
&bank.fee_structure, &bank.fee_structure,
); );
@ -2979,8 +2983,7 @@ fn test_filter_program_errors_and_collect_compute_unit_fee() {
.fee_rate_governor .fee_rate_governor
.burn( .burn(
calculate_test_fee( calculate_test_fee(
&SanitizedMessage::try_from(Message::new(&[], Some(&Pubkey::new_unique()))) &new_sanitized_message(Message::new(&[], Some(&Pubkey::new_unique()))),
.unwrap(),
genesis_config genesis_config
.fee_rate_governor .fee_rate_governor
.create_fee_calculator() .create_fee_calculator()
@ -5275,7 +5278,7 @@ fn test_nonce_transaction() {
recent_message.recent_blockhash = bank.last_blockhash(); recent_message.recent_blockhash = bank.last_blockhash();
let mut expected_balance = 4_650_000 let mut expected_balance = 4_650_000
- bank - bank
.get_fee_for_message(&recent_message.try_into().unwrap()) .get_fee_for_message(&new_sanitized_message(recent_message))
.unwrap(); .unwrap();
assert_eq!(bank.get_balance(&custodian_pubkey), expected_balance); assert_eq!(bank.get_balance(&custodian_pubkey), expected_balance);
assert_eq!(bank.get_balance(&nonce_pubkey), 250_000); assert_eq!(bank.get_balance(&nonce_pubkey), 250_000);
@ -5334,7 +5337,7 @@ fn test_nonce_transaction() {
let mut recent_message = nonce_tx.message.clone(); let mut recent_message = nonce_tx.message.clone();
recent_message.recent_blockhash = bank.last_blockhash(); recent_message.recent_blockhash = bank.last_blockhash();
expected_balance -= bank expected_balance -= bank
.get_fee_for_message(&SanitizedMessage::try_from(recent_message).unwrap()) .get_fee_for_message(&new_sanitized_message(recent_message))
.unwrap(); .unwrap();
assert_eq!(bank.get_balance(&custodian_pubkey), expected_balance); assert_eq!(bank.get_balance(&custodian_pubkey), expected_balance);
assert_ne!( assert_ne!(
@ -5402,7 +5405,7 @@ fn test_nonce_transaction_with_tx_wide_caps() {
recent_message.recent_blockhash = bank.last_blockhash(); recent_message.recent_blockhash = bank.last_blockhash();
let mut expected_balance = 4_650_000 let mut expected_balance = 4_650_000
- bank - bank
.get_fee_for_message(&recent_message.try_into().unwrap()) .get_fee_for_message(&new_sanitized_message(recent_message))
.unwrap(); .unwrap();
assert_eq!(bank.get_balance(&custodian_pubkey), expected_balance); assert_eq!(bank.get_balance(&custodian_pubkey), expected_balance);
assert_eq!(bank.get_balance(&nonce_pubkey), 250_000); assert_eq!(bank.get_balance(&nonce_pubkey), 250_000);
@ -5461,7 +5464,7 @@ fn test_nonce_transaction_with_tx_wide_caps() {
let mut recent_message = nonce_tx.message.clone(); let mut recent_message = nonce_tx.message.clone();
recent_message.recent_blockhash = bank.last_blockhash(); recent_message.recent_blockhash = bank.last_blockhash();
expected_balance -= bank expected_balance -= bank
.get_fee_for_message(&SanitizedMessage::try_from(recent_message).unwrap()) .get_fee_for_message(&new_sanitized_message(recent_message))
.unwrap(); .unwrap();
assert_eq!(bank.get_balance(&custodian_pubkey), expected_balance); assert_eq!(bank.get_balance(&custodian_pubkey), expected_balance);
assert_ne!( assert_ne!(
@ -5593,7 +5596,7 @@ fn test_nonce_payer() {
bank.get_balance(&nonce_pubkey), bank.get_balance(&nonce_pubkey),
nonce_starting_balance nonce_starting_balance
- bank - bank
.get_fee_for_message(&recent_message.try_into().unwrap()) .get_fee_for_message(&new_sanitized_message(recent_message))
.unwrap() .unwrap()
); );
assert_ne!( assert_ne!(
@ -5660,7 +5663,7 @@ fn test_nonce_payer_tx_wide_cap() {
bank.get_balance(&nonce_pubkey), bank.get_balance(&nonce_pubkey),
nonce_starting_balance nonce_starting_balance
- bank - bank
.get_fee_for_message(&recent_message.try_into().unwrap()) .get_fee_for_message(&new_sanitized_message(recent_message))
.unwrap() .unwrap()
); );
assert_ne!( assert_ne!(
@ -10034,8 +10037,7 @@ fn calculate_test_fee(
#[test] #[test]
fn test_calculate_fee() { fn test_calculate_fee() {
// Default: no fee. // Default: no fee.
let message = let message = new_sanitized_message(Message::new(&[], Some(&Pubkey::new_unique())));
SanitizedMessage::try_from(Message::new(&[], Some(&Pubkey::new_unique()))).unwrap();
assert_eq!( assert_eq!(
calculate_test_fee( calculate_test_fee(
&message, &message,
@ -10066,7 +10068,7 @@ fn test_calculate_fee() {
let key1 = Pubkey::new_unique(); let key1 = Pubkey::new_unique();
let ix0 = system_instruction::transfer(&key0, &key1, 1); let ix0 = system_instruction::transfer(&key0, &key1, 1);
let ix1 = system_instruction::transfer(&key1, &key0, 1); let ix1 = system_instruction::transfer(&key1, &key0, 1);
let message = SanitizedMessage::try_from(Message::new(&[ix0, ix1], Some(&key0))).unwrap(); let message = new_sanitized_message(Message::new(&[ix0, ix1], Some(&key0)));
assert_eq!( assert_eq!(
calculate_test_fee( calculate_test_fee(
&message, &message,
@ -10091,8 +10093,7 @@ fn test_calculate_fee_compute_units() {
// One signature, no unit request // One signature, no unit request
let message = let message = new_sanitized_message(Message::new(&[], Some(&Pubkey::new_unique())));
SanitizedMessage::try_from(Message::new(&[], Some(&Pubkey::new_unique()))).unwrap();
assert_eq!( assert_eq!(
calculate_test_fee(&message, 1, &fee_structure,), calculate_test_fee(&message, 1, &fee_structure,),
max_fee + lamports_per_signature max_fee + lamports_per_signature
@ -10102,8 +10103,7 @@ fn test_calculate_fee_compute_units() {
let ix0 = system_instruction::transfer(&Pubkey::new_unique(), &Pubkey::new_unique(), 1); let ix0 = system_instruction::transfer(&Pubkey::new_unique(), &Pubkey::new_unique(), 1);
let ix1 = system_instruction::transfer(&Pubkey::new_unique(), &Pubkey::new_unique(), 1); let ix1 = system_instruction::transfer(&Pubkey::new_unique(), &Pubkey::new_unique(), 1);
let message = let message = new_sanitized_message(Message::new(&[ix0, ix1], Some(&Pubkey::new_unique())));
SanitizedMessage::try_from(Message::new(&[ix0, ix1], Some(&Pubkey::new_unique()))).unwrap();
assert_eq!( assert_eq!(
calculate_test_fee(&message, 1, &fee_structure,), calculate_test_fee(&message, 1, &fee_structure,),
max_fee + 3 * lamports_per_signature max_fee + 3 * lamports_per_signature
@ -10129,15 +10129,14 @@ fn test_calculate_fee_compute_units() {
PrioritizationFeeType::ComputeUnitPrice(PRIORITIZATION_FEE_RATE), PrioritizationFeeType::ComputeUnitPrice(PRIORITIZATION_FEE_RATE),
requested_compute_units as u64, requested_compute_units as u64,
); );
let message = SanitizedMessage::try_from(Message::new( let message = new_sanitized_message(Message::new(
&[ &[
ComputeBudgetInstruction::set_compute_unit_limit(requested_compute_units), ComputeBudgetInstruction::set_compute_unit_limit(requested_compute_units),
ComputeBudgetInstruction::set_compute_unit_price(PRIORITIZATION_FEE_RATE), ComputeBudgetInstruction::set_compute_unit_price(PRIORITIZATION_FEE_RATE),
Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
], ],
Some(&Pubkey::new_unique()), Some(&Pubkey::new_unique()),
)) ));
.unwrap();
let fee = calculate_test_fee(&message, 1, &fee_structure); let fee = calculate_test_fee(&message, 1, &fee_structure);
assert_eq!( assert_eq!(
fee, fee,
@ -10161,14 +10160,13 @@ fn test_calculate_prioritization_fee() {
); );
let prioritization_fee = prioritization_fee_details.get_fee(); let prioritization_fee = prioritization_fee_details.get_fee();
let message = SanitizedMessage::try_from(Message::new( let message = new_sanitized_message(Message::new(
&[ &[
ComputeBudgetInstruction::set_compute_unit_limit(request_units), ComputeBudgetInstruction::set_compute_unit_limit(request_units),
ComputeBudgetInstruction::set_compute_unit_price(request_unit_price), ComputeBudgetInstruction::set_compute_unit_price(request_unit_price),
], ],
Some(&Pubkey::new_unique()), Some(&Pubkey::new_unique()),
)) ));
.unwrap();
let fee = calculate_test_fee( let fee = calculate_test_fee(
&message, &message,
@ -10202,24 +10200,22 @@ fn test_calculate_fee_secp256k1() {
data: vec![1], data: vec![1],
}; };
let message = SanitizedMessage::try_from(Message::new( let message = new_sanitized_message(Message::new(
&[ &[
ix0.clone(), ix0.clone(),
secp_instruction1.clone(), secp_instruction1.clone(),
secp_instruction2.clone(), secp_instruction2.clone(),
], ],
Some(&key0), Some(&key0),
)) ));
.unwrap();
assert_eq!(calculate_test_fee(&message, 1, &fee_structure,), 2); assert_eq!(calculate_test_fee(&message, 1, &fee_structure,), 2);
secp_instruction1.data = vec![0]; secp_instruction1.data = vec![0];
secp_instruction2.data = vec![10]; secp_instruction2.data = vec![10];
let message = SanitizedMessage::try_from(Message::new( let message = new_sanitized_message(Message::new(
&[ix0, secp_instruction1, secp_instruction2], &[ix0, secp_instruction1, secp_instruction2],
Some(&key0), Some(&key0),
)) ));
.unwrap();
assert_eq!(calculate_test_fee(&message, 1, &fee_structure,), 11); assert_eq!(calculate_test_fee(&message, 1, &fee_structure,), 11);
} }
@ -10745,7 +10741,7 @@ fn test_invalid_rent_state_changes_fee_payer() {
.unwrap(); .unwrap();
// Dummy message to determine fee amount // Dummy message to determine fee amount
let dummy_message = SanitizedMessage::try_from(Message::new_with_blockhash( let dummy_message = new_sanitized_message(Message::new_with_blockhash(
&[system_instruction::transfer( &[system_instruction::transfer(
&rent_exempt_fee_payer.pubkey(), &rent_exempt_fee_payer.pubkey(),
&recipient, &recipient,
@ -10753,8 +10749,7 @@ fn test_invalid_rent_state_changes_fee_payer() {
)], )],
Some(&rent_exempt_fee_payer.pubkey()), Some(&rent_exempt_fee_payer.pubkey()),
&recent_blockhash, &recent_blockhash,
)) ));
.unwrap();
let fee = bank.get_fee_for_message(&dummy_message).unwrap(); let fee = bank.get_fee_for_message(&dummy_message).unwrap();
// RentPaying fee-payer can remain RentPaying // RentPaying fee-payer can remain RentPaying
@ -11814,7 +11809,7 @@ fn test_calculate_fee_with_congestion_multiplier() {
let key1 = Pubkey::new_unique(); let key1 = Pubkey::new_unique();
let ix0 = system_instruction::transfer(&key0, &key1, 1); let ix0 = system_instruction::transfer(&key0, &key1, 1);
let ix1 = system_instruction::transfer(&key1, &key0, 1); let ix1 = system_instruction::transfer(&key1, &key0, 1);
let message = SanitizedMessage::try_from(Message::new(&[ix0, ix1], Some(&key0))).unwrap(); let message = new_sanitized_message(Message::new(&[ix0, ix1], Some(&key0)));
// assert when lamports_per_signature is less than BASE_LAMPORTS, turnning on/off // assert when lamports_per_signature is less than BASE_LAMPORTS, turnning on/off
// congestion_multiplier has no effect on fee. // congestion_multiplier has no effect on fee.
@ -11843,7 +11838,7 @@ fn test_calculate_fee_with_request_heap_frame_flag() {
lamports_per_signature: signature_fee, lamports_per_signature: signature_fee,
..FeeStructure::default() ..FeeStructure::default()
}; };
let message = SanitizedMessage::try_from(Message::new( let message = new_sanitized_message(Message::new(
&[ &[
system_instruction::transfer(&key0, &key1, 1), system_instruction::transfer(&key0, &key1, 1),
ComputeBudgetInstruction::set_compute_unit_limit(request_cu as u32), ComputeBudgetInstruction::set_compute_unit_limit(request_cu as u32),
@ -11851,8 +11846,7 @@ fn test_calculate_fee_with_request_heap_frame_flag() {
ComputeBudgetInstruction::set_compute_unit_price(lamports_per_cu * 1_000_000), ComputeBudgetInstruction::set_compute_unit_price(lamports_per_cu * 1_000_000),
], ],
Some(&key0), Some(&key0),
)) ));
.unwrap();
// assert when request_heap_frame is presented in tx, prioritization fee will be counted // assert when request_heap_frame is presented in tx, prioritization fee will be counted
// into transaction fee // into transaction fee

3
runtime/src/bank_client.rs
View File

@ -19,7 +19,6 @@ use {
transport::{Result, TransportError}, transport::{Result, TransportError},
}, },
std::{ std::{
convert::TryFrom,
io, io,
sync::{Arc, Mutex}, sync::{Arc, Mutex},
thread::{sleep, Builder}, thread::{sleep, Builder},
@ -286,7 +285,7 @@ impl SyncClient for BankClient {
} }
fn get_fee_for_message(&self, message: &Message) -> Result<u64> { fn get_fee_for_message(&self, message: &Message) -> Result<u64> {
SanitizedMessage::try_from(message.clone()) SanitizedMessage::try_from_legacy_message(message.clone())
.ok() .ok()
.and_then(|sanitized_message| self.bank.get_fee_for_message(&sanitized_message)) .and_then(|sanitized_message| self.bank.get_fee_for_message(&sanitized_message))
.ok_or_else(|| { .ok_or_else(|| {

9
runtime/src/compute_budget_details.rs
View File

@ -95,8 +95,7 @@ mod tests {
); );
// assert for SanitizedTransaction // assert for SanitizedTransaction
let sanitized_transaction = let sanitized_transaction = SanitizedTransaction::from_transaction_for_tests(transaction);
SanitizedTransaction::try_from_legacy_transaction(transaction).unwrap();
assert_eq!( assert_eq!(
sanitized_transaction.get_compute_budget_details(false), sanitized_transaction.get_compute_budget_details(false),
Some(ComputeBudgetDetails { Some(ComputeBudgetDetails {
@ -133,8 +132,7 @@ mod tests {
); );
// assert for SanitizedTransaction // assert for SanitizedTransaction
let sanitized_transaction = let sanitized_transaction = SanitizedTransaction::from_transaction_for_tests(transaction);
SanitizedTransaction::try_from_legacy_transaction(transaction).unwrap();
assert_eq!( assert_eq!(
sanitized_transaction.get_compute_budget_details(false), sanitized_transaction.get_compute_budget_details(false),
Some(ComputeBudgetDetails { Some(ComputeBudgetDetails {
@ -171,8 +169,7 @@ mod tests {
); );
// assert for SanitizedTransaction // assert for SanitizedTransaction
let sanitized_transaction = let sanitized_transaction = SanitizedTransaction::from_transaction_for_tests(transaction);
SanitizedTransaction::try_from_legacy_transaction(transaction).unwrap();
assert_eq!( assert_eq!(
sanitized_transaction.get_compute_budget_details(false), sanitized_transaction.get_compute_budget_details(false),
Some(ComputeBudgetDetails { Some(ComputeBudgetDetails {

2
runtime/src/prioritization_fee_cache.rs
View File

@ -459,7 +459,7 @@ mod tests {
Some(signer_account), Some(signer_account),
)); ));
SanitizedTransaction::try_from_legacy_transaction(transaction).unwrap() SanitizedTransaction::from_transaction_for_tests(transaction)
} }
// update fee cache is asynchronous, this test helper blocks until update is completed. // update fee cache is asynchronous, this test helper blocks until update is completed.

25
sdk/benches/serialize_instructions.rs
View File

@ -9,7 +9,6 @@ use {
pubkey::{self, Pubkey}, pubkey::{self, Pubkey},
sysvar::instructions::{self, construct_instructions_data}, sysvar::instructions::{self, construct_instructions_data},
}, },
std::convert::TryFrom,
test::Bencher, test::Bencher,
}; };
@ -30,9 +29,11 @@ fn bench_bincode_instruction_serialize(b: &mut Bencher) {
#[bench] #[bench]
fn bench_construct_instructions_data(b: &mut Bencher) { fn bench_construct_instructions_data(b: &mut Bencher) {
let instructions = make_instructions(); let instructions = make_instructions();
let message = let message = SanitizedMessage::try_from_legacy_message(Message::new(
SanitizedMessage::try_from(Message::new(&instructions, Some(&Pubkey::new_unique()))) &instructions,
.unwrap(); Some(&Pubkey::new_unique()),
))
.unwrap();
b.iter(|| { b.iter(|| {
let instructions = message.decompile_instructions(); let instructions = message.decompile_instructions();
test::black_box(construct_instructions_data(&instructions)); test::black_box(construct_instructions_data(&instructions));
@ -51,9 +52,11 @@ fn bench_bincode_instruction_deserialize(b: &mut Bencher) {
#[bench] #[bench]
fn bench_manual_instruction_deserialize(b: &mut Bencher) { fn bench_manual_instruction_deserialize(b: &mut Bencher) {
let instructions = make_instructions(); let instructions = make_instructions();
let message = let message = SanitizedMessage::try_from_legacy_message(Message::new(
SanitizedMessage::try_from(Message::new(&instructions, Some(&Pubkey::new_unique()))) &instructions,
.unwrap(); Some(&Pubkey::new_unique()),
))
.unwrap();
let serialized = construct_instructions_data(&message.decompile_instructions()); let serialized = construct_instructions_data(&message.decompile_instructions());
b.iter(|| { b.iter(|| {
for i in 0..instructions.len() { for i in 0..instructions.len() {
@ -66,9 +69,11 @@ fn bench_manual_instruction_deserialize(b: &mut Bencher) {
#[bench] #[bench]
fn bench_manual_instruction_deserialize_single(b: &mut Bencher) { fn bench_manual_instruction_deserialize_single(b: &mut Bencher) {
let instructions = make_instructions(); let instructions = make_instructions();
let message = let message = SanitizedMessage::try_from_legacy_message(Message::new(
SanitizedMessage::try_from(Message::new(&instructions, Some(&Pubkey::new_unique()))) &instructions,
.unwrap(); Some(&Pubkey::new_unique()),
))
.unwrap();
let serialized = construct_instructions_data(&message.decompile_instructions()); let serialized = construct_instructions_data(&message.decompile_instructions());
b.iter(|| { b.iter(|| {
#[allow(deprecated)] #[allow(deprecated)]

58
sdk/program/src/message/sanitized.rs
View File

@ -98,14 +98,6 @@ impl From<SanitizeError> for SanitizeMessageError {
} }
} }
impl TryFrom<legacy::Message> for SanitizedMessage {
type Error = SanitizeMessageError;
fn try_from(message: legacy::Message) -> Result<Self, Self::Error> {
message.sanitize()?;
Ok(Self::Legacy(LegacyMessage::new(message)))
}
}
impl SanitizedMessage { impl SanitizedMessage {
/// Create a sanitized message from a sanitized versioned message. /// Create a sanitized message from a sanitized versioned message.
/// If the input message uses address tables, attempt to look up the /// If the input message uses address tables, attempt to look up the
@ -126,6 +118,12 @@ impl SanitizedMessage {
}) })
} }
/// Create a sanitized legacy message
pub fn try_from_legacy_message(message: legacy::Message) -> Result<Self, SanitizeMessageError> {
message.sanitize()?;
Ok(Self::Legacy(LegacyMessage::new(message)))
}
/// Return true if this message contains duplicate account keys /// Return true if this message contains duplicate account keys
pub fn has_duplicates(&self) -> bool { pub fn has_duplicates(&self) -> bool {
match self { match self {
@ -374,14 +372,14 @@ mod tests {
use {super::*, crate::message::v0, std::collections::HashSet}; use {super::*, crate::message::v0, std::collections::HashSet};
#[test] #[test]
fn test_try_from_message() { fn test_try_from_legacy_message() {
let legacy_message_with_no_signers = legacy::Message { let legacy_message_with_no_signers = legacy::Message {
account_keys: vec![Pubkey::new_unique()], account_keys: vec![Pubkey::new_unique()],
..legacy::Message::default() ..legacy::Message::default()
}; };
assert_eq!( assert_eq!(
SanitizedMessage::try_from(legacy_message_with_no_signers).err(), SanitizedMessage::try_from_legacy_message(legacy_message_with_no_signers).err(),
Some(SanitizeMessageError::IndexOutOfBounds), Some(SanitizeMessageError::IndexOutOfBounds),
); );
} }
@ -396,14 +394,16 @@ mod tests {
CompiledInstruction::new(2, &(), vec![0, 1]), CompiledInstruction::new(2, &(), vec![0, 1]),
]; ];
let message = SanitizedMessage::try_from(legacy::Message::new_with_compiled_instructions( let message = SanitizedMessage::try_from_legacy_message(
1, legacy::Message::new_with_compiled_instructions(
0, 1,
2, 0,
vec![key0, key1, loader_key], 2,
Hash::default(), vec![key0, key1, loader_key],
instructions, Hash::default(),
)) instructions,
),
)
.unwrap(); .unwrap();
assert!(message.is_non_loader_key(0)); assert!(message.is_non_loader_key(0));
@ -420,7 +420,7 @@ mod tests {
let key4 = Pubkey::new_unique(); let key4 = Pubkey::new_unique();
let key5 = Pubkey::new_unique(); let key5 = Pubkey::new_unique();
let legacy_message = SanitizedMessage::try_from(legacy::Message { let legacy_message = SanitizedMessage::try_from_legacy_message(legacy::Message {
header: MessageHeader { header: MessageHeader {
num_required_signatures: 2, num_required_signatures: 2,
num_readonly_signed_accounts: 1, num_readonly_signed_accounts: 1,
@ -464,14 +464,16 @@ mod tests {
CompiledInstruction::new(3, &(), vec![0, 0]), CompiledInstruction::new(3, &(), vec![0, 0]),
]; ];
let message = SanitizedMessage::try_from(legacy::Message::new_with_compiled_instructions( let message = SanitizedMessage::try_from_legacy_message(
2, legacy::Message::new_with_compiled_instructions(
1, 2,
2, 1,
vec![signer0, signer1, non_signer, loader_key], 2,
Hash::default(), vec![signer0, signer1, non_signer, loader_key],
instructions, Hash::default(),
)) instructions,
),
)
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
@ -502,7 +504,7 @@ mod tests {
let key4 = Pubkey::new_unique(); let key4 = Pubkey::new_unique();
let key5 = Pubkey::new_unique(); let key5 = Pubkey::new_unique();
let legacy_message = SanitizedMessage::try_from(legacy::Message { let legacy_message = SanitizedMessage::try_from_legacy_message(legacy::Message {
header: MessageHeader { header: MessageHeader {
num_required_signatures: 2, num_required_signatures: 2,
num_readonly_signed_accounts: 1, num_readonly_signed_accounts: 1,

33
sdk/program/src/sysvar/instructions.rs
View File

@ -302,9 +302,12 @@ mod tests {
message::{Message as LegacyMessage, SanitizedMessage}, message::{Message as LegacyMessage, SanitizedMessage},
pubkey::Pubkey, pubkey::Pubkey,
}, },
std::convert::TryFrom,
}; };
fn new_sanitized_message(message: LegacyMessage) -> SanitizedMessage {
SanitizedMessage::try_from_legacy_message(message).unwrap()
}
#[test] #[test]
fn test_load_store_instruction() { fn test_load_store_instruction() {
let mut data = [4u8; 10]; let mut data = [4u8; 10];
@ -327,11 +330,11 @@ mod tests {
&0, &0,
vec![AccountMeta::new(Pubkey::new_unique(), false)], vec![AccountMeta::new(Pubkey::new_unique(), false)],
); );
let sanitized_message = SanitizedMessage::try_from(LegacyMessage::new( let message = LegacyMessage::new(
&[instruction0.clone(), instruction1.clone()], &[instruction0.clone(), instruction1.clone()],
Some(&Pubkey::new_unique()), Some(&Pubkey::new_unique()),
)) );
.unwrap(); let sanitized_message = new_sanitized_message(message);
let key = id(); let key = id();
let mut lamports = 0; let mut lamports = 0;
@ -381,11 +384,9 @@ mod tests {
&0, &0,
vec![AccountMeta::new(Pubkey::new_unique(), false)], vec![AccountMeta::new(Pubkey::new_unique(), false)],
); );
let sanitized_message = SanitizedMessage::try_from(LegacyMessage::new( let message =
&[instruction0, instruction1], LegacyMessage::new(&[instruction0, instruction1], Some(&Pubkey::new_unique()));
Some(&Pubkey::new_unique()), let sanitized_message = new_sanitized_message(message);
))
.unwrap();
let key = id(); let key = id();
let mut lamports = 0; let mut lamports = 0;
@ -435,15 +436,15 @@ mod tests {
&0, &0,
vec![AccountMeta::new(Pubkey::new_unique(), false)], vec![AccountMeta::new(Pubkey::new_unique(), false)],
); );
let sanitized_message = SanitizedMessage::try_from(LegacyMessage::new( let message = LegacyMessage::new(
&[ &[
instruction0.clone(), instruction0.clone(),
instruction1.clone(), instruction1.clone(),
instruction2.clone(), instruction2.clone(),
], ],
Some(&Pubkey::new_unique()), Some(&Pubkey::new_unique()),
)) );
.unwrap(); let sanitized_message = new_sanitized_message(message);
let key = id(); let key = id();
let mut lamports = 0; let mut lamports = 0;
@ -538,7 +539,7 @@ mod tests {
]; ];
let message = LegacyMessage::new(&instructions, Some(&id1)); let message = LegacyMessage::new(&instructions, Some(&id1));
let sanitized_message = SanitizedMessage::try_from(message).unwrap(); let sanitized_message = new_sanitized_message(message);
let serialized = serialize_instructions(&sanitized_message.decompile_instructions()); let serialized = serialize_instructions(&sanitized_message.decompile_instructions());
// assert that deserialize_instruction is compatible with SanitizedMessage::serialize_instructions // assert that deserialize_instruction is compatible with SanitizedMessage::serialize_instructions
@ -560,9 +561,9 @@ mod tests {
Instruction::new_with_bincode(program_id0, &0, vec![AccountMeta::new(id1, true)]), Instruction::new_with_bincode(program_id0, &0, vec![AccountMeta::new(id1, true)]),
]; ];
let message = let message = LegacyMessage::new(&instructions, Some(&id1));
SanitizedMessage::try_from(LegacyMessage::new(&instructions, Some(&id1))).unwrap(); let sanitized_message = new_sanitized_message(message);
let serialized = serialize_instructions(&message.decompile_instructions()); let serialized = serialize_instructions(&sanitized_message.decompile_instructions());
assert_eq!( assert_eq!(
deserialize_instruction(instructions.len(), &serialized).unwrap_err(), deserialize_instruction(instructions.len(), &serialized).unwrap_err(),
SanitizeError::IndexOutOfBounds, SanitizeError::IndexOutOfBounds,

2
sdk/src/nonce_info.rs
View File

@ -133,7 +133,7 @@ mod tests {
instructions: &[Instruction], instructions: &[Instruction],
payer: Option<&Pubkey>, payer: Option<&Pubkey>,
) -> SanitizedMessage { ) -> SanitizedMessage {
Message::new(instructions, payer).try_into().unwrap() SanitizedMessage::try_from_legacy_message(Message::new(instructions, payer)).unwrap()
} }
#[test] #[test]

4
svm/src/account_loader.rs
View File

@ -686,7 +686,7 @@ mod tests {
instructions, instructions,
); );
let message = SanitizedMessage::try_from(tx.message().clone()).unwrap(); let message = SanitizedMessage::try_from_legacy_message(tx.message().clone()).unwrap();
let fee = FeeStructure::default().calculate_fee( let fee = FeeStructure::default().calculate_fee(
&message, &message,
lamports_per_signature, lamports_per_signature,
@ -1215,7 +1215,7 @@ mod tests {
Hash::default(), Hash::default(),
); );
let message = SanitizedMessage::try_from(tx.message().clone()).unwrap(); let message = SanitizedMessage::try_from_legacy_message(tx.message().clone()).unwrap();
let fee = FeeStructure::default().calculate_fee( let fee = FeeStructure::default().calculate_fee(
&message, &message,
lamports_per_signature, lamports_per_signature,

2
svm/tests/rent_state.rs
View File

@ -55,7 +55,7 @@ fn test_rent_state_list_len() {
last_block_hash, last_block_hash,
); );
let num_accounts = tx.message().account_keys.len(); let num_accounts = tx.message().account_keys.len();
let sanitized_tx = SanitizedTransaction::try_from_legacy_transaction(tx).unwrap(); let sanitized_tx = SanitizedTransaction::from_transaction_for_tests(tx);
let mut error_counters = TransactionErrorMetrics::default(); let mut error_counters = TransactionErrorMetrics::default();
let loaded_txs = load_accounts( let loaded_txs = load_accounts(
&bank, &bank,