test(concurrency): add utilitis for commit tx test

crates/blockifier/src/concurrency/worker_logic_test.rs

@@ -3,30 +3,142 @@ use std::collections::HashMap;
 use num_bigint::BigUint;
 use starknet_api::core::{ContractAddress, PatriciaKey};
 use starknet_api::hash::{StarkFelt, StarkHash};
-use starknet_api::transaction::Fee;
+use starknet_api::transaction::{Fee, TransactionVersion};
 use starknet_api::{contract_address, patricia_key, stark_felt};
 
 use super::WorkerExecutor;
 use crate::abi::abi_utils::get_fee_token_var_address;
 use crate::abi::sierra_types::next_storage_key;
 use crate::concurrency::scheduler::{Task, TransactionStatus};
 use crate::concurrency::test_utils::safe_versioned_state_for_testing;
+use crate::concurrency::versioned_state::ThreadSafeVersionedState;
 use crate::concurrency::worker_logic::add_fee_to_sequencer_balance;
 use crate::context::BlockContext;
 use crate::execution::execution_utils::{felt_to_stark_felt, stark_felt_to_felt};
 use crate::fee::fee_utils::get_sequencer_balance_keys;
-use crate::state::cached_state::StateMaps;
-use crate::state::state_api::StateReader;
+use crate::state::cached_state::{ContractClassMapping, StateMaps};
+use crate::state::state_api::{StateReader, UpdatableState};
 use crate::test_utils::contracts::FeatureContract;
 use crate::test_utils::initial_test_state::test_state_reader;
 use crate::test_utils::{
-    create_calldata, CairoVersion, NonceManager, BALANCE, MAX_FEE, TEST_ERC20_CONTRACT_ADDRESS,
+    create_calldata, create_trivial_calldata, CairoVersion, NonceManager, BALANCE, MAX_FEE,
+    MAX_L1_GAS_AMOUNT, MAX_L1_GAS_PRICE, TEST_ERC20_CONTRACT_ADDRESS,
 };
+use crate::transaction::account_transaction::AccountTransaction;
+use crate::transaction::constants::TRANSFER_ENTRY_POINT_NAME;
 use crate::transaction::objects::FeeType;
-use crate::transaction::test_utils::account_invoke_tx;
+use crate::transaction::test_utils::{account_invoke_tx, l1_resource_bounds};
 use crate::transaction::transaction_execution::Transaction;
 use crate::{invoke_tx_args, nonce, storage_key};
 
+fn _trivial_calldata_invoke_tx(
+    account_address: ContractAddress,
+    nonce_manager: &mut NonceManager,
+) -> AccountTransaction {
+    account_invoke_tx(invoke_tx_args! {
+        sender_address: account_address,
+        calldata: create_trivial_calldata(account_address),
+        resource_bounds: l1_resource_bounds(MAX_L1_GAS_AMOUNT, MAX_L1_GAS_PRICE),
+        version: TransactionVersion::THREE,
+        nonce: nonce_manager.next(account_address),
+    })
+}
+
+fn _transfer_to_sequencer_tx(
+    account_address: ContractAddress,
+    block_context: &BlockContext,
+    transfer_amount: u128,
+    nonce_manager: &mut NonceManager,
+) -> AccountTransaction {
+    let sequencer_address = block_context.block_info.sequencer_address;
+    let transfer_calldata = create_calldata(
+        block_context.chain_info().fee_token_address(&FeeType::Strk),
+        TRANSFER_ENTRY_POINT_NAME,
+        &[
+            *sequencer_address.0.key(),   // Recipient address.
+            stark_felt!(transfer_amount), // Amount low.
+            stark_felt!(0_u8),            // Amount high.
+        ],
+    );
+
+    // Invokes transfer to the sequencer.
+    account_invoke_tx(invoke_tx_args! {
+        sender_address: account_address,
+        calldata: transfer_calldata,
+        resource_bounds: l1_resource_bounds(MAX_L1_GAS_AMOUNT, MAX_L1_GAS_PRICE),
+        version: TransactionVersion::THREE,
+        nonce: nonce_manager.next(account_address)
+    })
+}
+
+/// Creates an invalid transaction. The transaction has no calldata, making it fail validation.
+fn _invalid_tx(
+    account_address: ContractAddress,
+    nonce_manager: &mut NonceManager,
+) -> AccountTransaction {
+    account_invoke_tx(invoke_tx_args! {
+        sender_address: account_address,
+        resource_bounds: l1_resource_bounds(MAX_L1_GAS_AMOUNT, MAX_L1_GAS_PRICE),
+        version: TransactionVersion::THREE,
+        nonce: nonce_manager.next(account_address),
+    })
+}
+
+// This function checks that the storage values of the account and sequencer balances in the
+// versioned state of tx_index are equal to the expected_storage_values.
+fn _validate_fee_transfer<S: StateReader>(
+    executor: &WorkerExecutor<'_, S>,
+    account_address: ContractAddress,
+    tx_index: usize,
+    expected_account_balance_low: StarkFelt,
+    expected_sequencer_balance_low: StarkFelt,
+    expected_sequencer_balance_high: StarkFelt,
+) {
+    let tx_version_state = executor.state.pin_version(tx_index + 1);
+    let account_balance_key_low = get_fee_token_var_address(account_address);
+    let account_balance_key_high = next_storage_key(&account_balance_key_low).unwrap();
+
+    let (sequencer_balance_key_low, sequencer_balance_key_high) =
+        get_sequencer_balance_keys(&executor.block_context);
+    for (expected_balance, storage_key) in [
+        (expected_account_balance_low, account_balance_key_low),
+        // In tests, we assume that the account balance can be represented as u128.
+        (StarkFelt::ZERO, account_balance_key_high),
+        (expected_sequencer_balance_low, sequencer_balance_key_low),
+        (expected_sequencer_balance_high, sequencer_balance_key_high),
+    ] {
+        let actual_balance = tx_version_state
+            .get_storage_at(
+                executor.block_context.chain_info.fee_token_address(&FeeType::Strk),
+                storage_key,
+            )
+            .unwrap();
+        assert_eq!(expected_balance, actual_balance);
+    }
+}
+/// Changes an account's balance observed by transaction `tx_index`. Used to cause a transaction to
+/// either pass or fail validation in tests.
+fn _change_account_balance_at_version(
+    account_address: ContractAddress,
+    state: &mut ThreadSafeVersionedState<impl StateReader>,
+    tx_index: usize,
+    fee_token_address: ContractAddress,
+    new_balance_low: StarkFelt,
+    new_balance_high: StarkFelt,
+) {
+    let mut versioned_state = state.pin_version(tx_index - 1);
+    let account_balance_key_low = get_fee_token_var_address(account_address);
+    let account_balance_key_high = next_storage_key(&account_balance_key_low).unwrap();
+    let writes = StateMaps {
+        storage: HashMap::from([
+            ((fee_token_address, account_balance_key_low), new_balance_low),
+            ((fee_token_address, account_balance_key_high), new_balance_high),
+        ]),
+        ..StateMaps::default()
+    };
+    versioned_state.apply_writes(&writes, &ContractClassMapping::default(), &HashMap::default());
+}
+
 #[test]
 fn test_worker_execute() {
     // Settings.