starknet_os_runner: share test utils

Author: AvivYossef-starkware

crates/starknet_os_runner/src/lib.rs

@@ -5,4 +5,6 @@ pub mod virtual_block_executor;
 #[cfg(test)]
 mod storage_proofs_test;
 #[cfg(test)]
+pub mod test_utils;
+#[cfg(test)]
 mod virtual_block_executor_test;

crates/starknet_os_runner/src/storage_proofs_test.rs

@@ -1,28 +1,23 @@
 use std::collections::HashSet;
-use std::env;
 
 use blockifier::context::BlockContext;
 use blockifier::state::cached_state::StateMaps;
-use rstest::{fixture, rstest};
+use rstest::rstest;
 use starknet_api::block::BlockNumber;
 use starknet_api::core::ContractAddress;
 use starknet_api::state::StorageKey;
 use starknet_rust::providers::Provider;
 use starknet_types_core::felt::Felt;
-use url::Url;
 
 use crate::storage_proofs::{RpcStorageProofsProvider, StorageProofProvider};
+use crate::test_utils::{rpc_provider, STRK_TOKEN_ADDRESS};
 use crate::virtual_block_executor::VirtualBlockExecutionData;
 
-/// Mainnet STRK token contract address.
-const STRK_CONTRACT_ADDRESS: Felt =
-    Felt::from_hex_unchecked("0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d");
-
 /// Fixture: Creates initial reads with the STRK contract and storage slot 0.
-#[fixture]
+#[rstest::fixture]
 fn initial_reads() -> (StateMaps, ContractAddress, StorageKey) {
     let mut state_maps = StateMaps::default();
-    let contract_address = ContractAddress::try_from(STRK_CONTRACT_ADDRESS).unwrap();
+    let contract_address = ContractAddress::try_from(STRK_TOKEN_ADDRESS).unwrap();
 
     // Add a storage read for slot 0 (commonly used for total_supply or similar).
     let storage_key = StorageKey::from(0u32);
@@ -31,24 +26,17 @@ fn initial_reads() -> (StateMaps, ContractAddress, StorageKey) {
     (state_maps, contract_address, storage_key)
 }
 
-/// Fixture: Creates an RPC provider from the RPC_URL environment variable.
-#[fixture]
-fn rpc_provider() -> RpcStorageProofsProvider {
-    let rpc_url_str = env::var("NODE_URL").expect("NODE_URL environment variable must be set");
-    let rpc_url = Url::parse(&rpc_url_str).expect("Invalid RPC URL");
-    RpcStorageProofsProvider::new(rpc_url)
-}
-
 /// Sanity test that verifies storage proof fetching works with a real RPC endpoint.
 ///
 /// This test is ignored by default because it requires a running RPC node.
-/// Run with: `RPC_URL=<your_rpc_url> cargo test -p starknet_os_runner -- --ignored`
+/// Run with: `NODE_URL=<your_rpc_url> cargo test -p starknet_os_runner -- --ignored`
 #[rstest]
 #[ignore]
 fn test_get_storage_proofs_from_rpc(
     rpc_provider: RpcStorageProofsProvider,
     initial_reads: (StateMaps, ContractAddress, StorageKey),
 ) {
+    
     let (state_maps, contract_address, storage_key) = initial_reads;
 
     // Fetch latest block number.

crates/starknet_os_runner/src/test_utils.rs

@@ -0,0 +1,45 @@
+use std::env;
+
+use blockifier_reexecution::state_reader::rpc_state_reader::RpcStateReader;
+use rstest::fixture;
+use starknet_api::block::BlockNumber;
+use starknet_api::core::ChainId;
+use starknet_types_core::felt::Felt;
+use url::Url;
+
+use crate::storage_proofs::RpcStorageProofsProvider;
+
+/// Block number to use for testing (mainnet block with known state).
+pub const TEST_BLOCK_NUMBER: u64 = 800000;
+
+/// STRK token contract address on mainnet.
+pub const STRK_TOKEN_ADDRESS: Felt =
+    Felt::from_hex_unchecked("0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d");
+
+/// A known account address on mainnet (Starknet Foundation).
+pub const SENDER_ADDRESS: Felt =
+    Felt::from_hex_unchecked("0x01176a1bd84444c89232ec27754698e5d2e7e1a7f1539f12027f28b23ec9f3d8");
+
+/// Gets the RPC URL from the environment (NODE_URL).
+pub fn get_rpc_url() -> String {
+    env::var("NODE_URL").expect("NODE_URL environment variable required for this test")
+}
+
+/// Fixture that creates an RpcStateReader for testing.
+#[fixture]
+pub fn rpc_state_reader() -> RpcStateReader {
+    let node_url = get_rpc_url();
+    RpcStateReader::new_with_config_from_url(
+        node_url,
+        ChainId::Mainnet,
+        BlockNumber(TEST_BLOCK_NUMBER),
+    )
+}
+
+/// Fixture that creates an RpcStorageProofsProvider for testing.
+#[fixture]
+pub fn rpc_provider() -> RpcStorageProofsProvider {
+    let rpc_url_str = get_rpc_url();
+    let rpc_url = Url::parse(&rpc_url_str).expect("Invalid RPC URL");
+    RpcStorageProofsProvider::new(rpc_url)
+}

crates/starknet_os_runner/src/virtual_block_executor_test.rs

@@ -1,8 +1,7 @@
-use std::env;
-
 use blockifier::blockifier::config::ContractClassManagerConfig;
 use blockifier::state::contract_class_manager::ContractClassManager;
 use blockifier::transaction::transaction_execution::Transaction as BlockifierTransaction;
+use rstest::rstest;
 use starknet_api::abi::abi_utils::{get_storage_var_address, selector_from_name};
 use starknet_api::block::BlockNumber;
 use starknet_api::core::{ChainId, ContractAddress, Nonce};
@@ -12,18 +11,8 @@ use starknet_api::{calldata, felt, invoke_tx_args};
 
 use crate::errors::VirtualBlockExecutorError;
 use crate::virtual_block_executor::{RpcVirtualBlockExecutor, VirtualBlockExecutor};
-
-/// Block number to use for testing (mainnet block with known state).
-const TEST_BLOCK_NUMBER: u64 = 800000;
-
-/// STRK token contract address on mainnet.
-const STRK_TOKEN_ADDRESS: &str =
-    "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d";
-
-/// A known account address on mainnet (Starknet Foundation).
-/// This is a Cairo 0 OpenZeppelin account, which uses the following calldata format:
-/// [call_array_len, (to, selector, data_offset, data_len)..., calldata_len, calldata...]
-const SENDER_ADDRESS: &str = "0x01176a1bd84444c89232ec27754698e5d2e7e1a7f1539f12027f28b23ec9f3d8";
+use crate::test_utils::{rpc_state_reader, SENDER_ADDRESS, STRK_TOKEN_ADDRESS, TEST_BLOCK_NUMBER};
+use crate::virtual_block_executor::VirtualBlockExecutor;
 
 /// Test wrapper for RpcStateReader that overrides execution flags to skip validation.
 struct TestRpcVirtualBlockExecutor(RpcVirtualBlockExecutor);
@@ -72,8 +61,8 @@ impl VirtualBlockExecutor for TestRpcVirtualBlockExecutor {
 /// Since we skip validation and fee charging, we can use dummy values for signature,
 /// nonce, and resource bounds.
 fn construct_balance_of_invoke() -> (Transaction, TransactionHash) {
-    let strk_token = ContractAddress::try_from(felt!(STRK_TOKEN_ADDRESS)).unwrap();
-    let sender = ContractAddress::try_from(felt!(SENDER_ADDRESS)).unwrap();
+    let strk_token = ContractAddress::try_from(STRK_TOKEN_ADDRESS).unwrap();
+    let sender = ContractAddress::try_from(SENDER_ADDRESS).unwrap();
 
     // Calldata for account's __execute__ (Cairo 0 OZ account format):
     // [call_array_len, call_array..., calldata_len, calldata...]
@@ -117,22 +106,15 @@ fn construct_balance_of_invoke() -> (Transaction, TransactionHash) {
 /// ```bash
 /// NODE_URL=https://your-rpc-node cargo test -p starknet_os_runner -- --ignored
 /// ```
-#[test]
+#[rstest]
 #[ignore] // Requires RPC access 
-fn test_execute_constructed_balance_of_transaction() {
-    let node_url =
-        env::var("NODE_URL").expect("NODE_URL environment variable required for this test");
-
+fn test_execute_constructed_balance_of_transaction(rpc_state_reader: RpcStateReader) {
     // Construct a balanceOf transaction (with execution flags set).
     let (tx, tx_hash) = construct_balance_of_invoke();
 
     // Create the virtual block executor.
     let contract_class_manager = ContractClassManager::start(ContractClassManagerConfig::default());
-    let executor = TestRpcVirtualBlockExecutor(RpcVirtualBlockExecutor::new(
-        node_url,
-        ChainId::Mainnet,
-        BlockNumber(TEST_BLOCK_NUMBER),
-    ));
+    let executor = TestRpcVirtualBlockExecutor(rpc_state_reader);
 
     // Execute the transaction.
     let result = executor
@@ -170,8 +152,8 @@ fn test_execute_constructed_balance_of_transaction() {
 
     // Verify the specific ERC20 balance storage key was read.
     // ERC20 contracts store balances in "ERC20_balances" mapping keyed by address.
-    let strk_token = ContractAddress::try_from(felt!(STRK_TOKEN_ADDRESS)).unwrap();
-    let sender = ContractAddress::try_from(felt!(SENDER_ADDRESS)).unwrap();
+    let strk_token = ContractAddress::try_from(STRK_TOKEN_ADDRESS).unwrap();
+    let sender = ContractAddress::try_from(SENDER_ADDRESS).unwrap();
     let balance_storage_key = get_storage_var_address("ERC20_balances", &[*sender.0.key()]);
     assert!(
         result.initial_reads.storage.contains_key(&(strk_token, balance_storage_key)),