diff --git a/crates/blockifier/src/fee/fee_utils.rs b/crates/blockifier/src/fee/fee_utils.rs index 9a87eba0a8..498762dd01 100644 --- a/crates/blockifier/src/fee/fee_utils.rs +++ b/crates/blockifier/src/fee/fee_utils.rs @@ -119,12 +119,11 @@ pub fn verify_can_pay_committed_bounds( { Fee(u128::from(l1_gas.max_amount) * l1_gas.max_price_per_unit) } - // TODO!(Aner): add tests AllResources(AllResourceBounds { l1_gas, l2_gas, l1_data_gas }) => { // Committed fee is sum of products (resource_max_amount * resource_max_price) // of the different resources. - // The Sender will not be charged by`max_price_per_unit`, but this check should - // not depend on the current gas price + // The Sender will not be charged by `max_price_per_unit`, but this check should + // not depend on the current gas prices. Fee(u128::from(l1_gas.max_amount) * l1_gas.max_price_per_unit + u128::from(l1_data_gas.max_amount) * l1_data_gas.max_price_per_unit + u128::from(l2_gas.max_amount) * l2_gas.max_price_per_unit) diff --git a/crates/blockifier/src/test_utils.rs b/crates/blockifier/src/test_utils.rs index c96562f848..740a8701cc 100644 --- a/crates/blockifier/src/test_utils.rs +++ b/crates/blockifier/src/test_utils.rs @@ -99,6 +99,8 @@ pub const MAX_L1_GAS_AMOUNT: GasAmount = GasAmount(1000000); pub const MAX_L1_GAS_PRICE: NonzeroGasPrice = DEFAULT_STRK_L1_GAS_PRICE; pub const MAX_RESOURCE_COMMITMENT: Fee = MAX_L1_GAS_AMOUNT.nonzero_saturating_mul(MAX_L1_GAS_PRICE); pub const MAX_FEE: Fee = MAX_L1_GAS_AMOUNT.nonzero_saturating_mul(DEFAULT_ETH_L1_GAS_PRICE); +pub const MAX_L2_GAS_PRICE: NonzeroGasPrice = DEFAULT_STRK_L2_GAS_PRICE; +pub const MAX_L1_DATA_GAS_PRICE: NonzeroGasPrice = DEFAULT_STRK_L1_DATA_GAS_PRICE; // The amount of test-token allocated to the account in this test, set to a multiple of the max // amount deprecated / non-deprecated transactions commit to paying. diff --git a/crates/blockifier/src/transaction/transactions_test.rs b/crates/blockifier/src/transaction/transactions_test.rs index cc1b30c9be..e1d911cb87 100644 --- a/crates/blockifier/src/transaction/transactions_test.rs +++ b/crates/blockifier/src/transaction/transactions_test.rs @@ -104,8 +104,10 @@ use crate::test_utils::{ CURRENT_BLOCK_TIMESTAMP, CURRENT_BLOCK_TIMESTAMP_FOR_VALIDATE, MAX_FEE, + MAX_L1_DATA_GAS_PRICE, MAX_L1_GAS_AMOUNT, MAX_L1_GAS_PRICE, + MAX_L2_GAS_PRICE, TEST_SEQUENCER_ADDRESS, }; use crate::transaction::account_transaction::AccountTransaction; @@ -834,16 +836,39 @@ fn assert_failure_if_resource_bounds_exceed_balance( if max_fee == context.max_fee ); } - TransactionInfo::Current(context) => { - let l1_bounds = context.l1_resource_bounds(); - assert_matches!( + TransactionInfo::Current(context) => match &context.resource_bounds { + ValidResourceBounds::L1Gas(l1_bounds) => assert_matches!( invalid_tx.execute(state, block_context, true, true).unwrap_err(), TransactionExecutionError::TransactionPreValidationError( TransactionPreValidationError::TransactionFeeError( - TransactionFeeError::GasBoundsExceedBalance{resource, max_amount, max_price, .. })) + TransactionFeeError::GasBoundsExceedBalance{ resource, max_amount, max_price, .. })) if max_amount == l1_bounds.max_amount && max_price == l1_bounds.max_price_per_unit && resource == L1Gas - ); - } + ), + ValidResourceBounds::AllResources(AllResourceBounds { + l1_gas: l1_bounds, + l2_gas: l2_bounds, + l1_data_gas: l1_data_bounds, + }) => { + assert_matches!( + invalid_tx.execute(state, block_context, true, true).unwrap_err(), + TransactionExecutionError::TransactionPreValidationError( + TransactionPreValidationError::TransactionFeeError( + TransactionFeeError::ResourcesBoundsExceedBalance{ + l1_max_amount, + l1_max_price, + l1_data_max_amount, + l1_data_max_price, + l2_max_amount, + l2_max_price, .. } + ) + ) + if l1_max_amount == l1_bounds.max_amount && l1_max_price == l1_bounds.max_price_per_unit + && l2_max_amount == l2_bounds.max_amount && l2_max_price == l2_bounds.max_price_per_unit + && l1_data_max_amount == l1_data_bounds.max_amount + && l1_data_max_price == l1_data_bounds.max_price_per_unit + ); + } + }, }; } @@ -885,10 +910,12 @@ fn test_estimate_minimal_gas_vector( #[rstest] fn test_max_fee_exceeds_balance( - block_context: BlockContext, + mut block_context: BlockContext, max_l1_resource_bounds: ValidResourceBounds, + #[values(true, false)] use_kzg_da: bool, #[values(CairoVersion::Cairo0, CairoVersion::Cairo1)] account_cairo_version: CairoVersion, ) { + block_context.block_info.use_kzg_da = use_kzg_da; let block_context = &block_context; let account_contract = FeatureContract::AccountWithoutValidations(account_cairo_version); let test_contract = FeatureContract::TestContract(CairoVersion::Cairo0); @@ -905,9 +932,9 @@ fn test_max_fee_exceeds_balance( let invalid_max_fee = Fee(BALANCE.0 + 1); // TODO(Ori, 1/2/2024): Write an indicative expect message explaining why the conversion works. - let balance_over_gas_price = BALANCE / MAX_L1_GAS_PRICE; - let invalid_resource_bounds = - l1_resource_bounds((balance_over_gas_price.0 + 1).into(), MAX_L1_GAS_PRICE.into()); + let max_l1_gas_amount = BALANCE / MAX_L1_GAS_PRICE; + let invalid_l1_resource_bounds = + l1_resource_bounds((max_l1_gas_amount.0 + 1).into(), MAX_L1_GAS_PRICE.into()); // V1 Invoke. let invalid_tx = account_invoke_tx(invoke_tx_args! { @@ -919,8 +946,8 @@ fn test_max_fee_exceeds_balance( // V3 invoke. let invalid_tx = account_invoke_tx(invoke_tx_args! { - resource_bounds: invalid_resource_bounds, - ..default_args + resource_bounds: invalid_l1_resource_bounds, + ..default_args.clone() }); assert_failure_if_resource_bounds_exceed_balance(state, block_context, invalid_tx); @@ -942,11 +969,54 @@ fn test_max_fee_exceeds_balance( class_hash: contract_to_declare.get_class_hash(), compiled_class_hash: contract_to_declare.get_compiled_class_hash(), sender_address: account_contract_address, - resource_bounds: invalid_resource_bounds, + resource_bounds: invalid_l1_resource_bounds, }, class_info, ); assert_failure_if_resource_bounds_exceed_balance(state, block_context, invalid_tx); + + // Test all resource bounds. + // TODO!(Aner): remove magic numbers, use function to calculate minimal amounts. + let min_l1_amount = 1652; + let min_l2_amount = 445900; + let min_l1_data_amount = 128; + let max_l1_gas_amount: u64 = max_l1_gas_amount.0.try_into().unwrap(); + let max_l2_gas_amount: u64 = + (BALANCE / MAX_L2_GAS_PRICE).0.try_into().expect("Failed to convert u128 to u64."); + let max_l1_data_gas_amount: u64 = + (BALANCE / MAX_L1_DATA_GAS_PRICE).0.try_into().expect("Failed to convert u128 to u64."); + // Ensure that in the following, the test won't fall on min amount too low. + assert!(max_l1_gas_amount / 3 + 1 >= min_l1_amount); + assert!(max_l2_gas_amount / 3 + 1 >= min_l2_amount); + assert!(max_l1_data_gas_amount / 3 + 1 >= min_l1_data_amount); + // In the following cases, the balance is not enough to cover the gas price of the transaction. + // Minimal amounts are used to avoid failing the test due to min gas usage not covered. + for (l1_max_amount, l2_max_amount, l1_data_max_amount) in [ + (max_l1_gas_amount + 1, min_l2_amount, min_l1_data_amount), + (min_l1_amount, max_l2_gas_amount + 1, min_l1_data_amount), + (min_l1_amount, min_l2_amount, max_l1_data_gas_amount + 1), + (max_l1_gas_amount / 3 + 1, max_l2_gas_amount / 3 + 1, max_l1_data_gas_amount / 3 + 1), + ] { + let invalid_resource_bounds = ValidResourceBounds::AllResources(AllResourceBounds { + l1_gas: ResourceBounds { + max_amount: l1_max_amount, + max_price_per_unit: MAX_L1_GAS_PRICE.get().0, + }, + l2_gas: ResourceBounds { + max_amount: l2_max_amount, + max_price_per_unit: MAX_L2_GAS_PRICE.get().0, + }, + l1_data_gas: ResourceBounds { + max_amount: l1_data_max_amount, + max_price_per_unit: MAX_L1_DATA_GAS_PRICE.get().0, + }, + }); + let invalid_tx = account_invoke_tx(invoke_tx_args! { + resource_bounds: invalid_resource_bounds, + ..default_args.clone() + }); + assert_failure_if_resource_bounds_exceed_balance(state, block_context, invalid_tx); + } } #[rstest]