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

cleanup feature: tx-wide-compute-cap (#26326)

This commit is contained in:
Jack May 2022-06-29 23:54:45 -07:00 committed by GitHub
parent 36d13af015
commit 4563bf40f6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 269 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
core/src/unprocessed_packet_batches.rs
View File

@ -393,7 +393,6 @@ fn get_priority_details(message: &SanitizedVersionedMessage) -> Option<Transacti
let prioritization_fee_details = compute_budget let prioritization_fee_details = compute_budget
.process_instructions( .process_instructions(
message.program_instructions_iter(), message.program_instructions_iter(),
true, // don't reject txs that use request heap size ix
true, // use default units per instruction true, // use default units per instruction
true, // don't reject txs that use set compute unit price ix true, // don't reject txs that use set compute unit price ix
) )

69
program-runtime/src/compute_budget.rs
View File

@ -129,7 +129,6 @@ impl ComputeBudget {
pub fn process_instructions<'a>( pub fn process_instructions<'a>(
&mut self, &mut self,
instructions: impl Iterator<Item = (&'a Pubkey, &'a CompiledInstruction)>, instructions: impl Iterator<Item = (&'a Pubkey, &'a CompiledInstruction)>,
requestable_heap_size: bool,
default_units_per_instruction: bool, default_units_per_instruction: bool,
support_set_compute_unit_price_ix: bool, support_set_compute_unit_price_ix: bool,
) -> Result<PrioritizationFeeDetails, TransactionError> { ) -> Result<PrioritizationFeeDetails, TransactionError> {
@ -213,8 +212,7 @@ impl ComputeBudget {
} }
if let Some((bytes, i)) = requested_heap_size { if let Some((bytes, i)) = requested_heap_size {
if !requestable_heap_size if bytes > MAX_HEAP_FRAME_BYTES
|| bytes > MAX_HEAP_FRAME_BYTES
|| bytes < MIN_HEAP_FRAME_BYTES as u32 || bytes < MIN_HEAP_FRAME_BYTES as u32
|| bytes % 1024 != 0 || bytes % 1024 != 0
{ {
@ -283,7 +281,6 @@ mod tests {
let result = compute_budget.process_instructions( let result = compute_budget.process_instructions(
tx.message().program_instructions_iter(), tx.message().program_instructions_iter(),
true, true,
true,
$type_change, $type_change,
); );
assert_eq!($expected_result, result); assert_eq!($expected_result, result);
@ -308,7 +305,7 @@ mod tests {
test!( test!(
&[ &[
ComputeBudgetInstruction::set_compute_unit_limit(1), ComputeBudgetInstruction::set_compute_unit_limit(1),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
], ],
Ok(PrioritizationFeeDetails::default()), Ok(PrioritizationFeeDetails::default()),
ComputeBudget { ComputeBudget {
@ -319,7 +316,7 @@ mod tests {
test!( test!(
&[ &[
ComputeBudgetInstruction::set_compute_unit_limit(MAX_COMPUTE_UNIT_LIMIT + 1), ComputeBudgetInstruction::set_compute_unit_limit(MAX_COMPUTE_UNIT_LIMIT + 1),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
], ],
Ok(PrioritizationFeeDetails::default()), Ok(PrioritizationFeeDetails::default()),
ComputeBudget { ComputeBudget {
@ -329,7 +326,7 @@ mod tests {
); );
test!( test!(
&[ &[
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
ComputeBudgetInstruction::set_compute_unit_limit(MAX_COMPUTE_UNIT_LIMIT), ComputeBudgetInstruction::set_compute_unit_limit(MAX_COMPUTE_UNIT_LIMIT),
], ],
Ok(PrioritizationFeeDetails::default()), Ok(PrioritizationFeeDetails::default()),
@ -340,9 +337,9 @@ mod tests {
); );
test!( test!(
&[ &[
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
ComputeBudgetInstruction::set_compute_unit_limit(1), ComputeBudgetInstruction::set_compute_unit_limit(1),
], ],
Ok(PrioritizationFeeDetails::default()), Ok(PrioritizationFeeDetails::default()),
@ -354,9 +351,9 @@ mod tests {
test!( test!(
&[ &[
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
ComputeBudgetInstruction::set_compute_unit_limit(1), // ignored ComputeBudgetInstruction::set_compute_unit_limit(1), // ignored
], ],
Ok(PrioritizationFeeDetails::default()), Ok(PrioritizationFeeDetails::default()),
@ -421,7 +418,7 @@ mod tests {
test!( test!(
&[ &[
ComputeBudgetInstruction::request_heap_frame(40 * 1024), ComputeBudgetInstruction::request_heap_frame(40 * 1024),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
], ],
Ok(PrioritizationFeeDetails::default()), Ok(PrioritizationFeeDetails::default()),
ComputeBudget { ComputeBudget {
@ -433,7 +430,7 @@ mod tests {
test!( test!(
&[ &[
ComputeBudgetInstruction::request_heap_frame(40 * 1024 + 1), ComputeBudgetInstruction::request_heap_frame(40 * 1024 + 1),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
], ],
Err(TransactionError::InstructionError( Err(TransactionError::InstructionError(
0, 0,
@ -444,7 +441,7 @@ mod tests {
test!( test!(
&[ &[
ComputeBudgetInstruction::request_heap_frame(31 * 1024), ComputeBudgetInstruction::request_heap_frame(31 * 1024),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
], ],
Err(TransactionError::InstructionError( Err(TransactionError::InstructionError(
0, 0,
@ -455,7 +452,7 @@ mod tests {
test!( test!(
&[ &[
ComputeBudgetInstruction::request_heap_frame(MAX_HEAP_FRAME_BYTES + 1), ComputeBudgetInstruction::request_heap_frame(MAX_HEAP_FRAME_BYTES + 1),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
], ],
Err(TransactionError::InstructionError( Err(TransactionError::InstructionError(
0, 0,
@ -465,7 +462,7 @@ mod tests {
); );
test!( test!(
&[ &[
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
ComputeBudgetInstruction::request_heap_frame(MAX_HEAP_FRAME_BYTES), ComputeBudgetInstruction::request_heap_frame(MAX_HEAP_FRAME_BYTES),
], ],
Ok(PrioritizationFeeDetails::default()), Ok(PrioritizationFeeDetails::default()),
@ -477,9 +474,9 @@ mod tests {
); );
test!( test!(
&[ &[
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
ComputeBudgetInstruction::request_heap_frame(1), ComputeBudgetInstruction::request_heap_frame(1),
], ],
Err(TransactionError::InstructionError( Err(TransactionError::InstructionError(
@ -491,14 +488,14 @@ mod tests {
test!( test!(
&[ &[
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
], ],
Ok(PrioritizationFeeDetails::default()), Ok(PrioritizationFeeDetails::default()),
ComputeBudget { ComputeBudget {
@ -510,7 +507,7 @@ mod tests {
// Combined // Combined
test!( test!(
&[ &[
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
ComputeBudgetInstruction::request_heap_frame(MAX_HEAP_FRAME_BYTES), ComputeBudgetInstruction::request_heap_frame(MAX_HEAP_FRAME_BYTES),
ComputeBudgetInstruction::set_compute_unit_limit(MAX_COMPUTE_UNIT_LIMIT), ComputeBudgetInstruction::set_compute_unit_limit(MAX_COMPUTE_UNIT_LIMIT),
ComputeBudgetInstruction::set_compute_unit_price(u64::MAX), ComputeBudgetInstruction::set_compute_unit_price(u64::MAX),
@ -528,7 +525,7 @@ mod tests {
test!( test!(
&[ &[
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
ComputeBudgetInstruction::request_heap_frame(MAX_HEAP_FRAME_BYTES), ComputeBudgetInstruction::request_heap_frame(MAX_HEAP_FRAME_BYTES),
ComputeBudgetInstruction::set_compute_unit_limit(MAX_COMPUTE_UNIT_LIMIT), ComputeBudgetInstruction::set_compute_unit_limit(MAX_COMPUTE_UNIT_LIMIT),
ComputeBudgetInstruction::set_compute_unit_price(u64::MAX), ComputeBudgetInstruction::set_compute_unit_price(u64::MAX),
@ -543,7 +540,7 @@ mod tests {
test!( test!(
&[ &[
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
ComputeBudgetInstruction::set_compute_unit_limit(1), ComputeBudgetInstruction::set_compute_unit_limit(1),
ComputeBudgetInstruction::request_heap_frame(MAX_HEAP_FRAME_BYTES), ComputeBudgetInstruction::request_heap_frame(MAX_HEAP_FRAME_BYTES),
ComputeBudgetInstruction::set_compute_unit_price(u64::MAX), ComputeBudgetInstruction::set_compute_unit_price(u64::MAX),
@ -561,7 +558,7 @@ mod tests {
test!( test!(
&[ &[
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
request_units_deprecated(MAX_COMPUTE_UNIT_LIMIT, u32::MAX), request_units_deprecated(MAX_COMPUTE_UNIT_LIMIT, u32::MAX),
ComputeBudgetInstruction::request_heap_frame(MIN_HEAP_FRAME_BYTES as u32), ComputeBudgetInstruction::request_heap_frame(MIN_HEAP_FRAME_BYTES as u32),
], ],
@ -580,7 +577,7 @@ mod tests {
// Duplicates // Duplicates
test!( test!(
&[ &[
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
ComputeBudgetInstruction::set_compute_unit_limit(MAX_COMPUTE_UNIT_LIMIT), ComputeBudgetInstruction::set_compute_unit_limit(MAX_COMPUTE_UNIT_LIMIT),
ComputeBudgetInstruction::set_compute_unit_limit(MAX_COMPUTE_UNIT_LIMIT - 1), ComputeBudgetInstruction::set_compute_unit_limit(MAX_COMPUTE_UNIT_LIMIT - 1),
], ],
@ -590,7 +587,7 @@ mod tests {
test!( test!(
&[ &[
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
ComputeBudgetInstruction::request_heap_frame(MIN_HEAP_FRAME_BYTES as u32), ComputeBudgetInstruction::request_heap_frame(MIN_HEAP_FRAME_BYTES as u32),
ComputeBudgetInstruction::request_heap_frame(MAX_HEAP_FRAME_BYTES as u32), ComputeBudgetInstruction::request_heap_frame(MAX_HEAP_FRAME_BYTES as u32),
], ],
@ -600,7 +597,7 @@ mod tests {
test!( test!(
&[ &[
Instruction::new_with_bincode(Pubkey::new_unique(), &0, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
ComputeBudgetInstruction::set_compute_unit_price(0), ComputeBudgetInstruction::set_compute_unit_price(0),
ComputeBudgetInstruction::set_compute_unit_price(u64::MAX), ComputeBudgetInstruction::set_compute_unit_price(u64::MAX),
], ],

8
program-runtime/src/invoke_context.rs
View File

@ -16,8 +16,7 @@ use {
account::{AccountSharedData, ReadableAccount}, account::{AccountSharedData, ReadableAccount},
bpf_loader_upgradeable::{self, UpgradeableLoaderState}, bpf_loader_upgradeable::{self, UpgradeableLoaderState},
feature_set::{ feature_set::{
cap_accounts_data_len, record_instruction_in_transaction_context_push, cap_accounts_data_len, record_instruction_in_transaction_context_push, FeatureSet,
tx_wide_compute_cap, FeatureSet,
}, },
hash::Hash, hash::Hash,
instruction::{AccountMeta, Instruction, InstructionError}, instruction::{AccountMeta, Instruction, InstructionError},
@ -345,11 +344,6 @@ impl<'a> InvokeContext<'a> {
{ {
self.current_compute_budget = self.compute_budget; self.current_compute_budget = self.compute_budget;
if !self.feature_set.is_active(&tx_wide_compute_cap::id()) {
self.compute_meter =
ComputeMeter::new_ref(self.current_compute_budget.compute_unit_limit);
}
self.pre_accounts = Vec::with_capacity(instruction_accounts.len()); self.pre_accounts = Vec::with_capacity(instruction_accounts.len());
for (instruction_account_index, instruction_account) in for (instruction_account_index, instruction_account) in

2
programs/bpf/tests/programs.rs
View File

@ -3679,7 +3679,6 @@ fn test_program_fees() {
congestion_multiplier, congestion_multiplier,
&fee_structure, &fee_structure,
true, true,
true,
); );
bank_client bank_client
.send_and_confirm_message(&[&mint_keypair], message) .send_and_confirm_message(&[&mint_keypair], message)
@ -3701,7 +3700,6 @@ fn test_program_fees() {
congestion_multiplier, congestion_multiplier,
&fee_structure, &fee_structure,
true, true,
true,
); );
assert!(expected_normal_fee < expected_prioritized_fee); assert!(expected_normal_fee < expected_prioritized_fee);

17
programs/bpf_loader/src/lib.rs
View File

@ -44,7 +44,7 @@ use {
cap_accounts_data_len, disable_bpf_deprecated_load_instructions, cap_accounts_data_len, disable_bpf_deprecated_load_instructions,
disable_bpf_unresolved_symbols_at_runtime, disable_deploy_of_alloc_free_syscall, disable_bpf_unresolved_symbols_at_runtime, disable_deploy_of_alloc_free_syscall,
disable_deprecated_loader, error_on_syscall_bpf_function_hash_collisions, disable_deprecated_loader, error_on_syscall_bpf_function_hash_collisions,
reduce_required_deploy_balance, reject_callx_r10, requestable_heap_size, reduce_required_deploy_balance, reject_callx_r10,
}, },
instruction::{AccountMeta, InstructionError}, instruction::{AccountMeta, InstructionError},
loader_instruction::LoaderInstruction, loader_instruction::LoaderInstruction,
@ -296,16 +296,11 @@ pub fn create_vm<'a, 'b>(
) -> Result<EbpfVm<'a, RequisiteVerifier, BpfError, ThisInstructionMeter>, EbpfError<BpfError>> { ) -> Result<EbpfVm<'a, RequisiteVerifier, BpfError, ThisInstructionMeter>, EbpfError<BpfError>> {
let compute_budget = invoke_context.get_compute_budget(); let compute_budget = invoke_context.get_compute_budget();
let heap_size = compute_budget.heap_size.unwrap_or(HEAP_LENGTH); let heap_size = compute_budget.heap_size.unwrap_or(HEAP_LENGTH);
if invoke_context let _ = invoke_context.get_compute_meter().borrow_mut().consume(
.feature_set ((heap_size as u64).saturating_div(32_u64.saturating_mul(1024)))
.is_active(&requestable_heap_size::id()) .saturating_sub(1)
{ .saturating_mul(compute_budget.heap_cost),
let _ = invoke_context.get_compute_meter().borrow_mut().consume( );
((heap_size as u64).saturating_div(32_u64.saturating_mul(1024)))
.saturating_sub(1)
.saturating_mul(compute_budget.heap_cost),
);
}
let mut heap = let mut heap =
AlignedMemory::new_with_size(compute_budget.heap_size.unwrap_or(HEAP_LENGTH), HOST_ALIGN); AlignedMemory::new_with_size(compute_budget.heap_size.unwrap_or(HEAP_LENGTH), HOST_ALIGN);
let parameter_region = MemoryRegion::new_writable(parameter_bytes, MM_INPUT_START); let parameter_region = MemoryRegion::new_writable(parameter_bytes, MM_INPUT_START);

35
runtime/src/accounts.rs
View File

@ -34,7 +34,7 @@ use {
account_utils::StateMut, account_utils::StateMut,
bpf_loader_upgradeable::{self, UpgradeableLoaderState}, bpf_loader_upgradeable::{self, UpgradeableLoaderState},
clock::{BankId, Slot, INITIAL_RENT_EPOCH}, clock::{BankId, Slot, INITIAL_RENT_EPOCH},
feature_set::{self, add_set_compute_unit_price_ix, tx_wide_compute_cap, FeatureSet}, feature_set::{self, add_set_compute_unit_price_ix, FeatureSet},
fee::FeeStructure, fee::FeeStructure,
genesis_config::ClusterType, genesis_config::ClusterType,
hash::Hash, hash::Hash,
@ -547,7 +547,6 @@ impl Accounts {
tx.message(), tx.message(),
lamports_per_signature, lamports_per_signature,
fee_structure, fee_structure,
feature_set.is_active(&tx_wide_compute_cap::id()),
feature_set.is_active(&add_set_compute_unit_price_ix::id()), feature_set.is_active(&add_set_compute_unit_price_ix::id()),
) )
} else { } else {
@ -1642,6 +1641,7 @@ mod tests {
#[test] #[test]
fn test_load_accounts_insufficient_funds() { fn test_load_accounts_insufficient_funds() {
let lamports_per_signature = 5000;
let mut accounts: Vec<TransactionAccount> = Vec::new(); let mut accounts: Vec<TransactionAccount> = Vec::new();
let mut error_counters = TransactionErrorMetrics::default(); let mut error_counters = TransactionErrorMetrics::default();
@ -1662,14 +1662,14 @@ mod tests {
let fee = Bank::calculate_fee( let fee = Bank::calculate_fee(
&SanitizedMessage::try_from(tx.message().clone()).unwrap(), &SanitizedMessage::try_from(tx.message().clone()).unwrap(),
10, lamports_per_signature,
&FeeStructure::default(), &FeeStructure::default(),
false,
true, true,
); );
assert_eq!(fee, 10); assert_eq!(fee, lamports_per_signature);
let loaded_accounts = load_accounts_with_fee(tx, &accounts, 10, &mut error_counters); let loaded_accounts =
load_accounts_with_fee(tx, &accounts, lamports_per_signature, &mut error_counters);
assert_eq!(error_counters.insufficient_funds, 1); assert_eq!(error_counters.insufficient_funds, 1);
assert_eq!(loaded_accounts.len(), 1); assert_eq!(loaded_accounts.len(), 1);
@ -1711,9 +1711,8 @@ mod tests {
#[test] #[test]
fn test_load_accounts_fee_payer_is_nonce() { fn test_load_accounts_fee_payer_is_nonce() {
let lamports_per_signature = 5000;
let mut error_counters = TransactionErrorMetrics::default(); let mut error_counters = TransactionErrorMetrics::default();
let mut feature_set = FeatureSet::all_enabled();
feature_set.deactivate(&tx_wide_compute_cap::id());
let rent_collector = RentCollector::new( let rent_collector = RentCollector::new(
0, 0,
&EpochSchedule::default(), &EpochSchedule::default(),
@ -1728,7 +1727,7 @@ mod tests {
let mut accounts = vec![( let mut accounts = vec![(
nonce.pubkey(), nonce.pubkey(),
AccountSharedData::new_data( AccountSharedData::new_data(
min_balance * 2, min_balance + lamports_per_signature,
&NonceVersions::new( &NonceVersions::new(
NonceState::Initialized(nonce::state::Data::default()), NonceState::Initialized(nonce::state::Data::default()),
true, // separate_domains true, // separate_domains
@ -1750,10 +1749,10 @@ mod tests {
let loaded_accounts = load_accounts_with_fee_and_rent( let loaded_accounts = load_accounts_with_fee_and_rent(
tx.clone(), tx.clone(),
&accounts, &accounts,
min_balance, lamports_per_signature,
&rent_collector, &rent_collector,
&mut error_counters, &mut error_counters,
&feature_set, &FeatureSet::all_enabled(),
&FeeStructure::default(), &FeeStructure::default(),
); );
assert_eq!(loaded_accounts.len(), 1); assert_eq!(loaded_accounts.len(), 1);
@ -1762,14 +1761,14 @@ mod tests {
assert_eq!(loaded_transaction.accounts[0].1.lamports(), min_balance); assert_eq!(loaded_transaction.accounts[0].1.lamports(), min_balance);
// Fee leaves zero balance fails // Fee leaves zero balance fails
accounts[0].1.set_lamports(min_balance); accounts[0].1.set_lamports(lamports_per_signature);
let loaded_accounts = load_accounts_with_fee_and_rent( let loaded_accounts = load_accounts_with_fee_and_rent(
tx.clone(), tx.clone(),
&accounts, &accounts,
min_balance, lamports_per_signature,
&rent_collector, &rent_collector,
&mut error_counters, &mut error_counters,
&feature_set, &FeatureSet::all_enabled(),
&FeeStructure::default(), &FeeStructure::default(),
); );
assert_eq!(loaded_accounts.len(), 1); assert_eq!(loaded_accounts.len(), 1);
@ -1777,14 +1776,16 @@ mod tests {
assert_eq!(*load_res, Err(TransactionError::InsufficientFundsForFee)); assert_eq!(*load_res, Err(TransactionError::InsufficientFundsForFee));
// Fee leaves non-zero, but sub-min_balance balance fails // Fee leaves non-zero, but sub-min_balance balance fails
accounts[0].1.set_lamports(3 * min_balance / 2); accounts[0]
.1
.set_lamports(lamports_per_signature + min_balance / 2);
let loaded_accounts = load_accounts_with_fee_and_rent( let loaded_accounts = load_accounts_with_fee_and_rent(
tx, tx,
&accounts, &accounts,
min_balance, lamports_per_signature,
&rent_collector, &rent_collector,
&mut error_counters, &mut error_counters,
&feature_set, &FeatureSet::all_enabled(),
&FeeStructure::default(), &FeeStructure::default(),
); );
assert_eq!(loaded_accounts.len(), 1); assert_eq!(loaded_accounts.len(), 1);

392
runtime/src/bank.rs
View File

@ -109,8 +109,7 @@ use {
feature, feature,
feature_set::{ feature_set::{
self, add_set_compute_unit_price_ix, default_units_per_instruction, self, add_set_compute_unit_price_ix, default_units_per_instruction,
disable_fee_calculator, nonce_must_be_writable, requestable_heap_size, disable_fee_calculator, nonce_must_be_writable, FeatureSet,
tx_wide_compute_cap, FeatureSet,
}, },
fee::FeeStructure, fee::FeeStructure,
fee_calculator::{FeeCalculator, FeeRateGovernor}, fee_calculator::{FeeCalculator, FeeRateGovernor},
@ -3701,7 +3700,6 @@ impl Bank {
message, message,
lamports_per_signature, lamports_per_signature,
&self.fee_structure, &self.fee_structure,
self.feature_set.is_active(&tx_wide_compute_cap::id()),
self.feature_set self.feature_set
.is_active(&add_set_compute_unit_price_ix::id()), .is_active(&add_set_compute_unit_price_ix::id()),
)) ))
@ -3724,7 +3722,6 @@ impl Bank {
message, message,
lamports_per_signature, lamports_per_signature,
&self.fee_structure, &self.fee_structure,
self.feature_set.is_active(&tx_wide_compute_cap::id()),
self.feature_set self.feature_set
.is_active(&add_set_compute_unit_price_ix::id()), .is_active(&add_set_compute_unit_price_ix::id()),
) )
@ -4512,32 +4509,25 @@ impl Bank {
let compute_budget = if let Some(compute_budget) = self.compute_budget { let compute_budget = if let Some(compute_budget) = self.compute_budget {
compute_budget compute_budget
} else { } else {
let tx_wide_compute_cap = feature_set.is_active(&tx_wide_compute_cap::id()); let mut compute_budget =
let compute_unit_limit = if tx_wide_compute_cap { ComputeBudget::new(compute_budget::MAX_COMPUTE_UNIT_LIMIT as u64);
compute_budget::MAX_COMPUTE_UNIT_LIMIT
} else { let mut compute_budget_process_transaction_time =
compute_budget::DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT Measure::start("compute_budget_process_transaction_time");
}; let process_transaction_result = compute_budget.process_instructions(
let mut compute_budget = ComputeBudget::new(compute_unit_limit as u64); tx.message().program_instructions_iter(),
if tx_wide_compute_cap { feature_set.is_active(&default_units_per_instruction::id()),
let mut compute_budget_process_transaction_time = feature_set.is_active(&add_set_compute_unit_price_ix::id()),
Measure::start("compute_budget_process_transaction_time"); );
let process_transaction_result = compute_budget.process_instructions( compute_budget_process_transaction_time.stop();
tx.message().program_instructions_iter(), saturating_add_assign!(
feature_set.is_active(&requestable_heap_size::id()), timings
feature_set.is_active(&default_units_per_instruction::id()), .execute_accessories
feature_set.is_active(&add_set_compute_unit_price_ix::id()), .compute_budget_process_transaction_us,
); compute_budget_process_transaction_time.as_us()
compute_budget_process_transaction_time.stop(); );
saturating_add_assign!( if let Err(err) = process_transaction_result {
timings return TransactionExecutionResult::NotExecuted(err);
.execute_accessories
.compute_budget_process_transaction_us,
compute_budget_process_transaction_time.as_us()
);
if let Err(err) = process_transaction_result {
return TransactionExecutionResult::NotExecuted(err);
}
} }
compute_budget compute_budget
}; };
@ -4785,56 +4775,49 @@ impl Bank {
message: &SanitizedMessage, message: &SanitizedMessage,
lamports_per_signature: u64, lamports_per_signature: u64,
fee_structure: &FeeStructure, fee_structure: &FeeStructure,
tx_wide_compute_cap: bool,
support_set_compute_unit_price_ix: bool, support_set_compute_unit_price_ix: bool,
) -> u64 { ) -> u64 {
if tx_wide_compute_cap { // Fee based on compute units and signatures
// Fee based on compute units and signatures const BASE_CONGESTION: f64 = 5_000.0;
const BASE_CONGESTION: f64 = 5_000.0; let current_congestion = BASE_CONGESTION.max(lamports_per_signature as f64);
let current_congestion = BASE_CONGESTION.max(lamports_per_signature as f64); let congestion_multiplier = if lamports_per_signature == 0 {
let congestion_multiplier = if lamports_per_signature == 0 { 0.0 // test only
0.0 // test only
} else {
BASE_CONGESTION / current_congestion
};
let mut compute_budget = ComputeBudget::default();
let prioritization_fee_details = compute_budget
.process_instructions(
message.program_instructions_iter(),
false,
false,
support_set_compute_unit_price_ix,
)
.unwrap_or_default();
let prioritization_fee = prioritization_fee_details.get_fee();
let signature_fee = Self::get_num_signatures_in_message(message)
.saturating_mul(fee_structure.lamports_per_signature);
let write_lock_fee = Self::get_num_write_locks_in_message(message)
.saturating_mul(fee_structure.lamports_per_write_lock);
let compute_fee = fee_structure
.compute_fee_bins
.iter()
.find(|bin| compute_budget.compute_unit_limit <= bin.limit)
.map(|bin| bin.fee)
.unwrap_or_else(|| {
fee_structure
.compute_fee_bins
.last()
.map(|bin| bin.fee)
.unwrap_or_default()
});
((prioritization_fee
.saturating_add(signature_fee)
.saturating_add(write_lock_fee)
.saturating_add(compute_fee) as f64)
* congestion_multiplier)
.round() as u64
} else { } else {
// Fee based only on signatures BASE_CONGESTION / current_congestion
lamports_per_signature.saturating_mul(Self::get_num_signatures_in_message(message)) };
}
let mut compute_budget = ComputeBudget::default();
let prioritization_fee_details = compute_budget
.process_instructions(
message.program_instructions_iter(),
false,
support_set_compute_unit_price_ix,
)
.unwrap_or_default();
let prioritization_fee = prioritization_fee_details.get_fee();
let signature_fee = Self::get_num_signatures_in_message(message)
.saturating_mul(fee_structure.lamports_per_signature);
let write_lock_fee = Self::get_num_write_locks_in_message(message)
.saturating_mul(fee_structure.lamports_per_write_lock);
let compute_fee = fee_structure
.compute_fee_bins
.iter()
.find(|bin| compute_budget.compute_unit_limit <= bin.limit)
.map(|bin| bin.fee)
.unwrap_or_else(|| {
fee_structure
.compute_fee_bins
.last()
.map(|bin| bin.fee)
.unwrap_or_default()
});
((prioritization_fee
.saturating_add(signature_fee)
.saturating_add(write_lock_fee)
.saturating_add(compute_fee) as f64)
* congestion_multiplier)
.round() as u64
} }
fn filter_program_errors_and_collect_fee( fn filter_program_errors_and_collect_fee(
@ -4872,7 +4855,6 @@ impl Bank {
tx.message(), tx.message(),
lamports_per_signature, lamports_per_signature,
&self.fee_structure, &self.fee_structure,
self.feature_set.is_active(&tx_wide_compute_cap::id()),
self.feature_set self.feature_set
.is_active(&add_set_compute_unit_price_ix::id()), .is_active(&add_set_compute_unit_price_ix::id()),
); );
@ -10326,15 +10308,19 @@ pub(crate) mod tests {
// This test demonstrates that fees are paid even when a program fails. // This test demonstrates that fees are paid even when a program fails.
#[test] #[test]
fn test_detect_failed_duplicate_transactions() { fn test_detect_failed_duplicate_transactions() {
let (mut genesis_config, mint_keypair) = create_genesis_config(2); let (mut genesis_config, mint_keypair) = create_genesis_config(10_000);
genesis_config.fee_rate_governor = FeeRateGovernor::new(1, 0); genesis_config.fee_rate_governor = FeeRateGovernor::new(5_000, 0);
let bank = Bank::new_for_tests(&genesis_config); let bank = Bank::new_for_tests(&genesis_config);
let dest = Keypair::new(); let dest = Keypair::new();
// source with 0 program context // source with 0 program context
let tx = let tx = system_transaction::transfer(
system_transaction::transfer(&mint_keypair, &dest.pubkey(), 2, genesis_config.hash()); &mint_keypair,
&dest.pubkey(),
10_000,
genesis_config.hash(),
);
let signature = tx.signatures[0]; let signature = tx.signatures[0];
assert!(!bank.has_signature(&signature)); assert!(!bank.has_signature(&signature));
@ -10350,7 +10336,7 @@ pub(crate) mod tests {
assert_eq!(bank.get_balance(&dest.pubkey()), 0); assert_eq!(bank.get_balance(&dest.pubkey()), 0);
// This should be the original balance minus the transaction fee. // This should be the original balance minus the transaction fee.
assert_eq!(bank.get_balance(&mint_keypair.pubkey()), 1); assert_eq!(bank.get_balance(&mint_keypair.pubkey()), 5000);
} }
#[test] #[test]
@ -10514,7 +10500,7 @@ pub(crate) mod tests {
fn test_bank_tx_fee() { fn test_bank_tx_fee() {
solana_logger::setup(); solana_logger::setup();
let arbitrary_transfer_amount = 42; let arbitrary_transfer_amount = 42_000;
let mint = arbitrary_transfer_amount * 100; let mint = arbitrary_transfer_amount * 100;
let leader = solana_sdk::pubkey::new_rand(); let leader = solana_sdk::pubkey::new_rand();
let GenesisConfigInfo { let GenesisConfigInfo {
@ -10522,7 +10508,7 @@ pub(crate) mod tests {
mint_keypair, mint_keypair,
.. ..
} = create_genesis_config_with_leader(mint, &leader, 3); } = create_genesis_config_with_leader(mint, &leader, 3);
genesis_config.fee_rate_governor = FeeRateGovernor::new(4, 0); // something divisible by 2 genesis_config.fee_rate_governor = FeeRateGovernor::new(5000, 0); // something divisible by 2
let expected_fee_paid = genesis_config let expected_fee_paid = genesis_config
.fee_rate_governor .fee_rate_governor
@ -10532,7 +10518,6 @@ pub(crate) mod tests {
genesis_config.fee_rate_governor.burn(expected_fee_paid); genesis_config.fee_rate_governor.burn(expected_fee_paid);
let mut bank = Bank::new_for_tests(&genesis_config); let mut bank = Bank::new_for_tests(&genesis_config);
bank.deactivate_feature(&tx_wide_compute_cap::id());
let capitalization = bank.capitalization(); let capitalization = bank.capitalization();
@ -10640,7 +10625,6 @@ pub(crate) mod tests {
.lamports_per_signature, .lamports_per_signature,
&FeeStructure::default(), &FeeStructure::default(),
true, true,
true,
); );
let (expected_fee_collected, expected_fee_burned) = let (expected_fee_collected, expected_fee_burned) =
@ -10742,8 +10726,8 @@ pub(crate) mod tests {
} = create_genesis_config_with_leader(1_000_000, &leader, 3); } = create_genesis_config_with_leader(1_000_000, &leader, 3);
genesis_config genesis_config
.fee_rate_governor .fee_rate_governor
.target_lamports_per_signature = 1000; .target_lamports_per_signature = 5000;
genesis_config.fee_rate_governor.target_signatures_per_slot = 1; genesis_config.fee_rate_governor.target_signatures_per_slot = 0;
let mut bank = Bank::new_for_tests(&genesis_config); let mut bank = Bank::new_for_tests(&genesis_config);
goto_end_of_slot(&mut bank); goto_end_of_slot(&mut bank);
@ -10752,7 +10736,6 @@ pub(crate) mod tests {
assert_eq!(cheap_lamports_per_signature, 0); assert_eq!(cheap_lamports_per_signature, 0);
let mut bank = Bank::new_from_parent(&Arc::new(bank), &leader, 1); let mut bank = Bank::new_from_parent(&Arc::new(bank), &leader, 1);
bank.deactivate_feature(&tx_wide_compute_cap::id());
goto_end_of_slot(&mut bank); goto_end_of_slot(&mut bank);
let expensive_blockhash = bank.last_blockhash(); let expensive_blockhash = bank.last_blockhash();
let expensive_lamports_per_signature = bank.get_lamports_per_signature(); let expensive_lamports_per_signature = bank.get_lamports_per_signature();
@ -10823,7 +10806,6 @@ pub(crate) mod tests {
cheap_lamports_per_signature, cheap_lamports_per_signature,
&FeeStructure::default(), &FeeStructure::default(),
true, true,
true,
); );
assert_eq!( assert_eq!(
bank.get_balance(&mint_keypair.pubkey()), bank.get_balance(&mint_keypair.pubkey()),
@ -10841,7 +10823,6 @@ pub(crate) mod tests {
expensive_lamports_per_signature, expensive_lamports_per_signature,
&FeeStructure::default(), &FeeStructure::default(),
true, true,
true,
); );
assert_eq!( assert_eq!(
bank.get_balance(&mint_keypair.pubkey()), bank.get_balance(&mint_keypair.pubkey()),
@ -10856,10 +10837,9 @@ pub(crate) mod tests {
mut genesis_config, mut genesis_config,
mint_keypair, mint_keypair,
.. ..
} = create_genesis_config_with_leader(100, &leader, 3); } = create_genesis_config_with_leader(100_000, &leader, 3);
genesis_config.fee_rate_governor = FeeRateGovernor::new(2, 0); genesis_config.fee_rate_governor = FeeRateGovernor::new(5000, 0);
let mut bank = Bank::new_for_tests(&genesis_config); let bank = Bank::new_for_tests(&genesis_config);
bank.deactivate_feature(&tx_wide_compute_cap::id());
let key = Keypair::new(); let key = Keypair::new();
let tx1 = SanitizedTransaction::from_transaction_for_tests(system_transaction::transfer( let tx1 = SanitizedTransaction::from_transaction_for_tests(system_transaction::transfer(
@ -10958,7 +10938,6 @@ pub(crate) mod tests {
.lamports_per_signature, .lamports_per_signature,
&FeeStructure::default(), &FeeStructure::default(),
true, true,
true,
) * 2 ) * 2
) )
.0 .0
@ -12828,11 +12807,15 @@ pub(crate) mod tests {
#[test] #[test]
fn test_check_transaction_for_nonce_ok() { fn test_check_transaction_for_nonce_ok() {
let mut feature_set = FeatureSet::all_enabled(); let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
feature_set.deactivate(&tx_wide_compute_cap::id()); 10_000_000,
let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = |_| {},
setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None, feature_set) 5_000_000,
.unwrap(); 250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let custodian_pubkey = custodian_keypair.pubkey(); let custodian_pubkey = custodian_keypair.pubkey();
let nonce_pubkey = nonce_keypair.pubkey(); let nonce_pubkey = nonce_keypair.pubkey();
@ -12859,11 +12842,15 @@ pub(crate) mod tests {
#[test] #[test]
fn test_check_transaction_for_nonce_not_nonce_fail() { fn test_check_transaction_for_nonce_not_nonce_fail() {
let mut feature_set = FeatureSet::all_enabled(); let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
feature_set.deactivate(&tx_wide_compute_cap::id()); 10_000_000,
let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = |_| {},
setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None, feature_set) 5_000_000,
.unwrap(); 250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let custodian_pubkey = custodian_keypair.pubkey(); let custodian_pubkey = custodian_keypair.pubkey();
let nonce_pubkey = nonce_keypair.pubkey(); let nonce_pubkey = nonce_keypair.pubkey();
@ -12888,11 +12875,15 @@ pub(crate) mod tests {
#[test] #[test]
fn test_check_transaction_for_nonce_missing_ix_pubkey_fail() { fn test_check_transaction_for_nonce_missing_ix_pubkey_fail() {
let mut feature_set = FeatureSet::all_enabled(); let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
feature_set.deactivate(&tx_wide_compute_cap::id()); 10_000_000,
let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = |_| {},
setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None, feature_set) 5_000_000,
.unwrap(); 250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let custodian_pubkey = custodian_keypair.pubkey(); let custodian_pubkey = custodian_keypair.pubkey();
let nonce_pubkey = nonce_keypair.pubkey(); let nonce_pubkey = nonce_keypair.pubkey();
@ -12918,11 +12909,15 @@ pub(crate) mod tests {
#[test] #[test]
fn test_check_transaction_for_nonce_nonce_acc_does_not_exist_fail() { fn test_check_transaction_for_nonce_nonce_acc_does_not_exist_fail() {
let mut feature_set = FeatureSet::all_enabled(); let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
feature_set.deactivate(&tx_wide_compute_cap::id()); 10_000_000,
let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = |_| {},
setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None, feature_set) 5_000_000,
.unwrap(); 250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let custodian_pubkey = custodian_keypair.pubkey(); let custodian_pubkey = custodian_keypair.pubkey();
let nonce_pubkey = nonce_keypair.pubkey(); let nonce_pubkey = nonce_keypair.pubkey();
let missing_keypair = Keypair::new(); let missing_keypair = Keypair::new();
@ -12949,11 +12944,15 @@ pub(crate) mod tests {
#[test] #[test]
fn test_check_transaction_for_nonce_bad_tx_hash_fail() { fn test_check_transaction_for_nonce_bad_tx_hash_fail() {
let mut feature_set = FeatureSet::all_enabled(); let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
feature_set.deactivate(&tx_wide_compute_cap::id()); 10_000_000,
let (bank, _mint_keypair, custodian_keypair, nonce_keypair) = |_| {},
setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None, feature_set) 5_000_000,
.unwrap(); 250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let custodian_pubkey = custodian_keypair.pubkey(); let custodian_pubkey = custodian_keypair.pubkey();
let nonce_pubkey = nonce_keypair.pubkey(); let nonce_pubkey = nonce_keypair.pubkey();
@ -13040,11 +13039,15 @@ pub(crate) mod tests {
#[test] #[test]
fn test_nonce_transaction() { fn test_nonce_transaction() {
let mut feature_set = FeatureSet::all_enabled(); let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
feature_set.deactivate(&tx_wide_compute_cap::id()); 10_000_000,
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = |_| {},
setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None, feature_set) 5_000_000,
.unwrap(); 250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let alice_keypair = Keypair::new(); let alice_keypair = Keypair::new();
let alice_pubkey = alice_keypair.pubkey(); let alice_pubkey = alice_keypair.pubkey();
let custodian_pubkey = custodian_keypair.pubkey(); let custodian_pubkey = custodian_keypair.pubkey();
@ -13298,11 +13301,15 @@ pub(crate) mod tests {
#[test] #[test]
fn test_nonce_authority() { fn test_nonce_authority() {
solana_logger::setup(); solana_logger::setup();
let mut feature_set = FeatureSet::all_enabled(); let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
feature_set.deactivate(&tx_wide_compute_cap::id()); 10_000_000,
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = |_| {},
setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None, feature_set) 5_000_000,
.unwrap(); 250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
let alice_keypair = Keypair::new(); let alice_keypair = Keypair::new();
let alice_pubkey = alice_keypair.pubkey(); let alice_pubkey = alice_keypair.pubkey();
let custodian_pubkey = custodian_keypair.pubkey(); let custodian_pubkey = custodian_keypair.pubkey();
@ -13355,15 +13362,13 @@ pub(crate) mod tests {
fn test_nonce_payer() { fn test_nonce_payer() {
solana_logger::setup(); solana_logger::setup();
let nonce_starting_balance = 250_000; let nonce_starting_balance = 250_000;
let mut feature_set = FeatureSet::all_enabled();
feature_set.deactivate(&tx_wide_compute_cap::id());
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank( let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
10_000_000, 10_000_000,
|_| {}, |_| {},
5_000_000, 5_000_000,
nonce_starting_balance, nonce_starting_balance,
None, None,
feature_set, FeatureSet::all_enabled(),
) )
.unwrap(); .unwrap();
let alice_keypair = Keypair::new(); let alice_keypair = Keypair::new();
@ -13488,7 +13493,6 @@ pub(crate) mod tests {
genesis_config.rent.lamports_per_byte_year = 0; genesis_config.rent.lamports_per_byte_year = 0;
let mut bank = Bank::new_for_tests(&genesis_config); let mut bank = Bank::new_for_tests(&genesis_config);
bank.feature_set = Arc::new(FeatureSet::all_enabled()); bank.feature_set = Arc::new(FeatureSet::all_enabled());
bank.deactivate_feature(&tx_wide_compute_cap::id());
let mut bank = Arc::new(bank); let mut bank = Arc::new(bank);
// Deliberately use bank 0 to initialize nonce account, so that nonce account fee_calculator indicates 0 fees // Deliberately use bank 0 to initialize nonce account, so that nonce account fee_calculator indicates 0 fees
@ -13621,11 +13625,15 @@ pub(crate) mod tests {
#[test] #[test]
fn test_check_ro_durable_nonce_fails() { fn test_check_ro_durable_nonce_fails() {
let mut feature_set = FeatureSet::all_enabled(); let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = setup_nonce_with_bank(
feature_set.deactivate(&tx_wide_compute_cap::id()); 10_000_000,
let (mut bank, _mint_keypair, custodian_keypair, nonce_keypair) = |_| {},
setup_nonce_with_bank(10_000_000, |_| {}, 5_000_000, 250_000, None, feature_set) 5_000_000,
.unwrap(); 250_000,
None,
FeatureSet::all_enabled(),
)
.unwrap();
Arc::get_mut(&mut bank) Arc::get_mut(&mut bank)
.unwrap() .unwrap()
.activate_feature(&feature_set::nonce_must_be_writable::id()); .activate_feature(&feature_set::nonce_must_be_writable::id());
@ -13728,8 +13736,8 @@ pub(crate) mod tests {
#[test] #[test]
fn test_pre_post_transaction_balances() { fn test_pre_post_transaction_balances() {
let (mut genesis_config, _mint_keypair) = create_genesis_config(500); let (mut genesis_config, _mint_keypair) = create_genesis_config(500_000);
let fee_rate_governor = FeeRateGovernor::new(1, 0); let fee_rate_governor = FeeRateGovernor::new(5000, 0);
genesis_config.fee_rate_governor = fee_rate_governor; genesis_config.fee_rate_governor = fee_rate_governor;
let parent = Arc::new(Bank::new_for_tests(&genesis_config)); let parent = Arc::new(Bank::new_for_tests(&genesis_config));
let bank0 = Arc::new(new_from_parent(&parent)); let bank0 = Arc::new(new_from_parent(&parent));
@ -13739,18 +13747,18 @@ pub(crate) mod tests {
let pubkey0 = solana_sdk::pubkey::new_rand(); let pubkey0 = solana_sdk::pubkey::new_rand();
let pubkey1 = solana_sdk::pubkey::new_rand(); let pubkey1 = solana_sdk::pubkey::new_rand();
let pubkey2 = solana_sdk::pubkey::new_rand(); let pubkey2 = solana_sdk::pubkey::new_rand();
let keypair0_account = AccountSharedData::new(8, 0, &Pubkey::default()); let keypair0_account = AccountSharedData::new(8_000, 0, &Pubkey::default());
let keypair1_account = AccountSharedData::new(9, 0, &Pubkey::default()); let keypair1_account = AccountSharedData::new(9_000, 0, &Pubkey::default());
let account0 = AccountSharedData::new(11, 0, &Pubkey::default()); let account0 = AccountSharedData::new(11_000, 0, &Pubkey::default());
bank0.store_account(&keypair0.pubkey(), &keypair0_account); bank0.store_account(&keypair0.pubkey(), &keypair0_account);
bank0.store_account(&keypair1.pubkey(), &keypair1_account); bank0.store_account(&keypair1.pubkey(), &keypair1_account);
bank0.store_account(&pubkey0, &account0); bank0.store_account(&pubkey0, &account0);
let blockhash = bank0.last_blockhash(); let blockhash = bank0.last_blockhash();
let tx0 = system_transaction::transfer(&keypair0, &pubkey0, 2, blockhash); let tx0 = system_transaction::transfer(&keypair0, &pubkey0, 2_000, blockhash);
let tx1 = system_transaction::transfer(&Keypair::new(), &pubkey1, 2, blockhash); let tx1 = system_transaction::transfer(&Keypair::new(), &pubkey1, 2_000, blockhash);
let tx2 = system_transaction::transfer(&keypair1, &pubkey2, 12, blockhash); let tx2 = system_transaction::transfer(&keypair1, &pubkey2, 12_000, blockhash);
let txs = vec![tx0, tx1, tx2]; let txs = vec![tx0, tx1, tx2];
let lock_result = bank0.prepare_batch_for_tests(txs); let lock_result = bank0.prepare_batch_for_tests(txs);
@ -13769,8 +13777,14 @@ pub(crate) mod tests {
assert_eq!(transaction_balances_set.post_balances.len(), 3); assert_eq!(transaction_balances_set.post_balances.len(), 3);
assert!(transaction_results.execution_results[0].was_executed_successfully()); assert!(transaction_results.execution_results[0].was_executed_successfully());
assert_eq!(transaction_balances_set.pre_balances[0], vec![8, 11, 1]); assert_eq!(
assert_eq!(transaction_balances_set.post_balances[0], vec![5, 13, 1]); transaction_balances_set.pre_balances[0],
vec![8_000, 11_000, 1]
);
assert_eq!(
transaction_balances_set.post_balances[0],
vec![1_000, 13_000, 1]
);
// Failed transactions still produce balance sets // Failed transactions still produce balance sets
// This is a TransactionError - not possible to charge fees // This is a TransactionError - not possible to charge fees
@ -13796,8 +13810,8 @@ pub(crate) mod tests {
.. ..
}, },
)); ));
assert_eq!(transaction_balances_set.pre_balances[2], vec![9, 0, 1]); assert_eq!(transaction_balances_set.pre_balances[2], vec![9_000, 0, 1]);
assert_eq!(transaction_balances_set.post_balances[2], vec![8, 0, 1]); assert_eq!(transaction_balances_set.post_balances[2], vec![4_000, 0, 1]);
} }
#[test] #[test]
@ -17234,7 +17248,7 @@ pub(crate) mod tests {
fn test_compute_budget_program_noop() { fn test_compute_budget_program_noop() {
solana_logger::setup(); solana_logger::setup();
let GenesisConfigInfo { let GenesisConfigInfo {
mut genesis_config, genesis_config,
mint_keypair, mint_keypair,
.. ..
} = create_genesis_config_with_leader( } = create_genesis_config_with_leader(
@ -17242,15 +17256,6 @@ pub(crate) mod tests {
&Pubkey::new_unique(), &Pubkey::new_unique(),
bootstrap_validator_stake_lamports(), bootstrap_validator_stake_lamports(),
); );
// activate all features except..
activate_all_features(&mut genesis_config);
genesis_config
.accounts
.remove(&feature_set::tx_wide_compute_cap::id());
genesis_config
.accounts
.remove(&feature_set::requestable_heap_size::id());
let mut bank = Bank::new_for_tests(&genesis_config); let mut bank = Bank::new_for_tests(&genesis_config);
fn mock_ix_processor( fn mock_ix_processor(
@ -17261,8 +17266,8 @@ pub(crate) mod tests {
assert_eq!( assert_eq!(
*compute_budget, *compute_budget,
ComputeBudget { ComputeBudget {
compute_unit_limit: 200_000, compute_unit_limit: 1,
heap_size: None, heap_size: Some(48 * 1024),
..ComputeBudget::default() ..ComputeBudget::default()
} }
); );
@ -17563,13 +17568,29 @@ pub(crate) mod tests {
let message = let message =
SanitizedMessage::try_from(Message::new(&[], Some(&Pubkey::new_unique()))).unwrap(); SanitizedMessage::try_from(Message::new(&[], Some(&Pubkey::new_unique()))).unwrap();
assert_eq!( assert_eq!(
Bank::calculate_fee(&message, 0, &FeeStructure::default(), false, true), Bank::calculate_fee(
&message,
0,
&FeeStructure {
lamports_per_signature: 0,
..FeeStructure::default()
},
true
),
0 0
); );
// One signature, a fee. // One signature, a fee.
assert_eq!( assert_eq!(
Bank::calculate_fee(&message, 1, &FeeStructure::default(), false, true), Bank::calculate_fee(
&message,
1,
&FeeStructure {
lamports_per_signature: 1,
..FeeStructure::default()
},
true
),
1 1
); );
@ -17580,14 +17601,25 @@ pub(crate) mod tests {
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 = SanitizedMessage::try_from(Message::new(&[ix0, ix1], Some(&key0))).unwrap();
assert_eq!( assert_eq!(
Bank::calculate_fee(&message, 2, &FeeStructure::default(), false, true), Bank::calculate_fee(
&message,
2,
&FeeStructure {
lamports_per_signature: 2,
..FeeStructure::default()
},
true
),
4 4
); );
} }
#[test] #[test]
fn test_calculate_fee_compute_units() { fn test_calculate_fee_compute_units() {
let fee_structure = FeeStructure::default(); let fee_structure = FeeStructure {
lamports_per_signature: 1,
..FeeStructure::default()
};
let max_fee = fee_structure.compute_fee_bins.last().unwrap().fee; let max_fee = fee_structure.compute_fee_bins.last().unwrap().fee;
let lamports_per_signature = fee_structure.lamports_per_signature; let lamports_per_signature = fee_structure.lamports_per_signature;
@ -17596,7 +17628,7 @@ pub(crate) mod tests {
let message = let message =
SanitizedMessage::try_from(Message::new(&[], Some(&Pubkey::new_unique()))).unwrap(); SanitizedMessage::try_from(Message::new(&[], Some(&Pubkey::new_unique()))).unwrap();
assert_eq!( assert_eq!(
Bank::calculate_fee(&message, 1, &fee_structure, true, true), Bank::calculate_fee(&message, 1, &fee_structure, true),
max_fee + lamports_per_signature max_fee + lamports_per_signature
); );
@ -17608,7 +17640,7 @@ pub(crate) mod tests {
SanitizedMessage::try_from(Message::new(&[ix0, ix1], Some(&Pubkey::new_unique()))) SanitizedMessage::try_from(Message::new(&[ix0, ix1], Some(&Pubkey::new_unique())))
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
Bank::calculate_fee(&message, 1, &fee_structure, true, true), Bank::calculate_fee(&message, 1, &fee_structure, true),
max_fee + 3 * lamports_per_signature max_fee + 3 * lamports_per_signature
); );
@ -17636,12 +17668,12 @@ pub(crate) mod tests {
&[ &[
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, vec![]), Instruction::new_with_bincode(Pubkey::new_unique(), &0_u8, vec![]),
], ],
Some(&Pubkey::new_unique()), Some(&Pubkey::new_unique()),
)) ))
.unwrap(); .unwrap();
let fee = Bank::calculate_fee(&message, 1, &fee_structure, true, true); let fee = Bank::calculate_fee(&message, 1, &fee_structure, true);
assert_eq!( assert_eq!(
fee, fee,
lamports_per_signature + prioritization_fee_details.get_fee() lamports_per_signature + prioritization_fee_details.get_fee()
@ -17651,6 +17683,10 @@ pub(crate) mod tests {
#[test] #[test]
fn test_calculate_fee_secp256k1() { fn test_calculate_fee_secp256k1() {
let fee_structure = FeeStructure {
lamports_per_signature: 1,
..FeeStructure::default()
};
let key0 = Pubkey::new_unique(); let key0 = Pubkey::new_unique();
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);
@ -17675,10 +17711,7 @@ pub(crate) mod tests {
Some(&key0), Some(&key0),
)) ))
.unwrap(); .unwrap();
assert_eq!( assert_eq!(Bank::calculate_fee(&message, 1, &fee_structure, true), 2);
Bank::calculate_fee(&message, 1, &FeeStructure::default(), false, true),
2
);
secp_instruction1.data = vec![0]; secp_instruction1.data = vec![0];
secp_instruction2.data = vec![10]; secp_instruction2.data = vec![10];
@ -17687,10 +17720,7 @@ pub(crate) mod tests {
Some(&key0), Some(&key0),
)) ))
.unwrap(); .unwrap();
assert_eq!( assert_eq!(Bank::calculate_fee(&message, 1, &fee_structure, true), 11);
Bank::calculate_fee(&message, 1, &FeeStructure::default(), false, true),
11
);
} }
#[test] #[test]